@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/daemon/index.mjs

@@ -0,0 +1,1548 @@
+import {
+  RainfallDaemonContext,
+  RainfallListenerRegistry,
+  RainfallNetworkedExecutor
+} from "../chunk-7MRE4ZVI.mjs";
+import {
+  Rainfall
+} from "../chunk-VDPKDC3R.mjs";
+
+// src/daemon/index.ts
+import { WebSocketServer } from "ws";
+import express from "express";
+
+// src/services/mcp-proxy.ts
+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";
+import {
+  ListToolsResultSchema,
+  CallToolResultSchema,
+  ListResourcesResultSchema,
+  ReadResourceResultSchema,
+  ListPromptsResultSchema,
+  GetPromptResultSchema,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+var MCPProxyHub = class {
+  clients = /* @__PURE__ */ new Map();
+  options;
+  refreshTimer;
+  reconnectTimeouts = /* @__PURE__ */ new Map();
+  requestId = 0;
+  constructor(options = {}) {
+    this.options = {
+      debug: options.debug ?? false,
+      autoReconnect: options.autoReconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 5e3,
+      toolTimeout: options.toolTimeout ?? 3e4,
+      refreshInterval: options.refreshInterval ?? 3e4
+    };
+  }
+  /**
+   * Initialize the MCP proxy hub
+   */
+  async initialize() {
+    this.log("\u{1F50C} Initializing MCP Proxy Hub...");
+    this.startRefreshTimer();
+    this.log("\u2705 MCP Proxy Hub initialized");
+  }
+  /**
+   * Shutdown the MCP proxy hub and disconnect all clients
+   */
+  async shutdown() {
+    this.log("\u{1F6D1} Shutting down MCP Proxy Hub...");
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = void 0;
+    }
+    for (const timeout of this.reconnectTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.reconnectTimeouts.clear();
+    const disconnectPromises = Array.from(this.clients.entries()).map(
+      async ([name, client]) => {
+        try {
+          await this.disconnectClient(name);
+        } catch (error) {
+          this.log(`Error disconnecting ${name}:`, error);
+        }
+      }
+    );
+    await Promise.allSettled(disconnectPromises);
+    this.clients.clear();
+    this.log("\u{1F44B} MCP Proxy Hub shut down");
+  }
+  /**
+   * Connect to an MCP server
+   */
+  async connectClient(config) {
+    const { name, transport } = config;
+    if (this.clients.has(name)) {
+      this.log(`Reconnecting client: ${name}`);
+      await this.disconnectClient(name);
+    }
+    this.log(`Connecting to MCP server: ${name} (${transport})...`);
+    try {
+      const client = new Client(
+        {
+          name: `rainfall-daemon-${name}`,
+          version: "0.2.0"
+        },
+        {
+          capabilities: {}
+        }
+      );
+      let lastErrorTime = 0;
+      client.onerror = (error) => {
+        const now = Date.now();
+        if (now - lastErrorTime > 5e3) {
+          this.log(`MCP Server Error (${name}):`, error.message);
+          lastErrorTime = now;
+        }
+        if (this.options.autoReconnect) {
+          this.scheduleReconnect(name, config);
+        }
+      };
+      let transportInstance;
+      if (transport === "stdio" && config.command) {
+        const env = {};
+        for (const [key, value] of Object.entries({ ...process.env, ...config.env })) {
+          if (value !== void 0) {
+            env[key] = value;
+          }
+        }
+        transportInstance = new StdioClientTransport({
+          command: config.command,
+          args: config.args,
+          env
+        });
+      } else if (transport === "http" && config.url) {
+        transportInstance = new StreamableHTTPClientTransport(
+          new URL(config.url),
+          {
+            requestInit: {
+              headers: config.headers
+            }
+          }
+        );
+      } else if (transport === "websocket" && config.url) {
+        transportInstance = new WebSocket(config.url);
+        await new Promise((resolve, reject) => {
+          transportInstance.on("open", () => resolve());
+          transportInstance.on("error", reject);
+          setTimeout(() => reject(new Error("WebSocket connection timeout")), 1e4);
+        });
+      } else {
+        throw new Error(`Invalid transport configuration for ${name}`);
+      }
+      await client.connect(transportInstance);
+      const toolsResult = await client.request(
+        {
+          method: "tools/list",
+          params: {}
+        },
+        ListToolsResultSchema
+      );
+      const tools = toolsResult.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description || "",
+        inputSchema: tool.inputSchema,
+        serverName: name
+      }));
+      const clientInfo = {
+        name,
+        client,
+        transport: transportInstance,
+        transportType: transport,
+        tools,
+        connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString(),
+        config,
+        status: "connected"
+      };
+      this.clients.set(name, clientInfo);
+      this.log(`\u2705 Connected to ${name} (${tools.length} tools)`);
+      this.printAvailableTools(name, tools);
+      return name;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log(`\u274C Failed to connect to ${name}:`, errorMessage);
+      if (this.options.autoReconnect) {
+        this.scheduleReconnect(name, config);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect a specific MCP client
+   */
+  async disconnectClient(name) {
+    const client = this.clients.get(name);
+    if (!client) return;
+    const timeout = this.reconnectTimeouts.get(name);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.reconnectTimeouts.delete(name);
+    }
+    try {
+      await client.client.close();
+      if ("close" in client.transport && typeof client.transport.close === "function") {
+        await client.transport.close();
+      }
+    } catch (error) {
+      this.log(`Error closing client ${name}:`, error);
+    }
+    this.clients.delete(name);
+    this.log(`Disconnected from ${name}`);
+  }
+  /**
+   * Schedule a reconnection attempt
+   */
+  scheduleReconnect(name, config) {
+    if (this.reconnectTimeouts.has(name)) return;
+    const timeout = setTimeout(async () => {
+      this.reconnectTimeouts.delete(name);
+      this.log(`Attempting to reconnect to ${name}...`);
+      try {
+        await this.connectClient(config);
+      } catch (error) {
+        this.log(`Reconnection failed for ${name}`);
+      }
+    }, this.options.reconnectDelay);
+    this.reconnectTimeouts.set(name, timeout);
+  }
+  /**
+   * Call a tool on the appropriate MCP client
+   */
+  async callTool(toolName, args, options = {}) {
+    const timeout = options.timeout ?? this.options.toolTimeout;
+    let clientInfo;
+    let actualToolName = toolName;
+    if (options.namespace) {
+      clientInfo = this.clients.get(options.namespace);
+      if (!clientInfo) {
+        throw new Error(`Namespace '${options.namespace}' not found`);
+      }
+      const prefix = `${options.namespace}-`;
+      if (actualToolName.startsWith(prefix)) {
+        actualToolName = actualToolName.slice(prefix.length);
+      }
+      if (!clientInfo.tools.some((t) => t.name === actualToolName)) {
+        throw new Error(`Tool '${actualToolName}' not found in namespace '${options.namespace}'`);
+      }
+    } else {
+      for (const [, info] of this.clients) {
+        const tool = info.tools.find((t) => t.name === toolName);
+        if (tool) {
+          clientInfo = info;
+          break;
+        }
+      }
+    }
+    if (!clientInfo) {
+      throw new Error(`Tool '${toolName}' not found on any connected MCP server`);
+    }
+    const requestId = `req_${++this.requestId}`;
+    clientInfo.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      this.log(`[${requestId}] Calling '${actualToolName}' on '${clientInfo.name}'`);
+      const result = await Promise.race([
+        clientInfo.client.request(
+          {
+            method: "tools/call",
+            params: {
+              name: actualToolName,
+              arguments: args
+            }
+          },
+          CallToolResultSchema
+        ),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Tool call timeout after ${timeout}ms`)), timeout)
+        )
+      ]);
+      this.log(`[${requestId}] Completed successfully`);
+      return this.formatToolResult(result);
+    } catch (error) {
+      this.log(`[${requestId}] Failed:`, error instanceof Error ? error.message : error);
+      if (error instanceof McpError) {
+        throw new Error(`MCP Error (${toolName}): ${error.message} (code: ${error.code})`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Format MCP tool result for consistent output
+   */
+  formatToolResult(result) {
+    if (!result || !result.content) {
+      return "";
+    }
+    return result.content.map((item) => {
+      if (item.type === "text") {
+        return item.text || "";
+      } else if (item.type === "resource") {
+        return `[Resource: ${item.resource?.uri || "unknown"}]`;
+      } else if (item.type === "image") {
+        return `[Image: ${item.mimeType || "unknown"}]`;
+      } else if (item.type === "audio") {
+        return `[Audio: ${item.mimeType || "unknown"}]`;
+      } else {
+        return JSON.stringify(item);
+      }
+    }).join("\n");
+  }
+  /**
+   * Get all tools from all connected MCP clients
+   * Optionally with namespace prefix
+   */
+  getAllTools(options = {}) {
+    const allTools = [];
+    for (const [clientName, client] of this.clients) {
+      for (const tool of client.tools) {
+        if (options.namespacePrefix) {
+          allTools.push({
+            ...tool,
+            name: `${clientName}-${tool.name}`
+          });
+        } else {
+          allTools.push(tool);
+        }
+      }
+    }
+    return allTools;
+  }
+  /**
+   * Get tools from a specific client
+   */
+  getClientTools(clientName) {
+    const client = this.clients.get(clientName);
+    return client?.tools || [];
+  }
+  /**
+   * Get list of connected MCP clients
+   */
+  listClients() {
+    return Array.from(this.clients.entries()).map(([name, info]) => ({
+      name,
+      status: info.status,
+      toolCount: info.tools.length,
+      connectedAt: info.connectedAt,
+      lastUsed: info.lastUsed,
+      transportType: info.transportType
+    }));
+  }
+  /**
+   * Get client info by name
+   */
+  getClient(name) {
+    return this.clients.get(name);
+  }
+  /**
+   * Refresh tool lists from all connected clients
+   */
+  async refreshTools() {
+    for (const [name, client] of this.clients) {
+      try {
+        const toolsResult = await client.client.request(
+          {
+            method: "tools/list",
+            params: {}
+          },
+          ListToolsResultSchema
+        );
+        client.tools = toolsResult.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description || "",
+          inputSchema: tool.inputSchema,
+          serverName: name
+        }));
+        this.log(`Refreshed ${name}: ${client.tools.length} tools`);
+      } catch (error) {
+        this.log(`Failed to refresh tools for ${name}:`, error);
+        client.status = "error";
+        client.error = error instanceof Error ? error.message : String(error);
+      }
+    }
+  }
+  /**
+   * List resources from a specific client or all clients
+   */
+  async listResources(clientName) {
+    const results = [];
+    const clients = clientName ? [clientName] : Array.from(this.clients.keys());
+    for (const name of clients) {
+      const client = this.clients.get(name);
+      if (!client) continue;
+      try {
+        const result = await client.client.request(
+          {
+            method: "resources/list",
+            params: {}
+          },
+          ListResourcesResultSchema
+        );
+        results.push({
+          clientName: name,
+          resources: result.resources
+        });
+      } catch (error) {
+        this.log(`Failed to list resources for ${name}:`, error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Read a resource from a specific client
+   */
+  async readResource(uri, clientName) {
+    if (clientName) {
+      const client = this.clients.get(clientName);
+      if (!client) {
+        throw new Error(`Client '${clientName}' not found`);
+      }
+      const result = await client.client.request(
+        {
+          method: "resources/read",
+          params: { uri }
+        },
+        ReadResourceResultSchema
+      );
+      return result;
+    } else {
+      for (const [name, client] of this.clients) {
+        try {
+          const result = await client.client.request(
+            {
+              method: "resources/read",
+              params: { uri }
+            },
+            ReadResourceResultSchema
+          );
+          return { clientName: name, ...result };
+        } catch {
+        }
+      }
+      throw new Error(`Resource '${uri}' not found on any client`);
+    }
+  }
+  /**
+   * List prompts from a specific client or all clients
+   */
+  async listPrompts(clientName) {
+    const results = [];
+    const clients = clientName ? [clientName] : Array.from(this.clients.keys());
+    for (const name of clients) {
+      const client = this.clients.get(name);
+      if (!client) continue;
+      try {
+        const result = await client.client.request(
+          {
+            method: "prompts/list",
+            params: {}
+          },
+          ListPromptsResultSchema
+        );
+        results.push({
+          clientName: name,
+          prompts: result.prompts
+        });
+      } catch (error) {
+        this.log(`Failed to list prompts for ${name}:`, error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get a prompt from a specific client
+   */
+  async getPrompt(name, args, clientName) {
+    if (clientName) {
+      const client = this.clients.get(clientName);
+      if (!client) {
+        throw new Error(`Client '${clientName}' not found`);
+      }
+      const result = await client.client.request(
+        {
+          method: "prompts/get",
+          params: { name, arguments: args }
+        },
+        GetPromptResultSchema
+      );
+      return result;
+    } else {
+      for (const [cName, client] of this.clients) {
+        try {
+          const result = await client.client.request(
+            {
+              method: "prompts/get",
+              params: { name, arguments: args }
+            },
+            GetPromptResultSchema
+          );
+          return { clientName: cName, ...result };
+        } catch {
+        }
+      }
+      throw new Error(`Prompt '${name}' not found on any client`);
+    }
+  }
+  /**
+   * Health check for all connected clients
+   */
+  async healthCheck() {
+    const results = /* @__PURE__ */ new Map();
+    for (const [name, client] of this.clients) {
+      try {
+        const startTime = Date.now();
+        await client.client.request(
+          {
+            method: "tools/list",
+            params: {}
+          },
+          ListToolsResultSchema
+        );
+        results.set(name, {
+          status: "healthy",
+          responseTime: Date.now() - startTime
+        });
+      } catch (error) {
+        results.set(name, {
+          status: "unhealthy",
+          responseTime: 0,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        if (this.options.autoReconnect) {
+          this.scheduleReconnect(name, client.config);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Start the automatic refresh timer
+   */
+  startRefreshTimer() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+    }
+    if (this.options.refreshInterval > 0) {
+      this.refreshTimer = setInterval(async () => {
+        try {
+          await this.refreshTools();
+        } catch (error) {
+          this.log("Auto-refresh failed:", error);
+        }
+      }, this.options.refreshInterval);
+    }
+  }
+  /**
+   * Print available tools for a client
+   */
+  printAvailableTools(clientName, tools) {
+    if (tools.length === 0) {
+      this.log(`  No tools available from ${clientName}`);
+      return;
+    }
+    this.log(`
+  --- ${clientName} Tools (${tools.length}) ---`);
+    for (const tool of tools) {
+      this.log(`    \u2022 ${tool.name}: ${tool.description.slice(0, 60)}${tool.description.length > 60 ? "..." : ""}`);
+    }
+  }
+  /**
+   * Debug logging
+   */
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[MCP-Proxy]", ...args);
+    }
+  }
+  /**
+   * Get statistics about the MCP proxy hub
+   */
+  getStats() {
+    const clients = Array.from(this.clients.entries()).map(([name, info]) => ({
+      name,
+      toolCount: info.tools.length,
+      status: info.status,
+      transportType: info.transportType
+    }));
+    return {
+      totalClients: this.clients.size,
+      totalTools: clients.reduce((sum, c) => sum + c.toolCount, 0),
+      clients
+    };
+  }
+};
+
+// src/daemon/index.ts
+var RainfallDaemon = class {
+  wss;
+  openaiApp;
+  rainfall;
+  port;
+  openaiPort;
+  rainfallConfig;
+  tools = [];
+  toolSchemas = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Set();
+  debug;
+  // New services
+  networkedExecutor;
+  context;
+  listeners;
+  mcpProxy;
+  enableMcpProxy;
+  mcpNamespacePrefix;
+  constructor(config = {}) {
+    this.port = config.port || 8765;
+    this.openaiPort = config.openaiPort || 8787;
+    this.rainfallConfig = config.rainfallConfig;
+    this.debug = config.debug || false;
+    this.enableMcpProxy = config.enableMcpProxy ?? true;
+    this.mcpNamespacePrefix = config.mcpNamespacePrefix ?? true;
+    this.openaiApp = express();
+    this.openaiApp.use(express.json());
+  }
+  async start() {
+    this.log("\u{1F327}\uFE0F  Rainfall Daemon starting...");
+    await this.initializeRainfall();
+    if (!this.rainfall) {
+      throw new Error("Failed to initialize Rainfall SDK");
+    }
+    this.context = new RainfallDaemonContext(this.rainfall, {
+      maxLocalMemories: 1e3,
+      maxMessageHistory: 100,
+      ...this.rainfallConfig
+    });
+    await this.context.initialize();
+    this.networkedExecutor = new RainfallNetworkedExecutor(this.rainfall, {
+      wsPort: this.port,
+      httpPort: this.openaiPort,
+      hostname: process.env.HOSTNAME || "local-daemon",
+      capabilities: {
+        localExec: true,
+        fileWatch: true,
+        passiveListen: true
+      }
+    });
+    await this.networkedExecutor.registerEdgeNode();
+    await this.networkedExecutor.subscribeToResults((jobId, result, error) => {
+      this.log(`\u{1F4EC} Job ${jobId} ${error ? "failed" : "completed"}`, error || result);
+    });
+    this.listeners = new RainfallListenerRegistry(
+      this.rainfall,
+      this.context,
+      this.networkedExecutor
+    );
+    await this.loadTools();
+    if (this.enableMcpProxy) {
+      this.mcpProxy = new MCPProxyHub({ debug: this.debug });
+      await this.mcpProxy.initialize();
+      if (this.rainfallConfig?.mcpClients) {
+        for (const clientConfig of this.rainfallConfig.mcpClients) {
+          try {
+            await this.mcpProxy.connectClient(clientConfig);
+          } catch (error) {
+            this.log(`Failed to connect MCP client ${clientConfig.name}:`, error);
+          }
+        }
+      }
+    }
+    await this.startWebSocketServer();
+    await this.startOpenAIProxy();
+    console.log(`\u{1F680} Rainfall daemon running`);
+    console.log(`   WebSocket (MCP):     ws://localhost:${this.port}`);
+    console.log(`   OpenAI API:          http://localhost:${this.openaiPort}/v1/chat/completions`);
+    console.log(`   Health Check:        http://localhost:${this.openaiPort}/health`);
+    console.log(`   Edge Node ID:        ${this.networkedExecutor.getEdgeNodeId() || "local"}`);
+    console.log(`   Tools loaded:        ${this.tools.length}`);
+    console.log(`   Press Ctrl+C to stop`);
+    process.on("SIGINT", () => this.stop());
+    process.on("SIGTERM", () => this.stop());
+  }
+  async stop() {
+    this.log("\u{1F6D1} Shutting down Rainfall daemon...");
+    if (this.listeners) {
+      await this.listeners.stopAll();
+    }
+    if (this.networkedExecutor) {
+      await this.networkedExecutor.unregisterEdgeNode();
+    }
+    if (this.mcpProxy) {
+      await this.mcpProxy.shutdown();
+      this.mcpProxy = void 0;
+    }
+    for (const client of this.clients) {
+      client.close();
+    }
+    this.clients.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = void 0;
+    }
+    console.log("\u{1F44B} Rainfall daemon stopped");
+  }
+  /**
+   * Get the networked executor for distributed job management
+   */
+  getNetworkedExecutor() {
+    return this.networkedExecutor;
+  }
+  /**
+   * Get the context for memory/session management
+   */
+  getContext() {
+    return this.context;
+  }
+  /**
+   * Get the listener registry for passive triggers
+   */
+  getListenerRegistry() {
+    return this.listeners;
+  }
+  /**
+   * Get the MCP Proxy Hub for managing external MCP clients
+   */
+  getMCPProxy() {
+    return this.mcpProxy;
+  }
+  /**
+   * Connect an MCP client dynamically
+   */
+  async connectMCPClient(config) {
+    if (!this.mcpProxy) {
+      throw new Error("MCP Proxy Hub is not enabled");
+    }
+    return this.mcpProxy.connectClient(config);
+  }
+  /**
+   * Disconnect an MCP client
+   */
+  async disconnectMCPClient(name) {
+    if (!this.mcpProxy) {
+      throw new Error("MCP Proxy Hub is not enabled");
+    }
+    return this.mcpProxy.disconnectClient(name);
+  }
+  async initializeRainfall() {
+    if (this.rainfallConfig?.apiKey) {
+      this.rainfall = new Rainfall(this.rainfallConfig);
+    } else {
+      const { loadConfig } = await import("../config-7UT7GYSN.mjs");
+      const config = loadConfig();
+      if (config.apiKey) {
+        this.rainfall = new Rainfall({
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl
+        });
+      } else {
+        throw new Error("No API key configured. Run: rainfall auth login <api-key>");
+      }
+    }
+  }
+  async loadTools() {
+    if (!this.rainfall) return;
+    try {
+      this.tools = await this.rainfall.listTools();
+      this.log(`\u{1F4E6} Loaded ${this.tools.length} tools`);
+    } catch (error) {
+      console.warn("\u26A0\uFE0F  Failed to load tools:", error instanceof Error ? error.message : error);
+      this.tools = [];
+    }
+  }
+  async getToolSchema(toolId) {
+    if (this.toolSchemas.has(toolId)) {
+      return this.toolSchemas.get(toolId);
+    }
+    if (!this.rainfall) return null;
+    try {
+      const schema = await this.rainfall.getToolSchema(toolId);
+      this.toolSchemas.set(toolId, schema);
+      return schema;
+    } catch {
+      return null;
+    }
+  }
+  async startWebSocketServer() {
+    this.wss = new WebSocketServer({ port: this.port });
+    this.wss.on("connection", (ws) => {
+      this.log("\u{1F7E2} MCP client connected");
+      this.clients.add(ws);
+      ws.on("message", async (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          const response = await this.handleMCPMessage(message);
+          ws.send(JSON.stringify(response));
+        } catch (error) {
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: void 0,
+            error: {
+              code: -32700,
+              message: error instanceof Error ? error.message : "Parse error"
+            }
+          };
+          ws.send(JSON.stringify(errorResponse));
+        }
+      });
+      ws.on("close", () => {
+        this.log("\u{1F534} MCP client disconnected");
+        this.clients.delete(ws);
+      });
+      ws.on("error", (error) => {
+        console.error("WebSocket error:", error);
+        this.clients.delete(ws);
+      });
+    });
+  }
+  async handleMCPMessage(message) {
+    const { id, method, params } = message;
+    switch (method) {
+      case "initialize":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: { listChanged: true }
+            },
+            serverInfo: {
+              name: "rainfall-daemon",
+              version: "0.1.0"
+            }
+          }
+        };
+      case "tools/list":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: await this.getMCPTools()
+          }
+        };
+      case "tools/call": {
+        const toolName = params?.name;
+        const toolParams = params?.arguments;
+        try {
+          const startTime = Date.now();
+          const result = await this.executeToolWithMCP(toolName, toolParams);
+          const duration = Date.now() - startTime;
+          if (this.context) {
+            this.context.recordExecution(toolName, toolParams || {}, result, { duration });
+          }
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+                }
+              ]
+            }
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+          if (this.context) {
+            this.context.recordExecution(toolName, toolParams || {}, null, {
+              error: errorMessage,
+              duration: 0
+            });
+          }
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32603,
+              message: errorMessage
+            }
+          };
+        }
+      }
+      case "ping":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {}
+        };
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        };
+    }
+  }
+  async getMCPTools() {
+    const mcpTools = [];
+    for (const tool of this.tools) {
+      const schema = await this.getToolSchema(tool.id);
+      if (schema) {
+        const toolSchema = schema;
+        mcpTools.push({
+          name: tool.id,
+          description: toolSchema.description || tool.description,
+          inputSchema: toolSchema.parameters || { type: "object", properties: {} }
+        });
+      }
+    }
+    if (this.mcpProxy) {
+      const proxyTools = this.mcpProxy.getAllTools({ namespacePrefix: this.mcpNamespacePrefix });
+      for (const tool of proxyTools) {
+        mcpTools.push({
+          name: this.mcpNamespacePrefix ? `${tool.serverName}-${tool.name}` : tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema || { type: "object", properties: {} }
+        });
+      }
+    }
+    return mcpTools;
+  }
+  async executeTool(toolId, params) {
+    if (!this.rainfall) {
+      throw new Error("Rainfall SDK not initialized");
+    }
+    return this.rainfall.executeTool(toolId, params);
+  }
+  /**
+   * Execute a tool, trying MCP proxy first, then falling back to Rainfall tools
+   */
+  async executeToolWithMCP(toolName, params) {
+    if (this.mcpProxy) {
+      try {
+        if (this.mcpNamespacePrefix && toolName.includes("-")) {
+          const namespace = toolName.split("-")[0];
+          const actualToolName = toolName.slice(namespace.length + 1);
+          if (this.mcpProxy.getClient(namespace)) {
+            return await this.mcpProxy.callTool(toolName, params || {}, {
+              namespace
+            });
+          }
+        }
+        return await this.mcpProxy.callTool(toolName, params || {});
+      } catch (error) {
+        if (error instanceof Error && !error.message.includes("not found")) {
+          throw error;
+        }
+      }
+    }
+    return this.executeTool(toolName, params);
+  }
+  async startOpenAIProxy() {
+    this.openaiApp.get("/v1/models", async (_req, res) => {
+      try {
+        if (this.rainfall) {
+          const models = await this.rainfall.listModels();
+          res.json({
+            object: "list",
+            data: models.map((m) => ({
+              id: m.id,
+              object: "model",
+              created: Math.floor(Date.now() / 1e3),
+              owned_by: "rainfall"
+            }))
+          });
+        } else {
+          res.json({
+            object: "list",
+            data: [
+              { id: "llama-3.3-70b-versatile", object: "model", created: Date.now(), owned_by: "groq" },
+              { id: "gpt-4o", object: "model", created: Date.now(), owned_by: "openai" },
+              { id: "claude-3-5-sonnet", object: "model", created: Date.now(), owned_by: "anthropic" },
+              { id: "gemini-2.0-flash-exp", object: "model", created: Date.now(), owned_by: "gemini" }
+            ]
+          });
+        }
+      } catch (error) {
+        res.status(500).json({ error: "Failed to fetch models" });
+      }
+    });
+    this.openaiApp.post("/v1/chat/completions", async (req, res) => {
+      const body = req.body;
+      if (!body.messages || !Array.isArray(body.messages)) {
+        res.status(400).json({
+          error: {
+            message: "Missing required field: messages",
+            type: "invalid_request_error"
+          }
+        });
+        return;
+      }
+      if (!this.rainfall) {
+        res.status(503).json({
+          error: {
+            message: "Rainfall SDK not initialized",
+            type: "service_unavailable"
+          }
+        });
+        return;
+      }
+      try {
+        const me = await this.rainfall.getMe();
+        const subscriberId = me.id;
+        const localToolMap = await this.buildLocalToolMap();
+        let allTools = [];
+        if (body.tools && body.tools.length > 0) {
+          allTools = body.tools;
+        } else if (body.tool_choice) {
+          const openaiTools = await this.getOpenAITools();
+          allTools = openaiTools;
+        }
+        let messages = [...body.messages];
+        const maxToolIterations = 10;
+        let toolIterations = 0;
+        while (toolIterations < maxToolIterations) {
+          toolIterations++;
+          const llmResponse = await this.callLLM({
+            subscriberId,
+            model: body.model,
+            messages,
+            tools: allTools.length > 0 ? allTools : void 0,
+            tool_choice: body.tool_choice,
+            temperature: body.temperature,
+            max_tokens: body.max_tokens,
+            stream: false,
+            // Always non-streaming for tool loop
+            tool_priority: body.tool_priority,
+            enable_stacked: body.enable_stacked
+          });
+          const choice = llmResponse.choices?.[0];
+          let toolCalls = choice?.message?.tool_calls || [];
+          const content = choice?.message?.content || "";
+          const reasoningContent = choice?.message?.reasoning_content || "";
+          const fullContent = content + " " + reasoningContent;
+          const xmlToolCalls = this.parseXMLToolCalls(fullContent);
+          if (xmlToolCalls.length > 0) {
+            this.log(`\u{1F4CB} Parsed ${xmlToolCalls.length} XML tool calls from content`);
+            toolCalls = xmlToolCalls;
+          }
+          if (!toolCalls || toolCalls.length === 0) {
+            if (body.stream) {
+              await this.streamResponse(res, llmResponse);
+            } else {
+              res.json(llmResponse);
+            }
+            this.updateContext(body.messages, llmResponse);
+            return;
+          }
+          messages.push({
+            role: "assistant",
+            content: choice?.message?.content || "",
+            tool_calls: toolCalls
+          });
+          for (const toolCall of toolCalls) {
+            const toolName = toolCall.function?.name;
+            const toolArgsStr = toolCall.function?.arguments || "{}";
+            if (!toolName) continue;
+            this.log(`\u{1F527} Tool call: ${toolName}`);
+            let toolResult;
+            let toolError;
+            try {
+              const localTool = this.findLocalTool(toolName, localToolMap);
+              if (localTool) {
+                this.log(`  \u2192 Executing locally`);
+                const args = JSON.parse(toolArgsStr);
+                toolResult = await this.executeLocalTool(localTool.id, args);
+              } else if (this.mcpProxy) {
+                this.log(`  \u2192 Trying MCP proxy`);
+                const args = JSON.parse(toolArgsStr);
+                toolResult = await this.executeToolWithMCP(toolName.replace(/_/g, "-"), args);
+              } else {
+                const shouldExecuteLocal = body.tool_priority === "local" || body.tool_priority === "stacked";
+                if (shouldExecuteLocal) {
+                  try {
+                    const args = JSON.parse(toolArgsStr);
+                    toolResult = await this.rainfall.executeTool(toolName.replace(/_/g, "-"), args);
+                  } catch {
+                    toolResult = { _pending: true, tool: toolName, args: toolArgsStr };
+                  }
+                } else {
+                  toolResult = { _pending: true, tool: toolName, args: toolArgsStr };
+                }
+              }
+            } catch (error) {
+              toolError = error instanceof Error ? error.message : String(error);
+              this.log(`  \u2192 Error: ${toolError}`);
+            }
+            messages.push({
+              role: "tool",
+              content: toolError ? JSON.stringify({ error: toolError }) : typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
+              tool_call_id: toolCall.id
+            });
+            if (this.context) {
+              this.context.recordExecution(
+                toolName,
+                JSON.parse(toolArgsStr || "{}"),
+                toolResult,
+                { error: toolError, duration: 0 }
+              );
+            }
+          }
+        }
+        res.status(500).json({
+          error: {
+            message: "Maximum tool execution iterations reached",
+            type: "tool_execution_error"
+          }
+        });
+      } catch (error) {
+        this.log("Chat completions error:", error);
+        res.status(500).json({
+          error: {
+            message: error instanceof Error ? error.message : "Internal server error",
+            type: "internal_error"
+          }
+        });
+      }
+    });
+    this.openaiApp.get("/health", (_req, res) => {
+      const mcpStats = this.mcpProxy?.getStats();
+      res.json({
+        status: "ok",
+        daemon: "rainfall",
+        version: "0.2.0",
+        tools_loaded: this.tools.length,
+        mcp_clients: mcpStats?.totalClients || 0,
+        mcp_tools: mcpStats?.totalTools || 0,
+        edge_node_id: this.networkedExecutor?.getEdgeNodeId(),
+        clients_connected: this.clients.size
+      });
+    });
+    this.openaiApp.get("/v1/mcp/clients", (_req, res) => {
+      if (!this.mcpProxy) {
+        res.status(503).json({ error: "MCP proxy not enabled" });
+        return;
+      }
+      res.json(this.mcpProxy.listClients());
+    });
+    this.openaiApp.post("/v1/mcp/connect", async (req, res) => {
+      if (!this.mcpProxy) {
+        res.status(503).json({ error: "MCP proxy not enabled" });
+        return;
+      }
+      try {
+        const name = await this.mcpProxy.connectClient(req.body);
+        res.json({ success: true, client: name });
+      } catch (error) {
+        res.status(500).json({
+          error: error instanceof Error ? error.message : "Failed to connect MCP client"
+        });
+      }
+    });
+    this.openaiApp.post("/v1/mcp/disconnect", async (req, res) => {
+      if (!this.mcpProxy) {
+        res.status(503).json({ error: "MCP proxy not enabled" });
+        return;
+      }
+      const { name } = req.body;
+      if (!name) {
+        res.status(400).json({ error: "Missing required field: name" });
+        return;
+      }
+      await this.mcpProxy.disconnectClient(name);
+      res.json({ success: true });
+    });
+    this.openaiApp.get("/status", (_req, res) => {
+      res.json(this.getStatus());
+    });
+    this.openaiApp.post("/v1/queue", async (req, res) => {
+      const { tool_id, params, execution_mode = "any" } = req.body;
+      if (!tool_id) {
+        res.status(400).json({ error: "Missing required field: tool_id" });
+        return;
+      }
+      if (!this.networkedExecutor) {
+        res.status(503).json({ error: "Networked executor not available" });
+        return;
+      }
+      try {
+        const jobId = await this.networkedExecutor.queueToolExecution(
+          tool_id,
+          params || {},
+          { executionMode: execution_mode }
+        );
+        res.json({ job_id: jobId, status: "queued" });
+      } catch (error) {
+        res.status(500).json({
+          error: error instanceof Error ? error.message : "Failed to queue job"
+        });
+      }
+    });
+    return new Promise((resolve) => {
+      this.openaiApp.listen(this.openaiPort, () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * Build a map of local Rainfall tools for quick lookup
+   * Maps OpenAI-style underscore names to Rainfall tool IDs
+   */
+  async buildLocalToolMap() {
+    const map = /* @__PURE__ */ new Map();
+    for (const tool of this.tools) {
+      const openAiName = tool.id.replace(/-/g, "_");
+      map.set(openAiName, {
+        id: tool.id,
+        name: openAiName,
+        description: tool.description
+      });
+      map.set(tool.id, {
+        id: tool.id,
+        name: openAiName,
+        description: tool.description
+      });
+    }
+    return map;
+  }
+  /**
+   * Find a local Rainfall tool by name (OpenAI underscore format or original)
+   */
+  findLocalTool(toolName, localToolMap) {
+    if (localToolMap.has(toolName)) {
+      return localToolMap.get(toolName);
+    }
+    const dashedName = toolName.replace(/_/g, "-");
+    if (localToolMap.has(dashedName)) {
+      return localToolMap.get(dashedName);
+    }
+    return void 0;
+  }
+  /**
+   * Execute a local Rainfall tool
+   */
+  async executeLocalTool(toolId, args) {
+    if (!this.rainfall) {
+      throw new Error("Rainfall SDK not initialized");
+    }
+    const startTime = Date.now();
+    try {
+      const result = await this.rainfall.executeTool(toolId, args);
+      const duration = Date.now() - startTime;
+      this.log(`  \u2713 Completed in ${duration}ms`);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.log(`  \u2717 Failed after ${duration}ms`);
+      throw error;
+    }
+  }
+  /**
+   * Parse XML-style tool calls from model output
+   * Handles formats like: <function=name><parameter=key>value</parameter></function>
+   */
+  parseXMLToolCalls(content) {
+    const toolCalls = [];
+    const functionRegex = /<function=([^>]+)>([\s\S]*?)<\/function>/gi;
+    let match;
+    while ((match = functionRegex.exec(content)) !== null) {
+      const functionName = match[1].trim();
+      const paramsBlock = match[2];
+      const params = {};
+      const paramRegex = /<parameter=([^>]+)>([\s\S]*?)<\/parameter>/gi;
+      let paramMatch;
+      while ((paramMatch = paramRegex.exec(paramsBlock)) !== null) {
+        const paramName = paramMatch[1].trim();
+        const paramValue = paramMatch[2].trim();
+        params[paramName] = paramValue;
+      }
+      toolCalls.push({
+        id: `xml-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+        type: "function",
+        function: {
+          name: functionName,
+          arguments: JSON.stringify(params)
+        }
+      });
+      this.log(`\u{1F4CB} Parsed XML tool call: ${functionName}(${JSON.stringify(params)})`);
+    }
+    return toolCalls;
+  }
+  /**
+   * Call the LLM via Rainfall backend, LM Studio, RunPod, or other providers
+   * 
+   * Provider priority:
+   * 1. Config file (llm.provider, llm.baseUrl)
+   * 2. Environment variables (OPENAI_API_KEY, OLLAMA_HOST, etc.)
+   * 3. Default to Rainfall (credits-based)
+   */
+  async callLLM(params) {
+    if (!this.rainfall) {
+      throw new Error("Rainfall SDK not initialized");
+    }
+    const { loadConfig, getProviderBaseUrl } = await import("../config-7UT7GYSN.mjs");
+    const config = loadConfig();
+    const provider = config.llm?.provider || "rainfall";
+    switch (provider) {
+      case "local":
+      case "ollama":
+      case "custom":
+        return this.callLocalLLM(params, config);
+      case "openai":
+      case "anthropic":
+        return this.callExternalLLM(params, config, provider);
+      case "rainfall":
+      default:
+        return this.rainfall.chatCompletions({
+          subscriber_id: params.subscriberId,
+          model: params.model,
+          messages: params.messages,
+          stream: params.stream || false,
+          temperature: params.temperature,
+          max_tokens: params.max_tokens,
+          tools: params.tools,
+          tool_choice: params.tool_choice,
+          tool_priority: params.tool_priority,
+          enable_stacked: params.enable_stacked
+        });
+    }
+  }
+  /**
+   * Call external LLM provider (OpenAI, Anthropic) via their OpenAI-compatible APIs
+   */
+  async callExternalLLM(params, config, provider) {
+    const { getProviderBaseUrl } = await import("../config-7UT7GYSN.mjs");
+    const baseUrl = config.llm?.baseUrl || getProviderBaseUrl({ llm: { provider } });
+    const apiKey = config.llm?.apiKey;
+    if (!apiKey) {
+      throw new Error(`${provider} API key not configured. Set via: rainfall config set llm.apiKey <key>`);
+    }
+    const model = params.model || config.llm?.model || (provider === "anthropic" ? "claude-3-5-sonnet-20241022" : "gpt-4o");
+    const url = `${baseUrl}/chat/completions`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`,
+        "User-Agent": "Rainfall-DevKit/1.0"
+      },
+      body: JSON.stringify({
+        model,
+        messages: params.messages,
+        tools: params.tools,
+        tool_choice: params.tool_choice,
+        temperature: params.temperature,
+        max_tokens: params.max_tokens,
+        stream: false
+        // Tool loop requires non-streaming
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`${provider} API error: ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * Call a local LLM (LM Studio, Ollama, etc.)
+   */
+  async callLocalLLM(params, config) {
+    const baseUrl = config.llm?.baseUrl || "http://localhost:1234/v1";
+    const apiKey = config.llm?.apiKey || "not-needed";
+    const model = params.model || config.llm?.model || "local-model";
+    const url = `${baseUrl}/chat/completions`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`,
+        "User-Agent": "Rainfall-DevKit/1.0"
+      },
+      body: JSON.stringify({
+        model,
+        messages: params.messages,
+        tools: params.tools,
+        tool_choice: params.tool_choice,
+        temperature: params.temperature,
+        max_tokens: params.max_tokens,
+        stream: false
+        // Tool loop requires non-streaming
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Local LLM error: ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * Stream a response to the client (converts non-streaming to SSE format)
+   */
+  async streamResponse(res, response) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    const message = response.choices?.[0]?.message;
+    const id = response.id || `chatcmpl-${Date.now()}`;
+    const model = response.model || "unknown";
+    const created = Math.floor(Date.now() / 1e3);
+    res.write(`data: ${JSON.stringify({
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }]
+    })}
+
+`);
+    const content = message?.content || "";
+    const chunkSize = 10;
+    for (let i = 0; i < content.length; i += chunkSize) {
+      const chunk = content.slice(i, i + chunkSize);
+      res.write(`data: ${JSON.stringify({
+        id,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{ index: 0, delta: { content: chunk }, finish_reason: null }]
+      })}
+
+`);
+    }
+    res.write(`data: ${JSON.stringify({
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+    })}
+
+`);
+    res.write("data: [DONE]\n\n");
+    res.end();
+  }
+  /**
+   * Update context with conversation history
+   */
+  updateContext(originalMessages, response) {
+    if (!this.context) return;
+    const lastUserMessage = originalMessages.filter((m) => m.role === "user").pop();
+    if (lastUserMessage) {
+      this.context.addMessage("user", lastUserMessage.content);
+    }
+    const assistantContent = response.choices?.[0]?.message?.content;
+    if (assistantContent) {
+      this.context.addMessage("assistant", assistantContent);
+    }
+  }
+  async getOpenAITools() {
+    const tools = [];
+    for (const tool of this.tools.slice(0, 100)) {
+      const schema = await this.getToolSchema(tool.id);
+      if (schema) {
+        const toolSchema = schema;
+        let parameters = { type: "object", properties: {}, required: [] };
+        if (toolSchema.parameters && typeof toolSchema.parameters === "object") {
+          const rawParams = toolSchema.parameters;
+          parameters = {
+            type: rawParams.type || "object",
+            properties: rawParams.properties || {},
+            required: rawParams.required || []
+          };
+        }
+        tools.push({
+          type: "function",
+          function: {
+            name: tool.id.replace(/-/g, "_"),
+            // OpenAI requires underscore names
+            description: toolSchema.description || tool.description,
+            parameters
+          }
+        });
+      }
+    }
+    if (this.mcpProxy) {
+      const proxyTools = this.mcpProxy.getAllTools({ namespacePrefix: this.mcpNamespacePrefix });
+      for (const tool of proxyTools.slice(0, 28)) {
+        const inputSchema = tool.inputSchema || {};
+        tools.push({
+          type: "function",
+          function: {
+            name: this.mcpNamespacePrefix ? `${tool.serverName}_${tool.name}`.replace(/-/g, "_") : tool.name.replace(/-/g, "_"),
+            description: `[${tool.serverName}] ${tool.description}`,
+            parameters: {
+              type: "object",
+              properties: inputSchema.properties || {},
+              required: inputSchema.required || []
+            }
+          }
+        });
+      }
+    }
+    return tools;
+  }
+  buildResponseContent() {
+    const edgeNodeId = this.networkedExecutor?.getEdgeNodeId();
+    const toolCount = this.tools.length;
+    return `Rainfall daemon online. Edge node: ${edgeNodeId || "local"}. ${toolCount} tools available. What would you like to execute locally or in the cloud?`;
+  }
+  getStatus() {
+    return {
+      running: !!this.wss,
+      port: this.port,
+      openaiPort: this.openaiPort,
+      toolsLoaded: this.tools.length,
+      clientsConnected: this.clients.size,
+      edgeNodeId: this.networkedExecutor?.getEdgeNodeId(),
+      context: this.context?.getStatus() || {
+        memoriesCached: 0,
+        activeSessions: 0,
+        executionHistorySize: 0
+      },
+      listeners: this.listeners?.getStatus() || {
+        fileWatchers: 0,
+        cronTriggers: 0,
+        recentEvents: 0
+      }
+    };
+  }
+  log(...args) {
+    if (this.debug) {
+      console.log(...args);
+    }
+  }
+};
+var daemonInstance = null;
+async function startDaemon(config = {}) {
+  if (daemonInstance) {
+    console.log("Daemon already running");
+    return daemonInstance;
+  }
+  daemonInstance = new RainfallDaemon(config);
+  await daemonInstance.start();
+  return daemonInstance;
+}
+async function stopDaemon() {
+  if (!daemonInstance) {
+    console.log("Daemon not running");
+    return;
+  }
+  await daemonInstance.stop();
+  daemonInstance = null;
+}
+function getDaemonStatus() {
+  if (!daemonInstance) {
+    return null;
+  }
+  return daemonInstance.getStatus();
+}
+function getDaemonInstance() {
+  return daemonInstance;
+}
+export {
+  MCPProxyHub,
+  RainfallDaemon,
+  getDaemonInstance,
+  getDaemonStatus,
+  startDaemon,
+  stopDaemon
+};