@agentforge/patterns 0.5.4 → 0.6.1

package/dist/index.cjs

@@ -327,6 +327,9 @@ function createActionNode(tools, verbose = false) {
           console.log(`[action] Tool '${action.name}' executed successfully`);
         }
       } catch (error) {
+        if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
+          throw error;
+        }
         const errorMessage = error instanceof Error ? error.message : String(error);
         observations.push({
           toolCallId: action.id,
@@ -1891,6 +1894,33 @@ var MultiAgentState = (0, import_core6.createStateAnnotation)(MultiAgentStateCon
 
 // src/multi-agent/routing.ts
 var import_messages4 = require("@langchain/core/messages");
+async function executeTools(toolCalls, tools) {
+  const results = [];
+  for (const toolCall of toolCalls) {
+    const tool = tools.find((t) => t.metadata.name === toolCall.name);
+    if (!tool) {
+      results.push(new import_messages4.ToolMessage({
+        content: `Error: Tool '${toolCall.name}' not found`,
+        tool_call_id: toolCall.id
+      }));
+      continue;
+    }
+    try {
+      const result = await tool.execute(toolCall.args);
+      const content = typeof result === "string" ? result : JSON.stringify(result);
+      results.push(new import_messages4.ToolMessage({
+        content,
+        tool_call_id: toolCall.id
+      }));
+    } catch (error) {
+      results.push(new import_messages4.ToolMessage({
+        content: `Error executing tool: ${error.message}`,
+        tool_call_id: toolCall.id
+      }));
+    }
+  }
+  return results;
+}
 var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
 
 Your job is to:
@@ -1913,11 +1943,13 @@ var llmBasedRouting = {
       throw new Error("LLM-based routing requires a model to be configured");
     }
     const systemPrompt = config.systemPrompt || DEFAULT_SUPERVISOR_SYSTEM_PROMPT;
+    const maxRetries = config.maxToolRetries || 3;
+    const tools = config.tools || [];
     const workerInfo = Object.entries(state.workers).map(([id, caps]) => {
       const skills = caps.skills.join(", ");
-      const tools = caps.tools.join(", ");
+      const tools2 = caps.tools.join(", ");
       const available = caps.available ? "available" : "busy";
-      return `- ${id}: Skills: [${skills}], Tools: [${tools}], Status: ${available}, Workload: ${caps.currentWorkload}`;
+      return `- ${id}: Skills: [${skills}], Tools: [${tools2}], Status: ${available}, Workload: ${caps.currentWorkload}`;
     }).join("\n");
     const lastMessage = state.messages[state.messages.length - 1];
     const taskContext = lastMessage?.content || state.input;
@@ -1927,24 +1959,42 @@ Available workers:
 ${workerInfo}
 
 Select the best worker for this task and explain your reasoning.`;
-    const messages = [
-      new import_messages4.SystemMessage(systemPrompt),
-      new import_messages4.HumanMessage(userPrompt)
-    ];
-    const response = await config.model.invoke(messages);
-    const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-    try {
-      const decision = JSON.parse(content);
-      return {
-        targetAgent: decision.targetAgent,
-        reasoning: decision.reasoning,
-        confidence: decision.confidence,
-        strategy: "llm-based",
-        timestamp: Date.now()
-      };
-    } catch (error) {
-      throw new Error(`Failed to parse routing decision from LLM: ${error}`);
+    const conversationHistory = [];
+    let attempt = 0;
+    while (attempt < maxRetries) {
+      const messages = [
+        new import_messages4.SystemMessage(systemPrompt),
+        new import_messages4.HumanMessage(userPrompt),
+        ...conversationHistory
+      ];
+      const response = await config.model.invoke(messages);
+      if (response.tool_calls && response.tool_calls.length > 0) {
+        if (tools.length === 0) {
+          throw new Error("LLM requested tool calls but no tools are configured");
+        }
+        const toolResults = await executeTools(response.tool_calls, tools);
+        conversationHistory.push(
+          new import_messages4.AIMessage({ content: response.content || "", tool_calls: response.tool_calls }),
+          ...toolResults
+        );
+        attempt++;
+        continue;
+      }
+      const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      try {
+        const decision = JSON.parse(content);
+        return {
+          targetAgent: decision.targetAgent,
+          reasoning: decision.reasoning,
+          confidence: decision.confidence,
+          strategy: "llm-based",
+          timestamp: Date.now()
+        };
+      } catch (error) {
+        throw new Error(`Failed to parse routing decision from LLM: ${error}`);
+      }
     }
+    throw new Error(`Max tool retries (${maxRetries}) exceeded without routing decision`);
   }
 };
 var roundRobinRouting = {
@@ -2050,43 +2100,48 @@ function getRoutingStrategy(name) {
 }
 
 // src/multi-agent/utils.ts
+var import_core7 = require("@agentforge/core");
+var logLevel = process.env.LOG_LEVEL?.toLowerCase() || import_core7.LogLevel.INFO;
+var logger = (0, import_core7.createLogger)("multi-agent", { level: logLevel });
 function isReActAgent(obj) {
   return obj && typeof obj === "object" && typeof obj.invoke === "function" && typeof obj.stream === "function" && // Additional check to ensure it's not just any object with invoke/stream
   (obj.constructor?.name === "CompiledGraph" || obj.constructor?.name === "CompiledStateGraph");
 }
 function wrapReActAgent(workerId, agent, verbose = false) {
-  return async (state) => {
+  return async (state, config) => {
     try {
-      if (verbose) {
-        console.log(`[ReActWrapper:${workerId}] Wrapping ReAct agent execution`);
-      }
+      logger.debug("Wrapping ReAct agent execution", { workerId });
       const task = state.messages[state.messages.length - 1]?.content || state.input;
-      if (verbose) {
-        console.log(`[ReActWrapper:${workerId}] Task:`, task.substring(0, 100) + "...");
-      }
+      logger.debug("Extracted task", {
+        workerId,
+        taskPreview: task.substring(0, 100) + (task.length > 100 ? "..." : "")
+      });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === workerId && !state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
       );
       if (!currentAssignment) {
-        if (verbose) {
-          console.log(`[ReActWrapper:${workerId}] No active assignment found`);
-        }
+        logger.debug("No active assignment found", { workerId });
         return {
           currentAgent: "supervisor",
           status: "routing"
         };
       }
-      const result = await agent.invoke({
-        messages: [{ role: "user", content: task }]
-      });
+      const result = await agent.invoke(
+        {
+          messages: [{ role: "user", content: task }]
+        },
+        config
+        // Pass through the config for checkpointing and interrupt support
+      );
       const response = result.messages?.[result.messages.length - 1]?.content || "No response";
-      if (verbose) {
-        console.log(`[ReActWrapper:${workerId}] Response:`, response.substring(0, 100) + "...");
-      }
+      logger.debug("Received response from ReAct agent", {
+        workerId,
+        responsePreview: response.substring(0, 100) + (response.length > 100 ? "..." : "")
+      });
       const toolsUsed = result.actions?.map((action) => action.name).filter(Boolean) || [];
       const uniqueTools = [...new Set(toolsUsed)];
-      if (verbose && uniqueTools.length > 0) {
-        console.log(`[ReActWrapper:${workerId}] Tools used:`, uniqueTools.join(", "));
+      if (uniqueTools.length > 0) {
+        logger.debug("Tools used by ReAct agent", { workerId, tools: uniqueTools });
       }
       const taskResult = {
         assignmentId: currentAssignment.id,
@@ -2106,7 +2161,15 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         status: "routing"
       };
     } catch (error) {
-      console.error(`[ReActWrapper:${workerId}] Error:`, error);
+      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
+        logger.debug("GraphInterrupt detected - re-throwing", { workerId });
+        throw error;
+      }
+      logger.error("Error in ReAct agent execution", {
+        workerId,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === workerId
       );
@@ -2135,7 +2198,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
 
 // src/multi-agent/nodes.ts
 var import_messages5 = require("@langchain/core/messages");
-var import_core7 = require("@agentforge/core");
+var import_core8 = require("@agentforge/core");
 var DEFAULT_AGGREGATOR_SYSTEM_PROMPT = `You are an aggregator agent responsible for combining results from multiple worker agents.
 
 Your job is to:
@@ -2229,7 +2292,7 @@ function createWorkerNode(config) {
     executeFn,
     agent
   } = config;
-  return async (state) => {
+  return async (state, runConfig) => {
     try {
       if (verbose) {
         console.log(`[Worker:${id}] Executing task`);
@@ -2250,7 +2313,7 @@ function createWorkerNode(config) {
         if (verbose) {
           console.log(`[Worker:${id}] Using custom executeFn`);
         }
-        return await executeFn(state);
+        return await executeFn(state, runConfig);
       }
       if (agent) {
         if (isReActAgent(agent)) {
@@ -2258,7 +2321,7 @@ function createWorkerNode(config) {
             console.log(`[Worker:${id}] Using ReAct agent (auto-wrapped)`);
           }
           const wrappedFn = wrapReActAgent(id, agent, verbose);
-          return await wrappedFn(state);
+          return await wrappedFn(state, runConfig);
         } else {
           console.warn(`[Worker:${id}] Agent provided but does not appear to be a ReAct agent. Falling back to default execution.`);
         }
@@ -2279,7 +2342,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
       ];
       let modelToUse = model;
       if (tools.length > 0 && model.bindTools) {
-        const langchainTools = (0, import_core7.toLangChainTools)(tools);
+        const langchainTools = (0, import_core8.toLangChainTools)(tools);
         modelToUse = model.bindTools(langchainTools);
       }
       const response = await modelToUse.invoke(messages);
@@ -2324,6 +2387,9 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
         status: "routing"
       };
     } catch (error) {
+      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
+        throw error;
+      }
       console.error(`[Worker:${id}] Error:`, error);
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === id
@@ -2419,6 +2485,7 @@ Please synthesize these results into a comprehensive response that addresses the
 
 // src/multi-agent/agent.ts
 var import_langgraph4 = require("@langchain/langgraph");
+var import_core9 = require("@agentforge/core");
 function createMultiAgentSystem(config) {
   const {
     supervisor,
@@ -2429,11 +2496,13 @@ function createMultiAgentSystem(config) {
     checkpointer
   } = config;
   const workflow = new import_langgraph4.StateGraph(MultiAgentState);
-  const supervisorNode = createSupervisorNode({
-    ...supervisor,
-    maxIterations,
-    verbose
-  });
+  let supervisorConfig = { ...supervisor, maxIterations, verbose };
+  if (supervisor.model && supervisor.tools && supervisor.tools.length > 0) {
+    const langchainTools = (0, import_core9.toLangChainTools)(supervisor.tools);
+    const modelWithTools = supervisor.model.bindTools(langchainTools);
+    supervisorConfig.model = modelWithTools;
+  }
+  const supervisorNode = createSupervisorNode(supervisorConfig);
   workflow.addNode("supervisor", supervisorNode);
   const workerIds = [];
   const workerCapabilities = {};

package/dist/index.d.cts

@@ -2411,6 +2411,37 @@ interface SupervisorConfig {
      * Maximum number of routing iterations
      */
     maxIterations?: number;
+    /**
+     * Optional tools the supervisor can use during routing
+     *
+     * Enables the supervisor to gather additional information before making routing decisions.
+     * Common use case: askHuman tool for clarifying ambiguous queries.
+     *
+     * Note: Only works with LLM-based routing strategy.
+     *
+     * @example
+     * ```typescript
+     * import { createAskHumanTool } from '@agentforge/tools';
+     *
+     * const system = createMultiAgentSystem({
+     *   supervisor: {
+     *     strategy: 'llm-based',
+     *     model: chatModel,
+     *     tools: [createAskHumanTool()],
+     *   },
+     *   // ...
+     * });
+     * ```
+     */
+    tools?: Tool<any, any>[];
+    /**
+     * Maximum number of tool call retries before requiring routing decision
+     *
+     * Prevents infinite loops where the supervisor keeps calling tools without making a routing decision.
+     *
+     * @default 3
+     */
+    maxToolRetries?: number;
 }
 /**
  * Configuration for a worker agent node
@@ -2445,8 +2476,11 @@ interface WorkerConfig {
      *
      * If provided, this function will be used to execute tasks for this worker.
      * Takes precedence over the `agent` property.
+     *
+     * The config parameter contains LangGraph runtime configuration including
+     * thread_id for checkpointing, which is required for interrupt functionality.
      */
-    executeFn?: (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+    executeFn?: (state: MultiAgentStateType, config?: any) => Promise<Partial<MultiAgentStateType>>;
     /**
      * ReAct agent instance
      *
@@ -2576,6 +2610,8 @@ declare const DEFAULT_SUPERVISOR_SYSTEM_PROMPT = "You are a supervisor agent res
 /**
  * LLM-based routing strategy
  * Uses an LLM to intelligently route tasks based on worker capabilities
+ *
+ * Supports tool calls (e.g., askHuman) for gathering additional information before routing.
  */
 declare const llmBasedRouting: RoutingStrategyImpl;
 /**
@@ -2622,7 +2658,7 @@ declare function createSupervisorNode(config: SupervisorConfig): (state: MultiAg
 /**
  * Create a worker agent node
  */
-declare function createWorkerNode(config: WorkerConfig): (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+declare function createWorkerNode(config: WorkerConfig): (state: MultiAgentStateType, runConfig?: any) => Promise<Partial<MultiAgentStateType>>;
 /**
  * Create an aggregator node that combines worker results
  */

package/dist/index.d.ts

@@ -2411,6 +2411,37 @@ interface SupervisorConfig {
      * Maximum number of routing iterations
      */
     maxIterations?: number;
+    /**
+     * Optional tools the supervisor can use during routing
+     *
+     * Enables the supervisor to gather additional information before making routing decisions.
+     * Common use case: askHuman tool for clarifying ambiguous queries.
+     *
+     * Note: Only works with LLM-based routing strategy.
+     *
+     * @example
+     * ```typescript
+     * import { createAskHumanTool } from '@agentforge/tools';
+     *
+     * const system = createMultiAgentSystem({
+     *   supervisor: {
+     *     strategy: 'llm-based',
+     *     model: chatModel,
+     *     tools: [createAskHumanTool()],
+     *   },
+     *   // ...
+     * });
+     * ```
+     */
+    tools?: Tool<any, any>[];
+    /**
+     * Maximum number of tool call retries before requiring routing decision
+     *
+     * Prevents infinite loops where the supervisor keeps calling tools without making a routing decision.
+     *
+     * @default 3
+     */
+    maxToolRetries?: number;
 }
 /**
  * Configuration for a worker agent node
@@ -2445,8 +2476,11 @@ interface WorkerConfig {
      *
      * If provided, this function will be used to execute tasks for this worker.
      * Takes precedence over the `agent` property.
+     *
+     * The config parameter contains LangGraph runtime configuration including
+     * thread_id for checkpointing, which is required for interrupt functionality.
      */
-    executeFn?: (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+    executeFn?: (state: MultiAgentStateType, config?: any) => Promise<Partial<MultiAgentStateType>>;
     /**
      * ReAct agent instance
      *
@@ -2576,6 +2610,8 @@ declare const DEFAULT_SUPERVISOR_SYSTEM_PROMPT = "You are a supervisor agent res
 /**
  * LLM-based routing strategy
  * Uses an LLM to intelligently route tasks based on worker capabilities
+ *
+ * Supports tool calls (e.g., askHuman) for gathering additional information before routing.
  */
 declare const llmBasedRouting: RoutingStrategyImpl;
 /**
@@ -2622,7 +2658,7 @@ declare function createSupervisorNode(config: SupervisorConfig): (state: MultiAg
 /**
  * Create a worker agent node
  */
-declare function createWorkerNode(config: WorkerConfig): (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+declare function createWorkerNode(config: WorkerConfig): (state: MultiAgentStateType, runConfig?: any) => Promise<Partial<MultiAgentStateType>>;
 /**
  * Create an aggregator node that combines worker results
  */

package/dist/index.js

@@ -228,6 +228,9 @@ function createActionNode(tools, verbose = false) {
           console.log(`[action] Tool '${action.name}' executed successfully`);
         }
       } catch (error) {
+        if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
+          throw error;
+        }
         const errorMessage = error instanceof Error ? error.message : String(error);
         observations.push({
           toolCallId: action.id,
@@ -1791,7 +1794,34 @@ var MultiAgentStateConfig = {
 var MultiAgentState = createStateAnnotation4(MultiAgentStateConfig);
 
 // src/multi-agent/routing.ts
-import { HumanMessage as HumanMessage4, SystemMessage as SystemMessage4 } from "@langchain/core/messages";
+import { HumanMessage as HumanMessage4, SystemMessage as SystemMessage4, AIMessage as AIMessage2, ToolMessage as ToolMessage2 } from "@langchain/core/messages";
+async function executeTools(toolCalls, tools) {
+  const results = [];
+  for (const toolCall of toolCalls) {
+    const tool = tools.find((t) => t.metadata.name === toolCall.name);
+    if (!tool) {
+      results.push(new ToolMessage2({
+        content: `Error: Tool '${toolCall.name}' not found`,
+        tool_call_id: toolCall.id
+      }));
+      continue;
+    }
+    try {
+      const result = await tool.execute(toolCall.args);
+      const content = typeof result === "string" ? result : JSON.stringify(result);
+      results.push(new ToolMessage2({
+        content,
+        tool_call_id: toolCall.id
+      }));
+    } catch (error) {
+      results.push(new ToolMessage2({
+        content: `Error executing tool: ${error.message}`,
+        tool_call_id: toolCall.id
+      }));
+    }
+  }
+  return results;
+}
 var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
 
 Your job is to:
@@ -1814,11 +1844,13 @@ var llmBasedRouting = {
       throw new Error("LLM-based routing requires a model to be configured");
     }
     const systemPrompt = config.systemPrompt || DEFAULT_SUPERVISOR_SYSTEM_PROMPT;
+    const maxRetries = config.maxToolRetries || 3;
+    const tools = config.tools || [];
     const workerInfo = Object.entries(state.workers).map(([id, caps]) => {
       const skills = caps.skills.join(", ");
-      const tools = caps.tools.join(", ");
+      const tools2 = caps.tools.join(", ");
       const available = caps.available ? "available" : "busy";
-      return `- ${id}: Skills: [${skills}], Tools: [${tools}], Status: ${available}, Workload: ${caps.currentWorkload}`;
+      return `- ${id}: Skills: [${skills}], Tools: [${tools2}], Status: ${available}, Workload: ${caps.currentWorkload}`;
     }).join("\n");
     const lastMessage = state.messages[state.messages.length - 1];
     const taskContext = lastMessage?.content || state.input;
@@ -1828,24 +1860,42 @@ Available workers:
 ${workerInfo}
 
 Select the best worker for this task and explain your reasoning.`;
-    const messages = [
-      new SystemMessage4(systemPrompt),
-      new HumanMessage4(userPrompt)
-    ];
-    const response = await config.model.invoke(messages);
-    const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-    try {
-      const decision = JSON.parse(content);
-      return {
-        targetAgent: decision.targetAgent,
-        reasoning: decision.reasoning,
-        confidence: decision.confidence,
-        strategy: "llm-based",
-        timestamp: Date.now()
-      };
-    } catch (error) {
-      throw new Error(`Failed to parse routing decision from LLM: ${error}`);
+    const conversationHistory = [];
+    let attempt = 0;
+    while (attempt < maxRetries) {
+      const messages = [
+        new SystemMessage4(systemPrompt),
+        new HumanMessage4(userPrompt),
+        ...conversationHistory
+      ];
+      const response = await config.model.invoke(messages);
+      if (response.tool_calls && response.tool_calls.length > 0) {
+        if (tools.length === 0) {
+          throw new Error("LLM requested tool calls but no tools are configured");
+        }
+        const toolResults = await executeTools(response.tool_calls, tools);
+        conversationHistory.push(
+          new AIMessage2({ content: response.content || "", tool_calls: response.tool_calls }),
+          ...toolResults
+        );
+        attempt++;
+        continue;
+      }
+      const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      try {
+        const decision = JSON.parse(content);
+        return {
+          targetAgent: decision.targetAgent,
+          reasoning: decision.reasoning,
+          confidence: decision.confidence,
+          strategy: "llm-based",
+          timestamp: Date.now()
+        };
+      } catch (error) {
+        throw new Error(`Failed to parse routing decision from LLM: ${error}`);
+      }
     }
+    throw new Error(`Max tool retries (${maxRetries}) exceeded without routing decision`);
   }
 };
 var roundRobinRouting = {
@@ -1951,43 +2001,48 @@ function getRoutingStrategy(name) {
 }
 
 // src/multi-agent/utils.ts
+import { createLogger, LogLevel } from "@agentforge/core";
+var logLevel = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
+var logger = createLogger("multi-agent", { level: logLevel });
 function isReActAgent(obj) {
   return obj && typeof obj === "object" && typeof obj.invoke === "function" && typeof obj.stream === "function" && // Additional check to ensure it's not just any object with invoke/stream
   (obj.constructor?.name === "CompiledGraph" || obj.constructor?.name === "CompiledStateGraph");
 }
 function wrapReActAgent(workerId, agent, verbose = false) {
-  return async (state) => {
+  return async (state, config) => {
     try {
-      if (verbose) {
-        console.log(`[ReActWrapper:${workerId}] Wrapping ReAct agent execution`);
-      }
+      logger.debug("Wrapping ReAct agent execution", { workerId });
       const task = state.messages[state.messages.length - 1]?.content || state.input;
-      if (verbose) {
-        console.log(`[ReActWrapper:${workerId}] Task:`, task.substring(0, 100) + "...");
-      }
+      logger.debug("Extracted task", {
+        workerId,
+        taskPreview: task.substring(0, 100) + (task.length > 100 ? "..." : "")
+      });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === workerId && !state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
       );
       if (!currentAssignment) {
-        if (verbose) {
-          console.log(`[ReActWrapper:${workerId}] No active assignment found`);
-        }
+        logger.debug("No active assignment found", { workerId });
         return {
           currentAgent: "supervisor",
           status: "routing"
         };
       }
-      const result = await agent.invoke({
-        messages: [{ role: "user", content: task }]
-      });
+      const result = await agent.invoke(
+        {
+          messages: [{ role: "user", content: task }]
+        },
+        config
+        // Pass through the config for checkpointing and interrupt support
+      );
       const response = result.messages?.[result.messages.length - 1]?.content || "No response";
-      if (verbose) {
-        console.log(`[ReActWrapper:${workerId}] Response:`, response.substring(0, 100) + "...");
-      }
+      logger.debug("Received response from ReAct agent", {
+        workerId,
+        responsePreview: response.substring(0, 100) + (response.length > 100 ? "..." : "")
+      });
       const toolsUsed = result.actions?.map((action) => action.name).filter(Boolean) || [];
       const uniqueTools = [...new Set(toolsUsed)];
-      if (verbose && uniqueTools.length > 0) {
-        console.log(`[ReActWrapper:${workerId}] Tools used:`, uniqueTools.join(", "));
+      if (uniqueTools.length > 0) {
+        logger.debug("Tools used by ReAct agent", { workerId, tools: uniqueTools });
       }
       const taskResult = {
         assignmentId: currentAssignment.id,
@@ -2007,7 +2062,15 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         status: "routing"
       };
     } catch (error) {
-      console.error(`[ReActWrapper:${workerId}] Error:`, error);
+      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
+        logger.debug("GraphInterrupt detected - re-throwing", { workerId });
+        throw error;
+      }
+      logger.error("Error in ReAct agent execution", {
+        workerId,
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === workerId
       );
@@ -2130,7 +2193,7 @@ function createWorkerNode(config) {
     executeFn,
     agent
   } = config;
-  return async (state) => {
+  return async (state, runConfig) => {
     try {
       if (verbose) {
         console.log(`[Worker:${id}] Executing task`);
@@ -2151,7 +2214,7 @@ function createWorkerNode(config) {
         if (verbose) {
           console.log(`[Worker:${id}] Using custom executeFn`);
         }
-        return await executeFn(state);
+        return await executeFn(state, runConfig);
       }
       if (agent) {
         if (isReActAgent(agent)) {
@@ -2159,7 +2222,7 @@ function createWorkerNode(config) {
             console.log(`[Worker:${id}] Using ReAct agent (auto-wrapped)`);
           }
           const wrappedFn = wrapReActAgent(id, agent, verbose);
-          return await wrappedFn(state);
+          return await wrappedFn(state, runConfig);
         } else {
           console.warn(`[Worker:${id}] Agent provided but does not appear to be a ReAct agent. Falling back to default execution.`);
         }
@@ -2225,6 +2288,9 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
         status: "routing"
       };
     } catch (error) {
+      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
+        throw error;
+      }
       console.error(`[Worker:${id}] Error:`, error);
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === id
@@ -2320,6 +2386,7 @@ Please synthesize these results into a comprehensive response that addresses the
 
 // src/multi-agent/agent.ts
 import { StateGraph as StateGraph4, END as END4 } from "@langchain/langgraph";
+import { toLangChainTools as toLangChainTools3 } from "@agentforge/core";
 function createMultiAgentSystem(config) {
   const {
     supervisor,
@@ -2330,11 +2397,13 @@ function createMultiAgentSystem(config) {
     checkpointer
   } = config;
   const workflow = new StateGraph4(MultiAgentState);
-  const supervisorNode = createSupervisorNode({
-    ...supervisor,
-    maxIterations,
-    verbose
-  });
+  let supervisorConfig = { ...supervisor, maxIterations, verbose };
+  if (supervisor.model && supervisor.tools && supervisor.tools.length > 0) {
+    const langchainTools = toLangChainTools3(supervisor.tools);
+    const modelWithTools = supervisor.model.bindTools(langchainTools);
+    supervisorConfig.model = modelWithTools;
+  }
+  const supervisorNode = createSupervisorNode(supervisorConfig);
   workflow.addNode("supervisor", supervisorNode);
   const workerIds = [];
   const workerCapabilities = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/patterns",
-  "version": "0.5.4",
+  "version": "0.6.1",
   "description": "Agent patterns (ReAct, Planner-Executor) for AgentForge framework",
   "type": "module",
   "main": "./dist/index.cjs",