@agentforge/core 0.18.6 → 0.18.8

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) {
@@ -4448,7 +4449,7 @@ function toErrorPayload(error) {
   }
   return { error: String(error) };
 }
-function toError3(error) {
+function toError2(error) {
   if (error instanceof Error) {
     return error;
   }
@@ -4483,7 +4484,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) {
@@ -4272,7 +4273,7 @@ function toErrorPayload(error) {
   }
   return { error: String(error) };
 }
-function toError3(error) {
+function toError2(error) {
   if (error instanceof Error) {
     return error;
   }
@@ -4307,7 +4308,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.6",
+  "version": "0.18.8",
   "description": "Production-ready TypeScript agent framework built on LangGraph with orchestration, middleware, and typed abstractions.",
   "type": "module",
   "main": "./dist/index.cjs",