@agentforge/core 0.18.7 → 0.18.9

package/dist/index.cjs

@@ -1245,6 +1245,47 @@ function snapshotExecutionMetrics(metrics) {
   };
 }
 
+// src/tools/execution-resilience.ts
+function normalizeThrownValue(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function executeWithRetries(execute, maxAttempts, retryDelay, shouldRetry) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await execute();
+    } catch (thrownValue) {
+      const error = normalizeThrownValue(thrownValue);
+      if (attempt === maxAttempts || !shouldRetry(error)) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt, error)));
+    }
+  }
+  throw new Error("Retry execution requires at least one attempt");
+}
+async function executeWithTimeout(execute, timeoutMs, timeoutError, startOrder = "timeout-first") {
+  let timeoutId;
+  const startTimeout = () => new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(timeoutError()), timeoutMs);
+  });
+  try {
+    let executionPromise;
+    let timeoutPromise;
+    if (startOrder === "execution-first") {
+      executionPromise = execute();
+      timeoutPromise = startTimeout();
+    } else {
+      timeoutPromise = startTimeout();
+      executionPromise = execute();
+    }
+    return await Promise.race([executionPromise, timeoutPromise]);
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
 // src/tools/executor-retry.ts
 function calculateBackoff(attempt, policy) {
   const initialDelay = policy.initialDelay || 1e3;
@@ -1264,10 +1305,7 @@ function calculateBackoff(attempt, policy) {
   return Math.min(delay, maxDelay);
 }
 function toError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(String(error));
+  return normalizeThrownValue(error);
 }
 function resolveExecutionMethod(tool, logger6) {
   const executeFn = tool.invoke || tool.execute;
@@ -1293,28 +1331,20 @@ async function executeWithRetry(tool, input, policy, logger6) {
       `Invalid retry policy: maxAttempts must be an integer >= 1 (received ${String(policy.maxAttempts)})`
     );
   }
-  let lastError;
-  for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
-    try {
-      return await executeFn.call(tool, input);
-    } catch (error) {
-      const currentError = toError(error);
-      lastError = currentError;
-      if (policy.retryableErrors && policy.retryableErrors.length > 0) {
-        const isRetryable = policy.retryableErrors.some(
-          (message) => currentError.message.includes(message)
-        );
-        if (!isRetryable) {
-          throw currentError;
-        }
-      }
-      if (attempt < policy.maxAttempts) {
-        const delay = calculateBackoff(attempt, policy);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-  throw lastError ?? new Error("Tool execution failed after retries");
+  return executeWithRetries(
+    () => executeFn.call(tool, input),
+    policy.maxAttempts,
+    (attempt) => calculateBackoff(attempt, policy),
+    (error) => !policy.retryableErrors?.length || policy.retryableErrors.some((message) => error.message.includes(message))
+  );
+}
+async function executeWithTimeout2(execute, timeout2) {
+  return executeWithTimeout(
+    execute,
+    timeout2,
+    () => new Error("Tool execution timeout"),
+    "execution-first"
+  );
 }
 
 // src/tools/executor-types.ts
@@ -1342,15 +1372,12 @@ function createToolExecutor(config = {}) {
   const metrics = createExecutionMetrics();
   async function executeSingle(tool, input, priority) {
     const startTime = Date.now();
-    let timeoutId;
     try {
       onExecutionStart?.(tool, input);
-      const result = await Promise.race([
-        executeWithRetry(tool, input, retryPolicy, logger2),
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => reject(new Error("Tool execution timeout")), timeout2);
-        })
-      ]);
+      const result = await executeWithTimeout2(
+        () => executeWithRetry(tool, input, retryPolicy, logger2),
+        timeout2
+      );
       const duration = Date.now() - startTime;
       recordExecutionResult(metrics, priority, duration, true);
       onExecutionComplete?.(tool, input, result, duration);
@@ -1361,10 +1388,6 @@ function createToolExecutor(config = {}) {
       recordExecutionResult(metrics, priority, duration, false);
       onExecutionError?.(tool, input, normalizedError, duration);
       throw normalizedError;
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
     }
   }
   function processQueue() {
@@ -1739,9 +1762,6 @@ function isConditionalStep(step) {
 function calculateRetryDelay(attempt, delay, backoff) {
   return backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
 }
-function toError2(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
 function sequential(tools) {
   return {
     name: `sequential(${tools.map((t) => t.name).join(" -> ")})`,
@@ -1806,42 +1826,23 @@ function retry(tool, options = {}) {
   return {
     name: `retry(${tool.name})`,
     description: `${tool.description} (with retry)`,
-    invoke: async (input) => {
-      let lastError = new Error(`Tool ${tool.name} failed without an explicit error`);
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-          return await tool.invoke(input);
-        } catch (error) {
-          lastError = toError2(error);
-          if (attempt < maxAttempts) {
-            const waitTime = calculateRetryDelay(attempt, delay, backoff);
-            await new Promise((resolve) => setTimeout(resolve, waitTime));
-          }
-        }
-      }
-      throw lastError;
-    }
+    invoke: async (input) => executeWithRetries(
+      () => tool.invoke(input),
+      maxAttempts,
+      (attempt) => calculateRetryDelay(attempt, delay, backoff),
+      () => true
+    )
   };
 }
 function timeout(tool, ms) {
   return {
     name: `timeout(${tool.name})`,
     description: `${tool.description} (with ${ms}ms timeout)`,
-    invoke: async (input) => {
-      let timer;
-      const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(new Error(`Tool ${tool.name} timed out after ${ms}ms`));
-        }, ms);
-      });
-      try {
-        return await Promise.race([tool.invoke(input), timeoutPromise]);
-      } finally {
-        if (timer !== void 0) {
-          clearTimeout(timer);
-        }
-      }
-    }
+    invoke: async (input) => executeWithTimeout(
+      () => tool.invoke(input),
+      ms,
+      () => new Error(`Tool ${tool.name} timed out after ${ms}ms`)
+    )
   };
 }
 function cache(tool, ttl) {
@@ -2129,12 +2130,11 @@ function mergeState(currentState, update, config) {
 }
 
 // src/langgraph/builders/sequential.ts
+var import_langgraph3 = require("@langchain/langgraph");
+
+// src/langgraph/builders/workflow-node-registration.ts
 var import_langgraph2 = require("@langchain/langgraph");
-function createSequentialWorkflow(stateSchema, nodes, options = {}) {
-  const { autoStartEnd = true } = options;
-  if (nodes.length === 0) {
-    throw new Error("Sequential workflow must have at least one node");
-  }
+function createRegisteredWorkflowGraph(stateSchema, nodes, options = {}) {
   const nodeNames = /* @__PURE__ */ new Set();
   for (const node of nodes) {
     if (nodeNames.has(node.name)) {
@@ -2144,25 +2144,38 @@ function createSequentialWorkflow(stateSchema, nodes, options = {}) {
   }
   let graph;
   try {
-    graph = new import_langgraph2.StateGraph(
-      stateSchema
-    );
+    graph = new import_langgraph2.StateGraph(stateSchema);
   } catch (error) {
-    throw new Error("Sequential workflow requires a LangGraph Annotation.Root schema", {
-      cause: error
-    });
+    if (options.translateGraphConstructionError) {
+      throw options.translateGraphConstructionError(error);
+    }
+    throw error;
   }
-  for (const { name: nodeName, node } of nodes) {
-    graph.addNode(nodeName, node);
+  for (const { name, node } of nodes) {
+    graph.addNode(name, node);
   }
+  return graph;
+}
+
+// src/langgraph/builders/sequential.ts
+function createSequentialWorkflow(stateSchema, nodes, options = {}) {
+  const { autoStartEnd = true } = options;
+  if (nodes.length === 0) {
+    throw new Error("Sequential workflow must have at least one node");
+  }
+  const graph = createRegisteredWorkflowGraph(stateSchema, nodes, {
+    translateGraphConstructionError: (error) => new Error("Sequential workflow requires a LangGraph Annotation.Root schema", {
+      cause: error
+    })
+  });
   if (autoStartEnd) {
-    graph.addEdge(import_langgraph2.START, nodes[0].name);
+    graph.addEdge(import_langgraph3.START, nodes[0].name);
   }
   for (let i = 0; i < nodes.length - 1; i++) {
     graph.addEdge(nodes[i].name, nodes[i + 1].name);
   }
   if (autoStartEnd) {
-    graph.addEdge(nodes[nodes.length - 1].name, import_langgraph2.END);
+    graph.addEdge(nodes[nodes.length - 1].name, import_langgraph3.END);
   }
   return graph;
 }
@@ -2194,33 +2207,20 @@ function sequentialBuilder(stateSchema) {
 }
 
 // src/langgraph/builders/parallel.ts
-var import_langgraph3 = require("@langchain/langgraph");
+var import_langgraph4 = require("@langchain/langgraph");
 function createParallelWorkflow(stateSchema, config, options = {}) {
   const { parallel: parallel2, aggregate } = config;
   const { autoStartEnd = true } = options;
   if (parallel2.length === 0) {
     throw new Error("Parallel workflow must have at least one parallel node");
   }
-  const nodeNames = /* @__PURE__ */ new Set();
-  for (const node of parallel2) {
-    if (nodeNames.has(node.name)) {
-      throw new Error(`Duplicate node name: ${node.name}`);
-    }
-    nodeNames.add(node.name);
-  }
-  if (aggregate && nodeNames.has(aggregate.name)) {
-    throw new Error(`Duplicate node name: ${aggregate.name}`);
-  }
-  const graph = new import_langgraph3.StateGraph(stateSchema);
-  for (const { name: nodeName, node } of parallel2) {
-    graph.addNode(nodeName, node);
-  }
-  if (aggregate) {
-    graph.addNode(aggregate.name, aggregate.node);
-  }
+  const graph = createRegisteredWorkflowGraph(
+    stateSchema,
+    aggregate ? [...parallel2, aggregate] : parallel2
+  );
   if (autoStartEnd) {
     for (const { name: nodeName } of parallel2) {
-      graph.addEdge(import_langgraph3.START, nodeName);
+      graph.addEdge(import_langgraph4.START, nodeName);
     }
   }
   if (aggregate) {
@@ -2228,11 +2228,11 @@ function createParallelWorkflow(stateSchema, config, options = {}) {
       graph.addEdge(nodeName, aggregate.name);
     }
     if (autoStartEnd) {
-      graph.addEdge(aggregate.name, import_langgraph3.END);
+      graph.addEdge(aggregate.name, import_langgraph4.END);
     }
   } else if (autoStartEnd) {
     for (const { name: nodeName } of parallel2) {
-      graph.addEdge(nodeName, import_langgraph3.END);
+      graph.addEdge(nodeName, import_langgraph4.END);
     }
   }
   return graph;
@@ -2283,9 +2283,9 @@ function createMultiRouter(config) {
 }
 
 // src/langgraph/builders/subgraph.ts
-var import_langgraph4 = require("@langchain/langgraph");
+var import_langgraph5 = require("@langchain/langgraph");
 function createSubgraph(stateSchema, builder) {
-  const graph = new import_langgraph4.StateGraph(stateSchema);
+  const graph = new import_langgraph5.StateGraph(stateSchema);
   const configured = builder(graph);
   return configured.compile();
 }
@@ -3360,9 +3360,9 @@ function createSharedConcurrencyController(options = {}) {
 }
 
 // src/langgraph/persistence/checkpointer.ts
-var import_langgraph5 = require("@langchain/langgraph");
+var import_langgraph6 = require("@langchain/langgraph");
 function createMemoryCheckpointer(options) {
-  return new import_langgraph5.MemorySaver();
+  return new import_langgraph6.MemorySaver();
 }
 async function createSqliteCheckpointer(options = {}) {
   const { path = ":memory:", autoMigrate = true } = options;
@@ -3383,7 +3383,7 @@ async function createSqliteCheckpointer(options = {}) {
   }
 }
 function isMemoryCheckpointer(checkpointer) {
-  return checkpointer instanceof import_langgraph5.MemorySaver;
+  return checkpointer instanceof import_langgraph6.MemorySaver;
 }
 
 // src/langgraph/persistence/thread.ts
@@ -4448,7 +4448,7 @@ function toErrorPayload(error) {
   }
   return { error: String(error) };
 }
-function toError3(error) {
+function toError2(error) {
   if (error instanceof Error) {
     return error;
   }
@@ -4483,7 +4483,7 @@ var ConnectionPool = class {
       const interval = healthCheck.interval || 3e4;
       this.runtime.healthCheckTimer = setInterval(() => {
         performHealthChecks(this.runtime).catch((error) => {
-          const normalizedError = toError3(error);
+          const normalizedError = toError2(error);
           logger4.error("Health check failed", toErrorPayload(normalizedError));
           options.onHealthCheckFail?.(normalizedError);
         });

package/dist/index.js

@@ -1069,6 +1069,47 @@ function snapshotExecutionMetrics(metrics) {
   };
 }
 
+// src/tools/execution-resilience.ts
+function normalizeThrownValue(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+async function executeWithRetries(execute, maxAttempts, retryDelay, shouldRetry) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await execute();
+    } catch (thrownValue) {
+      const error = normalizeThrownValue(thrownValue);
+      if (attempt === maxAttempts || !shouldRetry(error)) {
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt, error)));
+    }
+  }
+  throw new Error("Retry execution requires at least one attempt");
+}
+async function executeWithTimeout(execute, timeoutMs, timeoutError, startOrder = "timeout-first") {
+  let timeoutId;
+  const startTimeout = () => new Promise((_, reject) => {
+    timeoutId = setTimeout(() => reject(timeoutError()), timeoutMs);
+  });
+  try {
+    let executionPromise;
+    let timeoutPromise;
+    if (startOrder === "execution-first") {
+      executionPromise = execute();
+      timeoutPromise = startTimeout();
+    } else {
+      timeoutPromise = startTimeout();
+      executionPromise = execute();
+    }
+    return await Promise.race([executionPromise, timeoutPromise]);
+  } finally {
+    if (timeoutId !== void 0) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
 // src/tools/executor-retry.ts
 function calculateBackoff(attempt, policy) {
   const initialDelay = policy.initialDelay || 1e3;
@@ -1088,10 +1129,7 @@ function calculateBackoff(attempt, policy) {
   return Math.min(delay, maxDelay);
 }
 function toError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(String(error));
+  return normalizeThrownValue(error);
 }
 function resolveExecutionMethod(tool, logger6) {
   const executeFn = tool.invoke || tool.execute;
@@ -1117,28 +1155,20 @@ async function executeWithRetry(tool, input, policy, logger6) {
       `Invalid retry policy: maxAttempts must be an integer >= 1 (received ${String(policy.maxAttempts)})`
     );
   }
-  let lastError;
-  for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
-    try {
-      return await executeFn.call(tool, input);
-    } catch (error) {
-      const currentError = toError(error);
-      lastError = currentError;
-      if (policy.retryableErrors && policy.retryableErrors.length > 0) {
-        const isRetryable = policy.retryableErrors.some(
-          (message) => currentError.message.includes(message)
-        );
-        if (!isRetryable) {
-          throw currentError;
-        }
-      }
-      if (attempt < policy.maxAttempts) {
-        const delay = calculateBackoff(attempt, policy);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-  throw lastError ?? new Error("Tool execution failed after retries");
+  return executeWithRetries(
+    () => executeFn.call(tool, input),
+    policy.maxAttempts,
+    (attempt) => calculateBackoff(attempt, policy),
+    (error) => !policy.retryableErrors?.length || policy.retryableErrors.some((message) => error.message.includes(message))
+  );
+}
+async function executeWithTimeout2(execute, timeout2) {
+  return executeWithTimeout(
+    execute,
+    timeout2,
+    () => new Error("Tool execution timeout"),
+    "execution-first"
+  );
 }
 
 // src/tools/executor-types.ts
@@ -1166,15 +1196,12 @@ function createToolExecutor(config = {}) {
   const metrics = createExecutionMetrics();
   async function executeSingle(tool, input, priority) {
     const startTime = Date.now();
-    let timeoutId;
     try {
       onExecutionStart?.(tool, input);
-      const result = await Promise.race([
-        executeWithRetry(tool, input, retryPolicy, logger2),
-        new Promise((_, reject) => {
-          timeoutId = setTimeout(() => reject(new Error("Tool execution timeout")), timeout2);
-        })
-      ]);
+      const result = await executeWithTimeout2(
+        () => executeWithRetry(tool, input, retryPolicy, logger2),
+        timeout2
+      );
       const duration = Date.now() - startTime;
       recordExecutionResult(metrics, priority, duration, true);
       onExecutionComplete?.(tool, input, result, duration);
@@ -1185,10 +1212,6 @@ function createToolExecutor(config = {}) {
       recordExecutionResult(metrics, priority, duration, false);
       onExecutionError?.(tool, input, normalizedError, duration);
       throw normalizedError;
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
     }
   }
   function processQueue() {
@@ -1563,9 +1586,6 @@ function isConditionalStep(step) {
 function calculateRetryDelay(attempt, delay, backoff) {
   return backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
 }
-function toError2(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
 function sequential(tools) {
   return {
     name: `sequential(${tools.map((t) => t.name).join(" -> ")})`,
@@ -1630,42 +1650,23 @@ function retry(tool, options = {}) {
   return {
     name: `retry(${tool.name})`,
     description: `${tool.description} (with retry)`,
-    invoke: async (input) => {
-      let lastError = new Error(`Tool ${tool.name} failed without an explicit error`);
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-          return await tool.invoke(input);
-        } catch (error) {
-          lastError = toError2(error);
-          if (attempt < maxAttempts) {
-            const waitTime = calculateRetryDelay(attempt, delay, backoff);
-            await new Promise((resolve) => setTimeout(resolve, waitTime));
-          }
-        }
-      }
-      throw lastError;
-    }
+    invoke: async (input) => executeWithRetries(
+      () => tool.invoke(input),
+      maxAttempts,
+      (attempt) => calculateRetryDelay(attempt, delay, backoff),
+      () => true
+    )
   };
 }
 function timeout(tool, ms) {
   return {
     name: `timeout(${tool.name})`,
     description: `${tool.description} (with ${ms}ms timeout)`,
-    invoke: async (input) => {
-      let timer;
-      const timeoutPromise = new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(new Error(`Tool ${tool.name} timed out after ${ms}ms`));
-        }, ms);
-      });
-      try {
-        return await Promise.race([tool.invoke(input), timeoutPromise]);
-      } finally {
-        if (timer !== void 0) {
-          clearTimeout(timer);
-        }
-      }
-    }
+    invoke: async (input) => executeWithTimeout(
+      () => tool.invoke(input),
+      ms,
+      () => new Error(`Tool ${tool.name} timed out after ${ms}ms`)
+    )
   };
 }
 function cache(tool, ttl) {
@@ -1953,12 +1954,11 @@ function mergeState(currentState, update, config) {
 }
 
 // src/langgraph/builders/sequential.ts
-import { StateGraph, END, START } from "@langchain/langgraph";
-function createSequentialWorkflow(stateSchema, nodes, options = {}) {
-  const { autoStartEnd = true } = options;
-  if (nodes.length === 0) {
-    throw new Error("Sequential workflow must have at least one node");
-  }
+import { END, START } from "@langchain/langgraph";
+
+// src/langgraph/builders/workflow-node-registration.ts
+import { StateGraph } from "@langchain/langgraph";
+function createRegisteredWorkflowGraph(stateSchema, nodes, options = {}) {
   const nodeNames = /* @__PURE__ */ new Set();
   for (const node of nodes) {
     if (nodeNames.has(node.name)) {
@@ -1968,17 +1968,30 @@ function createSequentialWorkflow(stateSchema, nodes, options = {}) {
   }
   let graph;
   try {
-    graph = new StateGraph(
-      stateSchema
-    );
+    graph = new StateGraph(stateSchema);
   } catch (error) {
-    throw new Error("Sequential workflow requires a LangGraph Annotation.Root schema", {
-      cause: error
-    });
+    if (options.translateGraphConstructionError) {
+      throw options.translateGraphConstructionError(error);
+    }
+    throw error;
   }
-  for (const { name: nodeName, node } of nodes) {
-    graph.addNode(nodeName, node);
+  for (const { name, node } of nodes) {
+    graph.addNode(name, node);
   }
+  return graph;
+}
+
+// src/langgraph/builders/sequential.ts
+function createSequentialWorkflow(stateSchema, nodes, options = {}) {
+  const { autoStartEnd = true } = options;
+  if (nodes.length === 0) {
+    throw new Error("Sequential workflow must have at least one node");
+  }
+  const graph = createRegisteredWorkflowGraph(stateSchema, nodes, {
+    translateGraphConstructionError: (error) => new Error("Sequential workflow requires a LangGraph Annotation.Root schema", {
+      cause: error
+    })
+  });
   if (autoStartEnd) {
     graph.addEdge(START, nodes[0].name);
   }
@@ -2018,30 +2031,17 @@ function sequentialBuilder(stateSchema) {
 }
 
 // src/langgraph/builders/parallel.ts
-import { StateGraph as StateGraph2, END as END2, START as START2 } from "@langchain/langgraph";
+import { END as END2, START as START2 } from "@langchain/langgraph";
 function createParallelWorkflow(stateSchema, config, options = {}) {
   const { parallel: parallel2, aggregate } = config;
   const { autoStartEnd = true } = options;
   if (parallel2.length === 0) {
     throw new Error("Parallel workflow must have at least one parallel node");
   }
-  const nodeNames = /* @__PURE__ */ new Set();
-  for (const node of parallel2) {
-    if (nodeNames.has(node.name)) {
-      throw new Error(`Duplicate node name: ${node.name}`);
-    }
-    nodeNames.add(node.name);
-  }
-  if (aggregate && nodeNames.has(aggregate.name)) {
-    throw new Error(`Duplicate node name: ${aggregate.name}`);
-  }
-  const graph = new StateGraph2(stateSchema);
-  for (const { name: nodeName, node } of parallel2) {
-    graph.addNode(nodeName, node);
-  }
-  if (aggregate) {
-    graph.addNode(aggregate.name, aggregate.node);
-  }
+  const graph = createRegisteredWorkflowGraph(
+    stateSchema,
+    aggregate ? [...parallel2, aggregate] : parallel2
+  );
   if (autoStartEnd) {
     for (const { name: nodeName } of parallel2) {
       graph.addEdge(START2, nodeName);
@@ -2107,9 +2107,9 @@ function createMultiRouter(config) {
 }
 
 // src/langgraph/builders/subgraph.ts
-import { StateGraph as StateGraph3 } from "@langchain/langgraph";
+import { StateGraph as StateGraph2 } from "@langchain/langgraph";
 function createSubgraph(stateSchema, builder) {
-  const graph = new StateGraph3(stateSchema);
+  const graph = new StateGraph2(stateSchema);
   const configured = builder(graph);
   return configured.compile();
 }
@@ -4272,7 +4272,7 @@ function toErrorPayload(error) {
   }
   return { error: String(error) };
 }
-function toError3(error) {
+function toError2(error) {
   if (error instanceof Error) {
     return error;
   }
@@ -4307,7 +4307,7 @@ var ConnectionPool = class {
       const interval = healthCheck.interval || 3e4;
       this.runtime.healthCheckTimer = setInterval(() => {
         performHealthChecks(this.runtime).catch((error) => {
-          const normalizedError = toError3(error);
+          const normalizedError = toError2(error);
           logger4.error("Health check failed", toErrorPayload(normalizedError));
           options.onHealthCheckFail?.(normalizedError);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.18.7",
+  "version": "0.18.9",
   "description": "Production-ready TypeScript agent framework built on LangGraph with orchestration, middleware, and typed abstractions.",
   "type": "module",
   "main": "./dist/index.cjs",