@rainfall-devkit/sdk 0.1.7 → 0.2.0

package/dist/daemon/index.mjs

@@ -0,0 +1,836 @@
+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";
+var RainfallDaemon = class {
+  wss;
+  openaiApp;
+  rainfall;
+  port;
+  openaiPort;
+  rainfallConfig;
+  tools = [];
+  toolSchemas = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Set();
+  debug;
+  // New services
+  networkedExecutor;
+  context;
+  listeners;
+  constructor(config = {}) {
+    this.port = config.port || 8765;
+    this.openaiPort = config.openaiPort || 8787;
+    this.rainfallConfig = config.rainfallConfig;
+    this.debug = config.debug || false;
+    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();
+    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();
+    }
+    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;
+  }
+  async initializeRainfall() {
+    if (this.rainfallConfig?.apiKey) {
+      this.rainfall = new Rainfall(this.rainfallConfig);
+    } else {
+      const { loadConfig } = await import("../config-DDTQQBN7.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.executeTool(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: {} }
+        });
+      }
+    }
+    return mcpTools;
+  }
+  async executeTool(toolId, params) {
+    if (!this.rainfall) {
+      throw new Error("Rainfall SDK not initialized");
+    }
+    return this.rainfall.executeTool(toolId, 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 {
+                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) => {
+      res.json({
+        status: "ok",
+        daemon: "rainfall",
+        version: "0.1.0",
+        tools_loaded: this.tools.length,
+        edge_node_id: this.networkedExecutor?.getEdgeNodeId(),
+        clients_connected: this.clients.size
+      });
+    });
+    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-DDTQQBN7.mjs");
+    const config = loadConfig();
+    const provider = config.llm?.provider || "rainfall";
+    switch (provider) {
+      case "local":
+      case "ollama":
+        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-DDTQQBN7.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}`
+      },
+      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}`
+      },
+      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, 128)) {
+      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
+          }
+        });
+      }
+    }
+    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 {
+  RainfallDaemon,
+  getDaemonInstance,
+  getDaemonStatus,
+  startDaemon,
+  stopDaemon
+};