@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/sdk-Xw0BjsLd.d.ts

@@ -0,0 +1,1054 @@
+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>;
+    }
+}
+
+/**
+ * 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
+     */
+    executeTool<T = unknown>(toolId: string, params?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+    /**
+     * List all available tools
+     */
+    listTools(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        category: string;
+    }>>;
+    /**
+     * Get tool schema/parameters
+     */
+    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)
+     */
+    executeTool<T = unknown>(toolId: string, params?: Record<string, unknown>): Promise<T>;
+    /**
+     * 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, Rainfall as R, type ToolSchema as T, Utils as U, Web as W, type ApiError as a, type ApiResponse as b, Articles as c, RainfallClient as d, type RainfallConfig as e, type RateLimitInfo as f, type RequestOptions as g, type MCPClientConfig as h, MCPProxyHub as i };