@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/listeners-jLwetUnx.d.mts

@@ -0,0 +1,372 @@
+import { R as Rainfall } from './sdk-CN1ezZrI.mjs';
+
+/**
+ * Rainfall Networked Executor - Distributed job execution via Rainfall API
+ *
+ * This service enables multi-computer networked executions without direct Redis access.
+ * All communication goes through the authenticated Rainfall API.
+ */
+
+interface NodeCapabilities {
+    /** Can execute local commands/shell */
+    localExec?: boolean;
+    /** Can watch files for changes */
+    fileWatch?: boolean;
+    /** Can listen to passive events (webhooks, etc.) */
+    passiveListen?: boolean;
+    /** Can execute browser automation */
+    browser?: boolean;
+    /** Custom capability flags */
+    custom?: string[];
+}
+interface EdgeNodeRegistration {
+    edgeNodeId: string;
+    hostname: string;
+    capabilities: string[];
+    wsPort?: number;
+    httpPort?: number;
+    registeredAt: string;
+}
+interface QueuedJob {
+    jobId: string;
+    toolId: string;
+    params: Record<string, unknown>;
+    status: 'queued' | 'running' | 'completed' | 'failed';
+    executionMode: 'local-only' | 'distributed' | 'any';
+    requesterEdgeNodeId?: string;
+    executorEdgeNodeId?: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    result?: unknown;
+    error?: string;
+}
+interface NetworkedExecutorOptions {
+    /** WebSocket port for receiving push jobs */
+    wsPort?: number;
+    /** HTTP port for health checks */
+    httpPort?: number;
+    /** Edge node capabilities */
+    capabilities?: NodeCapabilities;
+    /** Hostname identifier */
+    hostname?: string;
+}
+declare class RainfallNetworkedExecutor {
+    private rainfall;
+    private options;
+    private edgeNodeId?;
+    private jobCallbacks;
+    private resultPollingInterval?;
+    constructor(rainfall: Rainfall, options?: NetworkedExecutorOptions);
+    /**
+     * Register this edge node with the Rainfall backend
+     */
+    registerEdgeNode(): Promise<string>;
+    /**
+     * Unregister this edge node on shutdown
+     */
+    unregisterEdgeNode(): Promise<void>;
+    /**
+     * Queue a tool execution for distributed processing
+     * Non-blocking - returns immediately with a job ID
+     */
+    queueToolExecution(toolId: string, params: Record<string, unknown>, options?: {
+        executionMode?: 'local-only' | 'distributed' | 'any';
+        callback?: (result: unknown, error?: string) => void;
+    }): Promise<string>;
+    /**
+     * Get status of a queued job
+     */
+    getJobStatus(jobId: string): Promise<QueuedJob | null>;
+    /**
+     * Subscribe to job results via polling (WebSocket fallback)
+     * In the future, this will use WebSocket push from ApresMoi
+     */
+    subscribeToResults(callback: (jobId: string, result: unknown, error?: string) => void): Promise<void>;
+    private onResultReceived?;
+    /**
+     * Start polling for job results (fallback until WebSocket push is ready)
+     */
+    private startResultPolling;
+    /**
+     * Claim a job for execution on this edge node
+     */
+    claimJob(): Promise<QueuedJob | null>;
+    /**
+     * Submit job result after execution
+     */
+    submitJobResult(jobId: string, result: unknown, error?: string): Promise<void>;
+    /**
+     * Get this edge node's ID
+     */
+    getEdgeNodeId(): string | undefined;
+    /**
+     * Build capabilities list from options
+     */
+    private buildCapabilitiesList;
+}
+
+/**
+ * Rainfall Daemon Context - Persistent memory and session state
+ *
+ * Provides:
+ * - Persistent memory storage (local + cloud sync)
+ * - Session context for ongoing conversations/workflows
+ * - Tool execution history
+ * - Local state management
+ */
+
+interface MemoryEntry {
+    id: string;
+    content: string;
+    keywords: string[];
+    timestamp: string;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SessionContext {
+    id: string;
+    startedAt: string;
+    lastActivity: string;
+    variables: Record<string, unknown>;
+    messageHistory: Array<{
+        role: 'user' | 'assistant' | 'system' | 'tool';
+        content: string;
+        timestamp: string;
+    }>;
+}
+interface ToolExecutionRecord {
+    id: string;
+    toolId: string;
+    params: Record<string, unknown>;
+    result: unknown;
+    error?: string;
+    timestamp: string;
+    duration: number;
+    edgeNodeId?: string;
+}
+interface ContextOptions {
+    /** Maximum number of memories to cache locally */
+    maxLocalMemories?: number;
+    /** Maximum message history per session */
+    maxMessageHistory?: number;
+    /** Maximum execution history to keep */
+    maxExecutionHistory?: number;
+    /** Session TTL in milliseconds */
+    sessionTtl?: number;
+}
+declare class RainfallDaemonContext {
+    private rainfall;
+    private options;
+    private localMemories;
+    private sessions;
+    private executionHistory;
+    private currentSessionId?;
+    constructor(rainfall: Rainfall, options?: ContextOptions);
+    /**
+     * Initialize the context - load recent memories from cloud
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create or get a session
+     */
+    getSession(sessionId?: string): SessionContext;
+    /**
+     * Get the current active session
+     */
+    getCurrentSession(): SessionContext | undefined;
+    /**
+     * Set the current active session
+     */
+    setCurrentSession(sessionId: string): void;
+    /**
+     * Add a message to the current session history
+     */
+    addMessage(role: 'user' | 'assistant' | 'system' | 'tool', content: string): void;
+    /**
+     * Store a memory (local + cloud sync)
+     */
+    storeMemory(content: string, options?: {
+        keywords?: string[];
+        source?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<string>;
+    /**
+     * Recall memories by query
+     */
+    recallMemories(query: string, topK?: number): Promise<MemoryEntry[]>;
+    /**
+     * Set a session variable
+     */
+    setVariable(key: string, value: unknown): void;
+    /**
+     * Get a session variable
+     */
+    getVariable<T = unknown>(key: string): T | undefined;
+    /**
+     * Record a tool execution
+     */
+    recordExecution(toolId: string, params: Record<string, unknown>, result: unknown, options?: {
+        error?: string;
+        duration: number;
+        edgeNodeId?: string;
+    }): void;
+    /**
+     * Get recent execution history
+     */
+    getExecutionHistory(limit?: number): ToolExecutionRecord[];
+    /**
+     * Get execution statistics
+     */
+    getExecutionStats(): {
+        total: number;
+        successful: number;
+        failed: number;
+        averageDuration: number;
+        byTool: Record<string, number>;
+    };
+    /**
+     * Clear old sessions based on TTL
+     */
+    cleanupSessions(): void;
+    /**
+     * Get context summary for debugging
+     */
+    getStatus(): {
+        memoriesCached: number;
+        activeSessions: number;
+        currentSession?: string;
+        executionHistorySize: number;
+    };
+    private trimLocalMemories;
+}
+
+/**
+ * Rainfall Daemon Passive Listeners - File watchers, cron triggers, etc.
+ *
+ * Provides:
+ * - File system watchers for triggering workflows
+ * - Cron-style scheduled triggers
+ * - Webhook listeners (future)
+ * - Event bus for inter-node communication
+ */
+
+interface FileWatcherConfig {
+    id: string;
+    name: string;
+    watchPath: string;
+    pattern?: string;
+    events: ('create' | 'modify' | 'delete')[];
+    workflow: {
+        toolId: string;
+        params: Record<string, unknown>;
+    }[];
+    options?: {
+        recursive?: boolean;
+        ignoreInitial?: boolean;
+        debounceMs?: number;
+    };
+}
+interface CronTriggerConfig {
+    id: string;
+    name: string;
+    cron: string;
+    timezone?: string;
+    workflow: {
+        toolId: string;
+        params: Record<string, unknown>;
+    }[];
+}
+interface ListenerEvent {
+    id: string;
+    type: 'file' | 'cron' | 'webhook' | 'manual';
+    source: string;
+    timestamp: string;
+    data: Record<string, unknown>;
+}
+interface ListenerRegistry {
+    fileWatchers: FileWatcherConfig[];
+    cronTriggers: CronTriggerConfig[];
+}
+declare class RainfallListenerRegistry {
+    private rainfall;
+    private context;
+    private executor;
+    private watchers;
+    private cronIntervals;
+    private eventHistory;
+    private maxEventHistory;
+    constructor(rainfall: Rainfall, context: RainfallDaemonContext, executor: RainfallNetworkedExecutor);
+    /**
+     * Register a file watcher
+     * Note: Actual file watching requires fs.watch or chokidar
+     * This is the registry - actual watching is done by the daemon
+     */
+    registerFileWatcher(config: FileWatcherConfig): Promise<void>;
+    /**
+     * Unregister a file watcher
+     */
+    unregisterFileWatcher(id: string): Promise<void>;
+    /**
+     * Register a cron trigger
+     */
+    registerCronTrigger(config: CronTriggerConfig): Promise<void>;
+    /**
+     * Unregister a cron trigger
+     */
+    unregisterCronTrigger(id: string): void;
+    /**
+     * Handle a file event
+     */
+    handleFileEvent(watcherId: string, eventType: 'create' | 'modify' | 'delete', filePath: string): Promise<void>;
+    /**
+     * Handle a cron tick
+     */
+    private handleCronTick;
+    /**
+     * Trigger a manual event (for testing or programmatic triggers)
+     */
+    triggerManual(name: string, data?: Record<string, unknown>): Promise<void>;
+    /**
+     * Get recent events
+     */
+    getRecentEvents(limit?: number): ListenerEvent[];
+    /**
+     * Get active listeners status
+     */
+    getStatus(): {
+        fileWatchers: number;
+        cronTriggers: number;
+        recentEvents: number;
+    };
+    /**
+     * Stop all listeners
+     */
+    stopAll(): Promise<void>;
+    private recordEvent;
+    /**
+     * Simple cron parser - converts basic cron expressions to milliseconds
+     * Supports: @hourly, @daily, @weekly, and simple intervals like every N minutes
+     */
+    private parseCronToMs;
+}
+/**
+ * Create a file watcher workflow helper
+ */
+declare function createFileWatcherWorkflow(name: string, watchPath: string, options: {
+    pattern?: string;
+    events?: ('create' | 'modify' | 'delete')[];
+    workflow: {
+        toolId: string;
+        params: Record<string, unknown>;
+    }[];
+}): FileWatcherConfig;
+/**
+ * Create a cron trigger workflow helper
+ */
+declare function createCronWorkflow(name: string, cron: string, workflow: {
+    toolId: string;
+    params: Record<string, unknown>;
+}[]): CronTriggerConfig;
+
+export { type ContextOptions as C, type EdgeNodeRegistration as E, type FileWatcherConfig as F, type ListenerEvent as L, type MemoryEntry as M, type NetworkedExecutorOptions as N, type QueuedJob as Q, RainfallDaemonContext as R, type SessionContext as S, type ToolExecutionRecord as T, type CronTriggerConfig as a, type ListenerRegistry as b, type NodeCapabilities as c, RainfallListenerRegistry as d, RainfallNetworkedExecutor as e, createCronWorkflow as f, createFileWatcherWorkflow as g };

package/dist/mcp.d.mts

@@ -1,5 +1,10 @@
-import { g as RainfallConfig, R as Rainfall } from './errors-COkXMRZk.mjs';
-export { A as AI, a as ApiError, b as ApiResponse, c as Articles, d as AuthenticationError, D as Data, I as Integrations, M as Memory, N as NetworkError, e as NotFoundError, h as RainfallError, i as RateLimitError, j as RateLimitInfo, k as RequestOptions, S as ServerError, T as TimeoutError, l as ToolNotFoundError, m as ToolSchema, U as Utils, V as ValidationError, W as Web, p as parseErrorResponse } from './errors-COkXMRZk.mjs';
+import { R as RainfallConfig, a as Rainfall } from './sdk-4OvXPr8E.mjs';
+export { A as AI, b as ApiError, c as ApiResponse, d as Articles, D as Data, I as Integrations, M as Memory, e as RateLimitInfo, f as RequestOptions, T as ToolSchema, U as Utils, W as Web } from './sdk-4OvXPr8E.mjs';
+export { A as AuthenticationError, N as NetworkError, a as NotFoundError, R as RainfallError, b as RateLimitError, S as ServerError, T as TimeoutError, c as ToolNotFoundError, V as ValidationError, p as parseErrorResponse } from './errors-BMPseAnM.mjs';
+import 'ws';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/client/streamableHttp.js';
 
 /**
  * MCP (Model Context Protocol) server export for Rainfall SDK

package/dist/mcp.d.ts

@@ -1,5 +1,10 @@
-import { g as RainfallConfig, R as Rainfall } from './errors-COkXMRZk.js';
-export { A as AI, a as ApiError, b as ApiResponse, c as Articles, d as AuthenticationError, D as Data, I as Integrations, M as Memory, N as NetworkError, e as NotFoundError, h as RainfallError, i as RateLimitError, j as RateLimitInfo, k as RequestOptions, S as ServerError, T as TimeoutError, l as ToolNotFoundError, m as ToolSchema, U as Utils, V as ValidationError, W as Web, p as parseErrorResponse } from './errors-COkXMRZk.js';
+import { R as RainfallConfig, a as Rainfall } from './sdk-4OvXPr8E.js';
+export { A as AI, b as ApiError, c as ApiResponse, d as Articles, D as Data, I as Integrations, M as Memory, e as RateLimitInfo, f as RequestOptions, T as ToolSchema, U as Utils, W as Web } from './sdk-4OvXPr8E.js';
+export { A as AuthenticationError, N as NetworkError, a as NotFoundError, R as RainfallError, b as RateLimitError, S as ServerError, T as TimeoutError, c as ToolNotFoundError, V as ValidationError, p as parseErrorResponse } from './errors-BMPseAnM.js';
+import 'ws';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/client/streamableHttp.js';
 
 /**
  * MCP (Model Context Protocol) server export for Rainfall SDK

package/dist/mcp.js

@@ -348,6 +348,49 @@ var RainfallClient = class {
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
+  /**
+   * OpenAI-compatible chat completions with tool support
+   */
+  async chatCompletions(params) {
+    const { subscriber_id, ...body } = params;
+    if (body.stream) {
+      const url = `${this.baseUrl}/olympic/subscribers/${subscriber_id}/v1/chat/completions`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "x-api-key": this.apiKey,
+          "Content-Type": "application/json",
+          "Accept": "text/event-stream"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new RainfallError(`Chat completions failed: ${error}`, "CHAT_ERROR");
+      }
+      if (!response.body) {
+        throw new RainfallError("No response body", "CHAT_ERROR");
+      }
+      return response.body;
+    }
+    return this.request(
+      `/olympic/subscribers/${subscriber_id}/v1/chat/completions`,
+      {
+        method: "POST",
+        body
+      }
+    );
+  }
+  /**
+   * List available models (OpenAI-compatible format)
+   */
+  async listModels(subscriberId) {
+    const sid = subscriberId || this.subscriberId || await this.ensureSubscriberId();
+    const result = await this.request(
+      `/olympic/subscribers/${sid}/v1/models`
+    );
+    return result.data || [];
+  }
 };
 
 // src/namespaces/integrations.ts
@@ -517,7 +560,12 @@ function createAI(client) {
     chat: (params) => client.executeTool("xai-chat-completions", params),
     complete: (params) => client.executeTool("fim", params),
     classify: (params) => client.executeTool("jina-document-classifier", params),
-    segment: (params) => client.executeTool("jina-text-segmenter", params)
+    segment: (params) => client.executeTool("jina-text-segmenter", params),
+    /**
+     * OpenAI-compatible chat completions with full tool support
+     * This is the recommended method for multi-turn conversations with tools
+     */
+    chatCompletions: (params) => client.chatCompletions(params)
   };
 }
 
@@ -797,6 +845,49 @@ var Rainfall = class {
   getRateLimitInfo() {
     return this.client.getRateLimitInfo();
   }
+  /**
+   * 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
+   * });
+   * ```
+   */
+  async chatCompletions(params) {
+    return this.client.chatCompletions(params);
+  }
+  /**
+   * List available models (OpenAI-compatible format)
+   * 
+   * @example
+   * ```typescript
+   * const models = await rainfall.listModels();
+   * console.log(models); // [{ id: 'llama-3.3-70b-versatile', ... }]
+   * ```
+   */
+  async listModels(subscriberId) {
+    return this.client.listModels(subscriberId);
+  }
 };
 
 // src/mcp.ts

package/dist/mcp.mjs

@@ -10,7 +10,7 @@ import {
   ToolNotFoundError,
   ValidationError,
   parseErrorResponse
-} from "./chunk-RA3HDYF4.mjs";
+} from "./chunk-VDPKDC3R.mjs";
 
 // src/mcp.ts
 function createRainfallMCPServer(config) {