@rainfall-devkit/sdk 0.2.2 → 0.2.4

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,122 +30,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
   AuthenticationError: () => AuthenticationError,
-  EdgeNodeSecurity: () => EdgeNodeSecurity,
   NetworkError: () => NetworkError,
   NotFoundError: () => NotFoundError,
-  Rainfall: () => Rainfall,
-  RainfallClient: () => RainfallClient,
-  RainfallDaemonContext: () => RainfallDaemonContext,
   RainfallError: () => RainfallError,
-  RainfallListenerRegistry: () => RainfallListenerRegistry,
-  RainfallNetworkedExecutor: () => RainfallNetworkedExecutor,
   RateLimitError: () => RateLimitError,
-  SecureEdgeClient: () => SecureEdgeClient,
   ServerError: () => ServerError,
   TimeoutError: () => TimeoutError,
   ToolNotFoundError: () => ToolNotFoundError,
-  VERSION: () => VERSION,
   ValidationError: () => ValidationError,
-  createCronWorkflow: () => createCronWorkflow,
-  createEdgeNodeSecurity: () => createEdgeNodeSecurity,
-  createFileWatcherWorkflow: () => createFileWatcherWorkflow,
-  createSecureEdgeClient: () => createSecureEdgeClient
+  parseErrorResponse: () => parseErrorResponse
 });
-module.exports = __toCommonJS(index_exports);
-
-// 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 ServerError = class _ServerError extends RainfallError {
-  constructor(message = "Internal server error", statusCode = 500) {
-    super(message, "SERVER_ERROR", statusCode);
-    this.name = "ServerError";
-    Object.setPrototypeOf(this, _ServerError.prototype);
-  }
-};
-var TimeoutError = class _TimeoutError extends RainfallError {
-  constructor(timeoutMs) {
-    super(`Request timed out after ${timeoutMs}ms`, "TIMEOUT_ERROR", 408);
-    this.name = "TimeoutError";
-    Object.setPrototypeOf(this, _TimeoutError.prototype);
-  }
-};
-var NetworkError = class _NetworkError extends RainfallError {
-  constructor(message = "Network error", details) {
-    super(message, "NETWORK_ERROR", void 0, details);
-    this.name = "NetworkError";
-    Object.setPrototypeOf(this, _NetworkError.prototype);
-  }
-};
-var ToolNotFoundError = class _ToolNotFoundError extends RainfallError {
-  constructor(toolId) {
-    super(`Tool '${toolId}' not found`, "TOOL_NOT_FOUND", 404, { toolId });
-    this.name = "ToolNotFoundError";
-    Object.setPrototypeOf(this, _ToolNotFoundError.prototype);
-  }
-};
 function parseErrorResponse(response, data) {
   const statusCode = response.status;
   if (statusCode === 429) {
@@ -191,6 +99,586 @@ function parseErrorResponse(response, data) {
       );
   }
 }
+var RainfallError, AuthenticationError, RateLimitError, ValidationError, NotFoundError, ServerError, TimeoutError, NetworkError, ToolNotFoundError;
+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);
+      }
+    };
+    ToolNotFoundError = class _ToolNotFoundError extends RainfallError {
+      constructor(toolId) {
+        super(`Tool '${toolId}' not found`, "TOOL_NOT_FOUND", 404, { toolId });
+        this.name = "ToolNotFoundError";
+        Object.setPrototypeOf(this, _ToolNotFoundError.prototype);
+      }
+    };
+  }
+});
+
+// src/cli/core/display.ts
+var display_exports = {};
+__export(display_exports, {
+  detectImageData: () => detectImageData,
+  detectImageSupport: () => detectImageSupport,
+  displayImage: () => displayImage,
+  formatAsTable: () => formatAsTable,
+  formatResult: () => formatResult
+});
+function detectImageSupport() {
+  if (process.env.TERM_PROGRAM === "iTerm.app") {
+    return { supported: true, command: "imgcat" };
+  }
+  if (process.env.KITTY_WINDOW_ID) {
+    return { supported: true, command: "kitty +kitten icat" };
+  }
+  try {
+    return { supported: true, command: "xan" };
+  } catch {
+  }
+  try {
+    return { supported: true, command: "catimg" };
+  } catch {
+  }
+  return { supported: false };
+}
+async function displayImage(imageData, options = {}) {
+  const imageCommand = options.imageCommand || detectImageSupport().command;
+  if (!imageCommand) {
+    const { writeFileSync } = await import("fs");
+    const { tmpdir } = await import("os");
+    const { join: join2 } = await import("path");
+    const tempPath = join2(tmpdir(), `rainfall-image-${Date.now()}.png`);
+    const buffer = typeof imageData === "string" ? Buffer.from(imageData, "base64") : imageData;
+    writeFileSync(tempPath, buffer);
+    console.log(`Image saved to: ${tempPath}`);
+    return;
+  }
+  return new Promise((resolve, reject) => {
+    const buffer = typeof imageData === "string" ? Buffer.from(imageData, "base64") : imageData;
+    const child = (0, import_child_process.spawn)(imageCommand, [], {
+      stdio: ["pipe", "inherit", "inherit"],
+      shell: true
+    });
+    child.stdin.write(buffer);
+    child.stdin.end();
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Image display failed with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function formatAsTable(data, columns) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return "No data";
+  }
+  const cols = columns || Object.keys(data[0]);
+  const widths = {};
+  for (const col of cols) {
+    widths[col] = Math.max(
+      col.length,
+      ...data.map((row) => {
+        const val = row?.[col];
+        return String(val ?? "").slice(0, 50).length;
+      })
+    );
+  }
+  const lines = [];
+  const header = cols.map((col) => col.padEnd(widths[col])).join("  ");
+  lines.push(header);
+  lines.push(cols.map((col) => "-".repeat(widths[col])).join("  "));
+  for (const row of data) {
+    const line = cols.map((col) => {
+      const val = row?.[col];
+      const str = String(val ?? "").slice(0, 50);
+      return str.padEnd(widths[col]);
+    }).join("  ");
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+async function formatResult(result, options = {}) {
+  const mode = options.mode || "pretty";
+  switch (mode) {
+    case "raw":
+      return JSON.stringify(result);
+    case "pretty":
+      return JSON.stringify(result, null, 2);
+    case "table":
+      if (Array.isArray(result)) {
+        return formatAsTable(result, options.columns);
+      }
+      return JSON.stringify(result, null, 2);
+    case "terminal":
+      if (typeof result === "string") {
+        return result;
+      }
+      if (Array.isArray(result) && result.every((r) => typeof r === "string")) {
+        return result.join("\n");
+      }
+      return JSON.stringify(result);
+    default:
+      return JSON.stringify(result, null, 2);
+  }
+}
+function detectImageData(result) {
+  if (!result || typeof result !== "object") {
+    return { hasImage: false };
+  }
+  const obj = result;
+  const imageFields = ["image", "imageData", "imageBase64", "png", "jpeg", "data"];
+  for (const field of imageFields) {
+    if (obj[field] && typeof obj[field] === "string") {
+      const value = obj[field];
+      if (value.startsWith("data:image/") || value.length > 100) {
+        return {
+          hasImage: true,
+          imageData: value.startsWith("data:image/") ? value.split(",")[1] : value
+        };
+      }
+    }
+  }
+  if (obj.url && typeof obj.url === "string" && (obj.url.endsWith(".png") || obj.url.endsWith(".jpg") || obj.url.endsWith(".jpeg"))) {
+    return { hasImage: true, imagePath: obj.url };
+  }
+  return { hasImage: false };
+}
+var import_child_process;
+var init_display = __esm({
+  "src/cli/core/display.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_child_process = require("child_process");
+  }
+});
+
+// src/cli/core/param-parser.ts
+var param_parser_exports = {};
+__export(param_parser_exports, {
+  formatValueForDisplay: () => formatValueForDisplay,
+  generateParamExample: () => generateParamExample,
+  parseCliArgs: () => parseCliArgs,
+  parseValue: () => parseValue
+});
+function parseValue(value, schema, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!schema) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  const expectedType = schema.type;
+  switch (expectedType) {
+    case "array":
+      return parseArrayValue(value, schema, opts);
+    case "number":
+      return parseNumberValue(value, opts);
+    case "boolean":
+      return parseBooleanValue(value, opts);
+    case "string":
+      return value;
+    case "object":
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    default:
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+  }
+}
+function parseArrayValue(value, schema, options) {
+  if (value.startsWith("[") && value.endsWith("]")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+    }
+  }
+  if (options.arrayInterpolation && value.includes(options.arraySeparator)) {
+    const items = value.split(options.arraySeparator).map((s) => s.trim()).filter(Boolean);
+    if (schema.items) {
+      return items.map((item) => parseValue(item, schema.items, { ...options, arrayInterpolation: false }));
+    }
+    return items;
+  }
+  if (schema.items) {
+    return [parseValue(value, schema.items, { ...options, arrayInterpolation: false })];
+  }
+  return [value];
+}
+function parseNumberValue(value, options) {
+  if (!options.numberParsing) {
+    return value;
+  }
+  const num = Number(value);
+  if (!isNaN(num) && isFinite(num)) {
+    return num;
+  }
+  return value;
+}
+function parseBooleanValue(value, options) {
+  if (!options.booleanParsing) {
+    return value;
+  }
+  const lower = value.toLowerCase();
+  if (lower === "true" || lower === "yes" || lower === "1" || lower === "on") {
+    return true;
+  }
+  if (lower === "false" || lower === "no" || lower === "0" || lower === "off") {
+    return false;
+  }
+  return value;
+}
+function parseCliArgs(args, schema, options = {}) {
+  const params = {};
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const parameters = schema?.parameters || {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const value = args[++i];
+      if (value === void 0) {
+        params[key] = true;
+        continue;
+      }
+      const paramSchema = parameters[key];
+      params[key] = parseValue(value, paramSchema, opts);
+    }
+  }
+  return params;
+}
+function formatValueForDisplay(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return value.map(formatValueForDisplay).join(",");
+  }
+  return JSON.stringify(value);
+}
+function generateParamExample(key, schema) {
+  const type = schema.type || "string";
+  switch (type) {
+    case "array":
+      if (schema.items?.type === "string") {
+        return `--${key} item1,item2,item3`;
+      }
+      return `--${key} '["item1", "item2"]'`;
+    case "number":
+      return `--${key} 42`;
+    case "boolean":
+      return `--${key} true`;
+    case "object":
+      return `--${key} '{"key": "value"}'`;
+    default:
+      return `--${key} "value"`;
+  }
+}
+var DEFAULT_OPTIONS;
+var init_param_parser = __esm({
+  "src/cli/core/param-parser.ts"() {
+    "use strict";
+    init_cjs_shims();
+    DEFAULT_OPTIONS = {
+      arrayInterpolation: true,
+      numberParsing: true,
+      booleanParsing: true,
+      arraySeparator: ","
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  EdgeNodeSecurity: () => EdgeNodeSecurity,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  Rainfall: () => Rainfall,
+  RainfallClient: () => RainfallClient,
+  RainfallDaemonContext: () => RainfallDaemonContext,
+  RainfallError: () => RainfallError,
+  RainfallListenerRegistry: () => RainfallListenerRegistry,
+  RainfallNetworkedExecutor: () => RainfallNetworkedExecutor,
+  RateLimitError: () => RateLimitError,
+  SecureEdgeClient: () => SecureEdgeClient,
+  ServerError: () => ServerError,
+  TimeoutError: () => TimeoutError,
+  ToolNotFoundError: () => ToolNotFoundError,
+  VERSION: () => VERSION,
+  ValidationError: () => ValidationError,
+  clearSchemaCache: () => clearSchemaCache,
+  createCronWorkflow: () => createCronWorkflow,
+  createEdgeNodeSecurity: () => createEdgeNodeSecurity,
+  createFileWatcherWorkflow: () => createFileWatcherWorkflow,
+  createSecureEdgeClient: () => createSecureEdgeClient,
+  fetchToolSchema: () => fetchToolSchema,
+  formatValidationErrors: () => formatValidationErrors,
+  globalHandlerRegistry: () => globalHandlerRegistry,
+  validateParams: () => validateParams
+});
+module.exports = __toCommonJS(index_exports);
+init_cjs_shims();
+
+// src/client.ts
+init_cjs_shims();
+init_errors();
+
+// src/validation.ts
+init_cjs_shims();
+init_errors();
+var schemaCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+async function fetchToolSchema(client, toolId) {
+  const cached = schemaCache.get(toolId);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    return cached.schema;
+  }
+  const response = await client.request(
+    `/olympic/subscribers/me/nodes/${toolId}/params`
+  );
+  if (!response.success || !response.params) {
+    throw new ValidationError(`Failed to fetch schema for tool '${toolId}'`);
+  }
+  schemaCache.set(toolId, { schema: response.params, timestamp: Date.now() });
+  return response.params;
+}
+function clearSchemaCache() {
+  schemaCache.clear();
+}
+function validateParams(schema, params, toolId) {
+  const errors = [];
+  const parameters = schema.parameters || {};
+  for (const [key, paramSchema] of Object.entries(parameters)) {
+    if (paramSchema.optional !== true && !(key in (params || {}))) {
+      errors.push({
+        path: key,
+        message: `Missing required parameter '${key}'`,
+        expected: paramSchema.type
+      });
+    }
+  }
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      const paramSchema = parameters[key];
+      if (!paramSchema) {
+        errors.push({
+          path: key,
+          message: `Unknown parameter '${key}'`,
+          received: value
+        });
+        continue;
+      }
+      const typeError = validateType(key, value, paramSchema);
+      if (typeError) {
+        errors.push(typeError);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateType(path, value, schema) {
+  if (value === null || value === void 0) {
+    if (schema.optional === true) {
+      return null;
+    }
+    return {
+      path,
+      message: `Parameter '${path}' is required but received ${value}`,
+      received: value,
+      expected: schema.type
+    };
+  }
+  const expectedType = schema.type;
+  const actualType = getJsType(value);
+  switch (expectedType) {
+    case "string":
+      if (typeof value !== "string") {
+        return {
+          path,
+          message: `Parameter '${path}' must be a string, received ${actualType}`,
+          received: value,
+          expected: "string"
+        };
+      }
+      break;
+    case "number":
+      if (typeof value !== "number" || isNaN(value)) {
+        return {
+          path,
+          message: `Parameter '${path}' must be a number, received ${actualType}`,
+          received: value,
+          expected: "number"
+        };
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return {
+          path,
+          message: `Parameter '${path}' must be a boolean, received ${actualType}`,
+          received: value,
+          expected: "boolean"
+        };
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        return {
+          path,
+          message: `Parameter '${path}' must be an array, received ${actualType}`,
+          received: value,
+          expected: "array"
+        };
+      }
+      if (schema.items) {
+        for (let i = 0; i < value.length; i++) {
+          const itemError = validateType(`${path}[${i}]`, value[i], schema.items);
+          if (itemError) {
+            return itemError;
+          }
+        }
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return {
+          path,
+          message: `Parameter '${path}' must be an object, received ${actualType}`,
+          received: value,
+          expected: "object"
+        };
+      }
+      if (schema.properties) {
+        const objValue = value;
+        for (const [propKey, propSchema] of Object.entries(schema.properties)) {
+          if (objValue[propKey] !== void 0) {
+            const propError = validateType(`${path}.${propKey}`, objValue[propKey], propSchema);
+            if (propError) {
+              return propError;
+            }
+          }
+        }
+      }
+      break;
+    default:
+      break;
+  }
+  return null;
+}
+function getJsType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function formatValidationErrors(result) {
+  if (result.valid) return "No validation errors";
+  const lines = result.errors.map((err) => {
+    let line = `  - ${err.message}`;
+    if (err.received !== void 0) {
+      line += ` (received: ${JSON.stringify(err.received).slice(0, 50)})`;
+    }
+    return line;
+  });
+  return `Validation failed with ${result.errors.length} error(s):
+${lines.join("\n")}`;
+}
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://olympic-api.pragma-digital.org/v1";
@@ -203,6 +691,7 @@ var RainfallClient = class {
   defaultTimeout;
   defaultRetries;
   defaultRetryDelay;
+  disableValidation;
   lastRateLimitInfo;
   subscriberId;
   constructor(config) {
@@ -211,6 +700,7 @@ var RainfallClient = class {
     this.defaultTimeout = config.timeout || DEFAULT_TIMEOUT;
     this.defaultRetries = config.retries ?? DEFAULT_RETRIES;
     this.defaultRetryDelay = config.retryDelay || DEFAULT_RETRY_DELAY;
+    this.disableValidation = config.disableValidation ?? false;
   }
   /**
    * Get the last rate limit info from the API
@@ -293,15 +783,72 @@ var RainfallClient = class {
   }
   /**
    * Execute a tool/node by ID
+   * 
+   * @param toolId - The ID of the tool/node to execute
+   * @param params - Parameters to pass to the tool
+   * @param options - Request options including skipValidation to bypass param validation
    */
   async executeTool(toolId, params, options) {
+    if (!this.disableValidation && !options?.skipValidation) {
+      const validation = await this.validateToolParams(toolId, params);
+      if (!validation.valid) {
+        const { ValidationError: ValidationError2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+        throw new ValidationError2(
+          `Parameter validation failed for tool '${toolId}': ${formatValidationErrors(validation)}`,
+          { toolId, errors: validation.errors }
+        );
+      }
+    }
     const subscriberId = await this.ensureSubscriberId();
+    const body = params || {};
+    if (options?.targetEdge) {
+      body._targetEdge = options.targetEdge;
+    }
     const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}`, {
       method: "POST",
-      body: params || {}
+      body
     }, options);
+    if (response.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : JSON.stringify(response.error);
+      throw new RainfallError(
+        `Tool execution failed: ${errorMessage}`,
+        "TOOL_EXECUTION_ERROR",
+        400,
+        { toolId, error: response.error }
+      );
+    }
     return response.result;
   }
+  /**
+   * Validate parameters for a tool without executing it
+   * Fetches the tool schema and validates the provided params
+   * 
+   * @param toolId - The ID of the tool to validate params for
+   * @param params - Parameters to validate
+   * @returns Validation result with detailed error information
+   * 
+   * @example
+   * ```typescript
+   * const result = await client.validateToolParams('finviz-quotes', { tickers: ['AAPL'] });
+   * if (!result.valid) {
+   *   console.log('Validation errors:', result.errors);
+   * }
+   * ```
+   */
+  async validateToolParams(toolId, params) {
+    try {
+      const schema = await fetchToolSchema(this, toolId);
+      return validateParams(schema, params, toolId);
+    } catch (error) {
+      if (error instanceof RainfallError && error.statusCode === 404) {
+        return {
+          valid: false,
+          errors: [{ path: toolId, message: `Tool '${toolId}' not found` }]
+        };
+      }
+      return { valid: true, errors: [] };
+    }
+  }
   /**
    * List all available tools
    */
@@ -324,11 +871,20 @@ var RainfallClient = class {
   }
   /**
    * Get tool schema/parameters
+   * 
+   * @param toolId - The ID of the tool to get schema for
+   * @returns Tool schema including parameters and output definitions
    */
   async getToolSchema(toolId) {
-    const subscriberId = await this.ensureSubscriberId();
-    const response = await this.request(`/olympic/subscribers/${subscriberId}/nodes/${toolId}/params`);
-    return response.params;
+    const schema = await fetchToolSchema(this, toolId);
+    return {
+      name: schema.name,
+      description: schema.description,
+      category: schema.category,
+      parameters: schema.parameters,
+      output: schema.output,
+      metadata: schema.metadata || {}
+    };
   }
   /**
    * Get subscriber info
@@ -412,7 +968,11 @@ var RainfallClient = class {
   }
 };
 
+// src/sdk.ts
+init_cjs_shims();
+
 // src/namespaces/integrations.ts
+init_cjs_shims();
 function createIntegrations(client) {
   return new IntegrationsNamespace(client);
 }
@@ -525,6 +1085,7 @@ var IntegrationsNamespace = class {
 };
 
 // src/namespaces/memory.ts
+init_cjs_shims();
 function createMemory(client) {
   return {
     create: (params) => client.executeTool("memory-create", params),
@@ -537,6 +1098,7 @@ function createMemory(client) {
 }
 
 // src/namespaces/articles.ts
+init_cjs_shims();
 function createArticles(client) {
   return {
     search: (params) => client.executeTool("article-search", params),
@@ -551,6 +1113,7 @@ function createArticles(client) {
 }
 
 // src/namespaces/web.ts
+init_cjs_shims();
 function createWeb(client) {
   return {
     search: {
@@ -564,6 +1127,7 @@ function createWeb(client) {
 }
 
 // src/namespaces/ai.ts
+init_cjs_shims();
 function createAI(client) {
   return {
     embeddings: {
@@ -589,6 +1153,7 @@ function createAI(client) {
 }
 
 // src/namespaces/data.ts
+init_cjs_shims();
 function createData(client) {
   return {
     csv: {
@@ -610,6 +1175,7 @@ function createData(client) {
 }
 
 // src/namespaces/utils.ts
+init_cjs_shims();
 function createUtils(client) {
   return {
     mermaid: (params) => client.executeTool("mermaid-diagram-generator", { mermaid: params.diagram }),
@@ -848,9 +1414,40 @@ var Rainfall = class {
   }
   /**
    * Execute any tool by ID (low-level access)
+   * 
+   * @param toolId - The ID of the tool to execute
+   * @param params - Parameters to pass to the tool
+   * @param options - Execution options including skipValidation to bypass param validation
+   * 
+   * @example
+   * ```typescript
+   * // Execute with validation (default)
+   * const result = await rainfall.executeTool('finviz-quotes', { tickers: ['AAPL'] });
+   * 
+   * // Execute without validation
+   * const result = await rainfall.executeTool('finviz-quotes', { tickers: ['AAPL'] }, { skipValidation: true });
+   * ```
    */
-  async executeTool(toolId, params) {
-    return this.client.executeTool(toolId, params);
+  async executeTool(toolId, params, options) {
+    return this.client.executeTool(toolId, params, options);
+  }
+  /**
+   * Validate parameters for a tool without executing it
+   * 
+   * @param toolId - The ID of the tool to validate params for
+   * @param params - Parameters to validate
+   * @returns Validation result with detailed error information
+   * 
+   * @example
+   * ```typescript
+   * const result = await rainfall.validateToolParams('finviz-quotes', { tickers: ['AAPL'] });
+   * if (!result.valid) {
+   *   console.log('Validation errors:', result.errors);
+   * }
+   * ```
+   */
+  async validateToolParams(toolId, params) {
+    return this.client.validateToolParams(toolId, params);
   }
   /**
    * Get current subscriber info and usage
@@ -909,7 +1506,11 @@ var Rainfall = class {
   }
 };
 
+// src/index.ts
+init_errors();
+
 // src/services/networked.ts
+init_cjs_shims();
 var RainfallNetworkedExecutor = class {
   rainfall;
   options;
@@ -1101,6 +1702,7 @@ var RainfallNetworkedExecutor = class {
 };
 
 // src/services/context.ts
+init_cjs_shims();
 var RainfallDaemonContext = class {
   rainfall;
   options;
@@ -1354,6 +1956,7 @@ var RainfallDaemonContext = class {
 };
 
 // src/services/listeners.ts
+init_cjs_shims();
 var RainfallListenerRegistry = class {
   rainfall;
   context;
@@ -1564,7 +2167,11 @@ function createCronWorkflow(name, cron, workflow) {
   };
 }
 
+// src/security/index.ts
+init_cjs_shims();
+
 // src/security/edge-node.ts
+init_cjs_shims();
 var import_libsodium_wrappers_sumo = __toESM(require("libsodium-wrappers-sumo"));
 var EdgeNodeSecurity = class {
   sodiumReady;
@@ -1830,6 +2437,7 @@ async function createEdgeNodeSecurity(options = {}) {
 }
 
 // src/security/edge-client.ts
+init_cjs_shims();
 var import_fs = require("fs");
 var import_path = require("path");
 var SecureEdgeClient = class {
@@ -2034,6 +2642,176 @@ async function createSecureEdgeClient(client, options) {
   return secureClient;
 }
 
+// src/cli/handlers/_registry.ts
+init_cjs_shims();
+
+// src/cli/core/types.ts
+init_cjs_shims();
+var ToolHandlerRegistry = class {
+  handlers = [];
+  register(handler) {
+    this.handlers.push(handler);
+  }
+  findHandler(toolId) {
+    return this.handlers.find((h) => {
+      if (typeof h.toolId === "string") {
+        return h.toolId === toolId;
+      }
+      return h.toolId.test(toolId);
+    });
+  }
+  getAllHandlers() {
+    return [...this.handlers];
+  }
+};
+var globalHandlerRegistry = new ToolHandlerRegistry();
+
+// src/cli/handlers/_registry.ts
+var imageGenerationHandler = {
+  toolId: /image-generation|generate-image/,
+  async display(context) {
+    const { detectImageData: detectImageData2, displayImage: displayImage2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+    const { result, flags } = context;
+    const imageInfo = detectImageData2(result);
+    if (imageInfo.hasImage && !flags.raw) {
+      try {
+        if (imageInfo.imageData) {
+          await displayImage2(imageInfo.imageData);
+          return true;
+        }
+      } catch (error) {
+        console.warn("Failed to display image:", error instanceof Error ? error.message : error);
+      }
+    }
+    return false;
+  }
+};
+var finvizQuotesHandler = {
+  toolId: "finviz-quotes",
+  async preflight(context) {
+    const { parseValue: parseValue2 } = await Promise.resolve().then(() => (init_param_parser(), param_parser_exports));
+    const params = { ...context.params };
+    if (params.tickers && typeof params.tickers === "string") {
+      params.tickers = parseValue2(params.tickers, { type: "array", items: { type: "string" } });
+    }
+    return { params };
+  },
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    const obj = result;
+    const quotes = obj?.quotes;
+    if (Array.isArray(quotes) && quotes.length > 0) {
+      const { formatAsTable: formatAsTable2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+      const tableData = quotes.map((q) => {
+        const quote = q;
+        const data = quote.data || {};
+        return {
+          Ticker: quote.ticker || data.Ticker || "-",
+          Price: data.Price || data.Close || "-",
+          Change: data.Change || "-",
+          Volume: data.Volume || "-",
+          "Market Cap": data.MarketCap || "-"
+        };
+      });
+      console.log(formatAsTable2(tableData));
+      const summary = obj?.summary;
+      if (summary && typeof summary === "string") {
+        console.log(`
+${summary}`);
+      }
+      return true;
+    }
+    return false;
+  }
+};
+var csvQueryHandler = {
+  toolId: /query-csv|csv-query/,
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    if (Array.isArray(result) && result.length > 0) {
+      const { formatAsTable: formatAsTable2 } = await Promise.resolve().then(() => (init_display(), display_exports));
+      console.log(formatAsTable2(result));
+      return true;
+    }
+    return false;
+  }
+};
+var webSearchHandler = {
+  toolId: /web-search|exa-web-search|perplexity/,
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    const obj = result;
+    if (obj.results && typeof obj.results === "string") {
+      console.log(obj.results);
+      return true;
+    }
+    if (obj.answer || obj.summary) {
+      console.log(obj.answer || obj.summary);
+      if (obj.sources && Array.isArray(obj.sources)) {
+        console.log("\n--- Sources ---");
+        obj.sources.forEach((source, i) => {
+          if (typeof source === "string") {
+            console.log(`  ${i + 1}. ${source}`);
+          } else if (source && typeof source === "object") {
+            const s = source;
+            console.log(`  ${i + 1}. ${s.title || s.url || JSON.stringify(source)}`);
+          }
+        });
+      }
+      return true;
+    }
+    return false;
+  }
+};
+var memoryRecallHandler = {
+  toolId: /memory-recall|recall/,
+  async display(context) {
+    const { result, flags } = context;
+    if (flags.raw) {
+      return false;
+    }
+    if (Array.isArray(result)) {
+      if (result.length === 0) {
+        console.log("No memories found.");
+        return true;
+      }
+      console.log(`Found ${result.length} memory(s):
+`);
+      result.forEach((mem, i) => {
+        const memory = mem;
+        console.log(`\u2500`.repeat(60));
+        console.log(`  ${i + 1}. ${memory.content || memory.text || JSON.stringify(memory).slice(0, 100)}`);
+        if (memory.similarity) {
+          console.log(`     Similarity: ${(Number(memory.similarity) * 100).toFixed(1)}%`);
+        }
+        if (memory.keywords && Array.isArray(memory.keywords)) {
+          console.log(`     Keywords: ${memory.keywords.join(", ")}`);
+        }
+        console.log();
+      });
+      return true;
+    }
+    return false;
+  }
+};
+function registerBuiltInHandlers(registry = globalHandlerRegistry) {
+  registry.register(imageGenerationHandler);
+  registry.register(finvizQuotesHandler);
+  registry.register(csvQueryHandler);
+  registry.register(webSearchHandler);
+  registry.register(memoryRecallHandler);
+}
+registerBuiltInHandlers();
+
 // src/index.ts
 var VERSION = "0.1.0";
 // Annotate the CommonJS export names for ESM import in node:
@@ -2055,8 +2833,13 @@ var VERSION = "0.1.0";
   ToolNotFoundError,
   VERSION,
   ValidationError,
+  clearSchemaCache,
   createCronWorkflow,
   createEdgeNodeSecurity,
   createFileWatcherWorkflow,
-  createSecureEdgeClient
+  createSecureEdgeClient,
+  fetchToolSchema,
+  formatValidationErrors,
+  globalHandlerRegistry,
+  validateParams
 });