@rainfall-devkit/sdk 0.2.1 → 0.2.3

package/dist/sdk-DQKNbBce.d.ts

@@ -0,0 +1,1162 @@
+import { WebSocket } from 'ws';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+/**
+ * MCP Proxy Hub - Manages external MCP clients (Chrome DevTools, etc.)
+ *
+ * This service allows the Rainfall daemon to act as a central MCP hub:
+ * - External MCP servers (like Chrome DevTools) connect via WebSocket or stdio
+ * - Their tools are exposed as native Rainfall tools with optional namespacing
+ * - Tool calls are proxied back to the appropriate MCP client
+ * - Multiple clients can connect simultaneously with unique namespaces
+ */
+
+type MCPTransportType = 'stdio' | 'websocket' | 'http';
+interface MCPClientConfig {
+    name: string;
+    transport: MCPTransportType;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    autoConnect?: boolean;
+}
+interface MCPClientInfo {
+    name: string;
+    client: Client;
+    transport: StdioClientTransport | StreamableHTTPClientTransport | WebSocket;
+    transportType: MCPTransportType;
+    tools: MCPToolInfo[];
+    connectedAt: string;
+    lastUsed: string;
+    config: MCPClientConfig;
+    status: 'connected' | 'disconnected' | 'error';
+    error?: string;
+}
+interface MCPToolInfo {
+    name: string;
+    description: string;
+    inputSchema: unknown;
+    serverName: string;
+}
+interface MCPProxyOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Auto-reconnect disconnected clients */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms */
+    reconnectDelay?: number;
+    /** Tool call timeout in ms */
+    toolTimeout?: number;
+    /** Refresh interval for tool lists in ms */
+    refreshInterval?: number;
+}
+declare class MCPProxyHub {
+    private clients;
+    private options;
+    private refreshTimer?;
+    private reconnectTimeouts;
+    private requestId;
+    constructor(options?: MCPProxyOptions);
+    /**
+     * Initialize the MCP proxy hub
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the MCP proxy hub and disconnect all clients
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Connect to an MCP server
+     */
+    connectClient(config: MCPClientConfig): Promise<string>;
+    /**
+     * Disconnect a specific MCP client
+     */
+    disconnectClient(name: string): Promise<void>;
+    /**
+     * Schedule a reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Call a tool on the appropriate MCP client
+     */
+    callTool(toolName: string, args: Record<string, unknown>, options?: {
+        timeout?: number;
+        namespace?: string;
+    }): Promise<unknown>;
+    /**
+     * Format MCP tool result for consistent output
+     */
+    private formatToolResult;
+    /**
+     * Get all tools from all connected MCP clients
+     * Optionally with namespace prefix
+     */
+    getAllTools(options?: {
+        namespacePrefix?: boolean;
+    }): MCPToolInfo[];
+    /**
+     * Get tools from a specific client
+     */
+    getClientTools(clientName: string): MCPToolInfo[];
+    /**
+     * Get list of connected MCP clients
+     */
+    listClients(): Array<{
+        name: string;
+        status: string;
+        toolCount: number;
+        connectedAt: string;
+        lastUsed: string;
+        transportType: MCPTransportType;
+    }>;
+    /**
+     * Get client info by name
+     */
+    getClient(name: string): MCPClientInfo | undefined;
+    /**
+     * Refresh tool lists from all connected clients
+     */
+    refreshTools(): Promise<void>;
+    /**
+     * List resources from a specific client or all clients
+     */
+    listResources(clientName?: string): Promise<Array<{
+        clientName: string;
+        resources: unknown[];
+    }>>;
+    /**
+     * Read a resource from a specific client
+     */
+    readResource(uri: string, clientName?: string): Promise<unknown>;
+    /**
+     * List prompts from a specific client or all clients
+     */
+    listPrompts(clientName?: string): Promise<Array<{
+        clientName: string;
+        prompts: unknown[];
+    }>>;
+    /**
+     * Get a prompt from a specific client
+     */
+    getPrompt(name: string, args: Record<string, unknown>, clientName?: string): Promise<unknown>;
+    /**
+     * Health check for all connected clients
+     */
+    healthCheck(): Promise<Map<string, {
+        status: string;
+        responseTime: number;
+        error?: string;
+    }>>;
+    /**
+     * Start the automatic refresh timer
+     */
+    private startRefreshTimer;
+    /**
+     * Print available tools for a client
+     */
+    private printAvailableTools;
+    /**
+     * Debug logging
+     */
+    private log;
+    /**
+     * Get statistics about the MCP proxy hub
+     */
+    getStats(): {
+        totalClients: number;
+        totalTools: number;
+        clients: Array<{
+            name: string;
+            toolCount: number;
+            status: string;
+            transportType: MCPTransportType;
+        }>;
+    };
+}
+
+/**
+ * Core types for the Rainfall SDK
+ */
+interface RainfallConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    /** Pre-configured MCP clients to connect on daemon startup */
+    mcpClients?: MCPClientConfig[];
+}
+interface RequestOptions {
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+}
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: ApiError;
+}
+interface ApiError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    resetAt: Date;
+}
+interface ToolSchema {
+    name: string;
+    description: string;
+    category: string;
+    parameters: unknown;
+    output: unknown;
+    metadata: Record<string, unknown>;
+}
+declare namespace Integrations {
+    interface GitHub {
+        issues: {
+            create(params: {
+                owner: string;
+                repo: string;
+                title: string;
+                body?: string;
+            }): Promise<unknown>;
+            list(params: {
+                owner: string;
+                repo: string;
+                state?: 'open' | 'closed' | 'all';
+            }): Promise<unknown>;
+            get(params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+            }): Promise<unknown>;
+            update(params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+                title?: string;
+                body?: string;
+                state?: 'open' | 'closed';
+            }): Promise<unknown>;
+            addComment(params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+                body: string;
+            }): Promise<unknown>;
+        };
+        repos: {
+            get(params: {
+                owner: string;
+                repo: string;
+            }): Promise<unknown>;
+            listBranches(params: {
+                owner: string;
+                repo: string;
+            }): Promise<unknown>;
+        };
+        pullRequests: {
+            list(params: {
+                owner: string;
+                repo: string;
+                state?: 'open' | 'closed' | 'all';
+            }): Promise<unknown>;
+            get(params: {
+                owner: string;
+                repo: string;
+                pullNumber: number;
+            }): Promise<unknown>;
+        };
+    }
+    interface Notion {
+        pages: {
+            create(params: {
+                parent: unknown;
+                properties: unknown;
+                children?: unknown[];
+            }): Promise<unknown>;
+            retrieve(params: {
+                pageId: string;
+            }): Promise<unknown>;
+            update(params: {
+                pageId: string;
+                properties: unknown;
+            }): Promise<unknown>;
+        };
+        databases: {
+            query(params: {
+                databaseId: string;
+                filter?: unknown;
+                sorts?: unknown[];
+            }): Promise<unknown>;
+            retrieve(params: {
+                databaseId: string;
+            }): Promise<unknown>;
+        };
+        blocks: {
+            appendChildren(params: {
+                blockId: string;
+                children: unknown[];
+            }): Promise<unknown>;
+            retrieveChildren(params: {
+                blockId: string;
+            }): Promise<unknown>;
+        };
+    }
+    interface Linear {
+        issues: {
+            create(params: {
+                title: string;
+                description?: string;
+                teamId?: string;
+                assigneeId?: string;
+                priority?: number;
+                labels?: string[];
+            }): Promise<unknown>;
+            list(params?: {
+                filter?: unknown;
+                orderBy?: string;
+            }): Promise<unknown>;
+            get(params: {
+                issueId: string;
+            }): Promise<unknown>;
+            update(params: {
+                issueId: string;
+                title?: string;
+                description?: string;
+                state?: string;
+            }): Promise<unknown>;
+            archive(params: {
+                issueId: string;
+            }): Promise<unknown>;
+        };
+        teams: {
+            list(): Promise<unknown>;
+        };
+    }
+    interface Slack {
+        messages: {
+            send(params: {
+                channelId: string;
+                text: string;
+                blocks?: unknown[];
+            }): Promise<unknown>;
+            list(params: {
+                channelId: string;
+                limit?: number;
+            }): Promise<unknown>;
+        };
+        channels: {
+            list(): Promise<unknown>;
+        };
+        users: {
+            list(): Promise<unknown>;
+        };
+        reactions: {
+            add(params: {
+                channelId: string;
+                timestamp: string;
+                reaction: string;
+            }): Promise<unknown>;
+        };
+    }
+    interface Figma {
+        files: {
+            get(params: {
+                fileKey: string;
+            }): Promise<unknown>;
+            getNodes(params: {
+                fileKey: string;
+                nodeIds: string[];
+            }): Promise<unknown>;
+            getImages(params: {
+                fileKey: string;
+                nodeIds: string[];
+                format?: 'png' | 'svg' | 'pdf';
+            }): Promise<unknown>;
+            getComments(params: {
+                fileKey: string;
+            }): Promise<unknown>;
+            postComment(params: {
+                fileKey: string;
+                message: string;
+                nodeId?: string;
+            }): Promise<unknown>;
+        };
+        projects: {
+            list(params: {
+                teamId: string;
+            }): Promise<unknown>;
+            getFiles(params: {
+                projectId: string;
+            }): Promise<unknown>;
+        };
+    }
+    interface Stripe {
+        customers: {
+            create(params: {
+                email: string;
+                name?: string;
+                metadata?: Record<string, string>;
+            }): Promise<unknown>;
+            retrieve(params: {
+                customerId: string;
+            }): Promise<unknown>;
+            update(params: {
+                customerId: string;
+                metadata?: Record<string, string>;
+            }): Promise<unknown>;
+            listPaymentMethods(params: {
+                customerId: string;
+            }): Promise<unknown>;
+        };
+        paymentIntents: {
+            create(params: {
+                amount: number;
+                currency: string;
+                customer?: string;
+            }): Promise<unknown>;
+            retrieve(params: {
+                paymentIntentId: string;
+            }): Promise<unknown>;
+            confirm(params: {
+                paymentIntentId: string;
+            }): Promise<unknown>;
+        };
+        subscriptions: {
+            create(params: {
+                customer: string;
+                items: unknown[];
+            }): Promise<unknown>;
+            retrieve(params: {
+                subscriptionId: string;
+            }): Promise<unknown>;
+            cancel(params: {
+                subscriptionId: string;
+            }): Promise<unknown>;
+        };
+    }
+}
+declare namespace Memory {
+    interface MemoryClient {
+        create(params: {
+            content: string;
+            keywords?: string[];
+            metadata?: Record<string, unknown>;
+        }): Promise<unknown>;
+        get(params: {
+            memoryId: string;
+        }): Promise<unknown>;
+        recall(params: {
+            query: string;
+            topK?: number;
+            threshold?: number;
+        }): Promise<unknown>;
+        list(params?: {
+            limit?: number;
+            offset?: number;
+        }): Promise<unknown>;
+        update(params: {
+            memoryId: string;
+            content?: string;
+            metadata?: Record<string, unknown>;
+        }): Promise<unknown>;
+        delete(params: {
+            memoryId: string;
+        }): Promise<unknown>;
+    }
+}
+declare namespace Articles {
+    interface ArticlesClient {
+        search(params: {
+            query: string;
+            limit?: number;
+        }): Promise<unknown>;
+        create(params: {
+            title: string;
+            content: string;
+            topics?: string[];
+            metadata?: Record<string, unknown>;
+        }): Promise<unknown>;
+        createFromUrl(params: {
+            url: string;
+        }): Promise<unknown>;
+        fetch(params: {
+            articleId: string;
+        }): Promise<unknown>;
+        recent(params?: {
+            limit?: number;
+        }): Promise<unknown>;
+        relevant(params: {
+            query: string;
+            limit?: number;
+        }): Promise<unknown>;
+        summarize(params: {
+            articleId?: string;
+            text?: string;
+            length?: 'short' | 'medium' | 'long';
+        }): Promise<unknown>;
+        extractTopics(params: {
+            text: string;
+        }): Promise<unknown>;
+    }
+}
+declare namespace Web {
+    interface WebClient {
+        search: {
+            exa(params: {
+                query: string;
+                numResults?: number;
+                includeDomains?: string[];
+                excludeDomains?: string[];
+            }): Promise<unknown>;
+            perplexity(params: {
+                query: string;
+            }): Promise<unknown>;
+        };
+        fetch(params: {
+            url: string;
+            headers?: Record<string, string>;
+        }): Promise<unknown>;
+        htmlToMarkdown(params: {
+            html: string;
+            baseUrl?: string;
+        }): Promise<unknown>;
+        extractHtml(params: {
+            html: string;
+            selector: string;
+        }): Promise<unknown>;
+    }
+}
+declare namespace AI {
+    interface AIClient {
+        embeddings: {
+            document(params: {
+                text: string;
+            }): Promise<unknown>;
+            query(params: {
+                text: string;
+            }): Promise<unknown>;
+            image(params: {
+                imageBase64: string;
+            }): Promise<unknown>;
+        };
+        image: {
+            generate(params: {
+                prompt: string;
+                size?: '256x256' | '512x512' | '1024x1024';
+            }): Promise<unknown>;
+        };
+        ocr(params: {
+            imageBase64: string;
+        }): Promise<unknown>;
+        vision(params: {
+            imageBase64: string;
+            prompt?: string;
+        }): Promise<unknown>;
+        chat(params: {
+            messages: Array<{
+                role: 'user' | 'assistant' | 'system';
+                content: string;
+            }>;
+            model?: string;
+        }): Promise<unknown>;
+        complete(params: {
+            prompt: string;
+            suffix?: string;
+        }): Promise<unknown>;
+        classify(params: {
+            text: string;
+            labels: string[];
+        }): Promise<unknown>;
+        segment(params: {
+            text: string;
+            maxLength?: number;
+        }): Promise<unknown[]>;
+    }
+}
+declare namespace Data {
+    interface DataClient {
+        csv: {
+            query(params: {
+                sql: string;
+                csvData?: string;
+                fileId?: string;
+            }): Promise<unknown>;
+            convert(params: {
+                data: string;
+                fromFormat: string;
+                toFormat: string;
+            }): Promise<unknown>;
+        };
+        scripts: {
+            create(params: {
+                name: string;
+                code: string;
+                language?: string;
+            }): Promise<unknown>;
+            execute(params: {
+                name: string;
+                params?: Record<string, unknown>;
+            }): Promise<unknown>;
+            list(): Promise<unknown>;
+            update(params: {
+                name: string;
+                code: string;
+            }): Promise<unknown>;
+            delete(params: {
+                name: string;
+            }): Promise<unknown>;
+        };
+        similarity: {
+            search(params: {
+                query: number[];
+                embeddings: number[][];
+                topK?: number;
+            }): Promise<unknown>;
+            duckDbSearch(params: {
+                query: number[];
+                tableName: string;
+            }): Promise<unknown>;
+        };
+    }
+}
+declare namespace Utils {
+    interface UtilsClient {
+        mermaid(params: {
+            diagram: string;
+        }): Promise<unknown>;
+        documentConvert(params: {
+            document: string;
+            mimeType: string;
+            format: string;
+        }): Promise<unknown>;
+        regex: {
+            match(params: {
+                text: string;
+                pattern: string;
+                flags?: string;
+            }): Promise<unknown>;
+            replace(params: {
+                text: string;
+                pattern: string;
+                replacement: string;
+                flags?: string;
+            }): Promise<unknown>;
+        };
+        jsonExtract(params: {
+            text: string;
+        }): Promise<unknown>;
+        digest(params: {
+            data: string;
+        }): Promise<string>;
+        monteCarlo(params: {
+            iterations?: number;
+            formula: string;
+            variables?: Record<string, {
+                mean: number;
+                stdDev: number;
+            }>;
+        }): Promise<unknown>;
+    }
+}
+
+/**
+ * Parameter validation for Rainfall SDK
+ * Fetches node schemas and validates params before execution
+ */
+
+interface ParamSchema {
+    type: string;
+    description?: string;
+    optional?: boolean;
+    items?: ParamSchema;
+    properties?: Record<string, ParamSchema>;
+    [key: string]: unknown;
+}
+interface ToolParamsSchema {
+    name: string;
+    description: string;
+    category: string;
+    parameters: Record<string, ParamSchema>;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+}
+interface ValidationIssue {
+    path: string;
+    message: string;
+    received?: unknown;
+    expected?: string;
+}
+/**
+ * Fetch and cache tool schema from the API
+ */
+declare function fetchToolSchema(client: RainfallClient, toolId: string): Promise<ToolParamsSchema>;
+/**
+ * Clear the schema cache (useful for testing or when schemas may have changed)
+ */
+declare function clearSchemaCache(): void;
+/**
+ * Validate params against a tool's schema
+ */
+declare function validateParams(schema: ToolParamsSchema, params: Record<string, unknown> | undefined, toolId: string): ValidationResult;
+/**
+ * Format validation errors into a readable message
+ */
+declare function formatValidationErrors(result: ValidationResult): string;
+
+/**
+ * Core HTTP client for Rainfall SDK
+ */
+
+declare class RainfallClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly defaultTimeout;
+    private readonly defaultRetries;
+    private readonly defaultRetryDelay;
+    private lastRateLimitInfo?;
+    private subscriberId?;
+    constructor(config: RainfallConfig);
+    /**
+     * Get the last rate limit info from the API
+     */
+    getRateLimitInfo(): RateLimitInfo | undefined;
+    /**
+     * Make an authenticated request to the Rainfall API
+     */
+    request<T = unknown>(path: string, options?: {
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+        body?: unknown;
+        headers?: Record<string, string>;
+    }, requestOptions?: RequestOptions): Promise<T>;
+    /**
+     * Execute a tool/node by ID
+     *
+     * @param toolId - The ID of the tool/node to execute
+     * @param params - Parameters to pass to the tool
+     * @param options - Request options including skipValidation to bypass param validation
+     */
+    executeTool<T = unknown>(toolId: string, params?: Record<string, unknown>, options?: RequestOptions & {
+        skipValidation?: boolean;
+    }): Promise<T>;
+    /**
+     * Validate parameters for a tool without executing it
+     * Fetches the tool schema and validates the provided params
+     *
+     * @param toolId - The ID of the tool to validate params for
+     * @param params - Parameters to validate
+     * @returns Validation result with detailed error information
+     *
+     * @example
+     * ```typescript
+     * const result = await client.validateToolParams('finviz-quotes', { tickers: ['AAPL'] });
+     * if (!result.valid) {
+     *   console.log('Validation errors:', result.errors);
+     * }
+     * ```
+     */
+    validateToolParams(toolId: string, params?: Record<string, unknown>): Promise<ValidationResult>;
+    /**
+     * List all available tools
+     */
+    listTools(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        category: string;
+    }>>;
+    /**
+     * Get tool schema/parameters
+     *
+     * @param toolId - The ID of the tool to get schema for
+     * @returns Tool schema including parameters and output definitions
+     */
+    getToolSchema(toolId: string): Promise<ToolSchema>;
+    /**
+     * Get subscriber info
+     */
+    getMe(): Promise<{
+        id: string;
+        name: string;
+        email?: string;
+        plan?: string;
+        billingStatus?: string;
+        usage: {
+            callsThisMonth: number;
+            callsLimit: number;
+        };
+    }>;
+    /**
+     * Ensure we have a subscriber ID, fetching it if necessary
+     */
+    private ensureSubscriberId;
+    private sleep;
+    /**
+     * OpenAI-compatible chat completions with tool support
+     */
+    chatCompletions(params: {
+        subscriber_id: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            name?: string;
+        }>;
+        model?: string;
+        stream?: boolean;
+        temperature?: number;
+        max_tokens?: number;
+        tools?: unknown[];
+        tool_choice?: string | {
+            type: string;
+            function?: {
+                name: string;
+            };
+        };
+        conversation_id?: string;
+        agent_name?: string;
+        incognito?: boolean;
+        tool_priority?: 'local' | 'rainfall' | 'serverside' | 'stacked';
+        enable_stacked?: boolean;
+    }): Promise<unknown>;
+    /**
+     * List available models (OpenAI-compatible format)
+     */
+    listModels(subscriberId?: string): Promise<Array<{
+        id: string;
+        [key: string]: unknown;
+    }>>;
+}
+
+/**
+ * Integrations namespace for Rainfall SDK
+ * GitHub, Notion, Linear, Slack, Figma, Stripe
+ */
+
+declare class IntegrationsNamespace {
+    private client;
+    constructor(client: RainfallClient);
+    get github(): Integrations.GitHub;
+    get notion(): Integrations.Notion;
+    get linear(): Integrations.Linear;
+    get slack(): Integrations.Slack;
+    get figma(): Integrations.Figma;
+    get stripe(): Integrations.Stripe;
+}
+
+declare class Rainfall {
+    private readonly client;
+    private _integrations?;
+    private _memory?;
+    private _articles?;
+    private _web?;
+    private _ai?;
+    private _data?;
+    private _utils?;
+    constructor(config: RainfallConfig);
+    /**
+     * Integrations namespace - GitHub, Notion, Linear, Slack, Figma, Stripe
+     *
+     * @example
+     * ```typescript
+     * // GitHub
+     * await rainfall.integrations.github.issues.create({
+     *   owner: 'facebook',
+     *   repo: 'react',
+     *   title: 'Bug report'
+     * });
+     *
+     * // Slack
+     * await rainfall.integrations.slack.messages.send({
+     *   channelId: 'C123456',
+     *   text: 'Hello team!'
+     * });
+     *
+     * // Linear
+     * const issues = await rainfall.integrations.linear.issues.list();
+     * ```
+     */
+    get integrations(): IntegrationsNamespace;
+    /**
+     * Memory namespace - Semantic memory storage and retrieval
+     *
+     * @example
+     * ```typescript
+     * // Store a memory
+     * await rainfall.memory.create({
+     *   content: 'User prefers dark mode',
+     *   keywords: ['preference', 'ui']
+     * });
+     *
+     * // Recall similar memories
+     * const memories = await rainfall.memory.recall({
+     *   query: 'user preferences',
+     *   topK: 5
+     * });
+     * ```
+     */
+    get memory(): Memory.MemoryClient;
+    /**
+     * Articles namespace - News aggregation and article management
+     *
+     * @example
+     * ```typescript
+     * // Search news
+     * const articles = await rainfall.articles.search({
+     *   query: 'artificial intelligence'
+     * });
+     *
+     * // Create from URL
+     * const article = await rainfall.articles.createFromUrl({
+     *   url: 'https://example.com/article'
+     * });
+     *
+     * // Summarize
+     * const summary = await rainfall.articles.summarize({
+     *   text: article.content
+     * });
+     * ```
+     */
+    get articles(): Articles.ArticlesClient;
+    /**
+     * Web namespace - Web search, scraping, and content extraction
+     *
+     * @example
+     * ```typescript
+     * // Search with Exa
+     * const results = await rainfall.web.search.exa({
+     *   query: 'latest AI research'
+     * });
+     *
+     * // Fetch and convert
+     * const html = await rainfall.web.fetch({ url: 'https://example.com' });
+     * const markdown = await rainfall.web.htmlToMarkdown({ html });
+     *
+     * // Extract specific elements
+     * const links = await rainfall.web.extractHtml({
+     *   html,
+     *   selector: 'a[href]'
+     * });
+     * ```
+     */
+    get web(): Web.WebClient;
+    /**
+     * AI namespace - Embeddings, image generation, OCR, vision, chat
+     *
+     * @example
+     * ```typescript
+     * // Generate embeddings
+     * const embedding = await rainfall.ai.embeddings.document({
+     *   text: 'Hello world'
+     * });
+     *
+     * // Generate image
+     * const image = await rainfall.ai.image.generate({
+     *   prompt: 'A serene mountain landscape'
+     * });
+     *
+     * // OCR
+     * const text = await rainfall.ai.ocr({ imageBase64: '...' });
+     *
+     * // Chat
+     * const response = await rainfall.ai.chat({
+     *   messages: [{ role: 'user', content: 'Hello!' }]
+     * });
+     * ```
+     */
+    get ai(): AI.AIClient;
+    /**
+     * Data namespace - CSV processing, scripts, similarity search
+     *
+     * @example
+     * ```typescript
+     * // Query CSV with SQL
+     * const results = await rainfall.data.csv.query({
+     *   sql: 'SELECT * FROM data WHERE value > 100'
+     * });
+     *
+     * // Execute saved script
+     * const result = await rainfall.data.scripts.execute({
+     *   name: 'my-script',
+     *   params: { input: 'data' }
+     * });
+     * ```
+     */
+    get data(): Data.DataClient;
+    /**
+     * Utils namespace - Mermaid diagrams, document conversion, regex, JSON extraction
+     *
+     * @example
+     * ```typescript
+     * // Generate diagram
+     * const diagram = await rainfall.utils.mermaid({
+     *   diagram: 'graph TD; A-->B;'
+     * });
+     *
+     * // Convert document
+     * const pdf = await rainfall.utils.documentConvert({
+     *   document: markdownContent,
+     *   mimeType: 'text/markdown',
+     *   format: 'pdf'
+     * });
+     *
+     * // Extract JSON from text
+     * const json = await rainfall.utils.jsonExtract({
+     *   text: 'Here is some data: {"key": "value"}'
+     * });
+     * ```
+     */
+    get utils(): Utils.UtilsClient;
+    /**
+     * Get the underlying HTTP client for advanced usage
+     */
+    getClient(): RainfallClient;
+    /**
+     * List all available tools
+     */
+    listTools(): Promise<{
+        id: string;
+        name: string;
+        description: string;
+        category: string;
+    }[]>;
+    /**
+     * Get schema for a specific tool
+     */
+    getToolSchema(toolId: string): Promise<ToolSchema>;
+    /**
+     * Execute any tool by ID (low-level access)
+     *
+     * @param toolId - The ID of the tool to execute
+     * @param params - Parameters to pass to the tool
+     * @param options - Execution options including skipValidation to bypass param validation
+     *
+     * @example
+     * ```typescript
+     * // Execute with validation (default)
+     * const result = await rainfall.executeTool('finviz-quotes', { tickers: ['AAPL'] });
+     *
+     * // Execute without validation
+     * const result = await rainfall.executeTool('finviz-quotes', { tickers: ['AAPL'] }, { skipValidation: true });
+     * ```
+     */
+    executeTool<T = unknown>(toolId: string, params?: Record<string, unknown>, options?: {
+        skipValidation?: boolean;
+        timeout?: number;
+        retries?: number;
+        retryDelay?: number;
+    }): Promise<T>;
+    /**
+     * Validate parameters for a tool without executing it
+     *
+     * @param toolId - The ID of the tool to validate params for
+     * @param params - Parameters to validate
+     * @returns Validation result with detailed error information
+     *
+     * @example
+     * ```typescript
+     * const result = await rainfall.validateToolParams('finviz-quotes', { tickers: ['AAPL'] });
+     * if (!result.valid) {
+     *   console.log('Validation errors:', result.errors);
+     * }
+     * ```
+     */
+    validateToolParams(toolId: string, params?: Record<string, unknown>): Promise<ValidationResult>;
+    /**
+     * Get current subscriber info and usage
+     */
+    getMe(): Promise<{
+        id: string;
+        name: string;
+        email?: string;
+        plan?: string;
+        billingStatus?: string;
+        usage: {
+            callsThisMonth: number;
+            callsLimit: number;
+        };
+    }>;
+    /**
+     * Get current rate limit info
+     */
+    getRateLimitInfo(): RateLimitInfo | undefined;
+    /**
+     * OpenAI-compatible chat completions with tool support
+     *
+     * @example
+     * ```typescript
+     * // Simple chat
+     * const response = await rainfall.chatCompletions({
+     *   subscriber_id: 'my-subscriber',
+     *   messages: [{ role: 'user', content: 'Hello!' }],
+     *   model: 'llama-3.3-70b-versatile'
+     * });
+     *
+     * // With tools
+     * const response = await rainfall.chatCompletions({
+     *   subscriber_id: 'my-subscriber',
+     *   messages: [{ role: 'user', content: 'Search for AI news' }],
+     *   tools: [{ type: 'function', function: { name: 'web-search' } }],
+     *   enable_stacked: true
+     * });
+     *
+     * // Streaming
+     * const stream = await rainfall.chatCompletions({
+     *   subscriber_id: 'my-subscriber',
+     *   messages: [{ role: 'user', content: 'Tell me a story' }],
+     *   stream: true
+     * });
+     * ```
+     */
+    chatCompletions(params: {
+        subscriber_id: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            name?: string;
+        }>;
+        model?: string;
+        stream?: boolean;
+        temperature?: number;
+        max_tokens?: number;
+        tools?: unknown[];
+        tool_choice?: string | {
+            type: string;
+            function?: {
+                name: string;
+            };
+        };
+        conversation_id?: string;
+        agent_name?: string;
+        incognito?: boolean;
+        tool_priority?: 'local' | 'rainfall' | 'serverside' | 'stacked';
+        enable_stacked?: boolean;
+    }): Promise<unknown>;
+    /**
+     * List available models (OpenAI-compatible format)
+     *
+     * @example
+     * ```typescript
+     * const models = await rainfall.listModels();
+     * console.log(models); // [{ id: 'llama-3.3-70b-versatile', ... }]
+     * ```
+     */
+    listModels(subscriberId?: string): Promise<Array<{
+        id: string;
+        [key: string]: unknown;
+    }>>;
+}
+
+export { AI as A, Data as D, Integrations as I, Memory as M, type ParamSchema as P, type RainfallConfig as R, type ToolSchema as T, Utils as U, type ValidationIssue as V, Web as W, Rainfall as a, type ApiError as b, type ApiResponse as c, Articles as d, type RateLimitInfo as e, type RequestOptions as f, type MCPClientConfig as g, MCPProxyHub as h, type MCPClientInfo as i, type MCPToolInfo as j, type MCPTransportType as k, RainfallClient as l, type ToolParamsSchema as m, type ValidationResult as n, clearSchemaCache as o, fetchToolSchema as p, formatValidationErrors as q, validateParams as v };