@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/sdk-DD1OeGRJ.d.mts

@@ -0,0 +1,871 @@
+/**
+ * Core types for the Rainfall SDK
+ */
+interface RainfallConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+}
+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 };