@agentforge/core 0.15.4 → 0.15.6

package/dist/index.cjs

@@ -1566,7 +1566,7 @@ function createToolExecutor(config = {}) {
     }
     return Math.min(delay, maxDelay);
   }
-  function toError(error) {
+  function toError2(error) {
     if (error instanceof Error) {
       return error;
     }
@@ -1597,7 +1597,7 @@ function createToolExecutor(config = {}) {
       try {
         return await executeFn.call(tool, input);
       } catch (error) {
-        const currentError = toError(error);
+        const currentError = toError2(error);
         lastError = currentError;
         if (policy.retryableErrors && policy.retryableErrors.length > 0) {
           const isRetryable = policy.retryableErrors.some(
@@ -1635,7 +1635,7 @@ function createToolExecutor(config = {}) {
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      const normalizedError = toError(error);
+      const normalizedError = toError2(error);
       metrics.totalExecutions++;
       metrics.failedExecutions++;
       metrics.totalDuration += duration;
@@ -1902,6 +1902,15 @@ function createManagedTool(config) {
 }
 
 // src/tools/composition.ts
+function isConditionalStep(step) {
+  return !Array.isArray(step) && "condition" in step;
+}
+function calculateRetryDelay(attempt, delay, backoff) {
+  return backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
 function sequential(tools) {
   return {
     name: `sequential(${tools.map((t) => t.name).join(" -> ")})`,
@@ -1945,7 +1954,7 @@ function composeTool(config) {
       for (const step of config.steps) {
         if (Array.isArray(step)) {
           result = await parallel(step).invoke(result);
-        } else if ("condition" in step) {
+        } else if (isConditionalStep(step)) {
           result = await conditional(step).invoke(result);
         } else {
           result = await step.invoke(result);
@@ -1960,18 +1969,21 @@ function composeTool(config) {
 }
 function retry(tool, options = {}) {
   const { maxAttempts = 3, delay = 1e3, backoff = "exponential" } = options;
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error("Invalid retry options: maxAttempts must be an integer >= 1");
+  }
   return {
     name: `retry(${tool.name})`,
     description: `${tool.description} (with retry)`,
     invoke: async (input) => {
-      let lastError;
+      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 = error;
+          lastError = toError(error);
           if (attempt < maxAttempts) {
-            const waitTime = backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
+            const waitTime = calculateRetryDelay(attempt, delay, backoff);
             await new Promise((resolve) => setTimeout(resolve, waitTime));
           }
         }
@@ -1985,12 +1997,19 @@ function timeout(tool, ms) {
     name: `timeout(${tool.name})`,
     description: `${tool.description} (with ${ms}ms timeout)`,
     invoke: async (input) => {
-      return Promise.race([
-        tool.invoke(input),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Tool ${tool.name} timed out after ${ms}ms`)), ms)
-        )
-      ]);
+      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);
+        }
+      }
     }
   };
 }

package/dist/index.d.cts

@@ -1670,54 +1670,57 @@ declare function createManagedTool<TContext = any, TInput = any, TOutput = any>(
  * Tool Composition - Compose tools into higher-level operations
  * @module tools/composition
  */
-interface ComposedTool {
+type RetryBackoffStrategy = 'linear' | 'exponential';
+interface RetryOptions$1 {
+    maxAttempts?: number;
+    delay?: number;
+    backoff?: RetryBackoffStrategy;
+}
+interface ComposedTool<TInput = unknown, TOutput = unknown> {
     name: string;
     description: string;
-    invoke: (input: any) => Promise<any>;
+    invoke(input: TInput): Promise<TOutput>;
 }
-interface ConditionalConfig {
-    condition: (input: any) => boolean | Promise<boolean>;
-    onTrue: ComposedTool;
-    onFalse: ComposedTool;
+interface ConditionalConfig<TInput = unknown, TTrueOutput = unknown, TFalseOutput = unknown> {
+    condition(input: TInput): boolean | Promise<boolean>;
+    onTrue: ComposedTool<TInput, TTrueOutput>;
+    onFalse: ComposedTool<TInput, TFalseOutput>;
 }
-interface ComposeToolConfig {
+type ComposedStep = ComposedTool<unknown, unknown> | ComposedTool<unknown, unknown>[] | ConditionalConfig<unknown, unknown, unknown>;
+interface ComposeToolConfig<TOutput = unknown> {
     name: string;
     description?: string;
-    steps: Array<ComposedTool | ComposedTool[] | ConditionalConfig>;
-    transformResult?: (result: any) => any;
+    steps: ComposedStep[];
+    transformResult?: (result: unknown) => TOutput;
 }
 /**
  * Execute tools sequentially
  */
-declare function sequential(tools: ComposedTool[]): ComposedTool;
+declare function sequential<TInput = unknown>(tools: ComposedTool<unknown, unknown>[]): ComposedTool<TInput, unknown>;
 /**
  * Execute tools in parallel
  */
-declare function parallel(tools: ComposedTool[]): ComposedTool;
+declare function parallel<TInput = unknown>(tools: ComposedTool<TInput, unknown>[]): ComposedTool<TInput, unknown[]>;
 /**
  * Execute tool conditionally
  */
-declare function conditional(config: ConditionalConfig): ComposedTool;
+declare function conditional<TInput = unknown, TTrueOutput = unknown, TFalseOutput = unknown>(config: ConditionalConfig<TInput, TTrueOutput, TFalseOutput>): ComposedTool<TInput, TTrueOutput | TFalseOutput>;
 /**
  * Compose tools into a complex workflow
  */
-declare function composeTool(config: ComposeToolConfig): ComposedTool;
+declare function composeTool<TInput = unknown, TOutput = unknown>(config: ComposeToolConfig<TOutput>): ComposedTool<TInput, TOutput>;
 /**
  * Create a tool that retries on failure
  */
-declare function retry(tool: ComposedTool, options?: {
-    maxAttempts?: number;
-    delay?: number;
-    backoff?: 'linear' | 'exponential';
-}): ComposedTool;
+declare function retry<TInput = unknown, TOutput = unknown>(tool: ComposedTool<TInput, TOutput>, options?: RetryOptions$1): ComposedTool<TInput, TOutput>;
 /**
  * Create a tool that times out
  */
-declare function timeout(tool: ComposedTool, ms: number): ComposedTool;
+declare function timeout<TInput = unknown, TOutput = unknown>(tool: ComposedTool<TInput, TOutput>, ms: number): ComposedTool<TInput, TOutput>;
 /**
  * Create a tool that caches results
  */
-declare function cache(tool: ComposedTool, ttl?: number): ComposedTool;
+declare function cache<TInput = unknown, TOutput = unknown>(tool: ComposedTool<TInput, TOutput>, ttl?: number): ComposedTool<TInput, TOutput>;
 
 /**
  * Tool Mocking & Testing - Mock tools for testing

package/dist/index.d.ts

@@ -1670,54 +1670,57 @@ declare function createManagedTool<TContext = any, TInput = any, TOutput = any>(
  * Tool Composition - Compose tools into higher-level operations
  * @module tools/composition
  */
-interface ComposedTool {
+type RetryBackoffStrategy = 'linear' | 'exponential';
+interface RetryOptions$1 {
+    maxAttempts?: number;
+    delay?: number;
+    backoff?: RetryBackoffStrategy;
+}
+interface ComposedTool<TInput = unknown, TOutput = unknown> {
     name: string;
     description: string;
-    invoke: (input: any) => Promise<any>;
+    invoke(input: TInput): Promise<TOutput>;
 }
-interface ConditionalConfig {
-    condition: (input: any) => boolean | Promise<boolean>;
-    onTrue: ComposedTool;
-    onFalse: ComposedTool;
+interface ConditionalConfig<TInput = unknown, TTrueOutput = unknown, TFalseOutput = unknown> {
+    condition(input: TInput): boolean | Promise<boolean>;
+    onTrue: ComposedTool<TInput, TTrueOutput>;
+    onFalse: ComposedTool<TInput, TFalseOutput>;
 }
-interface ComposeToolConfig {
+type ComposedStep = ComposedTool<unknown, unknown> | ComposedTool<unknown, unknown>[] | ConditionalConfig<unknown, unknown, unknown>;
+interface ComposeToolConfig<TOutput = unknown> {
     name: string;
     description?: string;
-    steps: Array<ComposedTool | ComposedTool[] | ConditionalConfig>;
-    transformResult?: (result: any) => any;
+    steps: ComposedStep[];
+    transformResult?: (result: unknown) => TOutput;
 }
 /**
  * Execute tools sequentially
  */
-declare function sequential(tools: ComposedTool[]): ComposedTool;
+declare function sequential<TInput = unknown>(tools: ComposedTool<unknown, unknown>[]): ComposedTool<TInput, unknown>;
 /**
  * Execute tools in parallel
  */
-declare function parallel(tools: ComposedTool[]): ComposedTool;
+declare function parallel<TInput = unknown>(tools: ComposedTool<TInput, unknown>[]): ComposedTool<TInput, unknown[]>;
 /**
  * Execute tool conditionally
  */
-declare function conditional(config: ConditionalConfig): ComposedTool;
+declare function conditional<TInput = unknown, TTrueOutput = unknown, TFalseOutput = unknown>(config: ConditionalConfig<TInput, TTrueOutput, TFalseOutput>): ComposedTool<TInput, TTrueOutput | TFalseOutput>;
 /**
  * Compose tools into a complex workflow
  */
-declare function composeTool(config: ComposeToolConfig): ComposedTool;
+declare function composeTool<TInput = unknown, TOutput = unknown>(config: ComposeToolConfig<TOutput>): ComposedTool<TInput, TOutput>;
 /**
  * Create a tool that retries on failure
  */
-declare function retry(tool: ComposedTool, options?: {
-    maxAttempts?: number;
-    delay?: number;
-    backoff?: 'linear' | 'exponential';
-}): ComposedTool;
+declare function retry<TInput = unknown, TOutput = unknown>(tool: ComposedTool<TInput, TOutput>, options?: RetryOptions$1): ComposedTool<TInput, TOutput>;
 /**
  * Create a tool that times out
  */
-declare function timeout(tool: ComposedTool, ms: number): ComposedTool;
+declare function timeout<TInput = unknown, TOutput = unknown>(tool: ComposedTool<TInput, TOutput>, ms: number): ComposedTool<TInput, TOutput>;
 /**
  * Create a tool that caches results
  */
-declare function cache(tool: ComposedTool, ttl?: number): ComposedTool;
+declare function cache<TInput = unknown, TOutput = unknown>(tool: ComposedTool<TInput, TOutput>, ttl?: number): ComposedTool<TInput, TOutput>;
 
 /**
  * Tool Mocking & Testing - Mock tools for testing

package/dist/index.js

@@ -1391,7 +1391,7 @@ function createToolExecutor(config = {}) {
     }
     return Math.min(delay, maxDelay);
   }
-  function toError(error) {
+  function toError2(error) {
     if (error instanceof Error) {
       return error;
     }
@@ -1422,7 +1422,7 @@ function createToolExecutor(config = {}) {
       try {
         return await executeFn.call(tool, input);
       } catch (error) {
-        const currentError = toError(error);
+        const currentError = toError2(error);
         lastError = currentError;
         if (policy.retryableErrors && policy.retryableErrors.length > 0) {
           const isRetryable = policy.retryableErrors.some(
@@ -1460,7 +1460,7 @@ function createToolExecutor(config = {}) {
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      const normalizedError = toError(error);
+      const normalizedError = toError2(error);
       metrics.totalExecutions++;
       metrics.failedExecutions++;
       metrics.totalDuration += duration;
@@ -1727,6 +1727,15 @@ function createManagedTool(config) {
 }
 
 // src/tools/composition.ts
+function isConditionalStep(step) {
+  return !Array.isArray(step) && "condition" in step;
+}
+function calculateRetryDelay(attempt, delay, backoff) {
+  return backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
 function sequential(tools) {
   return {
     name: `sequential(${tools.map((t) => t.name).join(" -> ")})`,
@@ -1770,7 +1779,7 @@ function composeTool(config) {
       for (const step of config.steps) {
         if (Array.isArray(step)) {
           result = await parallel(step).invoke(result);
-        } else if ("condition" in step) {
+        } else if (isConditionalStep(step)) {
           result = await conditional(step).invoke(result);
         } else {
           result = await step.invoke(result);
@@ -1785,18 +1794,21 @@ function composeTool(config) {
 }
 function retry(tool, options = {}) {
   const { maxAttempts = 3, delay = 1e3, backoff = "exponential" } = options;
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error("Invalid retry options: maxAttempts must be an integer >= 1");
+  }
   return {
     name: `retry(${tool.name})`,
     description: `${tool.description} (with retry)`,
     invoke: async (input) => {
-      let lastError;
+      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 = error;
+          lastError = toError(error);
           if (attempt < maxAttempts) {
-            const waitTime = backoff === "exponential" ? delay * Math.pow(2, attempt - 1) : delay * attempt;
+            const waitTime = calculateRetryDelay(attempt, delay, backoff);
             await new Promise((resolve) => setTimeout(resolve, waitTime));
           }
         }
@@ -1810,12 +1822,19 @@ function timeout(tool, ms) {
     name: `timeout(${tool.name})`,
     description: `${tool.description} (with ${ms}ms timeout)`,
     invoke: async (input) => {
-      return Promise.race([
-        tool.invoke(input),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Tool ${tool.name} timed out after ${ms}ms`)), ms)
-        )
-      ]);
+      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);
+        }
+      }
     }
   };
 }

package/package.json

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