@rainfall-devkit/sdk 0.1.7 → 0.2.0

package/dist/cli/index.js

@@ -1,93 +1,46 @@
 #!/usr/bin/env node
 "use strict";
-
-// src/cli/index.ts
-var import_fs = require("fs");
-var import_path = require("path");
-var import_os = require("os");
-
-// src/errors.ts
-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 __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 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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-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 __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 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);
+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
+));
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl, importMetaUrl;
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+    getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+    importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
   }
-};
+});
+
+// src/errors.ts
 function parseErrorResponse(response, data) {
   const statusCode = response.status;
   if (statusCode === 429) {
@@ -136,294 +89,441 @@ function parseErrorResponse(response, data) {
       );
   }
 }
+var RainfallError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, ServerError, TimeoutError, NetworkError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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
+        };
+      }
+    };
+    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);
+      }
+    };
+    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);
+      }
+    };
+    ValidationError = class _ValidationError extends RainfallError {
+      constructor(message, details) {
+        super(message, "VALIDATION_ERROR", 400, details);
+        this.name = "ValidationError";
+        Object.setPrototypeOf(this, _ValidationError.prototype);
+      }
+    };
+    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);
+      }
+    };
+    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);
+      }
+    };
+    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);
+      }
+    };
+    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);
+      }
+    };
+  }
+});
 
 // 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();
+var DEFAULT_BASE_URL, DEFAULT_TIMEOUT, DEFAULT_RETRIES, DEFAULT_RETRY_DELAY, RainfallClient;
+var init_client = __esm({
+  "src/client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_errors();
+    DEFAULT_BASE_URL = "https://olympic-api.pragma-digital.org/v1";
+    DEFAULT_TIMEOUT = 3e4;
+    DEFAULT_RETRIES = 3;
+    DEFAULT_RETRY_DELAY = 1e3;
+    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);
+          }
         }
-        if (!response.ok) {
-          throw parseErrorResponse(response, data);
+        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);
         }
-        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;
+        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;
         }
-        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));
+        const me = await this.getMe();
+        if (!me.id) {
+          throw new RainfallError("Failed to get subscriber ID", "NO_SUBSCRIBER_ID");
         }
-        if (attempt >= maxRetries) {
-          break;
+        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;
         }
-        const delay = retryDelay * Math.pow(2, attempt) + Math.random() * 1e3;
-        await this.sleep(delay);
+        return this.request(
+          `/olympic/subscribers/${subscriber_id}/v1/chat/completions`,
+          {
+            method: "POST",
+            body
+          }
+        );
       }
-    }
-    throw lastError || new RainfallError("Request failed", "REQUEST_FAILED");
-  }
-  /**
-   * Execute a tool/node by ID
-   */
-  async executeTool(toolId, params, options) {
-    const subscriberId = await this.ensureSubscriberId();
-    return this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}`, {
-      method: "POST",
-      body: params
-    }, options);
-  }
-  /**
-   * 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
+      /**
+       * 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 || [];
       }
     };
   }
-  /**
-   * 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));
-  }
-};
+});
 
 // src/namespaces/integrations.ts
 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)
+var IntegrationsNamespace;
+var init_integrations = __esm({
+  "src/namespaces/integrations.ts"() {
+    "use strict";
+    init_cjs_shims();
+    IntegrationsNamespace = class {
+      constructor(client) {
+        this.client = client;
       }
-    };
-  }
-  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 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 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 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 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 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 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 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 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 })
+      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
 function createMemory(client) {
@@ -436,6 +536,12 @@ function createMemory(client) {
     delete: (params) => client.executeTool("memory-delete", { memoryId: params.memoryId })
   };
 }
+var init_memory = __esm({
+  "src/namespaces/memory.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/articles.ts
 function createArticles(client) {
@@ -450,6 +556,12 @@ function createArticles(client) {
     extractTopics: (params) => client.executeTool("article-topic-extractor", params)
   };
 }
+var init_articles = __esm({
+  "src/namespaces/articles.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/web.ts
 function createWeb(client) {
@@ -463,6 +575,12 @@ function createWeb(client) {
     extractHtml: (params) => client.executeTool("extract-html-selector", params)
   };
 }
+var init_web = __esm({
+  "src/namespaces/web.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/ai.ts
 function createAI(client) {
@@ -480,9 +598,20 @@ function createAI(client) {
     chat: (params) => client.executeTool("xai-chat-completions", params),
     complete: (params) => client.executeTool("fim", params),
     classify: (params) => client.executeTool("jina-document-classifier", params),
-    segment: (params) => client.executeTool("jina-text-segmenter", params)
+    segment: (params) => client.executeTool("jina-text-segmenter", params),
+    /**
+     * OpenAI-compatible chat completions with full tool support
+     * This is the recommended method for multi-turn conversations with tools
+     */
+    chatCompletions: (params) => client.chatCompletions(params)
   };
 }
+var init_ai = __esm({
+  "src/namespaces/ai.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/data.ts
 function createData(client) {
@@ -504,6 +633,12 @@ function createData(client) {
     }
   };
 }
+var init_data = __esm({
+  "src/namespaces/data.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/namespaces/utils.ts
 function createUtils(client) {
@@ -522,276 +657,1908 @@ function createUtils(client) {
     monteCarlo: (params) => client.executeTool("monte-carlo-simulation", params)
   };
 }
+var init_utils = __esm({
+  "src/namespaces/utils.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/sdk.ts
-var Rainfall = class {
-  client;
-  _integrations;
-  _memory;
-  _articles;
-  _web;
-  _ai;
-  _data;
-  _utils;
-  constructor(config) {
-    this.client = new RainfallClient(config);
+var Rainfall;
+var init_sdk = __esm({
+  "src/sdk.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_client();
+    init_integrations();
+    init_memory();
+    init_articles();
+    init_web();
+    init_ai();
+    init_data();
+    init_utils();
+    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);
+      }
+    };
   }
-  /**
-   * 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);
+});
+
+// src/cli/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getLLMConfig: () => getLLMConfig,
+  getProviderBaseUrl: () => getProviderBaseUrl,
+  isLocalProvider: () => isLocalProvider,
+  loadConfig: () => loadConfig,
+  saveConfig: () => saveConfig
+});
+function loadConfig() {
+  let config = {};
+  if ((0, import_fs.existsSync)(CONFIG_FILE)) {
+    try {
+      config = JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf8"));
+    } catch {
+      config = {};
     }
-    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;
+  if (process.env.RAINFALL_API_KEY) {
+    config.apiKey = process.env.RAINFALL_API_KEY;
   }
-  /**
-   * 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;
+  if (process.env.RAINFALL_BASE_URL) {
+    config.baseUrl = process.env.RAINFALL_BASE_URL;
   }
-  /**
-   * 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;
+  if (!config.llm) {
+    config.llm = { provider: "rainfall" };
   }
-  /**
-   * 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;
+  if (process.env.OPENAI_API_KEY) {
+    config.llm.provider = config.llm.provider || "openai";
+    config.llm.apiKey = process.env.OPENAI_API_KEY;
   }
-  /**
-   * 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;
+  if (process.env.ANTHROPIC_API_KEY) {
+    config.llm.provider = "anthropic";
+    config.llm.apiKey = process.env.ANTHROPIC_API_KEY;
   }
-  /**
-   * Get the underlying HTTP client for advanced usage
-   */
-  getClient() {
-    return this.client;
+  if (process.env.OLLAMA_HOST || process.env.OLLAMA_URL) {
+    config.llm.provider = "ollama";
+    config.llm.baseUrl = process.env.OLLAMA_HOST || process.env.OLLAMA_URL;
   }
-  /**
-   * List all available tools
-   */
-  async listTools() {
-    return this.client.listTools();
+  if (process.env.LLM_MODEL) {
+    config.llm.model = process.env.LLM_MODEL;
   }
-  /**
-   * Get schema for a specific tool
-   */
-  async getToolSchema(toolId) {
-    return this.client.getToolSchema(toolId);
+  return config;
+}
+function saveConfig(config) {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
+    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
   }
-  /**
-   * Execute any tool by ID (low-level access)
-   */
-  async executeTool(toolId, params) {
-    return this.client.executeTool(toolId, params);
+  (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":
+      return config.llm?.baseUrl || "http://localhost:1234/v1";
+    case "rainfall":
+    default:
+      return config.baseUrl || "https://api.rainfall.com";
   }
-  /**
-   * Get current subscriber info and usage
-   */
-  async getMe() {
-    return this.client.getMe();
+}
+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");
   }
-  /**
-   * Get current rate limit info
-   */
-  getRateLimitInfo() {
-    return this.client.getRateLimitInfo();
+});
+
+// src/services/networked.ts
+var RainfallNetworkedExecutor;
+var init_networked = __esm({
+  "src/services/networked.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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/cli/index.ts
-var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".rainfall");
-var CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
-function loadConfig() {
-  if (!(0, import_fs.existsSync)(CONFIG_FILE)) {
-    return {};
+// src/services/context.ts
+var RainfallDaemonContext;
+var init_context = __esm({
+  "src/services/context.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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);
+        }
+      }
+    };
   }
-  try {
-    return JSON.parse((0, import_fs.readFileSync)(CONFIG_FILE, "utf8"));
-  } catch {
-    return {};
+});
+
+// src/services/listeners.ts
+var RainfallListenerRegistry;
+var init_listeners = __esm({
+  "src/services/listeners.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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/daemon/index.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  RainfallDaemon: () => RainfallDaemon,
+  getDaemonInstance: () => getDaemonInstance,
+  getDaemonStatus: () => getDaemonStatus,
+  startDaemon: () => startDaemon,
+  stopDaemon: () => stopDaemon
+});
+async function startDaemon(config = {}) {
+  if (daemonInstance) {
+    console.log("Daemon already running");
+    return daemonInstance;
+  }
+  daemonInstance = new RainfallDaemon(config);
+  await daemonInstance.start();
+  return daemonInstance;
 }
-function saveConfig(config) {
-  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
-    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+async function stopDaemon() {
+  if (!daemonInstance) {
+    console.log("Daemon not running");
+    return;
   }
-  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+  await daemonInstance.stop();
+  daemonInstance = null;
 }
-function getRainfall() {
-  const config = loadConfig();
-  if (!config.apiKey) {
-    console.error("Error: No API key configured. Run: rainfall auth login");
-    process.exit(1);
+function getDaemonStatus() {
+  if (!daemonInstance) {
+    return null;
   }
-  return new Rainfall({
-    apiKey: config.apiKey,
-    baseUrl: config.baseUrl
-  });
+  return daemonInstance.getStatus();
+}
+function getDaemonInstance() {
+  return daemonInstance;
 }
+var import_ws, import_express, RainfallDaemon, daemonInstance;
+var init_daemon = __esm({
+  "src/daemon/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_ws = require("ws");
+    import_express = __toESM(require("express"));
+    init_sdk();
+    init_networked();
+    init_context();
+    init_listeners();
+    RainfallDaemon = class {
+      wss;
+      openaiApp;
+      rainfall;
+      port;
+      openaiPort;
+      rainfallConfig;
+      tools = [];
+      toolSchemas = /* @__PURE__ */ new Map();
+      clients = /* @__PURE__ */ new Set();
+      debug;
+      // New services
+      networkedExecutor;
+      context;
+      listeners;
+      constructor(config = {}) {
+        this.port = config.port || 8765;
+        this.openaiPort = config.openaiPort || 8787;
+        this.rainfallConfig = config.rainfallConfig;
+        this.debug = config.debug || false;
+        this.openaiApp = (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();
+        await this.startWebSocketServer();
+        await this.startOpenAIProxy();
+        console.log(`\u{1F680} Rainfall daemon running`);
+        console.log(`   WebSocket (MCP):     ws://localhost:${this.port}`);
+        console.log(`   OpenAI API:          http://localhost:${this.openaiPort}/v1/chat/completions`);
+        console.log(`   Health Check:        http://localhost:${this.openaiPort}/health`);
+        console.log(`   Edge Node ID:        ${this.networkedExecutor.getEdgeNodeId() || "local"}`);
+        console.log(`   Tools loaded:        ${this.tools.length}`);
+        console.log(`   Press Ctrl+C to stop`);
+        process.on("SIGINT", () => this.stop());
+        process.on("SIGTERM", () => this.stop());
+      }
+      async stop() {
+        this.log("\u{1F6D1} Shutting down Rainfall daemon...");
+        if (this.listeners) {
+          await this.listeners.stopAll();
+        }
+        if (this.networkedExecutor) {
+          await this.networkedExecutor.unregisterEdgeNode();
+        }
+        for (const client of this.clients) {
+          client.close();
+        }
+        this.clients.clear();
+        if (this.wss) {
+          this.wss.close();
+          this.wss = void 0;
+        }
+        console.log("\u{1F44B} Rainfall daemon stopped");
+      }
+      /**
+       * Get the networked executor for distributed job management
+       */
+      getNetworkedExecutor() {
+        return this.networkedExecutor;
+      }
+      /**
+       * Get the context for memory/session management
+       */
+      getContext() {
+        return this.context;
+      }
+      /**
+       * Get the listener registry for passive triggers
+       */
+      getListenerRegistry() {
+        return this.listeners;
+      }
+      async initializeRainfall() {
+        if (this.rainfallConfig?.apiKey) {
+          this.rainfall = new Rainfall(this.rainfallConfig);
+        } else {
+          const { loadConfig: 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_ws.WebSocketServer({ port: this.port });
+        this.wss.on("connection", (ws) => {
+          this.log("\u{1F7E2} MCP client connected");
+          this.clients.add(ws);
+          ws.on("message", async (data) => {
+            try {
+              const message = JSON.parse(data.toString());
+              const response = await this.handleMCPMessage(message);
+              ws.send(JSON.stringify(response));
+            } catch (error) {
+              const errorResponse = {
+                jsonrpc: "2.0",
+                id: void 0,
+                error: {
+                  code: -32700,
+                  message: error instanceof Error ? error.message : "Parse error"
+                }
+              };
+              ws.send(JSON.stringify(errorResponse));
+            }
+          });
+          ws.on("close", () => {
+            this.log("\u{1F534} MCP client disconnected");
+            this.clients.delete(ws);
+          });
+          ws.on("error", (error) => {
+            console.error("WebSocket error:", error);
+            this.clients.delete(ws);
+          });
+        });
+      }
+      async handleMCPMessage(message) {
+        const { id, method, params } = message;
+        switch (method) {
+          case "initialize":
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {
+                protocolVersion: "2024-11-05",
+                capabilities: {
+                  tools: { listChanged: true }
+                },
+                serverInfo: {
+                  name: "rainfall-daemon",
+                  version: "0.1.0"
+                }
+              }
+            };
+          case "tools/list":
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {
+                tools: await this.getMCPTools()
+              }
+            };
+          case "tools/call": {
+            const toolName = params?.name;
+            const toolParams = params?.arguments;
+            try {
+              const startTime = Date.now();
+              const result = await this.executeTool(toolName, toolParams);
+              const duration = Date.now() - startTime;
+              if (this.context) {
+                this.context.recordExecution(toolName, toolParams || {}, result, { duration });
+              }
+              return {
+                jsonrpc: "2.0",
+                id,
+                result: {
+                  content: [
+                    {
+                      type: "text",
+                      text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+                    }
+                  ]
+                }
+              };
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
+              if (this.context) {
+                this.context.recordExecution(toolName, toolParams || {}, null, {
+                  error: errorMessage,
+                  duration: 0
+                });
+              }
+              return {
+                jsonrpc: "2.0",
+                id,
+                error: {
+                  code: -32603,
+                  message: errorMessage
+                }
+              };
+            }
+          }
+          case "ping":
+            return {
+              jsonrpc: "2.0",
+              id,
+              result: {}
+            };
+          default:
+            return {
+              jsonrpc: "2.0",
+              id,
+              error: {
+                code: -32601,
+                message: `Method not found: ${method}`
+              }
+            };
+        }
+      }
+      async getMCPTools() {
+        const mcpTools = [];
+        for (const tool of this.tools) {
+          const schema = await this.getToolSchema(tool.id);
+          if (schema) {
+            const toolSchema = schema;
+            mcpTools.push({
+              name: tool.id,
+              description: toolSchema.description || tool.description,
+              inputSchema: toolSchema.parameters || { type: "object", properties: {} }
+            });
+          }
+        }
+        return mcpTools;
+      }
+      async executeTool(toolId, params) {
+        if (!this.rainfall) {
+          throw new Error("Rainfall SDK not initialized");
+        }
+        return this.rainfall.executeTool(toolId, params);
+      }
+      async startOpenAIProxy() {
+        this.openaiApp.get("/v1/models", async (_req, res) => {
+          try {
+            if (this.rainfall) {
+              const models = await this.rainfall.listModels();
+              res.json({
+                object: "list",
+                data: models.map((m) => ({
+                  id: m.id,
+                  object: "model",
+                  created: Math.floor(Date.now() / 1e3),
+                  owned_by: "rainfall"
+                }))
+              });
+            } else {
+              res.json({
+                object: "list",
+                data: [
+                  { id: "llama-3.3-70b-versatile", object: "model", created: Date.now(), owned_by: "groq" },
+                  { id: "gpt-4o", object: "model", created: Date.now(), owned_by: "openai" },
+                  { id: "claude-3-5-sonnet", object: "model", created: Date.now(), owned_by: "anthropic" },
+                  { id: "gemini-2.0-flash-exp", object: "model", created: Date.now(), owned_by: "gemini" }
+                ]
+              });
+            }
+          } catch (error) {
+            res.status(500).json({ error: "Failed to fetch models" });
+          }
+        });
+        this.openaiApp.post("/v1/chat/completions", async (req, res) => {
+          const body = req.body;
+          if (!body.messages || !Array.isArray(body.messages)) {
+            res.status(400).json({
+              error: {
+                message: "Missing required field: messages",
+                type: "invalid_request_error"
+              }
+            });
+            return;
+          }
+          if (!this.rainfall) {
+            res.status(503).json({
+              error: {
+                message: "Rainfall SDK not initialized",
+                type: "service_unavailable"
+              }
+            });
+            return;
+          }
+          try {
+            const me = await this.rainfall.getMe();
+            const subscriberId = me.id;
+            const localToolMap = await this.buildLocalToolMap();
+            let allTools = [];
+            if (body.tools && body.tools.length > 0) {
+              allTools = body.tools;
+            } else if (body.tool_choice) {
+              const openaiTools = await this.getOpenAITools();
+              allTools = openaiTools;
+            }
+            let messages = [...body.messages];
+            const maxToolIterations = 10;
+            let toolIterations = 0;
+            while (toolIterations < maxToolIterations) {
+              toolIterations++;
+              const llmResponse = await this.callLLM({
+                subscriberId,
+                model: body.model,
+                messages,
+                tools: allTools.length > 0 ? allTools : void 0,
+                tool_choice: body.tool_choice,
+                temperature: body.temperature,
+                max_tokens: body.max_tokens,
+                stream: false,
+                // Always non-streaming for tool loop
+                tool_priority: body.tool_priority,
+                enable_stacked: body.enable_stacked
+              });
+              const choice = llmResponse.choices?.[0];
+              let toolCalls = choice?.message?.tool_calls || [];
+              const content = choice?.message?.content || "";
+              const reasoningContent = choice?.message?.reasoning_content || "";
+              const fullContent = content + " " + reasoningContent;
+              const xmlToolCalls = this.parseXMLToolCalls(fullContent);
+              if (xmlToolCalls.length > 0) {
+                this.log(`\u{1F4CB} Parsed ${xmlToolCalls.length} XML tool calls from content`);
+                toolCalls = xmlToolCalls;
+              }
+              if (!toolCalls || toolCalls.length === 0) {
+                if (body.stream) {
+                  await this.streamResponse(res, llmResponse);
+                } else {
+                  res.json(llmResponse);
+                }
+                this.updateContext(body.messages, llmResponse);
+                return;
+              }
+              messages.push({
+                role: "assistant",
+                content: choice?.message?.content || "",
+                tool_calls: toolCalls
+              });
+              for (const toolCall of toolCalls) {
+                const toolName = toolCall.function?.name;
+                const toolArgsStr = toolCall.function?.arguments || "{}";
+                if (!toolName) continue;
+                this.log(`\u{1F527} Tool call: ${toolName}`);
+                let toolResult;
+                let toolError;
+                try {
+                  const localTool = this.findLocalTool(toolName, localToolMap);
+                  if (localTool) {
+                    this.log(`  \u2192 Executing locally`);
+                    const args = JSON.parse(toolArgsStr);
+                    toolResult = await this.executeLocalTool(localTool.id, args);
+                  } else {
+                    const shouldExecuteLocal = body.tool_priority === "local" || body.tool_priority === "stacked";
+                    if (shouldExecuteLocal) {
+                      try {
+                        const args = JSON.parse(toolArgsStr);
+                        toolResult = await this.rainfall.executeTool(toolName.replace(/_/g, "-"), args);
+                      } catch {
+                        toolResult = { _pending: true, tool: toolName, args: toolArgsStr };
+                      }
+                    } else {
+                      toolResult = { _pending: true, tool: toolName, args: toolArgsStr };
+                    }
+                  }
+                } catch (error) {
+                  toolError = error instanceof Error ? error.message : String(error);
+                  this.log(`  \u2192 Error: ${toolError}`);
+                }
+                messages.push({
+                  role: "tool",
+                  content: toolError ? JSON.stringify({ error: toolError }) : typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult),
+                  tool_call_id: toolCall.id
+                });
+                if (this.context) {
+                  this.context.recordExecution(
+                    toolName,
+                    JSON.parse(toolArgsStr || "{}"),
+                    toolResult,
+                    { error: toolError, duration: 0 }
+                  );
+                }
+              }
+            }
+            res.status(500).json({
+              error: {
+                message: "Maximum tool execution iterations reached",
+                type: "tool_execution_error"
+              }
+            });
+          } catch (error) {
+            this.log("Chat completions error:", error);
+            res.status(500).json({
+              error: {
+                message: error instanceof Error ? error.message : "Internal server error",
+                type: "internal_error"
+              }
+            });
+          }
+        });
+        this.openaiApp.get("/health", (_req, res) => {
+          res.json({
+            status: "ok",
+            daemon: "rainfall",
+            version: "0.1.0",
+            tools_loaded: this.tools.length,
+            edge_node_id: this.networkedExecutor?.getEdgeNodeId(),
+            clients_connected: this.clients.size
+          });
+        });
+        this.openaiApp.get("/status", (_req, res) => {
+          res.json(this.getStatus());
+        });
+        this.openaiApp.post("/v1/queue", async (req, res) => {
+          const { tool_id, params, execution_mode = "any" } = req.body;
+          if (!tool_id) {
+            res.status(400).json({ error: "Missing required field: tool_id" });
+            return;
+          }
+          if (!this.networkedExecutor) {
+            res.status(503).json({ error: "Networked executor not available" });
+            return;
+          }
+          try {
+            const jobId = await this.networkedExecutor.queueToolExecution(
+              tool_id,
+              params || {},
+              { executionMode: execution_mode }
+            );
+            res.json({ job_id: jobId, status: "queued" });
+          } catch (error) {
+            res.status(500).json({
+              error: error instanceof Error ? error.message : "Failed to queue job"
+            });
+          }
+        });
+        return new Promise((resolve) => {
+          this.openaiApp.listen(this.openaiPort, () => {
+            resolve();
+          });
+        });
+      }
+      /**
+       * Build a map of local Rainfall tools for quick lookup
+       * Maps OpenAI-style underscore names to Rainfall tool IDs
+       */
+      async buildLocalToolMap() {
+        const map = /* @__PURE__ */ new Map();
+        for (const tool of this.tools) {
+          const openAiName = tool.id.replace(/-/g, "_");
+          map.set(openAiName, {
+            id: tool.id,
+            name: openAiName,
+            description: tool.description
+          });
+          map.set(tool.id, {
+            id: tool.id,
+            name: openAiName,
+            description: tool.description
+          });
+        }
+        return map;
+      }
+      /**
+       * Find a local Rainfall tool by name (OpenAI underscore format or original)
+       */
+      findLocalTool(toolName, localToolMap) {
+        if (localToolMap.has(toolName)) {
+          return localToolMap.get(toolName);
+        }
+        const dashedName = toolName.replace(/_/g, "-");
+        if (localToolMap.has(dashedName)) {
+          return localToolMap.get(dashedName);
+        }
+        return void 0;
+      }
+      /**
+       * Execute a local Rainfall tool
+       */
+      async executeLocalTool(toolId, args) {
+        if (!this.rainfall) {
+          throw new Error("Rainfall SDK not initialized");
+        }
+        const startTime = Date.now();
+        try {
+          const result = await this.rainfall.executeTool(toolId, args);
+          const duration = Date.now() - startTime;
+          this.log(`  \u2713 Completed in ${duration}ms`);
+          return result;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          this.log(`  \u2717 Failed after ${duration}ms`);
+          throw error;
+        }
+      }
+      /**
+       * Parse XML-style tool calls from model output
+       * Handles formats like: <function=name><parameter=key>value</parameter></function>
+       */
+      parseXMLToolCalls(content) {
+        const toolCalls = [];
+        const functionRegex = /<function=([^>]+)>([\s\S]*?)<\/function>/gi;
+        let match;
+        while ((match = functionRegex.exec(content)) !== null) {
+          const functionName = match[1].trim();
+          const paramsBlock = match[2];
+          const params = {};
+          const paramRegex = /<parameter=([^>]+)>([\s\S]*?)<\/parameter>/gi;
+          let paramMatch;
+          while ((paramMatch = paramRegex.exec(paramsBlock)) !== null) {
+            const paramName = paramMatch[1].trim();
+            const paramValue = paramMatch[2].trim();
+            params[paramName] = paramValue;
+          }
+          toolCalls.push({
+            id: `xml-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+            type: "function",
+            function: {
+              name: functionName,
+              arguments: JSON.stringify(params)
+            }
+          });
+          this.log(`\u{1F4CB} Parsed XML tool call: ${functionName}(${JSON.stringify(params)})`);
+        }
+        return toolCalls;
+      }
+      /**
+       * Call the LLM via Rainfall backend, LM Studio, RunPod, or other providers
+       * 
+       * Provider priority:
+       * 1. Config file (llm.provider, llm.baseUrl)
+       * 2. Environment variables (OPENAI_API_KEY, OLLAMA_HOST, etc.)
+       * 3. Default to Rainfall (credits-based)
+       */
+      async callLLM(params) {
+        if (!this.rainfall) {
+          throw new Error("Rainfall SDK not initialized");
+        }
+        const { loadConfig: 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":
+            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}`
+          },
+          body: JSON.stringify({
+            model,
+            messages: params.messages,
+            tools: params.tools,
+            tool_choice: params.tool_choice,
+            temperature: params.temperature,
+            max_tokens: params.max_tokens,
+            stream: false
+            // Tool loop requires non-streaming
+          })
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`${provider} API error: ${error}`);
+        }
+        return response.json();
+      }
+      /**
+       * Call a local LLM (LM Studio, Ollama, etc.)
+       */
+      async callLocalLLM(params, config) {
+        const baseUrl = config.llm?.baseUrl || "http://localhost:1234/v1";
+        const apiKey = config.llm?.apiKey || "not-needed";
+        const model = params.model || config.llm?.model || "local-model";
+        const url = `${baseUrl}/chat/completions`;
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`
+          },
+          body: JSON.stringify({
+            model,
+            messages: params.messages,
+            tools: params.tools,
+            tool_choice: params.tool_choice,
+            temperature: params.temperature,
+            max_tokens: params.max_tokens,
+            stream: false
+            // Tool loop requires non-streaming
+          })
+        });
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`Local LLM error: ${error}`);
+        }
+        return response.json();
+      }
+      /**
+       * Stream a response to the client (converts non-streaming to SSE format)
+       */
+      async streamResponse(res, response) {
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        const message = response.choices?.[0]?.message;
+        const id = response.id || `chatcmpl-${Date.now()}`;
+        const model = response.model || "unknown";
+        const created = Math.floor(Date.now() / 1e3);
+        res.write(`data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }]
+        })}
+
+`);
+        const content = message?.content || "";
+        const chunkSize = 10;
+        for (let i = 0; i < content.length; i += chunkSize) {
+          const chunk = content.slice(i, i + chunkSize);
+          res.write(`data: ${JSON.stringify({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{ index: 0, delta: { content: chunk }, finish_reason: null }]
+          })}
+
+`);
+        }
+        res.write(`data: ${JSON.stringify({
+          id,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+        })}
+
+`);
+        res.write("data: [DONE]\n\n");
+        res.end();
+      }
+      /**
+       * Update context with conversation history
+       */
+      updateContext(originalMessages, response) {
+        if (!this.context) return;
+        const lastUserMessage = originalMessages.filter((m) => m.role === "user").pop();
+        if (lastUserMessage) {
+          this.context.addMessage("user", lastUserMessage.content);
+        }
+        const assistantContent = response.choices?.[0]?.message?.content;
+        if (assistantContent) {
+          this.context.addMessage("assistant", assistantContent);
+        }
+      }
+      async getOpenAITools() {
+        const tools = [];
+        for (const tool of this.tools.slice(0, 128)) {
+          const schema = await this.getToolSchema(tool.id);
+          if (schema) {
+            const toolSchema = schema;
+            let parameters = { type: "object", properties: {}, required: [] };
+            if (toolSchema.parameters && typeof toolSchema.parameters === "object") {
+              const rawParams = toolSchema.parameters;
+              parameters = {
+                type: rawParams.type || "object",
+                properties: rawParams.properties || {},
+                required: rawParams.required || []
+              };
+            }
+            tools.push({
+              type: "function",
+              function: {
+                name: tool.id.replace(/-/g, "_"),
+                // OpenAI requires underscore names
+                description: toolSchema.description || tool.description,
+                parameters
+              }
+            });
+          }
+        }
+        return tools;
+      }
+      buildResponseContent() {
+        const edgeNodeId = this.networkedExecutor?.getEdgeNodeId();
+        const toolCount = this.tools.length;
+        return `Rainfall daemon online. Edge node: ${edgeNodeId || "local"}. ${toolCount} tools available. What would you like to execute locally or in the cloud?`;
+      }
+      getStatus() {
+        return {
+          running: !!this.wss,
+          port: this.port,
+          openaiPort: this.openaiPort,
+          toolsLoaded: this.tools.length,
+          clientsConnected: this.clients.size,
+          edgeNodeId: this.networkedExecutor?.getEdgeNodeId(),
+          context: this.context?.getStatus() || {
+            memoriesCached: 0,
+            activeSessions: 0,
+            executionHistorySize: 0
+          },
+          listeners: this.listeners?.getStatus() || {
+            fileWatchers: 0,
+            cronTriggers: 0,
+            recentEvents: 0
+          }
+        };
+      }
+      log(...args) {
+        if (this.debug) {
+          console.log(...args);
+        }
+      }
+    };
+    daemonInstance = null;
+  }
+});
+
+// src/cli/index.ts
+init_cjs_shims();
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_url = require("url");
+init_sdk();
+init_config();
+var import_child_process = require("child_process");
 function printHelp() {
   console.log(`
 Rainfall CLI - 200+ tools, one key
@@ -809,28 +2576,66 @@ Commands:
   tools search <query>          Search for tools
   
   run <tool> [options]          Execute a tool
+
+  daemon start                  Start the Rainfall daemon
+  daemon stop                   Stop the Rainfall daemon
+  daemon restart                Restart the Rainfall daemon
+  daemon status                 Check daemon status
+  
+  workflow new                  Create a new workflow (interactive)
+  workflow run <workflow>       Run a saved workflow
   
   me                            Show account info and usage
   
   config get [key]              Get configuration value
   config set <key> <value>      Set configuration value
+  config llm                    Show LLM configuration
+  
+  version                       Show version information
+  upgrade                       Upgrade to the latest version
   
   help                          Show this help message
 
+Configuration keys:
+  llm.provider                  LLM provider (rainfall|openai|anthropic|ollama|local)
+  llm.baseUrl                   Base URL for the LLM API
+  llm.apiKey                    API key for the LLM provider
+  llm.model                     Default model to use
+
 Options for 'run':
   --params, -p <json>           Tool parameters as JSON
   --file, -f <path>             Read parameters from file
   --raw                         Output raw JSON
+  --<key> <value>               Pass individual parameters (e.g., --query "AI news")
+
+Options for 'daemon start':
+  --port <port>                 WebSocket port (default: 8765)
+  --openai-port <port>          OpenAI API port (default: 8787)
+  --debug                       Enable verbose debug logging
 
 Examples:
   rainfall auth login
   rainfall tools list
   rainfall tools describe github-create-issue
   rainfall run exa-web-search -p '{"query": "AI news"}'
+  rainfall run exa-web-search --query "AI news"
+  rainfall run github-create-issue --owner facebook --repo react --title "Bug"
   rainfall run article-summarize -f ./article.json
+  rainfall daemon start
   echo '{"query": "hello"}' | rainfall run exa-web-search
 `);
 }
+function getRainfall() {
+  const config = loadConfig();
+  if (!config.apiKey) {
+    console.error("Error: No API key configured. Run: rainfall auth login");
+    process.exit(1);
+  }
+  return new Rainfall({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  });
+}
 async function authLogin(args) {
   const apiKey = args[0] || process.env.RAINFALL_API_KEY;
   if (!apiKey) {
@@ -985,7 +2790,30 @@ async function runTool(args) {
     console.error("\nUsage: rainfall run <tool-id> [options]");
     process.exit(1);
   }
+  if (toolId === "--help" || toolId === "-h") {
+    console.log(`
+Usage: rainfall run <tool-id> [options]
+
+Execute a tool by ID.
+
+Options:
+  -p, --params <json>    Tool parameters as JSON string
+  -f, --file <path>      Read parameters from JSON file
+  --raw                  Output raw JSON (no formatting)
+  --<key> <value>        Pass individual parameters (e.g., --query "AI news")
+
+Examples:
+  rainfall run figma-users-getMe
+  rainfall run exa-web-search -p '{"query": "AI news"}'
+  rainfall run exa-web-search --query "AI news"
+  rainfall run github-create-issue --owner facebook --repo react --title "Bug"
+  rainfall run github-create-issue -f ./issue.json
+  echo '{"query": "hello"}' | rainfall run exa-web-search
+`);
+    return;
+  }
   let params = {};
+  const rawArgs = [];
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--params" || arg === "-p") {
@@ -1007,28 +2835,77 @@ async function runTool(args) {
         process.exit(1);
       }
       try {
-        params = JSON.parse((0, import_fs.readFileSync)(filePath, "utf8"));
+        params = JSON.parse((0, import_fs2.readFileSync)(filePath, "utf8"));
       } catch {
         console.error(`Error: Could not read or parse file: ${filePath}`);
         process.exit(1);
       }
     } else if (arg === "--raw") {
+    } else if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[++i];
+      if (value === void 0) {
+        console.error(`Error: ${arg} requires a value`);
+        process.exit(1);
+      }
+      try {
+        params[key] = JSON.parse(value);
+      } catch {
+        params[key] = value;
+      }
+    } else {
+      rawArgs.push(arg);
     }
   }
   if (!process.stdin.isTTY) {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(chunk);
-    }
-    if (chunks.length > 0) {
-      try {
-        const piped = JSON.parse(Buffer.concat(chunks).toString());
-        params = { ...params, ...piped };
-      } catch {
+    process.stdin.pause();
+    const fs = await import("fs");
+    try {
+      const buffer = Buffer.alloc(1024);
+      const bytesRead = await new Promise((resolve) => {
+        const timeout = setTimeout(() => resolve(0), 50);
+        fs.read(process.stdin.fd, buffer, 0, 1024, null, (err, n) => {
+          clearTimeout(timeout);
+          resolve(err ? 0 : n);
+        });
+      });
+      if (bytesRead > 0) {
+        let data = buffer.toString("utf8", 0, bytesRead);
+        while (true) {
+          const more = await new Promise((resolve) => {
+            fs.read(process.stdin.fd, buffer, 0, 1024, null, (err, n) => {
+              resolve(err ? 0 : n);
+            });
+          });
+          if (more === 0) break;
+          data += buffer.toString("utf8", 0, more);
+        }
+        if (data.trim()) {
+          try {
+            const piped = JSON.parse(data);
+            params = { ...params, ...piped };
+          } catch {
+          }
+        }
       }
+    } catch {
     }
   }
   const rainfall = getRainfall();
+  if (rawArgs.length === 1 && Object.keys(params).length === 0) {
+    try {
+      const schema = await rainfall.getToolSchema(toolId);
+      if (schema.parameters && typeof schema.parameters === "object") {
+        const paramEntries = Object.entries(schema.parameters);
+        const requiredParams = paramEntries.filter(([, p]) => !p.optional);
+        if (requiredParams.length === 1) {
+          const [paramName] = requiredParams[0];
+          params = { [paramName]: rawArgs[0] };
+        }
+      }
+    } catch {
+    }
+  }
   try {
     const result = await rainfall.executeTool(toolId, params);
     if (args.includes("--raw")) {
@@ -1055,7 +2932,16 @@ function configGet(args) {
   const key = args[0];
   const config = loadConfig();
   if (key) {
-    console.log(config[key] || "");
+    const parts = key.split(".");
+    let value = config;
+    for (const part of parts) {
+      value = value?.[part];
+    }
+    if (typeof value === "object" && value !== null) {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value ?? "");
+    }
   } else {
     console.log(JSON.stringify(config, null, 2));
   }
@@ -1066,13 +2952,231 @@ function configSet(args) {
   if (!key || !value) {
     console.error("Error: Both key and value required");
     console.error("\nUsage: rainfall config set <key> <value>");
+    console.error("\nExamples:");
+    console.error("  rainfall config set llm.provider local");
+    console.error("  rainfall config set llm.baseUrl http://localhost:1234/v1");
+    console.error("  rainfall config set llm.model llama-3.3-70b-versatile");
     process.exit(1);
   }
   const config = loadConfig();
-  config[key] = value;
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    config[key] = value;
+  } else {
+    let target = config;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!target[parts[i]] || typeof target[parts[i]] !== "object") {
+        target[parts[i]] = {};
+      }
+      target = target[parts[i]];
+    }
+    target[parts[parts.length - 1]] = value;
+  }
   saveConfig(config);
   console.log(`\u2713 Set ${key} = ${value}`);
 }
+function configLLM() {
+  const config = loadConfig();
+  const llm = config.llm || { provider: "rainfall" };
+  console.log("LLM Configuration:");
+  console.log(`  Provider: ${llm.provider}`);
+  console.log(`  Base URL: ${llm.baseUrl || "(default)"}`);
+  console.log(`  Model: ${llm.model || "(default)"}`);
+  console.log(`  API Key: ${llm.apiKey ? "****" + llm.apiKey.slice(-4) : "(none)"}`);
+  console.log();
+  console.log("Providers:");
+  console.log("  rainfall  - Use Rainfall backend (default, uses your credits)");
+  console.log("  openai    - Use OpenAI API directly");
+  console.log("  anthropic - Use Anthropic API directly");
+  console.log("  ollama    - Use local Ollama instance");
+  console.log("  local     - Use any OpenAI-compatible endpoint (LM Studio, etc.)");
+  console.log();
+  console.log("Examples:");
+  console.log("  rainfall config set llm.provider local");
+  console.log("  rainfall config set llm.baseUrl http://localhost:1234/v1");
+  console.log("  rainfall config set llm.provider openai");
+  console.log("  rainfall config set llm.apiKey sk-...");
+}
+function getPackageJson() {
+  try {
+    const __filename2 = (0, import_url.fileURLToPath)(importMetaUrl);
+    const __dirname = (0, import_path2.dirname)(__filename2);
+    const packagePath = (0, import_path2.join)(__dirname, "..", "..", "package.json");
+    const content = (0, import_fs2.readFileSync)(packagePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { version: "unknown", name: "@rainfall-devkit/sdk" };
+  }
+}
+function showVersion() {
+  const pkg = getPackageJson();
+  console.log(`${pkg.name} v${pkg.version}`);
+}
+async function upgrade() {
+  const pkg = getPackageJson();
+  console.log(`Upgrading ${pkg.name}...`);
+  const execPath = process.argv[0];
+  const isBun = execPath.includes("bun");
+  let command;
+  let args;
+  if (isBun) {
+    command = "bun";
+    args = ["add", "-g", `${pkg.name}@latest`];
+  } else {
+    command = "npm";
+    args = ["i", "-g", `${pkg.name}@latest`];
+  }
+  console.log(`Running: ${command} ${args.join(" ")}`);
+  console.log();
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log();
+        console.log("\u2713 Upgrade complete");
+        resolve();
+      } else {
+        reject(new Error(`Upgrade failed with exit code ${code}`));
+      }
+    });
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+async function daemonStart(args) {
+  let port;
+  let openaiPort;
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) port = val;
+    } else if (arg === "--openai-port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) openaiPort = val;
+    } else if (arg === "--debug") {
+      debug = true;
+    }
+  }
+  const { startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  try {
+    await startDaemon2({ port, openaiPort, debug });
+    process.on("SIGINT", async () => {
+      console.log("\n");
+      const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stopDaemon2();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stopDaemon2();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to start daemon:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function daemonStop() {
+  const { stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  await stopDaemon2();
+}
+async function daemonRestart(args) {
+  const { stopDaemon: stopDaemon2, startDaemon: startDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  let port;
+  let openaiPort;
+  let debug = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) port = val;
+    } else if (arg === "--openai-port") {
+      const val = parseInt(args[++i], 10);
+      if (!isNaN(val)) openaiPort = val;
+    } else if (arg === "--debug") {
+      debug = true;
+    }
+  }
+  console.log("\u{1F504} Restarting daemon...");
+  try {
+    await stopDaemon2();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    await startDaemon2({ port, openaiPort, debug });
+    process.on("SIGINT", async () => {
+      console.log("\n");
+      const { stopDaemon: stop } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      const { stopDaemon: stop } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+      await stop();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to restart daemon:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+async function daemonStatus() {
+  const { getDaemonStatus: getDaemonStatus2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+  const status = getDaemonStatus2();
+  if (!status) {
+    console.log("Daemon not running");
+    console.log("Run: rainfall daemon start");
+    return;
+  }
+  console.log("Daemon status:");
+  console.log(`  Running: ${status.running ? "yes" : "no"}`);
+  console.log(`  WebSocket port: ${status.port}`);
+  console.log(`  OpenAI API port: ${status.openaiPort}`);
+  console.log(`  Tools loaded: ${status.toolsLoaded}`);
+  console.log(`  Clients connected: ${status.clientsConnected}`);
+  console.log(`  Edge Node ID: ${status.edgeNodeId || "local"}`);
+  console.log();
+  console.log("Context:");
+  console.log(`  Memories cached: ${status.context.memoriesCached}`);
+  console.log(`  Active sessions: ${status.context.activeSessions}`);
+  console.log(`  Current session: ${status.context.currentSession || "none"}`);
+  console.log(`  Execution history: ${status.context.executionHistorySize}`);
+  console.log();
+  console.log("Listeners:");
+  console.log(`  File watchers: ${status.listeners.fileWatchers}`);
+  console.log(`  Cron triggers: ${status.listeners.cronTriggers}`);
+  console.log(`  Recent events: ${status.listeners.recentEvents}`);
+}
+async function workflowNew() {
+  console.log("\u{1F6A7} Interactive workflow creation coming soon!");
+  console.log();
+  console.log("For now, create workflows using the SDK:");
+  console.log('  import { createFileWatcherWorkflow } from "@rainfall-devkit/sdk/daemon";');
+  console.log();
+  console.log("Example:");
+  console.log(`  const workflow = createFileWatcherWorkflow('pdf-processor', '~/Downloads', {`);
+  console.log(`    pattern: '*.pdf',`);
+  console.log(`    events: ['create'],`);
+  console.log(`    workflow: [`);
+  console.log(`      { toolId: 'ocr-pdf', params: {} },`);
+  console.log(`      { toolId: 'notion-create-page', params: { parent: '...' } },`);
+  console.log(`    ],`);
+  console.log(`  });`);
+}
+async function workflowRun(args) {
+  const workflowId = args[0];
+  if (!workflowId) {
+    console.error("Error: Workflow ID required");
+    console.error("\nUsage: rainfall workflow run <workflow-id>");
+    process.exit(1);
+  }
+  console.log(`\u{1F6A7} Running workflow: ${workflowId}`);
+  console.log("Workflow execution coming soon!");
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
@@ -1114,7 +3218,41 @@ async function main() {
       }
       break;
     case "run":
-      await runTool(rest);
+      await runTool(args.slice(1));
+      break;
+    case "daemon":
+      switch (subcommand) {
+        case "start":
+          await daemonStart(rest);
+          break;
+        case "stop":
+          await daemonStop();
+          break;
+        case "restart":
+          await daemonRestart(rest);
+          break;
+        case "status":
+          await daemonStatus();
+          break;
+        default:
+          console.error("Error: Unknown daemon subcommand");
+          console.error("\nUsage: rainfall daemon <start|stop|restart|status>");
+          process.exit(1);
+      }
+      break;
+    case "workflow":
+      switch (subcommand) {
+        case "new":
+          await workflowNew();
+          break;
+        case "run":
+          await workflowRun(rest);
+          break;
+        default:
+          console.error("Error: Unknown workflow subcommand");
+          console.error("\nUsage: rainfall workflow <new|run>");
+          process.exit(1);
+      }
       break;
     case "me":
       await showMe();
@@ -1127,12 +3265,23 @@ async function main() {
         case "set":
           configSet(rest);
           break;
+        case "llm":
+          configLLM();
+          break;
         default:
           console.error("Error: Unknown config subcommand");
-          console.error("\nUsage: rainfall config <get|set>");
+          console.error("\nUsage: rainfall config <get|set|llm>");
           process.exit(1);
       }
       break;
+    case "version":
+    case "--version":
+    case "-v":
+      showVersion();
+      break;
+    case "upgrade":
+      await upgrade();
+      break;
     case "help":
     case "--help":
     case "-h":