@agentforge/core 0.15.5 → 0.15.7

package/dist/index.cjs

@@ -794,21 +794,42 @@ function toolBuilder() {
 // src/langchain/converter.ts
 var import_tools = require("@langchain/core/tools");
 var import_zod_to_json_schema = require("zod-to-json-schema");
+function serializeToolResult(result) {
+  if (typeof result === "string") {
+    return result;
+  }
+  if (typeof result === "object" && result !== null) {
+    return JSON.stringify(result, null, 2);
+  }
+  return String(result);
+}
+function isJsonSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonSchemaDefinitionMap(value) {
+  if (!isJsonSchemaObject(value)) {
+    return false;
+  }
+  return Object.values(value).every(isJsonSchemaObject);
+}
+function extractToolSchema(jsonSchema) {
+  if (!isJsonSchemaObject(jsonSchema)) {
+    return {};
+  }
+  const ref = jsonSchema.$ref;
+  const definitions = jsonSchema.definitions;
+  if (typeof ref !== "string" || !isJsonSchemaDefinitionMap(definitions)) {
+    return jsonSchema;
+  }
+  const refName = ref.replace("#/definitions/", "");
+  return definitions[refName] ?? jsonSchema;
+}
 function toLangChainTool(tool) {
   return new import_tools.DynamicStructuredTool({
     name: tool.metadata.name,
     description: tool.metadata.description,
     schema: tool.schema,
-    func: async (input) => {
-      const result = await tool.invoke(input);
-      if (typeof result === "string") {
-        return result;
-      }
-      if (typeof result === "object" && result !== null) {
-        return JSON.stringify(result, null, 2);
-      }
-      return String(result);
-    }
+    func: async (input) => serializeToolResult(await tool.invoke(input))
   });
 }
 function toLangChainTools(tools) {
@@ -820,11 +841,7 @@ function getToolJsonSchema(tool) {
     $refStrategy: "none"
     // Don't use $ref for nested schemas
   });
-  if (jsonSchema.$ref && jsonSchema.definitions) {
-    const refName = jsonSchema.$ref.replace("#/definitions/", "");
-    return jsonSchema.definitions[refName] || jsonSchema;
-  }
-  return jsonSchema;
+  return extractToolSchema(jsonSchema);
 }
 function getToolDescription(tool) {
   const { metadata } = tool;
@@ -1566,7 +1583,7 @@ function createToolExecutor(config = {}) {
     }
     return Math.min(delay, maxDelay);
   }
-  function toError(error) {
+  function toError2(error) {
     if (error instanceof Error) {
       return error;
     }
@@ -1597,7 +1614,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 +1652,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 +1919,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 +1971,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 +1986,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 +2014,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
@@ -1791,6 +1794,13 @@ declare function createToolSimulator(config: ToolSimulatorConfig): {
  * ```
  */
 
+type RuntimeSchema<TInput = unknown> = z.ZodSchema<TInput>;
+type JsonSchemaObject = Record<string, unknown>;
+interface LangChainConvertibleTool<TInput = unknown, TOutput = unknown> {
+    metadata: ToolMetadata;
+    schema: RuntimeSchema<TInput>;
+    invoke(input: TInput): Promise<TOutput>;
+}
 /**
  * Convert an AgentForge tool to a LangChain DynamicStructuredTool
  *
@@ -1823,7 +1833,7 @@ declare function createToolSimulator(config: ToolSimulatorConfig): {
  * });
  * ```
  */
-declare function toLangChainTool(tool: Tool<any, any>): DynamicStructuredTool<any>;
+declare function toLangChainTool<TInput, TOutput>(tool: Tool<TInput, TOutput>): DynamicStructuredTool<RuntimeSchema<TInput>, TInput, TInput, string>;
 /**
  * Convert multiple AgentForge tools to LangChain tools
  *
@@ -1841,7 +1851,7 @@ declare function toLangChainTool(tool: Tool<any, any>): DynamicStructuredTool<an
  * });
  * ```
  */
-declare function toLangChainTools(tools: Tool<any, any>[]): DynamicStructuredTool<any>[];
+declare function toLangChainTools(tools: readonly LangChainConvertibleTool[]): DynamicStructuredTool[];
 /**
  * Get the JSON Schema representation of a tool's input schema
  *
@@ -1856,7 +1866,7 @@ declare function toLangChainTools(tools: Tool<any, any>[]): DynamicStructuredToo
  * console.log(JSON.stringify(schema, null, 2));
  * ```
  */
-declare function getToolJsonSchema(tool: Tool<any, any>): Record<string, any>;
+declare function getToolJsonSchema<TInput, TOutput>(tool: Tool<TInput, TOutput>): JsonSchemaObject;
 /**
  * Get tool metadata in a format suitable for LLM prompts
  *
@@ -1877,7 +1887,7 @@ declare function getToolJsonSchema(tool: Tool<any, any>): Record<string, any>;
  * // ...
  * ```
  */
-declare function getToolDescription(tool: Tool<any, any>): string;
+declare function getToolDescription<TInput, TOutput>(tool: Tool<TInput, TOutput>): string;
 
 /**
  * LangGraph State Utilities

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
@@ -1791,6 +1794,13 @@ declare function createToolSimulator(config: ToolSimulatorConfig): {
  * ```
  */
 
+type RuntimeSchema<TInput = unknown> = z.ZodSchema<TInput>;
+type JsonSchemaObject = Record<string, unknown>;
+interface LangChainConvertibleTool<TInput = unknown, TOutput = unknown> {
+    metadata: ToolMetadata;
+    schema: RuntimeSchema<TInput>;
+    invoke(input: TInput): Promise<TOutput>;
+}
 /**
  * Convert an AgentForge tool to a LangChain DynamicStructuredTool
  *
@@ -1823,7 +1833,7 @@ declare function createToolSimulator(config: ToolSimulatorConfig): {
  * });
  * ```
  */
-declare function toLangChainTool(tool: Tool<any, any>): DynamicStructuredTool<any>;
+declare function toLangChainTool<TInput, TOutput>(tool: Tool<TInput, TOutput>): DynamicStructuredTool<RuntimeSchema<TInput>, TInput, TInput, string>;
 /**
  * Convert multiple AgentForge tools to LangChain tools
  *
@@ -1841,7 +1851,7 @@ declare function toLangChainTool(tool: Tool<any, any>): DynamicStructuredTool<an
  * });
  * ```
  */
-declare function toLangChainTools(tools: Tool<any, any>[]): DynamicStructuredTool<any>[];
+declare function toLangChainTools(tools: readonly LangChainConvertibleTool[]): DynamicStructuredTool[];
 /**
  * Get the JSON Schema representation of a tool's input schema
  *
@@ -1856,7 +1866,7 @@ declare function toLangChainTools(tools: Tool<any, any>[]): DynamicStructuredToo
  * console.log(JSON.stringify(schema, null, 2));
  * ```
  */
-declare function getToolJsonSchema(tool: Tool<any, any>): Record<string, any>;
+declare function getToolJsonSchema<TInput, TOutput>(tool: Tool<TInput, TOutput>): JsonSchemaObject;
 /**
  * Get tool metadata in a format suitable for LLM prompts
  *
@@ -1877,7 +1887,7 @@ declare function getToolJsonSchema(tool: Tool<any, any>): Record<string, any>;
  * // ...
  * ```
  */
-declare function getToolDescription(tool: Tool<any, any>): string;
+declare function getToolDescription<TInput, TOutput>(tool: Tool<TInput, TOutput>): string;
 
 /**
  * LangGraph State Utilities

package/dist/index.js

@@ -619,21 +619,42 @@ function toolBuilder() {
 // src/langchain/converter.ts
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { zodToJsonSchema } from "zod-to-json-schema";
+function serializeToolResult(result) {
+  if (typeof result === "string") {
+    return result;
+  }
+  if (typeof result === "object" && result !== null) {
+    return JSON.stringify(result, null, 2);
+  }
+  return String(result);
+}
+function isJsonSchemaObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonSchemaDefinitionMap(value) {
+  if (!isJsonSchemaObject(value)) {
+    return false;
+  }
+  return Object.values(value).every(isJsonSchemaObject);
+}
+function extractToolSchema(jsonSchema) {
+  if (!isJsonSchemaObject(jsonSchema)) {
+    return {};
+  }
+  const ref = jsonSchema.$ref;
+  const definitions = jsonSchema.definitions;
+  if (typeof ref !== "string" || !isJsonSchemaDefinitionMap(definitions)) {
+    return jsonSchema;
+  }
+  const refName = ref.replace("#/definitions/", "");
+  return definitions[refName] ?? jsonSchema;
+}
 function toLangChainTool(tool) {
   return new DynamicStructuredTool({
     name: tool.metadata.name,
     description: tool.metadata.description,
     schema: tool.schema,
-    func: async (input) => {
-      const result = await tool.invoke(input);
-      if (typeof result === "string") {
-        return result;
-      }
-      if (typeof result === "object" && result !== null) {
-        return JSON.stringify(result, null, 2);
-      }
-      return String(result);
-    }
+    func: async (input) => serializeToolResult(await tool.invoke(input))
   });
 }
 function toLangChainTools(tools) {
@@ -645,11 +666,7 @@ function getToolJsonSchema(tool) {
     $refStrategy: "none"
     // Don't use $ref for nested schemas
   });
-  if (jsonSchema.$ref && jsonSchema.definitions) {
-    const refName = jsonSchema.$ref.replace("#/definitions/", "");
-    return jsonSchema.definitions[refName] || jsonSchema;
-  }
-  return jsonSchema;
+  return extractToolSchema(jsonSchema);
 }
 function getToolDescription(tool) {
   const { metadata } = tool;
@@ -1391,7 +1408,7 @@ function createToolExecutor(config = {}) {
     }
     return Math.min(delay, maxDelay);
   }
-  function toError(error) {
+  function toError2(error) {
     if (error instanceof Error) {
       return error;
     }
@@ -1422,7 +1439,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 +1477,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 +1744,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 +1796,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 +1811,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 +1839,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.5",
+  "version": "0.15.7",
   "description": "Production-ready TypeScript agent framework built on LangGraph with orchestration, middleware, and typed abstractions.",
   "type": "module",
   "main": "./dist/index.cjs",