@agentforge/core 0.11.7 → 0.12.0

package/dist/index.cjs

@@ -31,10 +31,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AgentError: () => AgentError,
+  AlertManager: () => AlertManager,
+  AuditLogger: () => AuditLogger,
   BatchProcessor: () => BatchProcessor,
   CircuitBreaker: () => CircuitBreaker,
   ConnectionPool: () => ConnectionPool,
   DatabasePool: () => DatabasePool,
+  HealthChecker: () => HealthChecker,
   HttpPool: () => HttpPool,
   LogLevel: () => LogLevel,
   ManagedTool: () => ManagedTool,
@@ -42,6 +45,7 @@ __export(index_exports, {
   MetricType: () => MetricType,
   MiddlewareChain: () => MiddlewareChain,
   MissingDescriptionError: () => MissingDescriptionError,
+  Profiler: () => Profiler,
   RegistryEvent: () => RegistryEvent,
   TimeoutError: () => TimeoutError,
   ToolBuilder: () => ToolBuilder,
@@ -65,7 +69,9 @@ __export(index_exports, {
   composeWithOptions: () => composeWithOptions,
   conditional: () => conditional,
   configureLangSmith: () => configureLangSmith,
+  createAlertManager: () => createAlertManager,
   createApprovalRequiredInterrupt: () => createApprovalRequiredInterrupt,
+  createAuditLogger: () => createAuditLogger,
   createBatchProcessor: () => createBatchProcessor,
   createBinaryRouter: () => createBinaryRouter,
   createCircuitBreaker: () => createCircuitBreaker,
@@ -75,6 +81,7 @@ __export(index_exports, {
   createCustomInterrupt: () => createCustomInterrupt,
   createDatabasePool: () => createDatabasePool,
   createErrorReporter: () => createErrorReporter,
+  createHealthChecker: () => createHealthChecker,
   createHeartbeat: () => createHeartbeat,
   createHttpPool: () => createHttpPool,
   createHumanRequestInterrupt: () => createHumanRequestInterrupt,
@@ -88,6 +95,7 @@ __export(index_exports, {
   createMockTool: () => createMockTool,
   createMultiRouter: () => createMultiRouter,
   createParallelWorkflow: () => createParallelWorkflow,
+  createProfiler: () => createProfiler,
   createProgressTracker: () => createProgressTracker,
   createSSEFormatter: () => createSSEFormatter,
   createSequentialWorkflow: () => createSequentialWorkflow,
@@ -124,6 +132,7 @@ __export(index_exports, {
   isHumanRequestInterrupt: () => isHumanRequestInterrupt,
   isMemoryCheckpointer: () => isMemoryCheckpointer,
   isTracingEnabled: () => isTracingEnabled,
+  loadPrompt: () => loadPrompt,
   map: () => map,
   merge: () => merge,
   mergeState: () => mergeState,
@@ -132,8 +141,10 @@ __export(index_exports, {
   presets: () => presets,
   production: () => production,
   reduce: () => reduce,
+  renderTemplate: () => renderTemplate,
   retry: () => retry,
   safeValidateSchemaDescriptions: () => safeValidateSchemaDescriptions,
+  sanitizeValue: () => sanitizeValue,
   sendMessage: () => sendMessage,
   sequential: () => sequential,
   sequentialBuilder: () => sequentialBuilder,
@@ -2679,14 +2690,14 @@ var withLogging = (options) => {
     onComplete,
     onError
   } = options;
-  const logger4 = providedLogger || createLogger(name, { level });
+  const logger5 = providedLogger || createLogger(name, { level });
   return (node) => {
     return async (state) => {
       const startTime = Date.now();
       try {
         if (logInput) {
           const data = extractData ? extractData(state) : { state };
-          logger4.info("Node execution started", data);
+          logger5.info("Node execution started", data);
         }
         if (onStart) {
           onStart(state);
@@ -2696,9 +2707,9 @@ var withLogging = (options) => {
         if (logOutput) {
           const data = extractData ? extractData(result) : { result };
           if (logDuration) {
-            logger4.info(`Node execution completed (${duration}ms)`, data);
+            logger5.info(`Node execution completed (${duration}ms)`, data);
           } else {
-            logger4.info("Node execution completed", data);
+            logger5.info("Node execution completed", data);
           }
         }
         if (onComplete) {
@@ -2709,7 +2720,7 @@ var withLogging = (options) => {
         const duration = Date.now() - startTime;
         const err = error instanceof Error ? error : new Error(String(error));
         if (logErrors) {
-          logger4.error(`Node execution failed (${duration}ms)`, {
+          logger5.error(`Node execution failed (${duration}ms)`, {
             error: err.message,
             stack: err.stack
           });
@@ -2745,7 +2756,7 @@ function withLogging2(options) {
 function production(node, options) {
   const {
     nodeName,
-    logger: logger4,
+    logger: logger5,
     enableMetrics = true,
     enableTracing = true,
     enableRetry = true,
@@ -2753,7 +2764,7 @@ function production(node, options) {
     retryOptions = {},
     errorOptions = {}
   } = options;
-  const actualLogger = logger4 || createLogger(nodeName, { level: "info" /* INFO */ });
+  const actualLogger = logger5 || createLogger(nodeName, { level: "info" /* INFO */ });
   const middleware = [];
   middleware.push(
     withLogging2({
@@ -2817,9 +2828,9 @@ function development(node, options) {
   const {
     nodeName,
     verbose = true,
-    logger: logger4
+    logger: logger5
   } = options;
-  const actualLogger = logger4 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
+  const actualLogger = logger5 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
   return withLogging2({
     logger: actualLogger,
     name: nodeName,
@@ -4930,13 +4941,557 @@ var CircuitBreaker = class {
 function createCircuitBreaker(options) {
   return new CircuitBreaker(options);
 }
+
+// src/monitoring/health.ts
+var HealthChecker = class {
+  constructor(options) {
+    this.options = options;
+  }
+  checkTimer;
+  lastReport;
+  startTime = Date.now();
+  running = false;
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    const interval = this.options.interval || 3e4;
+    this.runChecks().catch((error) => {
+      console.error("Initial health check failed:", error);
+    });
+    this.checkTimer = setInterval(() => {
+      this.runChecks().catch((error) => {
+        console.error("Health check failed:", error);
+      });
+    }, interval);
+  }
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = void 0;
+    }
+  }
+  async getHealth() {
+    if (!this.lastReport) {
+      return this.runChecks();
+    }
+    return this.lastReport;
+  }
+  async getLiveness() {
+    return {
+      healthy: true,
+      status: "healthy",
+      message: "Application is running",
+      timestamp: Date.now()
+    };
+  }
+  async getReadiness() {
+    return this.getHealth();
+  }
+  async runChecks() {
+    const timeout2 = this.options.timeout || 5e3;
+    const results = {};
+    const checkPromises = Object.entries(this.options.checks).map(async ([name, check]) => {
+      const startTime = Date.now();
+      try {
+        const result = await Promise.race([
+          check(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout2)
+          )
+        ]);
+        results[name] = {
+          ...result,
+          timestamp: Date.now(),
+          duration: Date.now() - startTime
+        };
+      } catch (error) {
+        const errorMessage = error.message;
+        results[name] = {
+          healthy: false,
+          status: "unhealthy",
+          error: errorMessage,
+          timestamp: Date.now(),
+          duration: Date.now() - startTime
+        };
+        this.options.onCheckFail?.(name, error);
+      }
+    });
+    await Promise.all(checkPromises);
+    const allHealthy = Object.values(results).every((r) => r.healthy);
+    const anyUnhealthy = Object.values(results).some((r) => r.status === "unhealthy");
+    const status = allHealthy ? "healthy" : anyUnhealthy ? "unhealthy" : "degraded";
+    const report = {
+      healthy: allHealthy,
+      status,
+      timestamp: Date.now(),
+      checks: results,
+      uptime: Date.now() - this.startTime
+    };
+    if (this.lastReport && this.lastReport.healthy !== report.healthy) {
+      this.options.onHealthChange?.(report);
+    }
+    this.lastReport = report;
+    return report;
+  }
+};
+function createHealthChecker(options) {
+  return new HealthChecker(options);
+}
+
+// src/monitoring/profiler.ts
+var Profiler = class {
+  profiles = /* @__PURE__ */ new Map();
+  enabled;
+  sampleRate;
+  includeMemory;
+  includeStack;
+  maxSamples;
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? true;
+    this.sampleRate = options.sampleRate ?? 1;
+    this.includeMemory = options.includeMemory ?? false;
+    this.includeStack = options.includeStack ?? false;
+    this.maxSamples = options.maxSamples ?? 1e3;
+  }
+  profile(name, fn) {
+    return async (...args) => {
+      if (!this.enabled || Math.random() > this.sampleRate) {
+        return fn(...args);
+      }
+      const startTime = Date.now();
+      const startMemory = this.includeMemory ? process.memoryUsage() : void 0;
+      const stack = this.includeStack ? new Error().stack : void 0;
+      try {
+        const result = await fn(...args);
+        this.recordSample(name, startTime, startMemory, stack);
+        return result;
+      } catch (error) {
+        this.recordSample(name, startTime, startMemory, stack);
+        throw error;
+      }
+    };
+  }
+  wrap(name, promise) {
+    if (!this.enabled || Math.random() > this.sampleRate) {
+      return promise;
+    }
+    const startTime = Date.now();
+    const startMemory = this.includeMemory ? process.memoryUsage() : void 0;
+    const stack = this.includeStack ? new Error().stack : void 0;
+    return promise.finally(() => {
+      this.recordSample(name, startTime, startMemory, stack);
+    });
+  }
+  recordSample(name, startTime, startMemory, stack) {
+    const duration = Date.now() - startTime;
+    const sample = {
+      timestamp: startTime,
+      duration
+    };
+    if (this.includeMemory && startMemory) {
+      const currentMemory = process.memoryUsage();
+      sample.memory = {
+        heapUsed: currentMemory.heapUsed - startMemory.heapUsed,
+        heapTotal: currentMemory.heapTotal,
+        external: currentMemory.external
+      };
+    }
+    if (this.includeStack && stack) {
+      sample.stack = stack;
+    }
+    if (!this.profiles.has(name)) {
+      this.profiles.set(name, []);
+    }
+    const samples = this.profiles.get(name);
+    samples.push(sample);
+    if (samples.length > this.maxSamples) {
+      samples.shift();
+    }
+  }
+  getReport() {
+    const report = {};
+    for (const [name, samples] of this.profiles.entries()) {
+      if (samples.length === 0) {
+        continue;
+      }
+      const durations = samples.map((s) => s.duration).sort((a, b) => a - b);
+      const totalTime = durations.reduce((sum, d) => sum + d, 0);
+      const stats = {
+        calls: samples.length,
+        totalTime,
+        avgTime: totalTime / samples.length,
+        minTime: durations[0],
+        maxTime: durations[durations.length - 1],
+        p50: this.percentile(durations, 0.5),
+        p95: this.percentile(durations, 0.95),
+        p99: this.percentile(durations, 0.99),
+        samples
+      };
+      if (this.includeMemory) {
+        const memorySamples = samples.filter((s) => s.memory).map((s) => s.memory.heapUsed);
+        if (memorySamples.length > 0) {
+          stats.memory = {
+            avgHeapUsed: memorySamples.reduce((sum, m) => sum + m, 0) / memorySamples.length,
+            maxHeapUsed: Math.max(...memorySamples),
+            minHeapUsed: Math.min(...memorySamples)
+          };
+        }
+      }
+      report[name] = stats;
+    }
+    return report;
+  }
+  percentile(sorted, p) {
+    const index = Math.ceil(sorted.length * p) - 1;
+    return sorted[Math.max(0, index)];
+  }
+  reset(name) {
+    if (name) {
+      this.profiles.delete(name);
+    } else {
+      this.profiles.clear();
+    }
+  }
+  export(path) {
+    const report = this.getReport();
+    console.log("Exporting profile report to:", path);
+    console.log(JSON.stringify(report, null, 2));
+  }
+};
+function createProfiler(options) {
+  return new Profiler(options);
+}
+
+// src/monitoring/alerts.ts
+var logger4 = createLogger("agentforge:core:monitoring:alerts", { level: "info" /* INFO */ });
+var AlertManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  lastAlertTime = /* @__PURE__ */ new Map();
+  monitorTimer;
+  running = false;
+  start(metrics, interval = 6e4) {
+    if (this.running || !metrics) {
+      return;
+    }
+    this.running = true;
+    this.monitorTimer = setInterval(() => {
+      const currentMetrics = metrics();
+      this.checkRules(currentMetrics);
+    }, interval);
+  }
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    if (this.monitorTimer) {
+      clearInterval(this.monitorTimer);
+      this.monitorTimer = void 0;
+    }
+  }
+  async alert(alert) {
+    const fullAlert = {
+      ...alert,
+      timestamp: alert.timestamp || Date.now()
+    };
+    if (this.isThrottled(alert.name)) {
+      return;
+    }
+    this.lastAlertTime.set(alert.name, Date.now());
+    this.options.onAlert?.(fullAlert);
+    logger4.warn("Alert triggered", {
+      name: alert.name,
+      severity: alert.severity,
+      message: alert.message,
+      data: alert.data
+    });
+  }
+  checkRules(metrics) {
+    if (!this.options.rules) {
+      return;
+    }
+    for (const rule of this.options.rules) {
+      try {
+        if (rule.condition(metrics)) {
+          this.alert({
+            name: rule.name,
+            severity: rule.severity,
+            message: rule.message || `Alert triggered: ${rule.name}`,
+            data: { metrics }
+          });
+        }
+      } catch (error) {
+        logger4.error("Rule check failed", {
+          ruleName: rule.name,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
+  isThrottled(name) {
+    const rule = this.options.rules?.find((r) => r.name === name);
+    if (!rule?.throttle) {
+      return false;
+    }
+    const lastTime = this.lastAlertTime.get(name);
+    if (!lastTime) {
+      return false;
+    }
+    return Date.now() - lastTime < rule.throttle;
+  }
+  async sendToChannel(channelName, alert) {
+    const channel = this.options.channels[channelName];
+    if (!channel) {
+      throw new Error(`Channel not found: ${channelName}`);
+    }
+    switch (channel.type) {
+      case "email":
+        logger4.info("Alert sent to email", {
+          channel: channelName,
+          to: channel.config.to,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+        break;
+      case "slack":
+        logger4.info("Alert sent to Slack", {
+          channel: channelName,
+          webhookUrl: channel.config.webhookUrl,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+        break;
+      case "webhook":
+        logger4.info("Alert sent to webhook", {
+          channel: channelName,
+          url: channel.config.url,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+        break;
+      default:
+        logger4.info("Alert sent", {
+          channel: channelName,
+          channelType: channel.type,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+    }
+  }
+  getAlertHistory(name, limit = 100) {
+    return [];
+  }
+  clearAlertHistory(name) {
+    if (name) {
+      this.lastAlertTime.delete(name);
+    } else {
+      this.lastAlertTime.clear();
+    }
+  }
+};
+function createAlertManager(options) {
+  return new AlertManager(options);
+}
+
+// src/monitoring/audit.ts
+var AuditLogger = class {
+  constructor(options = {}) {
+    this.options = options;
+    if (options.retention?.autoCleanup) {
+      this.startCleanup();
+    }
+  }
+  logs = [];
+  cleanupTimer;
+  async log(entry) {
+    const fullEntry = {
+      ...entry,
+      id: this.generateId(),
+      timestamp: entry.timestamp || Date.now(),
+      success: entry.success ?? true
+    };
+    const fields = this.options.fields || {};
+    const filteredEntry = {
+      id: fullEntry.id,
+      userId: fields.userId !== false ? fullEntry.userId : "",
+      action: fields.action !== false ? fullEntry.action : "",
+      resource: fields.resource !== false ? fullEntry.resource : "",
+      timestamp: fields.timestamp !== false ? fullEntry.timestamp : void 0
+    };
+    if (fields.input !== false && fullEntry.input) {
+      filteredEntry.input = fullEntry.input;
+    }
+    if (fields.output !== false && fullEntry.output) {
+      filteredEntry.output = fullEntry.output;
+    }
+    if (fullEntry.metadata) {
+      filteredEntry.metadata = fullEntry.metadata;
+    }
+    if (fullEntry.error) {
+      filteredEntry.error = fullEntry.error;
+      filteredEntry.success = false;
+    }
+    this.logs.push(filteredEntry);
+    this.options.onLog?.(filteredEntry);
+  }
+  async query(query = {}) {
+    let results = [...this.logs];
+    if (query.userId) {
+      results = results.filter((log) => log.userId === query.userId);
+    }
+    if (query.action) {
+      results = results.filter((log) => log.action === query.action);
+    }
+    if (query.resource) {
+      results = results.filter((log) => log.resource === query.resource);
+    }
+    if (query.startDate) {
+      const startTime = query.startDate.getTime();
+      results = results.filter((log) => (log.timestamp || 0) >= startTime);
+    }
+    if (query.endDate) {
+      const endTime = query.endDate.getTime();
+      results = results.filter((log) => (log.timestamp || 0) <= endTime);
+    }
+    const offset = query.offset || 0;
+    const limit = query.limit || 100;
+    results = results.slice(offset, offset + limit);
+    return results;
+  }
+  async export(path, options = {}) {
+    const logs = await this.query({
+      startDate: options.startDate,
+      endDate: options.endDate
+    });
+    const format = options.format || "json";
+    if (format === "json") {
+      console.log(`Exporting ${logs.length} audit logs to ${path} (JSON)`);
+      console.log(JSON.stringify(logs, null, 2));
+    } else if (format === "csv") {
+      console.log(`Exporting ${logs.length} audit logs to ${path} (CSV)`);
+      const csv = this.convertToCSV(logs);
+      console.log(csv);
+    }
+  }
+  convertToCSV(logs) {
+    if (logs.length === 0) {
+      return "";
+    }
+    const headers = ["id", "userId", "action", "resource", "timestamp", "success"];
+    const rows = logs.map((log) => [
+      log.id,
+      log.userId,
+      log.action,
+      log.resource,
+      log.timestamp,
+      log.success
+    ]);
+    return [headers.join(","), ...rows.map((row) => row.join(","))].join("\n");
+  }
+  startCleanup() {
+    const interval = 24 * 60 * 60 * 1e3;
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, interval);
+  }
+  cleanup() {
+    if (!this.options.retention) {
+      return;
+    }
+    const retentionMs = this.options.retention.days * 24 * 60 * 60 * 1e3;
+    const cutoffTime = Date.now() - retentionMs;
+    this.logs = this.logs.filter((log) => (log.timestamp || 0) >= cutoffTime);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  stop() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+  }
+};
+function createAuditLogger(options) {
+  return new AuditLogger(options);
+}
+
+// src/prompt-loader/index.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var MAX_VARIABLE_LENGTH = 500;
+function sanitizeValue(value) {
+  if (value === void 0 || value === null) return "";
+  let sanitized = String(value);
+  sanitized = sanitized.replace(/^#+\s*/gm, "");
+  sanitized = sanitized.replace(/[\r\n]+/g, " ");
+  sanitized = sanitized.trim().replace(/\s+/g, " ");
+  if (sanitized.length > MAX_VARIABLE_LENGTH) {
+    sanitized = sanitized.substring(0, MAX_VARIABLE_LENGTH) + "...";
+  }
+  return sanitized;
+}
+function renderTemplate(template, options) {
+  let rawVariables;
+  let sanitizedVariables;
+  if ("trustedVariables" in options || "untrustedVariables" in options) {
+    const opts = options;
+    rawVariables = {
+      ...opts.trustedVariables,
+      ...opts.untrustedVariables
+    };
+    const sanitizedUntrusted = {};
+    if (opts.untrustedVariables) {
+      for (const [key, value] of Object.entries(opts.untrustedVariables)) {
+        sanitizedUntrusted[key] = sanitizeValue(value);
+      }
+    }
+    sanitizedVariables = {
+      ...opts.trustedVariables,
+      ...sanitizedUntrusted
+    };
+  } else {
+    rawVariables = options;
+    sanitizedVariables = options;
+  }
+  let result = template;
+  result = result.replace(/\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g, (_, varName, content) => {
+    return rawVariables[varName] ? content : "";
+  });
+  result = result.replace(/\{\{(\w+)\}\}/g, (_, varName) => {
+    const value = sanitizedVariables[varName];
+    if (value === void 0 || value === null) return "";
+    return String(value);
+  });
+  return result;
+}
+function loadPrompt(promptName, options = {}, promptsDir) {
+  const baseDir = promptsDir || (0, import_path.join)(process.cwd(), "prompts");
+  const promptPath = (0, import_path.join)(baseDir, `${promptName}.md`);
+  try {
+    const template = (0, import_fs.readFileSync)(promptPath, "utf-8");
+    return renderTemplate(template, options);
+  } catch (error) {
+    throw new Error(
+      `Failed to load prompt "${promptName}" from ${promptPath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentError,
+  AlertManager,
+  AuditLogger,
   BatchProcessor,
   CircuitBreaker,
   ConnectionPool,
   DatabasePool,
+  HealthChecker,
   HttpPool,
   LogLevel,
   ManagedTool,
@@ -4944,6 +5499,7 @@ function createCircuitBreaker(options) {
   MetricType,
   MiddlewareChain,
   MissingDescriptionError,
+  Profiler,
   RegistryEvent,
   TimeoutError,
   ToolBuilder,
@@ -4967,7 +5523,9 @@ function createCircuitBreaker(options) {
   composeWithOptions,
   conditional,
   configureLangSmith,
+  createAlertManager,
   createApprovalRequiredInterrupt,
+  createAuditLogger,
   createBatchProcessor,
   createBinaryRouter,
   createCircuitBreaker,
@@ -4977,6 +5535,7 @@ function createCircuitBreaker(options) {
   createCustomInterrupt,
   createDatabasePool,
   createErrorReporter,
+  createHealthChecker,
   createHeartbeat,
   createHttpPool,
   createHumanRequestInterrupt,
@@ -4990,6 +5549,7 @@ function createCircuitBreaker(options) {
   createMockTool,
   createMultiRouter,
   createParallelWorkflow,
+  createProfiler,
   createProgressTracker,
   createSSEFormatter,
   createSequentialWorkflow,
@@ -5026,6 +5586,7 @@ function createCircuitBreaker(options) {
   isHumanRequestInterrupt,
   isMemoryCheckpointer,
   isTracingEnabled,
+  loadPrompt,
   map,
   merge,
   mergeState,
@@ -5034,8 +5595,10 @@ function createCircuitBreaker(options) {
   presets,
   production,
   reduce,
+  renderTemplate,
   retry,
   safeValidateSchemaDescriptions,
+  sanitizeValue,
   sendMessage,
   sequential,
   sequentialBuilder,