@rainfall-devkit/sdk 0.1.8 → 0.2.1

package/dist/daemon/index.js

@@ -0,0 +1,3182 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/cli/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfigDir: () => getConfigDir,
+  getLLMConfig: () => getLLMConfig,
+  getProviderBaseUrl: () => getProviderBaseUrl,
+  isLocalProvider: () => isLocalProvider,
+  loadConfig: () => loadConfig,
+  saveConfig: () => saveConfig
+});
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function loadConfig() {
+  let config = {};
+  if ((0, import_fs.existsSync)(CONFIG_FILE)) {
+    try {
+      config = JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf8"));
+    } catch {
+      config = {};
+    }
+  }
+  if (process.env.RAINFALL_API_KEY) {
+    config.apiKey = process.env.RAINFALL_API_KEY;
+  }
+  if (process.env.RAINFALL_BASE_URL) {
+    config.baseUrl = process.env.RAINFALL_BASE_URL;
+  }
+  if (!config.llm) {
+    config.llm = { provider: "rainfall" };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    config.llm.provider = config.llm.provider || "openai";
+    config.llm.apiKey = process.env.OPENAI_API_KEY;
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    config.llm.provider = "anthropic";
+    config.llm.apiKey = process.env.ANTHROPIC_API_KEY;
+  }
+  if (process.env.OLLAMA_HOST || process.env.OLLAMA_URL) {
+    config.llm.provider = "ollama";
+    config.llm.baseUrl = process.env.OLLAMA_HOST || process.env.OLLAMA_URL;
+  }
+  if (process.env.LLM_MODEL) {
+    config.llm.model = process.env.LLM_MODEL;
+  }
+  return config;
+}
+function saveConfig(config) {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
+    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  }
+  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getLLMConfig(config) {
+  const defaults = {
+    provider: "rainfall",
+    apiKey: config.apiKey || "",
+    baseUrl: config.baseUrl || "https://api.rainfall.com",
+    model: "llama-3.3-70b-versatile",
+    options: {}
+  };
+  return { ...defaults, ...config.llm };
+}
+function isLocalProvider(config) {
+  return config.llm?.provider === "ollama" || config.llm?.provider === "local";
+}
+function getProviderBaseUrl(config) {
+  const provider = config.llm?.provider || "rainfall";
+  switch (provider) {
+    case "openai":
+      return config.llm?.baseUrl || "https://api.openai.com/v1";
+    case "anthropic":
+      return config.llm?.baseUrl || "https://api.anthropic.com/v1";
+    case "ollama":
+      return config.llm?.baseUrl || "http://localhost:11434/v1";
+    case "local":
+    case "custom":
+      return config.llm?.baseUrl || "http://localhost:1234/v1";
+    case "rainfall":
+    default:
+      return config.baseUrl || "https://api.rainfall.com";
+  }
+}
+var import_fs, import_path, import_os, CONFIG_DIR, CONFIG_FILE;
+var init_config = __esm({
+  "src/cli/config.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_fs = require("fs");
+    import_path = require("path");
+    import_os = require("os");
+    CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".rainfall");
+    CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
+  }
+});
+
+// src/daemon/index.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  MCPProxyHub: () => MCPProxyHub,
+  RainfallDaemon: () => RainfallDaemon,
+  getDaemonInstance: () => getDaemonInstance,
+  getDaemonStatus: () => getDaemonStatus,
+  startDaemon: () => startDaemon,
+  stopDaemon: () => stopDaemon
+});
+module.exports = __toCommonJS(daemon_exports);
+init_cjs_shims();
+var import_ws2 = require("ws");
+var import_express = __toESM(require("express"));
+
+// src/sdk.ts
+init_cjs_shims();
+
+// src/client.ts
+init_cjs_shims();
+
+// src/errors.ts
+init_cjs_shims();
+var RainfallError = class _RainfallError extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "RainfallError";
+    Object.setPrototypeOf(this, _RainfallError.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      details: this.details
+    };
+  }
+};
+var AuthenticationError = class _AuthenticationError extends RainfallError {
+  constructor(message = "Invalid API key", details) {
+    super(message, "AUTHENTICATION_ERROR", 401, details);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends RainfallError {
+  retryAfter;
+  limit;
+  remaining;
+  resetAt;
+  constructor(message = "Rate limit exceeded", retryAfter = 60, limit = 0, remaining = 0, resetAt) {
+    super(message, "RATE_LIMIT_ERROR", 429, { retryAfter, limit, remaining });
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    this.limit = limit;
+    this.remaining = remaining;
+    this.resetAt = resetAt || new Date(Date.now() + retryAfter * 1e3);
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends RainfallError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends RainfallError {
+  constructor(resource, identifier) {
+    super(
+      `${resource}${identifier ? ` '${identifier}'` : ""} not found`,
+      "NOT_FOUND_ERROR",
+      404,
+      { resource, identifier }
+    );
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var ServerError = class _ServerError extends RainfallError {
+  constructor(message = "Internal server error", statusCode = 500) {
+    super(message, "SERVER_ERROR", statusCode);
+    this.name = "ServerError";
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends RainfallError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", 408);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var NetworkError = class _NetworkError extends RainfallError {
+  constructor(message = "Network error", details) {
+    super(message, "NETWORK_ERROR", void 0, details);
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, _NetworkError.prototype);
+  }
+};
+function parseErrorResponse(response, data) {
+  const statusCode = response.status;
+  if (statusCode === 429) {
+    const retryAfter = parseInt(response.headers.get("retry-after") || "60", 10);
+    const limit = parseInt(response.headers.get("x-ratelimit-limit") || "0", 10);
+    const remaining = parseInt(response.headers.get("x-ratelimit-remaining") || "0", 10);
+    const resetHeader = response.headers.get("x-ratelimit-reset");
+    const resetAt = resetHeader ? new Date(parseInt(resetHeader, 10) * 1e3) : void 0;
+    return new RateLimitError(
+      typeof data === "object" && data && "message" in data ? String(data.message) : "Rate limit exceeded",
+      retryAfter,
+      limit,
+      remaining,
+      resetAt
+    );
+  }
+  switch (statusCode) {
+    case 401:
+      return new AuthenticationError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : "Invalid API key"
+      );
+    case 404:
+      return new NotFoundError(
+        typeof data === "object" && data && "resource" in data ? String(data.resource) : "Resource",
+        typeof data === "object" && data && "identifier" in data ? String(data.identifier) : void 0
+      );
+    case 400:
+      return new ValidationError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : "Invalid request",
+        typeof data === "object" && data && "details" in data ? data.details : void 0
+      );
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new ServerError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : "Server error",
+        statusCode
+      );
+    default:
+      return new RainfallError(
+        typeof data === "object" && data && "message" in data ? String(data.message) : `HTTP ${statusCode}`,
+        "UNKNOWN_ERROR",
+        statusCode,
+        typeof data === "object" ? data : void 0
+      );
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://olympic-api.pragma-digital.org/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRIES = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+var RainfallClient = class {
+  apiKey;
+  baseUrl;
+  defaultTimeout;
+  defaultRetries;
+  defaultRetryDelay;
+  lastRateLimitInfo;
+  subscriberId;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+    this.defaultTimeout = config.timeout || DEFAULT_TIMEOUT;
+    this.defaultRetries = config.retries ?? DEFAULT_RETRIES;
+    this.defaultRetryDelay = config.retryDelay || DEFAULT_RETRY_DELAY;
+  }
+  /**
+   * Get the last rate limit info from the API
+   */
+  getRateLimitInfo() {
+    return this.lastRateLimitInfo;
+  }
+  /**
+   * Make an authenticated request to the Rainfall API
+   */
+  async request(path, options = {}, requestOptions) {
+    const timeout = requestOptions?.timeout ?? this.defaultTimeout;
+    const maxRetries = requestOptions?.retries ?? this.defaultRetries;
+    const retryDelay = requestOptions?.retryDelay ?? this.defaultRetryDelay;
+    const url = `${this.baseUrl}${path}`;
+    const method = options.method || "GET";
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const response = await fetch(url, {
+          method,
+          headers: {
+            "x-api-key": this.apiKey,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "X-Rainfall-SDK-Version": "0.1.0",
+            ...options.headers
+          },
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const limit = response.headers.get("x-ratelimit-limit");
+        const remaining = response.headers.get("x-ratelimit-remaining");
+        const reset = response.headers.get("x-ratelimit-reset");
+        if (limit && remaining && reset) {
+          this.lastRateLimitInfo = {
+            limit: parseInt(limit, 10),
+            remaining: parseInt(remaining, 10),
+            resetAt: new Date(parseInt(reset, 10) * 1e3)
+          };
+        }
+        let data;
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          data = await response.json();
+        } else {
+          data = await response.text();
+        }
+        if (!response.ok) {
+          throw parseErrorResponse(response, data);
+        }
+        return data;
+      } catch (error) {
+        if (error instanceof RainfallError) {
+          if (error.statusCode && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+            throw error;
+          }
+          if (error.statusCode === 401) {
+            throw error;
+          }
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new TimeoutError(timeout);
+        } else if (error instanceof TypeError) {
+          lastError = new NetworkError(error.message);
+        } else {
+          lastError = error instanceof Error ? error : new Error(String(error));
+        }
+        if (attempt >= maxRetries) {
+          break;
+        }
+        const delay = retryDelay * Math.pow(2, attempt) + Math.random() * 1e3;
+        await this.sleep(delay);
+      }
+    }
+    throw lastError || new RainfallError("Request failed", "REQUEST_FAILED");
+  }
+  /**
+   * Execute a tool/node by ID
+   */
+  async executeTool(toolId, params, options) {
+    const subscriberId = await this.ensureSubscriberId();
+    const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}`, {
+      method: "POST",
+      body: params || {}
+    }, options);
+    return response.result;
+  }
+  /**
+   * List all available tools
+   */
+  async listTools() {
+    const subscriberId = await this.ensureSubscriberId();
+    const result = await this.request(`/olympic/subscribers/${subscriberId}/nodes/_utils/node-descriptions`);
+    if (result.success && result.nodes) {
+      return Object.values(result.nodes);
+    }
+    const legacyResult = await this.request(`/olympic/subscribers/${subscriberId}/nodes/_utils/node-list`);
+    if (legacyResult.keys && Array.isArray(legacyResult.keys)) {
+      return legacyResult.keys.map((key) => ({
+        id: key,
+        name: key,
+        description: "",
+        category: "general"
+      }));
+    }
+    return legacyResult.nodes || [];
+  }
+  /**
+   * Get tool schema/parameters
+   */
+  async getToolSchema(toolId) {
+    const subscriberId = await this.ensureSubscriberId();
+    const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}/params`);
+    return response.params;
+  }
+  /**
+   * Get subscriber info
+   */
+  async getMe() {
+    const result = await this.request("/olympic/subscribers/me");
+    if (result.subscriber?.id) {
+      this.subscriberId = result.subscriber.id;
+    }
+    const subscriber = result.subscriber;
+    return {
+      id: subscriber.id,
+      name: subscriber.name,
+      email: subscriber.google_id,
+      billingStatus: subscriber.billing_status,
+      plan: subscriber.billing_status,
+      usage: {
+        callsThisMonth: subscriber.metadata?.usage?.callsThisMonth ?? 0,
+        callsLimit: subscriber.metadata?.usage?.callsLimit ?? 5e3
+      }
+    };
+  }
+  /**
+   * Ensure we have a subscriber ID, fetching it if necessary
+   */
+  async ensureSubscriberId() {
+    if (this.subscriberId) {
+      return this.subscriberId;
+    }
+    const me = await this.getMe();
+    if (!me.id) {
+      throw new RainfallError("Failed to get subscriber ID", "NO_SUBSCRIBER_ID");
+    }
+    return me.id;
+  }
+  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
+init_cjs_shims();
+function createIntegrations(client) {
+  return new IntegrationsNamespace(client);
+}
+var IntegrationsNamespace = class {
+  constructor(client) {
+    this.client = client;
+  }
+  get github() {
+    return {
+      issues: {
+        create: (params) => this.client.executeTool("github-create-issue", params),
+        list: (params) => this.client.executeTool("github-list-issues", params),
+        get: (params) => this.client.executeTool("github-get-issue", params),
+        update: (params) => this.client.executeTool("github-update-issue", params),
+        addComment: (params) => this.client.executeTool("github-add-issue-comment", params)
+      },
+      repos: {
+        get: (params) => this.client.executeTool("github-get-repository", params),
+        listBranches: (params) => this.client.executeTool("github-list-branches", params)
+      },
+      pullRequests: {
+        list: (params) => this.client.executeTool("github-list-pull-requests", params),
+        get: (params) => this.client.executeTool("github-get-pull-request", params)
+      }
+    };
+  }
+  get notion() {
+    return {
+      pages: {
+        create: (params) => this.client.executeTool("notion-pages-create", params),
+        retrieve: (params) => this.client.executeTool("notion-pages-retrieve", params),
+        update: (params) => this.client.executeTool("notion-pages-update", params)
+      },
+      databases: {
+        query: (params) => this.client.executeTool("notion-databases-query", params),
+        retrieve: (params) => this.client.executeTool("notion-databases-retrieve", params)
+      },
+      blocks: {
+        appendChildren: (params) => this.client.executeTool("notion-blocks-append-children", params),
+        retrieveChildren: (params) => this.client.executeTool("notion-blocks-retrieve-children", params)
+      }
+    };
+  }
+  get linear() {
+    return {
+      issues: {
+        create: (params) => this.client.executeTool("linear-core-issueCreate", params),
+        list: (params) => this.client.executeTool("linear-core-issues", params),
+        get: (params) => this.client.executeTool("linear-core-issue", params),
+        update: (params) => this.client.executeTool("linear-core-issueUpdate", params),
+        archive: (params) => this.client.executeTool("linear-core-issueArchive", params)
+      },
+      teams: {
+        list: () => this.client.executeTool("linear-core-teams", {})
+      }
+    };
+  }
+  get slack() {
+    return {
+      messages: {
+        send: (params) => this.client.executeTool("slack-core-postMessage", params),
+        list: (params) => this.client.executeTool("slack-core-listMessages", params)
+      },
+      channels: {
+        list: () => this.client.executeTool("slack-core-listChannels", {})
+      },
+      users: {
+        list: () => this.client.executeTool("slack-core-listUsers", {})
+      },
+      reactions: {
+        add: (params) => this.client.executeTool("slack-core-addReaction", params)
+      }
+    };
+  }
+  get figma() {
+    return {
+      files: {
+        get: (params) => this.client.executeTool("figma-files-getFile", { fileKey: params.fileKey }),
+        getNodes: (params) => this.client.executeTool("figma-files-getFileNodes", { fileKey: params.fileKey, nodeIds: params.nodeIds }),
+        getImages: (params) => this.client.executeTool("figma-files-getFileImage", { fileKey: params.fileKey, nodeIds: params.nodeIds, format: params.format }),
+        getComments: (params) => this.client.executeTool("figma-comments-getFileComments", { fileKey: params.fileKey }),
+        postComment: (params) => this.client.executeTool("figma-comments-postComment", { fileKey: params.fileKey, message: params.message, nodeId: params.nodeId })
+      },
+      projects: {
+        list: (params) => this.client.executeTool("figma-projects-getTeamProjects", { teamId: params.teamId }),
+        getFiles: (params) => this.client.executeTool("figma-projects-getProjectFiles", { projectId: params.projectId })
+      }
+    };
+  }
+  get stripe() {
+    return {
+      customers: {
+        create: (params) => this.client.executeTool("stripe-customers-create", params),
+        retrieve: (params) => this.client.executeTool("stripe-customers-retrieve", { customerId: params.customerId }),
+        update: (params) => this.client.executeTool("stripe-customers-update", params),
+        listPaymentMethods: (params) => this.client.executeTool("stripe-customers-list-payment-methods", { customerId: params.customerId })
+      },
+      paymentIntents: {
+        create: (params) => this.client.executeTool("stripe-payment-intents-create", params),
+        retrieve: (params) => this.client.executeTool("stripe-payment-intents-retrieve", { paymentIntentId: params.paymentIntentId }),
+        confirm: (params) => this.client.executeTool("stripe-payment-intents-confirm", { paymentIntentId: params.paymentIntentId })
+      },
+      subscriptions: {
+        create: (params) => this.client.executeTool("stripe-subscriptions-create", params),
+        retrieve: (params) => this.client.executeTool("stripe-subscriptions-retrieve", { subscriptionId: params.subscriptionId }),
+        cancel: (params) => this.client.executeTool("stripe-subscriptions-cancel", { subscriptionId: params.subscriptionId })
+      }
+    };
+  }
+};
+
+// src/namespaces/memory.ts
+init_cjs_shims();
+function createMemory(client) {
+  return {
+    create: (params) => client.executeTool("memory-create", params),
+    get: (params) => client.executeTool("memory-get", { memoryId: params.memoryId }),
+    recall: (params) => client.executeTool("memory-recall", params),
+    list: (params) => client.executeTool("memory-list", params ?? {}),
+    update: (params) => client.executeTool("memory-update", params),
+    delete: (params) => client.executeTool("memory-delete", { memoryId: params.memoryId })
+  };
+}
+
+// src/namespaces/articles.ts
+init_cjs_shims();
+function createArticles(client) {
+  return {
+    search: (params) => client.executeTool("article-search", params),
+    create: (params) => client.executeTool("article-create", params),
+    createFromUrl: (params) => client.executeTool("article-create-from-url", params),
+    fetch: (params) => client.executeTool("article-fetch", params),
+    recent: (params) => client.executeTool("article-recent", params ?? {}),
+    relevant: (params) => client.executeTool("article-relevant-news", params),
+    summarize: (params) => client.executeTool("article-summarize", params),
+    extractTopics: (params) => client.executeTool("article-topic-extractor", params)
+  };
+}
+
+// src/namespaces/web.ts
+init_cjs_shims();
+function createWeb(client) {
+  return {
+    search: {
+      exa: (params) => client.executeTool("exa-web-search", params),
+      perplexity: (params) => client.executeTool("perplexity-search", params)
+    },
+    fetch: (params) => client.executeTool("web-fetch", params),
+    htmlToMarkdown: (params) => client.executeTool("html-to-markdown-converter", params),
+    extractHtml: (params) => client.executeTool("extract-html-selector", params)
+  };
+}
+
+// src/namespaces/ai.ts
+init_cjs_shims();
+function createAI(client) {
+  return {
+    embeddings: {
+      document: (params) => client.executeTool("jina-document-embedding", params),
+      query: (params) => client.executeTool("jina-query-embedding", params),
+      image: (params) => client.executeTool("jina-image-embedding", { image: params.imageBase64 })
+    },
+    image: {
+      generate: (params) => client.executeTool("image-generation", params)
+    },
+    ocr: (params) => client.executeTool("ocr-text-extraction", { image: params.imageBase64 }),
+    vision: (params) => client.executeTool("llama-scout-vision", { image: params.imageBase64, prompt: params.prompt }),
+    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),
+    /**
+     * OpenAI-compatible chat completions with full tool support
+     * This is the recommended method for multi-turn conversations with tools
+     */
+    chatCompletions: (params) => client.chatCompletions(params)
+  };
+}
+
+// src/namespaces/data.ts
+init_cjs_shims();
+function createData(client) {
+  return {
+    csv: {
+      query: (params) => client.executeTool("query-csv", params),
+      convert: (params) => client.executeTool("csv-convert", params)
+    },
+    scripts: {
+      create: (params) => client.executeTool("create-saved-script", params),
+      execute: (params) => client.executeTool("execute-saved-script", params),
+      list: () => client.executeTool("list-saved-scripts", {}),
+      update: (params) => client.executeTool("update-saved-script", params),
+      delete: (params) => client.executeTool("delete-saved-script", params)
+    },
+    similarity: {
+      search: (params) => client.executeTool("duck-db-similarity-search", params),
+      duckDbSearch: (params) => client.executeTool("duck-db-similarity-search", params)
+    }
+  };
+}
+
+// src/namespaces/utils.ts
+init_cjs_shims();
+function createUtils(client) {
+  return {
+    mermaid: (params) => client.executeTool("mermaid-diagram-generator", { mermaid: params.diagram }),
+    documentConvert: (params) => client.executeTool("document-format-converter", {
+      base64: `data:${params.mimeType};base64,${Buffer.from(params.document).toString("base64")}`,
+      format: params.format
+    }),
+    regex: {
+      match: (params) => client.executeTool("regex-match", params),
+      replace: (params) => client.executeTool("regex-replace", params)
+    },
+    jsonExtract: (params) => client.executeTool("json-extract", params),
+    digest: (params) => client.executeTool("digest-generator", { text: params.data }),
+    monteCarlo: (params) => client.executeTool("monte-carlo-simulation", params)
+  };
+}
+
+// src/sdk.ts
+var Rainfall = class {
+  client;
+  _integrations;
+  _memory;
+  _articles;
+  _web;
+  _ai;
+  _data;
+  _utils;
+  constructor(config) {
+    this.client = new RainfallClient(config);
+  }
+  /**
+   * Integrations namespace - GitHub, Notion, Linear, Slack, Figma, Stripe
+   * 
+   * @example
+   * ```typescript
+   * // GitHub
+   * await rainfall.integrations.github.issues.create({
+   *   owner: 'facebook',
+   *   repo: 'react',
+   *   title: 'Bug report'
+   * });
+   * 
+   * // Slack
+   * await rainfall.integrations.slack.messages.send({
+   *   channelId: 'C123456',
+   *   text: 'Hello team!'
+   * });
+   * 
+   * // Linear
+   * const issues = await rainfall.integrations.linear.issues.list();
+   * ```
+   */
+  get integrations() {
+    if (!this._integrations) {
+      this._integrations = createIntegrations(this.client);
+    }
+    return this._integrations;
+  }
+  /**
+   * Memory namespace - Semantic memory storage and retrieval
+   * 
+   * @example
+   * ```typescript
+   * // Store a memory
+   * await rainfall.memory.create({
+   *   content: 'User prefers dark mode',
+   *   keywords: ['preference', 'ui']
+   * });
+   * 
+   * // Recall similar memories
+   * const memories = await rainfall.memory.recall({
+   *   query: 'user preferences',
+   *   topK: 5
+   * });
+   * ```
+   */
+  get memory() {
+    if (!this._memory) {
+      this._memory = createMemory(this.client);
+    }
+    return this._memory;
+  }
+  /**
+   * Articles namespace - News aggregation and article management
+   * 
+   * @example
+   * ```typescript
+   * // Search news
+   * const articles = await rainfall.articles.search({
+   *   query: 'artificial intelligence'
+   * });
+   * 
+   * // Create from URL
+   * const article = await rainfall.articles.createFromUrl({
+   *   url: 'https://example.com/article'
+   * });
+   * 
+   * // Summarize
+   * const summary = await rainfall.articles.summarize({
+   *   text: article.content
+   * });
+   * ```
+   */
+  get articles() {
+    if (!this._articles) {
+      this._articles = createArticles(this.client);
+    }
+    return this._articles;
+  }
+  /**
+   * Web namespace - Web search, scraping, and content extraction
+   * 
+   * @example
+   * ```typescript
+   * // Search with Exa
+   * const results = await rainfall.web.search.exa({
+   *   query: 'latest AI research'
+   * });
+   * 
+   * // Fetch and convert
+   * const html = await rainfall.web.fetch({ url: 'https://example.com' });
+   * const markdown = await rainfall.web.htmlToMarkdown({ html });
+   * 
+   * // Extract specific elements
+   * const links = await rainfall.web.extractHtml({
+   *   html,
+   *   selector: 'a[href]'
+   * });
+   * ```
+   */
+  get web() {
+    if (!this._web) {
+      this._web = createWeb(this.client);
+    }
+    return this._web;
+  }
+  /**
+   * AI namespace - Embeddings, image generation, OCR, vision, chat
+   * 
+   * @example
+   * ```typescript
+   * // Generate embeddings
+   * const embedding = await rainfall.ai.embeddings.document({
+   *   text: 'Hello world'
+   * });
+   * 
+   * // Generate image
+   * const image = await rainfall.ai.image.generate({
+   *   prompt: 'A serene mountain landscape'
+   * });
+   * 
+   * // OCR
+   * const text = await rainfall.ai.ocr({ imageBase64: '...' });
+   * 
+   * // Chat
+   * const response = await rainfall.ai.chat({
+   *   messages: [{ role: 'user', content: 'Hello!' }]
+   * });
+   * ```
+   */
+  get ai() {
+    if (!this._ai) {
+      this._ai = createAI(this.client);
+    }
+    return this._ai;
+  }
+  /**
+   * Data namespace - CSV processing, scripts, similarity search
+   * 
+   * @example
+   * ```typescript
+   * // Query CSV with SQL
+   * const results = await rainfall.data.csv.query({
+   *   sql: 'SELECT * FROM data WHERE value > 100'
+   * });
+   * 
+   * // Execute saved script
+   * const result = await rainfall.data.scripts.execute({
+   *   name: 'my-script',
+   *   params: { input: 'data' }
+   * });
+   * ```
+   */
+  get data() {
+    if (!this._data) {
+      this._data = createData(this.client);
+    }
+    return this._data;
+  }
+  /**
+   * Utils namespace - Mermaid diagrams, document conversion, regex, JSON extraction
+   * 
+   * @example
+   * ```typescript
+   * // Generate diagram
+   * const diagram = await rainfall.utils.mermaid({
+   *   diagram: 'graph TD; A-->B;'
+   * });
+   * 
+   * // Convert document
+   * const pdf = await rainfall.utils.documentConvert({
+   *   document: markdownContent,
+   *   mimeType: 'text/markdown',
+   *   format: 'pdf'
+   * });
+   * 
+   * // Extract JSON from text
+   * const json = await rainfall.utils.jsonExtract({
+   *   text: 'Here is some data: {"key": "value"}'
+   * });
+   * ```
+   */
+  get utils() {
+    if (!this._utils) {
+      this._utils = createUtils(this.client);
+    }
+    return this._utils;
+  }
+  /**
+   * Get the underlying HTTP client for advanced usage
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * List all available tools
+   */
+  async listTools() {
+    return this.client.listTools();
+  }
+  /**
+   * Get schema for a specific tool
+   */
+  async getToolSchema(toolId) {
+    return this.client.getToolSchema(toolId);
+  }
+  /**
+   * Execute any tool by ID (low-level access)
+   */
+  async executeTool(toolId, params) {
+    return this.client.executeTool(toolId, params);
+  }
+  /**
+   * Get current subscriber info and usage
+   */
+  async getMe() {
+    return this.client.getMe();
+  }
+  /**
+   * Get current rate limit info
+   */
+  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/services/networked.ts
+init_cjs_shims();
+var RainfallNetworkedExecutor = class {
+  rainfall;
+  options;
+  edgeNodeId;
+  jobCallbacks = /* @__PURE__ */ new Map();
+  resultPollingInterval;
+  constructor(rainfall, options = {}) {
+    this.rainfall = rainfall;
+    this.options = {
+      wsPort: 8765,
+      httpPort: 8787,
+      hostname: process.env.HOSTNAME || "local-daemon",
+      capabilities: {
+        localExec: true,
+        fileWatch: true,
+        passiveListen: true
+      },
+      ...options
+    };
+  }
+  /**
+   * Register this edge node with the Rainfall backend
+   */
+  async registerEdgeNode() {
+    const capabilities = this.buildCapabilitiesList();
+    try {
+      const result = await this.rainfall.executeTool("register-edge-node", {
+        hostname: this.options.hostname,
+        capabilities,
+        wsPort: this.options.wsPort,
+        httpPort: this.options.httpPort,
+        version: "0.1.0"
+      });
+      this.edgeNodeId = result.edgeNodeId;
+      console.log(`\u{1F310} Edge node registered with Rainfall as ${this.edgeNodeId}`);
+      return this.edgeNodeId;
+    } catch (error) {
+      this.edgeNodeId = `edge-${this.options.hostname}-${Date.now()}`;
+      console.log(`\u{1F310} Edge node running in local mode (ID: ${this.edgeNodeId})`);
+      return this.edgeNodeId;
+    }
+  }
+  /**
+   * Unregister this edge node on shutdown
+   */
+  async unregisterEdgeNode() {
+    if (!this.edgeNodeId) return;
+    try {
+      await this.rainfall.executeTool("unregister-edge-node", {
+        edgeNodeId: this.edgeNodeId
+      });
+      console.log(`\u{1F310} Edge node ${this.edgeNodeId} unregistered`);
+    } catch {
+    }
+    if (this.resultPollingInterval) {
+      clearInterval(this.resultPollingInterval);
+    }
+  }
+  /**
+   * Queue a tool execution for distributed processing
+   * Non-blocking - returns immediately with a job ID
+   */
+  async queueToolExecution(toolId, params, options = {}) {
+    const executionMode = options.executionMode || "any";
+    try {
+      const result = await this.rainfall.executeTool("queue-job", {
+        toolId,
+        params,
+        executionMode,
+        requesterEdgeNodeId: this.edgeNodeId
+      });
+      if (options.callback) {
+        this.jobCallbacks.set(result.jobId, options.callback);
+        this.startResultPolling();
+      }
+      return result.jobId;
+    } catch (error) {
+      if (executionMode === "local-only" || executionMode === "any") {
+        try {
+          const result = await this.rainfall.executeTool(toolId, params);
+          if (options.callback) {
+            options.callback(result);
+          }
+          return `local-${Date.now()}`;
+        } catch (execError) {
+          if (options.callback) {
+            options.callback(null, String(execError));
+          }
+          throw execError;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get status of a queued job
+   */
+  async getJobStatus(jobId) {
+    try {
+      const result = await this.rainfall.executeTool("get-job-status", {
+        jobId
+      });
+      return result.job;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Subscribe to job results via polling (WebSocket fallback)
+   * In the future, this will use WebSocket push from ApresMoi
+   */
+  async subscribeToResults(callback) {
+    console.log("\u{1F4E1} Subscribed to job results via Rainfall (polling mode)");
+    this.onResultReceived = callback;
+  }
+  onResultReceived;
+  /**
+   * Start polling for job results (fallback until WebSocket push is ready)
+   */
+  startResultPolling() {
+    if (this.resultPollingInterval) return;
+    this.resultPollingInterval = setInterval(async () => {
+      for (const [jobId, callback] of this.jobCallbacks) {
+        try {
+          const job = await this.getJobStatus(jobId);
+          if (job?.status === "completed" || job?.status === "failed") {
+            callback(job.result, job.error);
+            this.jobCallbacks.delete(jobId);
+            if (this.onResultReceived) {
+              this.onResultReceived(jobId, job.result, job.error);
+            }
+          }
+        } catch {
+        }
+      }
+      if (this.jobCallbacks.size === 0 && this.resultPollingInterval) {
+        clearInterval(this.resultPollingInterval);
+        this.resultPollingInterval = void 0;
+      }
+    }, 2e3);
+  }
+  /**
+   * Claim a job for execution on this edge node
+   */
+  async claimJob() {
+    try {
+      const result = await this.rainfall.executeTool("claim-job", {
+        edgeNodeId: this.edgeNodeId,
+        capabilities: this.buildCapabilitiesList()
+      });
+      return result.job;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Submit job result after execution
+   */
+  async submitJobResult(jobId, result, error) {
+    try {
+      await this.rainfall.executeTool("submit-job-result", {
+        jobId,
+        edgeNodeId: this.edgeNodeId,
+        result,
+        error
+      });
+    } catch {
+    }
+  }
+  /**
+   * Get this edge node's ID
+   */
+  getEdgeNodeId() {
+    return this.edgeNodeId;
+  }
+  /**
+   * Build capabilities list from options
+   */
+  buildCapabilitiesList() {
+    const caps = this.options.capabilities || {};
+    const list = [];
+    if (caps.localExec) list.push("local-exec");
+    if (caps.fileWatch) list.push("file-watch");
+    if (caps.passiveListen) list.push("passive-listen");
+    if (caps.browser) list.push("browser");
+    if (caps.custom) list.push(...caps.custom);
+    return list;
+  }
+};
+
+// src/services/context.ts
+init_cjs_shims();
+var RainfallDaemonContext = class {
+  rainfall;
+  options;
+  localMemories = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  executionHistory = [];
+  currentSessionId;
+  constructor(rainfall, options = {}) {
+    this.rainfall = rainfall;
+    this.options = {
+      maxLocalMemories: 1e3,
+      maxMessageHistory: 100,
+      maxExecutionHistory: 500,
+      sessionTtl: 24 * 60 * 60 * 1e3,
+      // 24 hours
+      ...options
+    };
+  }
+  /**
+   * Initialize the context - load recent memories from cloud
+   */
+  async initialize() {
+    try {
+      const recentMemories = await this.rainfall.memory.recall({
+        query: "daemon:context",
+        topK: this.options.maxLocalMemories
+      });
+      for (const memory of recentMemories) {
+        this.localMemories.set(memory.id, {
+          id: memory.id,
+          content: memory.content,
+          keywords: memory.keywords || [],
+          timestamp: memory.timestamp,
+          source: memory.source,
+          metadata: memory.metadata
+        });
+      }
+      console.log(`\u{1F9E0} Loaded ${this.localMemories.size} memories into context`);
+    } catch (error) {
+      console.warn("\u26A0\uFE0F  Could not sync memories:", error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * Create or get a session
+   */
+  getSession(sessionId) {
+    if (sessionId && this.sessions.has(sessionId)) {
+      const session = this.sessions.get(sessionId);
+      session.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      return session;
+    }
+    const newSession = {
+      id: sessionId || `session-${Date.now()}`,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      variables: {},
+      messageHistory: []
+    };
+    this.sessions.set(newSession.id, newSession);
+    this.currentSessionId = newSession.id;
+    return newSession;
+  }
+  /**
+   * Get the current active session
+   */
+  getCurrentSession() {
+    if (this.currentSessionId) {
+      return this.sessions.get(this.currentSessionId);
+    }
+    return void 0;
+  }
+  /**
+   * Set the current active session
+   */
+  setCurrentSession(sessionId) {
+    if (this.sessions.has(sessionId)) {
+      this.currentSessionId = sessionId;
+    }
+  }
+  /**
+   * Add a message to the current session history
+   */
+  addMessage(role, content) {
+    const session = this.getCurrentSession();
+    if (!session) return;
+    session.messageHistory.push({
+      role,
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (session.messageHistory.length > this.options.maxMessageHistory) {
+      session.messageHistory = session.messageHistory.slice(-this.options.maxMessageHistory);
+    }
+  }
+  /**
+   * Store a memory (local + cloud sync)
+   */
+  async storeMemory(content, options = {}) {
+    const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const entry = {
+      id,
+      content,
+      keywords: options.keywords || [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: options.source || "daemon",
+      metadata: options.metadata
+    };
+    this.localMemories.set(id, entry);
+    try {
+      await this.rainfall.memory.create({
+        content,
+        keywords: [...options.keywords || [], "daemon:context"],
+        metadata: {
+          ...options.metadata,
+          daemonMemoryId: id,
+          source: options.source || "daemon"
+        }
+      });
+    } catch (error) {
+      console.warn("\u26A0\uFE0F  Could not sync memory to cloud:", error instanceof Error ? error.message : error);
+    }
+    this.trimLocalMemories();
+    return id;
+  }
+  /**
+   * Recall memories by query
+   */
+  async recallMemories(query, topK = 5) {
+    const localResults = Array.from(this.localMemories.values()).filter(
+      (m) => m.content.toLowerCase().includes(query.toLowerCase()) || m.keywords.some((k) => k.toLowerCase().includes(query.toLowerCase()))
+    ).slice(0, topK);
+    try {
+      const cloudResults = await this.rainfall.memory.recall({ query, topK });
+      const seen = new Set(localResults.map((r) => r.id));
+      for (const mem of cloudResults) {
+        if (!seen.has(mem.id)) {
+          localResults.push({
+            id: mem.id,
+            content: mem.content,
+            keywords: mem.keywords || [],
+            timestamp: mem.timestamp,
+            source: mem.source,
+            metadata: mem.metadata
+          });
+        }
+      }
+    } catch {
+    }
+    return localResults.slice(0, topK);
+  }
+  /**
+   * Set a session variable
+   */
+  setVariable(key, value) {
+    const session = this.getCurrentSession();
+    if (session) {
+      session.variables[key] = value;
+    }
+  }
+  /**
+   * Get a session variable
+   */
+  getVariable(key) {
+    const session = this.getCurrentSession();
+    return session?.variables[key];
+  }
+  /**
+   * Record a tool execution
+   */
+  recordExecution(toolId, params, result, options = { duration: 0 }) {
+    const record = {
+      id: `exec-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      toolId,
+      params,
+      result,
+      error: options.error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: options.duration,
+      edgeNodeId: options.edgeNodeId
+    };
+    this.executionHistory.push(record);
+    if (this.executionHistory.length > this.options.maxExecutionHistory) {
+      this.executionHistory = this.executionHistory.slice(-this.options.maxExecutionHistory);
+    }
+  }
+  /**
+   * Get recent execution history
+   */
+  getExecutionHistory(limit = 10) {
+    return this.executionHistory.slice(-limit).reverse();
+  }
+  /**
+   * Get execution statistics
+   */
+  getExecutionStats() {
+    const stats = {
+      total: this.executionHistory.length,
+      successful: 0,
+      failed: 0,
+      averageDuration: 0,
+      byTool: {}
+    };
+    let totalDuration = 0;
+    for (const exec of this.executionHistory) {
+      if (exec.error) {
+        stats.failed++;
+      } else {
+        stats.successful++;
+      }
+      totalDuration += exec.duration;
+      stats.byTool[exec.toolId] = (stats.byTool[exec.toolId] || 0) + 1;
+    }
+    stats.averageDuration = stats.total > 0 ? totalDuration / stats.total : 0;
+    return stats;
+  }
+  /**
+   * Clear old sessions based on TTL
+   */
+  cleanupSessions() {
+    const now = Date.now();
+    const ttl = this.options.sessionTtl;
+    for (const [id, session] of this.sessions) {
+      const lastActivity = new Date(session.lastActivity).getTime();
+      if (now - lastActivity > ttl) {
+        this.sessions.delete(id);
+        if (this.currentSessionId === id) {
+          this.currentSessionId = void 0;
+        }
+      }
+    }
+  }
+  /**
+   * Get context summary for debugging
+   */
+  getStatus() {
+    return {
+      memoriesCached: this.localMemories.size,
+      activeSessions: this.sessions.size,
+      currentSession: this.currentSessionId,
+      executionHistorySize: this.executionHistory.length
+    };
+  }
+  trimLocalMemories() {
+    if (this.localMemories.size <= this.options.maxLocalMemories) return;
+    const entries = Array.from(this.localMemories.entries()).sort((a, b) => new Date(a[1].timestamp).getTime() - new Date(b[1].timestamp).getTime());
+    const toRemove = entries.slice(0, entries.length - this.options.maxLocalMemories);
+    for (const [id] of toRemove) {
+      this.localMemories.delete(id);
+    }
+  }
+};
+
+// src/services/listeners.ts
+init_cjs_shims();
+var RainfallListenerRegistry = class {
+  rainfall;
+  context;
+  executor;
+  watchers = /* @__PURE__ */ new Map();
+  cronIntervals = /* @__PURE__ */ new Map();
+  eventHistory = [];
+  maxEventHistory = 100;
+  constructor(rainfall, context, executor) {
+    this.rainfall = rainfall;
+    this.context = context;
+    this.executor = executor;
+  }
+  /**
+   * Register a file watcher
+   * Note: Actual file watching requires fs.watch or chokidar
+   * This is the registry - actual watching is done by the daemon
+   */
+  async registerFileWatcher(config) {
+    console.log(`\u{1F441}\uFE0F  Registering file watcher: ${config.name} (${config.watchPath})`);
+    const existing = Array.from(this.watchers.keys());
+    if (existing.includes(config.id)) {
+      await this.unregisterFileWatcher(config.id);
+    }
+    this.watchers.set(config.id, {
+      stop: () => {
+        console.log(`\u{1F441}\uFE0F  Stopped file watcher: ${config.name}`);
+      }
+    });
+    await this.context.storeMemory(`File watcher registered: ${config.name}`, {
+      keywords: ["listener", "file-watcher", config.name],
+      metadata: { config }
+    });
+  }
+  /**
+   * Unregister a file watcher
+   */
+  async unregisterFileWatcher(id) {
+    const watcher = this.watchers.get(id);
+    if (watcher) {
+      watcher.stop();
+      this.watchers.delete(id);
+    }
+  }
+  /**
+   * Register a cron trigger
+   */
+  async registerCronTrigger(config) {
+    console.log(`\u23F0 Registering cron trigger: ${config.name} (${config.cron})`);
+    if (this.cronIntervals.has(config.id)) {
+      clearInterval(this.cronIntervals.get(config.id));
+      this.cronIntervals.delete(config.id);
+    }
+    const interval = this.parseCronToMs(config.cron);
+    if (interval) {
+      const intervalId = setInterval(async () => {
+        await this.handleCronTick(config);
+      }, interval);
+      this.cronIntervals.set(config.id, intervalId);
+    }
+    await this.context.storeMemory(`Cron trigger registered: ${config.name}`, {
+      keywords: ["listener", "cron", config.name],
+      metadata: { config }
+    });
+  }
+  /**
+   * Unregister a cron trigger
+   */
+  unregisterCronTrigger(id) {
+    const interval = this.cronIntervals.get(id);
+    if (interval) {
+      clearInterval(interval);
+      this.cronIntervals.delete(id);
+    }
+  }
+  /**
+   * Handle a file event
+   */
+  async handleFileEvent(watcherId, eventType, filePath) {
+    const event = {
+      id: `evt-${Date.now()}`,
+      type: "file",
+      source: watcherId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { eventType, filePath }
+    };
+    this.recordEvent(event);
+    console.log(`\u{1F4C1} File event: ${eventType} ${filePath}`);
+  }
+  /**
+   * Handle a cron tick
+   */
+  async handleCronTick(config) {
+    const event = {
+      id: `evt-${Date.now()}`,
+      type: "cron",
+      source: config.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data: { cron: config.cron }
+    };
+    this.recordEvent(event);
+    console.log(`\u23F0 Cron tick: ${config.name}`);
+    for (const step of config.workflow) {
+      try {
+        await this.executor.queueToolExecution(step.toolId, {
+          ...step.params,
+          _event: event
+        });
+      } catch (error) {
+        console.error(`\u274C Workflow step failed: ${step.toolId}`, error);
+      }
+    }
+  }
+  /**
+   * Trigger a manual event (for testing or programmatic triggers)
+   */
+  async triggerManual(name, data = {}) {
+    const event = {
+      id: `evt-${Date.now()}`,
+      type: "manual",
+      source: name,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    this.recordEvent(event);
+    console.log(`\u{1F446} Manual trigger: ${name}`);
+    await this.context.storeMemory(`Manual trigger fired: ${name}`, {
+      keywords: ["trigger", "manual", name],
+      metadata: { event }
+    });
+  }
+  /**
+   * Get recent events
+   */
+  getRecentEvents(limit = 10) {
+    return this.eventHistory.slice(-limit).reverse();
+  }
+  /**
+   * Get active listeners status
+   */
+  getStatus() {
+    return {
+      fileWatchers: this.watchers.size,
+      cronTriggers: this.cronIntervals.size,
+      recentEvents: this.eventHistory.length
+    };
+  }
+  /**
+   * Stop all listeners
+   */
+  async stopAll() {
+    for (const [id] of this.watchers) {
+      await this.unregisterFileWatcher(id);
+    }
+    for (const [id] of this.cronIntervals) {
+      this.unregisterCronTrigger(id);
+    }
+    console.log("\u{1F6D1} All listeners stopped");
+  }
+  recordEvent(event) {
+    this.eventHistory.push(event);
+    if (this.eventHistory.length > this.maxEventHistory) {
+      this.eventHistory = this.eventHistory.slice(-this.maxEventHistory);
+    }
+  }
+  /**
+   * Simple cron parser - converts basic cron expressions to milliseconds
+   * Supports: @hourly, @daily, @weekly, and simple intervals like every N minutes
+   */
+  parseCronToMs(cron) {
+    switch (cron) {
+      case "@hourly":
+        return 60 * 60 * 1e3;
+      case "@daily":
+        return 24 * 60 * 60 * 1e3;
+      case "@weekly":
+        return 7 * 24 * 60 * 60 * 1e3;
+      case "@minutely":
+        return 60 * 1e3;
+    }
+    const match = cron.match(/^\*\/(\d+)\s/);
+    if (match) {
+      const minutes = parseInt(match[1], 10);
+      if (minutes > 0 && minutes <= 60) {
+        return minutes * 60 * 1e3;
+      }
+    }
+    console.warn(`\u26A0\uFE0F  Unrecognized cron pattern "${cron}", using 1 minute interval`);
+    return 60 * 1e3;
+  }
+};
+
+// src/services/mcp-proxy.ts
+init_cjs_shims();
+var import_ws = require("ws");
+var import_client2 = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_types = require("@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 import_client2.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 import_stdio.StdioClientTransport({
+          command: config.command,
+          args: config.args,
+          env
+        });
+      } else if (transport === "http" && config.url) {
+        transportInstance = new import_streamableHttp.StreamableHTTPClientTransport(
+          new URL(config.url),
+          {
+            requestInit: {
+              headers: config.headers
+            }
+          }
+        );
+      } else if (transport === "websocket" && config.url) {
+        transportInstance = new import_ws.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: {}
+        },
+        import_types.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
+            }
+          },
+          import_types.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 import_types.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: {}
+          },
+          import_types.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: {}
+          },
+          import_types.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 }
+        },
+        import_types.ReadResourceResultSchema
+      );
+      return result;
+    } else {
+      for (const [name, client] of this.clients) {
+        try {
+          const result = await client.client.request(
+            {
+              method: "resources/read",
+              params: { uri }
+            },
+            import_types.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: {}
+          },
+          import_types.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 }
+        },
+        import_types.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 }
+            },
+            import_types.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: {}
+          },
+          import_types.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 = (0, import_express.default)();
+    this.openaiApp.use(import_express.default.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: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      const config = loadConfig2();
+      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 import_ws2.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: loadConfig2, getProviderBaseUrl: getProviderBaseUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config = loadConfig2();
+    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: getProviderBaseUrl2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const baseUrl = config.llm?.baseUrl || getProviderBaseUrl2({ 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPProxyHub,
+  RainfallDaemon,
+  getDaemonInstance,
+  getDaemonStatus,
+  startDaemon,
+  stopDaemon
+});