@agentforge/core 0.16.51 → 0.16.53

package/dist/index.cjs

@@ -1351,7 +1351,7 @@ function toError(error) {
   }
   return new Error(String(error));
 }
-function resolveExecutionMethod(tool, logger6) {
+function resolveExecutionMethod(tool, logger7) {
   const executeFn = tool.invoke || tool.execute;
   if (!executeFn) {
     throw new Error(
@@ -1359,14 +1359,14 @@ function resolveExecutionMethod(tool, logger6) {
     );
   }
   if (!tool.invoke && tool.execute) {
-    logger6.warn(
+    logger7.warn(
       `Tool "${tool.metadata?.name ?? tool.name ?? "unknown"}" only implements execute() which is deprecated. Please update to implement invoke() as the primary method. execute() will be removed in v1.0.0.`
     );
   }
   return executeFn;
 }
-async function executeWithRetry(tool, input, policy, logger6) {
-  const executeFn = resolveExecutionMethod(tool, logger6);
+async function executeWithRetry(tool, input, policy, logger7) {
+  const executeFn = resolveExecutionMethod(tool, logger7);
   if (!policy) {
     return await executeFn.call(tool, input);
   }
@@ -1645,7 +1645,7 @@ async function performManagedCleanup({
 function ensureManagedBeforeExitHandler({
   autoCleanup,
   cleanup,
-  logger: logger6,
+  logger: logger7,
   name,
   state
 }) {
@@ -1654,7 +1654,7 @@ function ensureManagedBeforeExitHandler({
   }
   state.beforeExitHandler = () => {
     cleanup().catch(
-      (err) => logger6.error("Cleanup failed", {
+      (err) => logger7.error("Cleanup failed", {
         toolName: name,
         error: getErrorMessage(err),
         ...err instanceof Error && err.stack ? { stack: err.stack } : {}
@@ -2107,8 +2107,10 @@ function createToolSimulator(config) {
   };
 }
 
-// src/langgraph/state.ts
+// src/langgraph/state-annotation.ts
 var import_langgraph = require("@langchain/langgraph");
+
+// src/langgraph/state-shared.ts
 function entriesOf(value) {
   return Object.entries(value);
 }
@@ -2127,6 +2129,8 @@ function setStateValue(target, key, value) {
 function setStateDefinitionValue(target, key, value) {
   target[key] = value;
 }
+
+// src/langgraph/state-annotation.ts
 function createChannel(channelConfig) {
   if (channelConfig.reducer) {
     return (0, import_langgraph.Annotation)({
@@ -2153,6 +2157,8 @@ function createStateAnnotation(config) {
   }
   return import_langgraph.Annotation.Root(stateDefinition);
 }
+
+// src/langgraph/state-validation.ts
 function validateState(state, config) {
   const validated = {};
   for (const [key, channelConfig] of entriesOf(config)) {
@@ -2170,6 +2176,8 @@ function validateState(state, config) {
   }
   return validated;
 }
+
+// src/langgraph/state-merge.ts
 function mergeState(currentState, update, config) {
   const merged = { ...currentState };
   for (const key of keysOf(update)) {
@@ -2617,14 +2625,14 @@ var withLogging = (options) => {
     onComplete,
     onError
   } = options;
-  const logger6 = providedLogger || createLogger(name, { level });
+  const logger7 = providedLogger || createLogger(name, { level });
   return (node) => {
     return async (state) => {
       const startTime = Date.now();
       try {
         if (logInput) {
           const data = extractData ? extractData(state) : { state };
-          logger6.info("Node execution started", data);
+          logger7.info("Node execution started", data);
         }
         if (onStart) {
           onStart(state);
@@ -2634,9 +2642,9 @@ var withLogging = (options) => {
         if (logOutput) {
           const data = extractData ? extractData(result) : { result };
           if (logDuration) {
-            logger6.info(`Node execution completed (${duration}ms)`, data);
+            logger7.info(`Node execution completed (${duration}ms)`, data);
           } else {
-            logger6.info("Node execution completed", data);
+            logger7.info("Node execution completed", data);
           }
         }
         if (onComplete) {
@@ -2647,7 +2655,7 @@ var withLogging = (options) => {
         const duration = Date.now() - startTime;
         const err = error instanceof Error ? error : new Error(String(error));
         if (logErrors) {
-          logger6.error(`Node execution failed (${duration}ms)`, {
+          logger7.error(`Node execution failed (${duration}ms)`, {
             error: err.message,
             ...err.stack ? { stack: err.stack } : {}
           });
@@ -2769,7 +2777,7 @@ function withLogging2(options) {
 function production(node, options) {
   const {
     nodeName,
-    logger: logger6,
+    logger: logger7,
     enableMetrics = true,
     enableTracing = true,
     enableRetry = true,
@@ -2777,7 +2785,7 @@ function production(node, options) {
     retryOptions = {},
     errorOptions = {}
   } = options;
-  const actualLogger = logger6 || createLogger(nodeName, { level: "info" /* INFO */ });
+  const actualLogger = logger7 || createLogger(nodeName, { level: "info" /* INFO */ });
   const middleware = [
     withLogging2({
       logger: actualLogger,
@@ -2832,8 +2840,8 @@ function production(node, options) {
 
 // src/langgraph/middleware/preset-development.ts
 function development(node, options) {
-  const { nodeName, verbose = true, logger: logger6 } = options;
-  const actualLogger = logger6 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
+  const { nodeName, verbose = true, logger: logger7 } = options;
+  const actualLogger = logger7 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
   return withLogging2({
     logger: actualLogger,
     name: nodeName,
@@ -4240,37 +4248,9 @@ function createMessage(type, data, error) {
   return { type, data, error };
 }
 
-// src/resources/pool.ts
-var ConnectionPool = class {
-  constructor(options) {
-    this.options = options;
-    const poolConfig = options.pool || {};
-    const min = poolConfig.min || 0;
-    if (min > 0) {
-      this.initialize(min).catch((error) => {
-        console.error("Failed to initialize pool:", error);
-      });
-    }
-    const evictionInterval = poolConfig.evictionInterval || 6e4;
-    this.evictionTimer = setInterval(() => {
-      this.evictIdleConnections().catch((error) => {
-        console.error("Failed to evict idle connections:", error);
-      });
-    }, evictionInterval);
-    const healthCheck = options.healthCheck || {};
-    if (healthCheck.enabled) {
-      const interval = healthCheck.interval || 3e4;
-      this.healthCheckTimer = setInterval(() => {
-        this.performHealthChecks().catch((error) => {
-          console.error("Health check failed:", error);
-          options.onHealthCheckFail?.(error);
-        });
-      }, interval);
-    }
-  }
-  connections = [];
-  pending = [];
-  stats = {
+// src/resources/pool-runtime.ts
+function createInitialPoolStats() {
+  return {
     size: 0,
     available: 0,
     pending: 0,
@@ -4280,178 +4260,347 @@ var ConnectionPool = class {
     healthChecksPassed: 0,
     healthChecksFailed: 0
   };
-  evictionTimer;
-  healthCheckTimer;
-  draining = false;
-  async initialize(count) {
-    const promises = Array.from({ length: count }, () => this.createConnection());
-    await Promise.all(promises);
-  }
-  async createConnection() {
-    const connection = await this.options.factory();
-    this.connections.push({
-      connection,
-      createdAt: Date.now(),
-      lastUsedAt: Date.now(),
-      inUse: false
-    });
-    this.stats.created++;
-    this.stats.size++;
-    this.stats.available++;
-    return connection;
-  }
-  async destroyConnection(pooled) {
-    const index = this.connections.indexOf(pooled);
-    if (index !== -1) {
-      this.connections.splice(index, 1);
-    }
-    if (this.options.destroyer) {
-      await this.options.destroyer(pooled.connection);
-    }
-    this.options.onDestroy?.(pooled.connection);
-    this.stats.destroyed++;
-    this.stats.size--;
-    if (!pooled.inUse) {
-      this.stats.available--;
+}
+async function initializeConnections(runtime, count) {
+  runtime.creating += count;
+  const promises = Array.from({ length: count }, async () => {
+    try {
+      const connection = await createConnection(runtime);
+      const pooled = runtime.connections.find((item) => item.connection === connection);
+      if (!pooled) {
+        throw new Error("Newly created connection not found in pool");
+      }
+      if (runtime.draining) {
+        await destroyConnection(runtime, pooled);
+        return;
+      }
+      assignConnectionToPendingAcquire(runtime, connection);
+    } finally {
+      runtime.creating--;
     }
+  });
+  await Promise.all(promises);
+}
+function assignConnectionToPendingAcquire(runtime, connection) {
+  const pending = runtime.pending.shift();
+  if (!pending) {
+    return;
   }
-  async acquire() {
-    if (this.draining) {
-      throw new Error("Pool is draining");
-    }
-    const available = this.connections.find((c) => !c.inUse);
-    if (available) {
-      available.inUse = true;
-      available.lastUsedAt = Date.now();
-      this.stats.available--;
-      this.stats.acquired++;
-      this.options.onAcquire?.(available.connection);
-      return available.connection;
-    }
-    const poolConfig = this.options.pool || {};
-    const max = poolConfig.max || 10;
-    if (this.connections.length < max) {
-      const connection = await this.createConnection();
-      const pooled = this.connections.find((c) => c.connection === connection);
+  const pooled = runtime.connections.find((item) => item.connection === connection);
+  if (!pooled) {
+    runtime.pending.unshift(pending);
+    return;
+  }
+  clearTimeout(pending.timeout);
+  runtime.stats.pending--;
+  pooled.inUse = true;
+  pooled.lastUsedAt = Date.now();
+  runtime.stats.available--;
+  runtime.stats.acquired++;
+  runtime.options.onAcquire?.(connection);
+  pending.resolve(connection);
+}
+async function createConnection(runtime) {
+  const connection = await runtime.options.factory();
+  const now = Date.now();
+  runtime.connections.push({
+    connection,
+    createdAt: now,
+    lastUsedAt: now,
+    inUse: false
+  });
+  runtime.stats.created++;
+  runtime.stats.size++;
+  runtime.stats.available++;
+  return connection;
+}
+async function destroyConnection(runtime, pooled) {
+  const index = runtime.connections.indexOf(pooled);
+  if (index !== -1) {
+    runtime.connections.splice(index, 1);
+  }
+  if (runtime.options.destroyer) {
+    await runtime.options.destroyer(pooled.connection);
+  }
+  runtime.options.onDestroy?.(pooled.connection);
+  runtime.stats.destroyed++;
+  runtime.stats.size--;
+  if (pooled.inUse) {
+    runtime.stats.acquired--;
+  } else {
+    runtime.stats.available--;
+  }
+}
+function getPoolConfig(runtime) {
+  return runtime.options.pool || {};
+}
+function getHealthCheckConfig(runtime) {
+  return runtime.options.healthCheck || {};
+}
+function clonePoolStats(runtime) {
+  return { ...runtime.stats };
+}
+
+// src/resources/pool-acquisition.ts
+async function acquireConnection(runtime) {
+  if (runtime.draining) {
+    throw new Error("Pool is draining");
+  }
+  const available = runtime.connections.find((connection) => !connection.inUse);
+  if (available) {
+    available.inUse = true;
+    available.lastUsedAt = Date.now();
+    runtime.stats.available--;
+    runtime.stats.acquired++;
+    runtime.options.onAcquire?.(available.connection);
+    return available.connection;
+  }
+  const poolConfig = getPoolConfig(runtime);
+  const max = poolConfig.max || 10;
+  if (runtime.connections.length + runtime.creating < max) {
+    runtime.creating++;
+    try {
+      const connection = await createConnection(runtime);
+      const pooled = runtime.connections.find((item) => item.connection === connection);
+      if (!pooled) {
+        throw new Error("Newly created connection not found in pool");
+      }
+      if (runtime.draining) {
+        await destroyConnection(runtime, pooled);
+        throw new Error("Pool is draining");
+      }
       pooled.inUse = true;
-      this.stats.available--;
-      this.stats.acquired++;
-      this.options.onAcquire?.(connection);
+      pooled.lastUsedAt = Date.now();
+      runtime.stats.available--;
+      runtime.stats.acquired++;
+      runtime.options.onAcquire?.(connection);
       return connection;
+    } finally {
+      runtime.creating--;
     }
-    return new Promise((resolve, reject) => {
-      const timeout2 = poolConfig.acquireTimeout || 3e4;
-      const timer = setTimeout(() => {
-        const index = this.pending.findIndex((p) => p.resolve === resolve);
-        if (index !== -1) {
-          this.pending.splice(index, 1);
-          this.stats.pending--;
-        }
-        reject(new Error("Acquire timeout"));
-      }, timeout2);
-      this.pending.push({ resolve, reject, timeout: timer });
-      this.stats.pending++;
-    });
   }
-  async release(connection) {
-    const pooled = this.connections.find((c) => c.connection === connection);
-    if (!pooled) {
-      throw new Error("Connection not found in pool");
-    }
-    if (!pooled.inUse) {
-      throw new Error("Connection is not in use");
-    }
-    pooled.inUse = false;
-    pooled.lastUsedAt = Date.now();
-    this.stats.available++;
-    this.stats.acquired--;
-    this.options.onRelease?.(connection);
-    const pending = this.pending.shift();
-    if (pending) {
-      clearTimeout(pending.timeout);
-      this.stats.pending--;
-      pooled.inUse = true;
-      this.stats.available--;
-      this.stats.acquired++;
-      this.options.onAcquire?.(connection);
-      pending.resolve(connection);
+  return new Promise((resolve, reject) => {
+    const timeout2 = poolConfig.acquireTimeout || 3e4;
+    const timer = setTimeout(() => {
+      const index = runtime.pending.findIndex((pending) => pending.resolve === resolve);
+      if (index !== -1) {
+        runtime.pending.splice(index, 1);
+        runtime.stats.pending--;
+      }
+      reject(new Error("Acquire timeout"));
+    }, timeout2);
+    runtime.pending.push({ resolve, reject, timeout: timer });
+    runtime.stats.pending++;
+  });
+}
+async function releaseConnection(runtime, connection) {
+  const pooled = runtime.connections.find((item) => item.connection === connection);
+  if (!pooled) {
+    throw new Error("Connection not found in pool");
+  }
+  if (!pooled.inUse) {
+    throw new Error("Connection is not in use");
+  }
+  pooled.inUse = false;
+  pooled.lastUsedAt = Date.now();
+  runtime.stats.available++;
+  runtime.stats.acquired--;
+  runtime.options.onRelease?.(connection);
+  const pending = runtime.pending.shift();
+  if (!pending) {
+    return;
+  }
+  clearTimeout(pending.timeout);
+  runtime.stats.pending--;
+  pooled.inUse = true;
+  pooled.lastUsedAt = Date.now();
+  runtime.stats.available--;
+  runtime.stats.acquired++;
+  runtime.options.onAcquire?.(connection);
+  pending.resolve(connection);
+}
+
+// src/resources/pool-eviction.ts
+function selectIdleConnectionsForEviction(runtime, idleTimeout, min, now) {
+  const idleConnections = runtime.connections.filter(
+    (connection) => !connection.inUse && now - connection.lastUsedAt > idleTimeout
+  );
+  const evictableCount = Math.max(0, runtime.connections.length - min);
+  return idleConnections.slice(0, evictableCount);
+}
+async function evictIdleConnections(runtime) {
+  const poolConfig = getPoolConfig(runtime);
+  const idleTimeout = poolConfig.idleTimeout || 6e4;
+  const min = poolConfig.min || 0;
+  const now = Date.now();
+  const toEvict = selectIdleConnectionsForEviction(runtime, idleTimeout, min, now);
+  for (const pooled of toEvict) {
+    if (!runtime.connections.includes(pooled)) {
+      continue;
+    }
+    if (pooled.inUse) {
+      continue;
+    }
+    if (runtime.connections.length <= min) {
+      break;
+    }
+    if (Date.now() - pooled.lastUsedAt <= idleTimeout) {
+      continue;
     }
+    await destroyConnection(runtime, pooled);
   }
-  async evictIdleConnections() {
-    const poolConfig = this.options.pool || {};
-    const idleTimeout = poolConfig.idleTimeout || 6e4;
-    const min = poolConfig.min || 0;
-    const now = Date.now();
-    const toEvict = this.connections.filter(
-      (c) => !c.inUse && now - c.lastUsedAt > idleTimeout && this.connections.length > min
-    );
-    for (const pooled of toEvict) {
-      await this.destroyConnection(pooled);
+}
+
+// src/resources/pool-health.ts
+async function runHealthCheckWithTimeout(runtime, connection, timeout2) {
+  let timer;
+  try {
+    return await Promise.race([
+      runtime.options.validator(connection),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Health check timeout")), timeout2);
+      })
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
     }
   }
-  async performHealthChecks() {
-    if (!this.options.validator) {
-      return;
+}
+async function performHealthChecks(runtime) {
+  if (!runtime.options.validator) {
+    return;
+  }
+  const healthCheck = getHealthCheckConfig(runtime);
+  const timeout2 = healthCheck.timeout || 5e3;
+  const retries = healthCheck.retries || 1;
+  for (const pooled of [...runtime.connections]) {
+    if (pooled.inUse) {
+      continue;
     }
-    const healthCheck = this.options.healthCheck || {};
-    const timeout2 = healthCheck.timeout || 5e3;
-    const retries = healthCheck.retries || 1;
-    for (const pooled of this.connections) {
-      if (pooled.inUse) {
-        continue;
-      }
-      let healthy = false;
-      for (let i = 0; i < retries; i++) {
-        try {
-          const result = await Promise.race([
-            this.options.validator(pooled.connection),
-            new Promise(
-              (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout2)
-            )
-          ]);
-          if (result) {
-            healthy = true;
-            break;
-          }
-        } catch (error) {
+    let healthy = false;
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const result = await runHealthCheckWithTimeout(runtime, pooled.connection, timeout2);
+        if (result) {
+          healthy = true;
+          break;
         }
-      }
-      if (healthy) {
-        this.stats.healthChecksPassed++;
-      } else {
-        this.stats.healthChecksFailed++;
-        await this.destroyConnection(pooled);
+      } catch {
       }
     }
-  }
-  async drain() {
-    this.draining = true;
-    for (const pending of this.pending) {
-      clearTimeout(pending.timeout);
-      pending.reject(new Error("Pool is draining"));
+    if (healthy) {
+      runtime.stats.healthChecksPassed++;
+      continue;
     }
-    this.pending = [];
-    this.stats.pending = 0;
-    while (this.connections.some((c) => c.inUse)) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+    if (!runtime.connections.includes(pooled) || pooled.inUse) {
+      continue;
     }
+    runtime.stats.healthChecksFailed++;
+    await destroyConnection(runtime, pooled);
   }
-  async clear() {
-    if (this.evictionTimer) {
-      clearInterval(this.evictionTimer);
-      this.evictionTimer = void 0;
-    }
-    if (this.healthCheckTimer) {
-      clearInterval(this.healthCheckTimer);
-      this.healthCheckTimer = void 0;
+}
+
+// src/resources/pool-lifecycle.ts
+function rejectPendingAcquisitions(runtime, message) {
+  for (const pending of runtime.pending) {
+    clearTimeout(pending.timeout);
+    pending.reject(new Error(message));
+  }
+  runtime.pending = [];
+  runtime.stats.pending = 0;
+}
+async function drainPool(runtime) {
+  runtime.draining = true;
+  rejectPendingAcquisitions(runtime, "Pool is draining");
+  while (runtime.connections.some((connection) => connection.inUse)) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+}
+async function clearPool(runtime) {
+  runtime.draining = true;
+  rejectPendingAcquisitions(runtime, "Pool is draining");
+  if (runtime.evictionTimer) {
+    clearInterval(runtime.evictionTimer);
+    runtime.evictionTimer = void 0;
+  }
+  if (runtime.healthCheckTimer) {
+    clearInterval(runtime.healthCheckTimer);
+    runtime.healthCheckTimer = void 0;
+  }
+  const connections = [...runtime.connections];
+  for (const pooled of connections) {
+    await destroyConnection(runtime, pooled);
+  }
+}
+
+// src/resources/pool.ts
+var logger4 = createLogger("agentforge:core:resources:pool");
+function toErrorPayload(error) {
+  if (error instanceof Error) {
+    return {
+      error: error.message,
+      stack: error.stack
+    };
+  }
+  return { error: String(error) };
+}
+function toError3(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+var ConnectionPool = class {
+  runtime;
+  constructor(options) {
+    this.runtime = {
+      connections: [],
+      pending: [],
+      stats: createInitialPoolStats(),
+      draining: false,
+      creating: 0,
+      options
+    };
+    const poolConfig = getPoolConfig(this.runtime);
+    const min = poolConfig.min || 0;
+    if (min > 0) {
+      initializeConnections(this.runtime, min).catch((error) => {
+        logger4.error("Failed to initialize pool", toErrorPayload(error));
+      });
     }
-    const connections = [...this.connections];
-    for (const pooled of connections) {
-      await this.destroyConnection(pooled);
+    const evictionInterval = poolConfig.evictionInterval || 6e4;
+    this.runtime.evictionTimer = setInterval(() => {
+      evictIdleConnections(this.runtime).catch((error) => {
+        logger4.error("Failed to evict idle connections", toErrorPayload(error));
+      });
+    }, evictionInterval);
+    const healthCheck = getHealthCheckConfig(this.runtime);
+    if (healthCheck.enabled) {
+      const interval = healthCheck.interval || 3e4;
+      this.runtime.healthCheckTimer = setInterval(() => {
+        performHealthChecks(this.runtime).catch((error) => {
+          const normalizedError = toError3(error);
+          logger4.error("Health check failed", toErrorPayload(normalizedError));
+          options.onHealthCheckFail?.(normalizedError);
+        });
+      }, interval);
     }
   }
+  async acquire() {
+    return acquireConnection(this.runtime);
+  }
+  async release(connection) {
+    return releaseConnection(this.runtime, connection);
+  }
+  async drain() {
+    return drainPool(this.runtime);
+  }
+  async clear() {
+    return clearPool(this.runtime);
+  }
   getStats() {
-    return { ...this.stats };
+    return clonePoolStats(this.runtime);
   }
 };
 function createConnectionPool(options) {
@@ -4984,7 +5133,7 @@ function createCircuitBreaker(options) {
 }
 
 // src/monitoring/health.ts
-var logger4 = createLogger("agentforge:core:monitoring:health", { level: "info" /* INFO */ });
+var logger5 = createLogger("agentforge:core:monitoring:health", { level: "info" /* INFO */ });
 var HealthChecker = class {
   constructor(options) {
     this.options = options;
@@ -5000,14 +5149,14 @@ var HealthChecker = class {
     this.running = true;
     const interval = this.options.interval || 3e4;
     this.runChecks().catch((error) => {
-      logger4.error("Initial health check failed", {
+      logger5.error("Initial health check failed", {
         error: error instanceof Error ? error.message : String(error),
         ...error instanceof Error && error.stack ? { stack: error.stack } : {}
       });
     });
     this.checkTimer = setInterval(() => {
       this.runChecks().catch((error) => {
-        logger4.error("Health check failed", {
+        logger5.error("Health check failed", {
           error: error instanceof Error ? error.message : String(error),
           ...error instanceof Error && error.stack ? { stack: error.stack } : {}
         });
@@ -5217,7 +5366,7 @@ function createProfiler(options) {
 }
 
 // src/monitoring/alerts.ts
-var logger5 = createLogger("agentforge:core:monitoring:alerts", { level: "info" /* INFO */ });
+var logger6 = createLogger("agentforge:core:monitoring:alerts", { level: "info" /* INFO */ });
 function toAlertSummary(alert) {
   return {
     name: alert.name,
@@ -5269,7 +5418,7 @@ var AlertManager = class {
         const currentMetrics = metrics();
         this.checkRules(currentMetrics);
       } catch (error) {
-        logger5.error("Metrics collection failed", toMetricsProviderErrorPayload(error));
+        logger6.error("Metrics collection failed", toMetricsProviderErrorPayload(error));
       }
     }, interval);
   }
@@ -5295,9 +5444,9 @@ var AlertManager = class {
     try {
       await this.options.onAlert?.(fullAlert);
     } catch (error) {
-      logger5.error("Alert callback failed", toAlertCallbackErrorPayload(error));
+      logger6.error("Alert callback failed", toAlertCallbackErrorPayload(error));
     }
-    logger5.warn("Alert triggered", {
+    logger6.warn("Alert triggered", {
       name: alert.name,
       severity: alert.severity,
       message: alert.message,
@@ -5317,11 +5466,11 @@ var AlertManager = class {
             message: rule.message || `Alert triggered: ${rule.name}`,
             data: { metrics }
           }).catch((error) => {
-            logger5.error("Alert dispatch failed", toAlertDispatchErrorPayload(rule.name, error));
+            logger6.error("Alert dispatch failed", toAlertDispatchErrorPayload(rule.name, error));
           });
         }
       } catch (error) {
-        logger5.error("Rule check failed", toRuleErrorPayload(rule.name, error));
+        logger6.error("Rule check failed", toRuleErrorPayload(rule.name, error));
       }
     }
   }
@@ -5343,28 +5492,28 @@ var AlertManager = class {
     }
     switch (channel.type) {
       case "email":
-        logger5.info("Alert sent to email", {
+        logger6.info("Alert sent to email", {
           channel: channelName,
           to: channel.config.to,
           alert: toAlertSummary(alert)
         });
         break;
       case "slack":
-        logger5.info("Alert sent to Slack", {
+        logger6.info("Alert sent to Slack", {
           channel: channelName,
           webhookUrl: channel.config.webhookUrl,
           alert: toAlertSummary(alert)
         });
         break;
       case "webhook":
-        logger5.info("Alert sent to webhook", {
+        logger6.info("Alert sent to webhook", {
           channel: channelName,
           url: channel.config.url,
           alert: toAlertSummary(alert)
         });
         break;
       default:
-        logger5.info("Alert sent", {
+        logger6.info("Alert sent", {
           channel: channelName,
           channelType: channel.type,
           alert: toAlertSummary(alert)