@agentforge/core 0.16.47 → 0.16.49

package/dist/index.cjs

@@ -173,7 +173,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/tools/types.ts
+// src/tools/types-category.ts
 var ToolCategory = /* @__PURE__ */ ((ToolCategory2) => {
   ToolCategory2["FILE_SYSTEM"] = "file-system";
   ToolCategory2["WEB"] = "web";
@@ -1290,14 +1290,125 @@ var ToolRegistry = class {
   }
 };
 
-// src/tools/executor.ts
-var logger2 = createLogger("agentforge:tools:executor");
+// src/tools/executor-metrics.ts
+function createExecutionMetrics() {
+  return {
+    totalExecutions: 0,
+    successfulExecutions: 0,
+    failedExecutions: 0,
+    totalDuration: 0,
+    averageDuration: 0,
+    byPriority: { low: 0, normal: 0, high: 0, critical: 0 }
+  };
+}
+function recordExecutionResult(metrics, priority, duration, successful) {
+  metrics.totalExecutions++;
+  if (successful) {
+    metrics.successfulExecutions++;
+  } else {
+    metrics.failedExecutions++;
+  }
+  metrics.totalDuration += duration;
+  metrics.averageDuration = metrics.totalDuration / metrics.totalExecutions;
+  metrics.byPriority[priority]++;
+}
+function resetExecutionMetrics(metrics) {
+  metrics.totalExecutions = 0;
+  metrics.successfulExecutions = 0;
+  metrics.failedExecutions = 0;
+  metrics.totalDuration = 0;
+  metrics.averageDuration = 0;
+  metrics.byPriority = { low: 0, normal: 0, high: 0, critical: 0 };
+}
+function snapshotExecutionMetrics(metrics) {
+  return {
+    ...metrics,
+    byPriority: { ...metrics.byPriority }
+  };
+}
+
+// src/tools/executor-retry.ts
+function calculateBackoff(attempt, policy) {
+  const initialDelay = policy.initialDelay || 1e3;
+  const maxDelay = policy.maxDelay || 3e4;
+  let delay;
+  switch (policy.backoff) {
+    case "linear":
+      delay = initialDelay * attempt;
+      break;
+    case "exponential":
+      delay = initialDelay * Math.pow(2, attempt - 1);
+      break;
+    case "fixed":
+    default:
+      delay = initialDelay;
+  }
+  return Math.min(delay, maxDelay);
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function resolveExecutionMethod(tool, logger6) {
+  const executeFn = tool.invoke || tool.execute;
+  if (!executeFn) {
+    throw new Error(
+      "Tool must implement invoke() method. Tools created with createTool() or toolBuilder automatically have this method. If you are manually constructing a tool, ensure it has an invoke() method."
+    );
+  }
+  if (!tool.invoke && tool.execute) {
+    logger6.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);
+  if (!policy) {
+    return await executeFn.call(tool, input);
+  }
+  if (!Number.isInteger(policy.maxAttempts) || policy.maxAttempts < 1) {
+    throw new Error(
+      `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");
+}
+
+// src/tools/executor-types.ts
 var PRIORITY_ORDER = {
   critical: 0,
   high: 1,
   normal: 2,
   low: 3
 };
+
+// src/tools/executor.ts
+var logger2 = createLogger("agentforge:core:tools:executor");
 function createToolExecutor(config = {}) {
   const {
     maxConcurrent = 5,
@@ -1310,119 +1421,47 @@ function createToolExecutor(config = {}) {
   } = config;
   let activeExecutions = 0;
   const queue = [];
-  const metrics = {
-    totalExecutions: 0,
-    successfulExecutions: 0,
-    failedExecutions: 0,
-    totalDuration: 0,
-    averageDuration: 0,
-    byPriority: { low: 0, normal: 0, high: 0, critical: 0 }
-  };
-  function calculateBackoff(attempt, policy) {
-    const initialDelay = policy.initialDelay || 1e3;
-    const maxDelay = policy.maxDelay || 3e4;
-    let delay;
-    switch (policy.backoff) {
-      case "linear":
-        delay = initialDelay * attempt;
-        break;
-      case "exponential":
-        delay = initialDelay * Math.pow(2, attempt - 1);
-        break;
-      case "fixed":
-      default:
-        delay = initialDelay;
-    }
-    return Math.min(delay, maxDelay);
-  }
-  function toError2(error) {
-    if (error instanceof Error) {
-      return error;
-    }
-    return new Error(String(error));
-  }
-  async function executeWithRetry(tool, input, policy) {
-    const executeFn = tool.invoke || tool.execute;
-    if (!executeFn) {
-      throw new Error(
-        "Tool must implement invoke() method. Tools created with createTool() or toolBuilder automatically have this method. If you are manually constructing a tool, ensure it has an invoke() method."
-      );
-    }
-    if (!tool.invoke && tool.execute) {
-      logger2.warn(
-        `Tool "${tool.metadata?.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.`
-      );
-    }
-    if (!policy) {
-      return await executeFn.call(tool, input);
-    }
-    if (!Number.isInteger(policy.maxAttempts) || policy.maxAttempts < 1) {
-      throw new Error(
-        `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 = toError2(error);
-        lastError = currentError;
-        if (policy.retryableErrors && policy.retryableErrors.length > 0) {
-          const isRetryable = policy.retryableErrors.some(
-            (msg) => currentError.message.includes(msg)
-          );
-          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");
-  }
+  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),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("Tool execution timeout")), timeout2)
-        )
+        executeWithRetry(tool, input, retryPolicy, logger2),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => reject(new Error("Tool execution timeout")), timeout2);
+        })
       ]);
       const duration = Date.now() - startTime;
-      metrics.totalExecutions++;
-      metrics.successfulExecutions++;
-      metrics.totalDuration += duration;
-      metrics.averageDuration = metrics.totalDuration / metrics.totalExecutions;
-      metrics.byPriority[priority]++;
+      recordExecutionResult(metrics, priority, duration, true);
       onExecutionComplete?.(tool, input, result, duration);
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      const normalizedError = toError2(error);
-      metrics.totalExecutions++;
-      metrics.failedExecutions++;
-      metrics.totalDuration += duration;
-      metrics.averageDuration = metrics.totalDuration / metrics.totalExecutions;
-      metrics.byPriority[priority]++;
+      const normalizedError = toError(error);
+      recordExecutionResult(metrics, priority, duration, false);
       onExecutionError?.(tool, input, normalizedError, duration);
       throw normalizedError;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
     }
   }
-  async function processQueue() {
+  function processQueue() {
     while (queue.length > 0 && activeExecutions < maxConcurrent) {
       queue.sort((a, b) => {
         const priorityDiff = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
-        if (priorityDiff !== 0) return priorityDiff;
+        if (priorityDiff !== 0) {
+          return priorityDiff;
+        }
         return a.timestamp - b.timestamp;
       });
       const execution = queue.shift();
-      if (!execution) break;
+      if (!execution) {
+        break;
+      }
       activeExecutions++;
       executeSingle(execution.tool, execution.input, execution.priority).then((result) => {
         execution.resolve(result);
@@ -1451,20 +1490,15 @@ function createToolExecutor(config = {}) {
   async function executeParallel(executions) {
     return Promise.all(
       executions.map(
-        (exec) => execute(exec.tool, exec.input, { priority: exec.priority })
+        (execution) => execute(execution.tool, execution.input, { priority: execution.priority })
       )
     );
   }
   function getMetrics() {
-    return { ...metrics };
+    return snapshotExecutionMetrics(metrics);
   }
   function resetMetrics() {
-    metrics.totalExecutions = 0;
-    metrics.successfulExecutions = 0;
-    metrics.failedExecutions = 0;
-    metrics.totalDuration = 0;
-    metrics.averageDuration = 0;
-    metrics.byPriority = { low: 0, normal: 0, high: 0, critical: 0 };
+    resetExecutionMetrics(metrics);
   }
   function getQueueStatus() {
     return {
@@ -1787,7 +1821,7 @@ function isConditionalStep(step) {
 function calculateRetryDelay(attempt, delay, backoff) {
   return backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
 }
-function toError(error) {
+function toError2(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 function sequential(tools) {
@@ -1860,7 +1894,7 @@ function retry(tool, options = {}) {
         try {
           return await tool.invoke(input);
         } catch (error) {
-          lastError = toError(error);
+          lastError = toError2(error);
           if (attempt < maxAttempts) {
             const waitTime = calculateRetryDelay(attempt, delay, backoff);
             await new Promise((resolve) => setTimeout(resolve, waitTime));