@agentforge/patterns 0.7.0 → 0.8.1

package/dist/index.cjs

@@ -283,8 +283,8 @@ function generateToolCallCacheKey(toolName, args) {
   return `${toolName}:${sortedArgs}`;
 }
 function createPatternLogger(name, defaultLevel = "info") {
-  const logLevel5 = process.env.LOG_LEVEL?.toLowerCase() || defaultLevel;
-  return (0, import_core2.createLogger)(name, { level: logLevel5 });
+  const logLevel4 = process.env.LOG_LEVEL?.toLowerCase() || defaultLevel;
+  return (0, import_core2.createLogger)(name, { level: logLevel4 });
 }
 function calculateDeduplicationSavings(duplicatesSkipped, toolsExecuted) {
   if (duplicatesSkipped === 0) {
@@ -604,7 +604,8 @@ function createReActAgent(config, options) {
     return ACTION_NODE;
   };
   const workflow = new import_langgraph.StateGraph(ReActState).addNode(REASONING_NODE, reasoningNode).addNode(ACTION_NODE, actionNode).addNode(OBSERVATION_NODE, observationNode).addEdge("__start__", REASONING_NODE).addConditionalEdges(REASONING_NODE, shouldContinue).addEdge(ACTION_NODE, OBSERVATION_NODE).addEdge(OBSERVATION_NODE, REASONING_NODE);
-  return workflow.compile(checkpointer ? { checkpointer } : void 0);
+  const checkpointerConfig = checkpointer === true ? { checkpointer: true } : checkpointer ? { checkpointer } : void 0;
+  return workflow.compile(checkpointerConfig);
 }
 
 // src/react/builder.ts
@@ -689,6 +690,43 @@ var ReActAgentBuilder = class {
     this.options.nodeNames = nodeNames;
     return this;
   }
+  /**
+   * Set the checkpointer for state persistence (optional)
+   *
+   * Can be:
+   * - A BaseCheckpointSaver instance (e.g., MemorySaver) for standalone agents
+   * - `true` to use the parent graph's checkpointer with a separate namespace (for nested graphs)
+   *
+   * Required for human-in-the-loop workflows (askHuman tool) and conversation continuity.
+   *
+   * @param checkpointer - Checkpointer instance or `true` for nested graphs
+   *
+   * @example
+   * Standalone agent with its own checkpointer:
+   * ```typescript
+   * import { MemorySaver } from '@langchain/langgraph';
+   *
+   * const agent = new ReActAgentBuilder()
+   *   .withModel(model)
+   *   .withTools(tools)
+   *   .withCheckpointer(new MemorySaver())
+   *   .build();
+   * ```
+   *
+   * @example
+   * Nested agent using parent's checkpointer (for multi-agent systems):
+   * ```typescript
+   * const agent = new ReActAgentBuilder()
+   *   .withModel(model)
+   *   .withTools(tools)
+   *   .withCheckpointer(true)  // Use parent's checkpointer with separate namespace
+   *   .build();
+   * ```
+   */
+  withCheckpointer(checkpointer) {
+    this.config.checkpointer = checkpointer;
+    return this;
+  }
   /**
    * Build the ReAct agent
    *
@@ -708,7 +746,8 @@ var ReActAgentBuilder = class {
       systemPrompt: this.config.systemPrompt || DEFAULT_REACT_SYSTEM_PROMPT,
       maxIterations: this.config.maxIterations ?? 10,
       returnIntermediateSteps: this.config.returnIntermediateSteps ?? false,
-      stopCondition: this.config.stopCondition
+      stopCondition: this.config.stopCondition,
+      checkpointer: this.config.checkpointer
     };
     return createReActAgent(finalConfig, this.options);
   }
@@ -2164,66 +2203,6 @@ var MultiAgentState = (0, import_core7.createStateAnnotation)(MultiAgentStateCon
 
 // src/multi-agent/routing.ts
 var import_messages4 = require("@langchain/core/messages");
-var import_core8 = require("@agentforge/core");
-var logLevel = process.env.LOG_LEVEL?.toLowerCase() || import_core8.LogLevel.INFO;
-var logger = (0, import_core8.createLogger)("multi-agent:routing", { level: logLevel });
-async function executeTools(toolCalls, tools) {
-  const results = [];
-  logger.debug("Executing tools", {
-    toolCallCount: toolCalls.length,
-    toolNames: toolCalls.map((tc) => tc.name)
-  });
-  for (const toolCall of toolCalls) {
-    const tool = tools.find((t) => t.metadata.name === toolCall.name);
-    if (!tool) {
-      logger.warn("Tool not found", {
-        toolName: toolCall.name,
-        availableTools: tools.map((t) => t.metadata.name)
-      });
-      results.push(new import_messages4.ToolMessage({
-        content: `Error: Tool '${toolCall.name}' not found`,
-        tool_call_id: toolCall.id
-      }));
-      continue;
-    }
-    try {
-      logger.debug("Executing tool", {
-        toolName: toolCall.name,
-        args: toolCall.args
-      });
-      const result = await tool.execute(toolCall.args);
-      const content = typeof result === "string" ? result : JSON.stringify(result);
-      logger.debug("Tool execution successful", {
-        toolName: toolCall.name,
-        resultLength: content.length
-      });
-      results.push(new import_messages4.ToolMessage({
-        content,
-        tool_call_id: toolCall.id
-      }));
-    } catch (error) {
-      logger.error("Tool execution failed", {
-        toolName: toolCall.name,
-        error: error.message
-      });
-      results.push(new import_messages4.ToolMessage({
-        content: `Error executing tool: ${error.message}`,
-        tool_call_id: toolCall.id
-      }));
-    }
-  }
-  logger.debug("Tool execution complete", {
-    successCount: results.filter((r) => {
-      const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
-      return !content.startsWith("Error");
-    }).length,
-    errorCount: results.filter((r) => {
-      const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
-      return content.startsWith("Error");
-    }).length
-  });
-  return results;
-}
 var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
 
 Your job is to:
@@ -2259,151 +2238,48 @@ Choose parallel routing when the task benefits from multiple perspectives or dat
 var llmBasedRouting = {
   name: "llm-based",
   async route(state, config) {
-    logger.info("Starting LLM-based routing", {
-      iteration: state.iteration,
-      availableWorkers: Object.keys(state.workers).length
-    });
     if (!config.model) {
       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 tools2 = caps.tools.join(", ");
+      const tools = caps.tools.join(", ");
       const available = caps.available ? "available" : "busy";
-      return `- ${id}: Skills: [${skills}], Tools: [${tools2}], Status: ${available}, Workload: ${caps.currentWorkload}`;
+      return `- ${id}: Skills: [${skills}], Tools: [${tools}], Status: ${available}, Workload: ${caps.currentWorkload}`;
     }).join("\n");
-    logger.debug("Worker capabilities", {
-      workers: Object.entries(state.workers).map(([id, caps]) => ({
-        id,
-        skills: caps.skills,
-        available: caps.available,
-        workload: caps.currentWorkload
-      }))
-    });
     const lastMessage = state.messages[state.messages.length - 1];
     const taskContext = lastMessage?.content || state.input;
-    logger.debug("Task context", {
-      taskLength: taskContext.length,
-      taskPreview: taskContext.substring(0, 100)
-    });
     const userPrompt = `Current task: ${taskContext}
 
 Available workers:
 ${workerInfo}
 
 Select the best worker(s) for this task and explain your reasoning.`;
-    const conversationHistory = [];
-    let attempt = 0;
-    while (attempt < maxRetries) {
-      logger.debug("LLM routing attempt", {
-        attempt: attempt + 1,
-        maxRetries,
-        conversationHistoryLength: conversationHistory.length
-      });
-      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) {
-        logger.info("LLM requested tool calls", {
-          toolCount: response.tool_calls.length,
-          toolNames: response.tool_calls.map((tc) => tc.name)
-        });
-        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++;
-        logger.debug("Retrying routing with tool results", { attempt });
-        continue;
-      }
-      logger.debug("Parsing routing decision from LLM response");
-      let decision;
-      if (response && typeof response === "object" && ("targetAgent" in response || "targetAgents" in response)) {
-        logger.debug("Response is structured output", {
-          hasTargetAgent: "targetAgent" in response,
-          hasTargetAgents: "targetAgents" in response
-        });
-        decision = response;
-      } else if (response.content) {
-        if (typeof response.content === "string") {
-          try {
-            decision = JSON.parse(response.content);
-            logger.debug("Parsed JSON from string response");
-          } catch (error) {
-            logger.error("Failed to parse routing decision", {
-              content: response.content,
-              error: error instanceof Error ? error.message : String(error)
-            });
-            throw new Error(`Failed to parse routing decision from LLM. Expected JSON but got: ${response.content}`);
-          }
-        } else if (typeof response.content === "object") {
-          logger.debug("Response content is already an object");
-          decision = response.content;
-        } else {
-          logger.error("Unexpected response content type", {
-            type: typeof response.content
-          });
-          throw new Error(`Unexpected response content type: ${typeof response.content}`);
-        }
-      } else {
-        logger.error("Unexpected response format", {
-          response: JSON.stringify(response)
-        });
-        throw new Error(`Unexpected response format: ${JSON.stringify(response)}`);
-      }
-      const result = {
-        targetAgent: decision.targetAgent,
-        targetAgents: decision.targetAgents,
-        reasoning: decision.reasoning,
-        confidence: decision.confidence,
-        strategy: "llm-based",
-        timestamp: Date.now()
-      };
-      logger.info("LLM routing decision made", {
-        targetAgent: result.targetAgent,
-        targetAgents: result.targetAgents,
-        isParallel: result.targetAgents && result.targetAgents.length > 1,
-        confidence: result.confidence,
-        reasoning: result.reasoning
-      });
-      return result;
-    }
-    logger.error("Max tool retries exceeded", { maxRetries });
-    throw new Error(`Max tool retries (${maxRetries}) exceeded without routing decision`);
+    const messages = [
+      new import_messages4.SystemMessage(systemPrompt),
+      new import_messages4.HumanMessage(userPrompt)
+    ];
+    const decision = await config.model.invoke(messages);
+    return {
+      targetAgent: decision.targetAgent,
+      targetAgents: decision.targetAgents,
+      reasoning: decision.reasoning,
+      confidence: decision.confidence,
+      strategy: "llm-based",
+      timestamp: Date.now()
+    };
   }
 };
 var roundRobinRouting = {
   name: "round-robin",
   async route(state, config) {
-    logger.info("Starting round-robin routing", {
-      iteration: state.iteration
-    });
     const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id]) => id);
-    logger.debug("Available workers for round-robin", {
-      count: availableWorkers.length,
-      workers: availableWorkers
-    });
     if (availableWorkers.length === 0) {
-      logger.error("No available workers for round-robin routing");
       throw new Error("No available workers for round-robin routing");
     }
     const lastRoutingIndex = state.routingHistory.length % availableWorkers.length;
     const targetAgent = availableWorkers[lastRoutingIndex];
-    logger.info("Round-robin routing decision", {
-      targetAgent,
-      index: lastRoutingIndex + 1,
-      totalWorkers: availableWorkers.length
-    });
     return {
       targetAgent,
       targetAgents: null,
@@ -2417,15 +2293,8 @@ var roundRobinRouting = {
 var skillBasedRouting = {
   name: "skill-based",
   async route(state, config) {
-    logger.info("Starting skill-based routing", {
-      iteration: state.iteration
-    });
     const lastMessage = state.messages[state.messages.length - 1];
     const taskContent = (lastMessage?.content || state.input).toLowerCase();
-    logger.debug("Task content for skill matching", {
-      taskLength: taskContent.length,
-      taskPreview: taskContent.substring(0, 100)
-    });
     const workerScores = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => {
       const skillMatches = caps.skills.filter(
         (skill) => taskContent.includes(skill.toLowerCase())
@@ -2436,20 +2305,11 @@ var skillBasedRouting = {
       const score = skillMatches * 2 + toolMatches;
       return { id, score, skills: caps.skills, tools: caps.tools };
     }).filter((w) => w.score > 0).sort((a, b) => b.score - a.score);
-    logger.debug("Worker skill scores", {
-      scoredWorkers: workerScores.map((w) => ({ id: w.id, score: w.score }))
-    });
     if (workerScores.length === 0) {
-      logger.warn("No skill matches found, using fallback");
       const firstAvailable = Object.entries(state.workers).find(([_, caps]) => caps.available);
       if (!firstAvailable) {
-        logger.error("No available workers for skill-based routing");
         throw new Error("No available workers for skill-based routing");
       }
-      logger.info("Skill-based routing fallback decision", {
-        targetAgent: firstAvailable[0],
-        confidence: 0.5
-      });
       return {
         targetAgent: firstAvailable[0],
         targetAgents: null,
@@ -2461,12 +2321,6 @@ var skillBasedRouting = {
     }
     const best = workerScores[0];
     const confidence = Math.min(best.score / 5, 1);
-    logger.info("Skill-based routing decision", {
-      targetAgent: best.id,
-      score: best.score,
-      confidence,
-      matchedSkills: best.skills
-    });
     return {
       targetAgent: best.id,
       targetAgents: null,
@@ -2480,26 +2334,13 @@ var skillBasedRouting = {
 var loadBalancedRouting = {
   name: "load-balanced",
   async route(state, config) {
-    logger.info("Starting load-balanced routing", {
-      iteration: state.iteration
-    });
     const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => ({ id, workload: caps.currentWorkload })).sort((a, b) => a.workload - b.workload);
-    logger.debug("Worker workloads", {
-      workers: availableWorkers.map((w) => ({ id: w.id, workload: w.workload }))
-    });
     if (availableWorkers.length === 0) {
-      logger.error("No available workers for load-balanced routing");
       throw new Error("No available workers for load-balanced routing");
     }
     const targetWorker = availableWorkers[0];
     const avgWorkload = availableWorkers.reduce((sum, w) => sum + w.workload, 0) / availableWorkers.length;
     const confidence = targetWorker.workload === 0 ? 1 : Math.max(0.5, 1 - targetWorker.workload / (avgWorkload * 2));
-    logger.info("Load-balanced routing decision", {
-      targetAgent: targetWorker.id,
-      workload: targetWorker.workload,
-      avgWorkload: avgWorkload.toFixed(1),
-      confidence
-    });
     return {
       targetAgent: targetWorker.id,
       targetAgents: null,
@@ -2513,24 +2354,13 @@ var loadBalancedRouting = {
 var ruleBasedRouting = {
   name: "rule-based",
   async route(state, config) {
-    logger.info("Starting rule-based routing", {
-      iteration: state.iteration
-    });
     if (!config.routingFn) {
-      logger.error("Rule-based routing requires a custom routing function");
       throw new Error("Rule-based routing requires a custom routing function");
     }
-    const decision = await config.routingFn(state);
-    logger.info("Rule-based routing decision", {
-      targetAgent: decision.targetAgent,
-      targetAgents: decision.targetAgents,
-      confidence: decision.confidence
-    });
-    return decision;
+    return await config.routingFn(state);
   }
 };
 function getRoutingStrategy(name) {
-  logger.debug("Getting routing strategy", { name });
   switch (name) {
     case "llm-based":
       return llmBasedRouting;
@@ -2543,15 +2373,14 @@ function getRoutingStrategy(name) {
     case "rule-based":
       return ruleBasedRouting;
     default:
-      logger.error("Unknown routing strategy", { name });
       throw new Error(`Unknown routing strategy: ${name}`);
   }
 }
 
 // src/multi-agent/utils.ts
-var import_core9 = require("@agentforge/core");
-var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || import_core9.LogLevel.INFO;
-var logger2 = (0, import_core9.createLogger)("multi-agent", { level: logLevel2 });
+var import_core8 = require("@agentforge/core");
+var logLevel = process.env.LOG_LEVEL?.toLowerCase() || import_core8.LogLevel.INFO;
+var logger = (0, import_core8.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");
@@ -2559,9 +2388,9 @@ function isReActAgent(obj) {
 function wrapReActAgent(workerId, agent, verbose = false) {
   return async (state, config) => {
     try {
-      logger2.debug("Wrapping ReAct agent execution", { workerId });
+      logger.debug("Wrapping ReAct agent execution", { workerId });
       const task = state.messages[state.messages.length - 1]?.content || state.input;
-      logger2.debug("Extracted task", {
+      logger.debug("Extracted task", {
         workerId,
         taskPreview: task.substring(0, 100) + (task.length > 100 ? "..." : "")
       });
@@ -2569,25 +2398,39 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         (assignment) => assignment.workerId === workerId && !state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
       );
       if (!currentAssignment) {
-        logger2.debug("No active assignment found", { workerId });
+        logger.debug("No active assignment found", { workerId });
         return {};
       }
+      const workerThreadId = config?.configurable?.thread_id ? `${config.configurable.thread_id}:worker:${workerId}` : void 0;
+      const workerConfig = workerThreadId ? {
+        ...config,
+        configurable: {
+          ...config.configurable,
+          thread_id: workerThreadId
+        }
+      } : config;
+      logger.debug("Invoking ReAct agent with worker-specific config", {
+        workerId,
+        parentThreadId: config?.configurable?.thread_id,
+        workerThreadId,
+        hasConfig: !!workerConfig
+      });
       const result = await agent.invoke(
         {
           messages: [{ role: "user", content: task }]
         },
-        config
-        // Pass through the config for checkpointing and interrupt support
+        workerConfig
+        // Worker-specific config with unique thread_id
       );
       const response = result.messages?.[result.messages.length - 1]?.content || "No response";
-      logger2.debug("Received response from ReAct agent", {
+      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 (uniqueTools.length > 0) {
-        logger2.debug("Tools used by ReAct agent", { workerId, tools: uniqueTools });
+        logger.debug("Tools used by ReAct agent", { workerId, tools: uniqueTools });
       }
       const taskResult = {
         assignmentId: currentAssignment.id,
@@ -2606,7 +2449,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
       };
     } catch (error) {
       const errorMessage = handleNodeError(error, `react-agent:${workerId}`, false);
-      logger2.error("Error in ReAct agent execution", {
+      logger.error("Error in ReAct agent execution", {
         workerId,
         error: errorMessage
       });
@@ -2638,9 +2481,9 @@ function wrapReActAgent(workerId, agent, verbose = false) {
 
 // src/multi-agent/nodes.ts
 var import_messages5 = require("@langchain/core/messages");
-var import_core10 = require("@agentforge/core");
-var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || import_core10.LogLevel.INFO;
-var logger3 = (0, import_core10.createLogger)("multi-agent:nodes", { level: logLevel3 });
+var import_core9 = require("@agentforge/core");
+var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || import_core9.LogLevel.INFO;
+var logger2 = (0, import_core9.createLogger)("multi-agent:nodes", { level: logLevel2 });
 var DEFAULT_AGGREGATOR_SYSTEM_PROMPT = `You are an aggregator agent responsible for combining results from multiple worker agents.
 
 Your job is to:
@@ -2658,19 +2501,19 @@ function createSupervisorNode(config) {
   } = config;
   return async (state) => {
     try {
-      logger3.info("Supervisor node executing", {
+      logger2.info("Supervisor node executing", {
         iteration: state.iteration,
         maxIterations,
         activeAssignments: state.activeAssignments.length,
         completedTasks: state.completedTasks.length
       });
-      logger3.debug(`Routing iteration ${state.iteration}/${maxIterations}`);
+      logger2.debug(`Routing iteration ${state.iteration}/${maxIterations}`);
       if (state.iteration >= maxIterations) {
-        logger3.warn("Max iterations reached", {
+        logger2.warn("Max iterations reached", {
           iteration: state.iteration,
           maxIterations
         });
-        logger3.debug("Max iterations reached, moving to aggregation");
+        logger2.debug("Max iterations reached, moving to aggregation");
         return {
           status: "aggregating",
           currentAgent: "aggregator"
@@ -2679,26 +2522,26 @@ function createSupervisorNode(config) {
       const allCompleted = state.activeAssignments.every(
         (assignment) => state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
       );
-      logger3.debug("Checking task completion", {
+      logger2.debug("Checking task completion", {
         activeAssignments: state.activeAssignments.length,
         completedTasks: state.completedTasks.length,
         allCompleted
       });
       if (allCompleted && state.activeAssignments.length > 0) {
-        logger3.info("All tasks completed, moving to aggregation", {
+        logger2.info("All tasks completed, moving to aggregation", {
           completedCount: state.completedTasks.length
         });
-        logger3.debug("All tasks completed, moving to aggregation");
+        logger2.debug("All tasks completed, moving to aggregation");
         return {
           status: "aggregating",
           currentAgent: "aggregator"
         };
       }
-      logger3.debug("Getting routing strategy", { strategy });
+      logger2.debug("Getting routing strategy", { strategy });
       const routingImpl = getRoutingStrategy(strategy);
       const decision = await routingImpl.route(state, config);
       const targetAgents = decision.targetAgents && decision.targetAgents.length > 0 ? decision.targetAgents : decision.targetAgent ? [decision.targetAgent] : [];
-      logger3.debug("Target agents determined", {
+      logger2.debug("Target agents determined", {
         targetAgents,
         isParallel: targetAgents.length > 1,
         decision: {
@@ -2707,17 +2550,17 @@ function createSupervisorNode(config) {
         }
       });
       if (targetAgents.length === 0) {
-        logger3.error("No target agents specified in routing decision");
+        logger2.error("No target agents specified in routing decision");
         throw new Error("Routing decision must specify at least one target agent");
       }
       if (targetAgents.length === 1) {
-        logger3.info("Routing to single agent", {
+        logger2.info("Routing to single agent", {
           targetAgent: targetAgents[0],
           reasoning: decision.reasoning,
           confidence: decision.confidence
         });
       } else {
-        logger3.info("Routing to multiple agents in parallel", {
+        logger2.info("Routing to multiple agents in parallel", {
           targetAgents,
           count: targetAgents.length,
           reasoning: decision.reasoning,
@@ -2725,9 +2568,9 @@ function createSupervisorNode(config) {
         });
       }
       if (targetAgents.length === 1) {
-        logger3.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
+        logger2.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
       } else {
-        logger3.debug(`Routing to ${targetAgents.length} agents in parallel [${targetAgents.join(", ")}]: ${decision.reasoning}`);
+        logger2.debug(`Routing to ${targetAgents.length} agents in parallel [${targetAgents.join(", ")}]: ${decision.reasoning}`);
       }
       const task = state.messages[state.messages.length - 1]?.content || state.input;
       const assignments = targetAgents.map((workerId) => ({
@@ -2737,7 +2580,7 @@ function createSupervisorNode(config) {
         priority: 5,
         assignedAt: Date.now()
       }));
-      logger3.debug("Created task assignments", {
+      logger2.debug("Created task assignments", {
         assignmentCount: assignments.length,
         assignments: assignments.map((a) => ({
           id: a.id,
@@ -2757,7 +2600,7 @@ function createSupervisorNode(config) {
           priority: assignment.priority
         }
       }));
-      logger3.info("Supervisor routing complete", {
+      logger2.info("Supervisor routing complete", {
         currentAgent: targetAgents.join(","),
         status: "executing",
         assignmentCount: assignments.length,
@@ -2774,7 +2617,7 @@ function createSupervisorNode(config) {
         iteration: state.iteration + 1
       };
     } catch (error) {
-      logger3.error("Supervisor node error", {
+      logger2.error("Supervisor node error", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         iteration: state.iteration
@@ -2799,7 +2642,7 @@ function createWorkerNode(config) {
   } = config;
   return async (state, runConfig) => {
     try {
-      logger3.info("Worker node executing", {
+      logger2.info("Worker node executing", {
         workerId: id,
         iteration: state.iteration,
         activeAssignments: state.activeAssignments.length
@@ -2808,39 +2651,39 @@ function createWorkerNode(config) {
         (assignment) => assignment.workerId === id && !state.completedTasks.some((task) => task.assignmentId === assignment.id)
       );
       if (!currentAssignment) {
-        logger3.debug("No active assignment found for worker", {
+        logger2.debug("No active assignment found for worker", {
           workerId: id,
           totalActiveAssignments: state.activeAssignments.length,
           completedTasks: state.completedTasks.length
         });
         return {};
       }
-      logger3.info("Worker processing assignment", {
+      logger2.info("Worker processing assignment", {
         workerId: id,
         assignmentId: currentAssignment.id,
         taskLength: currentAssignment.task.length,
         taskPreview: currentAssignment.task.substring(0, 100)
       });
       if (executeFn) {
-        logger3.debug("Using custom execution function", { workerId: id });
+        logger2.debug("Using custom execution function", { workerId: id });
         return await executeFn(state, runConfig);
       }
       if (agent) {
         if (isReActAgent(agent)) {
-          logger3.debug("Using ReAct agent", { workerId: id });
+          logger2.debug("Using ReAct agent", { workerId: id });
           const wrappedFn = wrapReActAgent(id, agent, verbose);
           return await wrappedFn(state, runConfig);
         } else {
-          logger3.warn("Agent provided but not a ReAct agent, falling back", { workerId: id });
+          logger2.warn("Agent provided but not a ReAct agent, falling back", { workerId: id });
         }
       }
       if (!model) {
-        logger3.error("Worker missing required configuration", { workerId: id });
+        logger2.error("Worker missing required configuration", { workerId: id });
         throw new Error(
           `Worker ${id} requires either a model, an agent, or a custom execution function. Provide one of: config.model, config.agent, or config.executeFn`
         );
       }
-      logger3.debug("Using default LLM execution", {
+      logger2.debug("Using default LLM execution", {
         workerId: id,
         hasTools: tools.length > 0,
         toolCount: tools.length
@@ -2856,18 +2699,18 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
       ];
       let modelToUse = model;
       if (tools.length > 0 && model.bindTools) {
-        logger3.debug("Binding tools to model", {
+        logger2.debug("Binding tools to model", {
           workerId: id,
           toolCount: tools.length,
           toolNames: tools.map((t) => t.metadata.name)
         });
-        const langchainTools = (0, import_core10.toLangChainTools)(tools);
+        const langchainTools = (0, import_core9.toLangChainTools)(tools);
         modelToUse = model.bindTools(langchainTools);
       }
-      logger3.debug("Invoking LLM", { workerId: id });
+      logger2.debug("Invoking LLM", { workerId: id });
       const response = await modelToUse.invoke(messages);
       const result = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      logger3.info("Worker task completed", {
+      logger2.info("Worker task completed", {
         workerId: id,
         assignmentId: currentAssignment.id,
         resultLength: result.length,
@@ -2902,7 +2745,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
           currentWorkload: Math.max(0, capabilities.currentWorkload - 1)
         }
       };
-      logger3.debug("Worker state update", {
+      logger2.debug("Worker state update", {
         workerId: id,
         newWorkload: updatedWorkers[id].currentWorkload
       });
@@ -2913,7 +2756,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
       };
     } catch (error) {
       const errorMessage = handleNodeError(error, `worker:${id}`, false);
-      logger3.error("Worker node error", {
+      logger2.error("Worker node error", {
         workerId: id,
         error: errorMessage
       });
@@ -2921,7 +2764,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
         (assignment) => assignment.workerId === id
       );
       if (currentAssignment) {
-        logger3.warn("Creating error result for assignment", {
+        logger2.warn("Creating error result for assignment", {
           workerId: id,
           assignmentId: currentAssignment.id
         });
@@ -2939,7 +2782,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
           status: "routing"
         };
       }
-      logger3.error("No assignment found for error handling", { workerId: id });
+      logger2.error("No assignment found for error handling", { workerId: id });
       return {
         status: "failed",
         error: errorMessage
@@ -2956,16 +2799,16 @@ function createAggregatorNode(config = {}) {
   } = config;
   return async (state) => {
     try {
-      logger3.info("Aggregator node executing", {
+      logger2.info("Aggregator node executing", {
         completedTasks: state.completedTasks.length,
         successfulTasks: state.completedTasks.filter((t) => t.success).length,
         failedTasks: state.completedTasks.filter((t) => !t.success).length
       });
-      logger3.debug("Combining results from workers");
+      logger2.debug("Combining results from workers");
       if (aggregateFn) {
-        logger3.debug("Using custom aggregation function");
+        logger2.debug("Using custom aggregation function");
         const response2 = await aggregateFn(state);
-        logger3.info("Custom aggregation complete", {
+        logger2.info("Custom aggregation complete", {
           responseLength: response2.length
         });
         return {
@@ -2974,16 +2817,16 @@ function createAggregatorNode(config = {}) {
         };
       }
       if (state.completedTasks.length === 0) {
-        logger3.warn("No completed tasks to aggregate");
+        logger2.warn("No completed tasks to aggregate");
         return {
           response: "No tasks were completed.",
           status: "completed"
         };
       }
       if (!model) {
-        logger3.debug("No model provided, concatenating results");
+        logger2.debug("No model provided, concatenating results");
         const combinedResults = state.completedTasks.filter((task) => task.success).map((task) => task.result).join("\n\n");
-        logger3.info("Simple concatenation complete", {
+        logger2.info("Simple concatenation complete", {
           resultLength: combinedResults.length
         });
         return {
@@ -2991,7 +2834,7 @@ function createAggregatorNode(config = {}) {
           status: "completed"
         };
       }
-      logger3.debug("Using LLM for intelligent aggregation", {
+      logger2.debug("Using LLM for intelligent aggregation", {
         taskCount: state.completedTasks.length
       });
       const taskResults = state.completedTasks.map((task, idx) => {
@@ -3010,20 +2853,20 @@ Please synthesize these results into a comprehensive response that addresses the
         new import_messages5.SystemMessage(systemPrompt),
         new import_messages5.HumanMessage(userPrompt)
       ];
-      logger3.debug("Invoking aggregation LLM");
+      logger2.debug("Invoking aggregation LLM");
       const response = await model.invoke(messages);
       const aggregatedResponse = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      logger3.info("Aggregation complete", {
+      logger2.info("Aggregation complete", {
         responseLength: aggregatedResponse.length,
         responsePreview: aggregatedResponse.substring(0, 100)
       });
-      logger3.debug("Aggregation complete");
+      logger2.debug("Aggregation complete");
       return {
         response: aggregatedResponse,
         status: "completed"
       };
     } catch (error) {
-      logger3.error("Aggregator node error", {
+      logger2.error("Aggregator node error", {
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : void 0,
         completedTasks: state.completedTasks.length
@@ -3038,9 +2881,9 @@ Please synthesize these results into a comprehensive response that addresses the
 
 // src/multi-agent/agent.ts
 var import_langgraph4 = require("@langchain/langgraph");
-var import_core11 = require("@agentforge/core");
-var logLevel4 = process.env.LOG_LEVEL?.toLowerCase() || import_core11.LogLevel.INFO;
-var logger4 = (0, import_core11.createLogger)("multi-agent:system", { level: logLevel4 });
+var import_core10 = require("@agentforge/core");
+var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || import_core10.LogLevel.INFO;
+var logger3 = (0, import_core10.createLogger)("multi-agent:system", { level: logLevel3 });
 function createMultiAgentSystem(config) {
   const {
     supervisor,
@@ -3057,10 +2900,6 @@ function createMultiAgentSystem(config) {
     if (supervisor.strategy === "llm-based") {
       configuredModel = configuredModel.withStructuredOutput(RoutingDecisionSchema);
     }
-    if (supervisor.tools && supervisor.tools.length > 0) {
-      const langchainTools = (0, import_core11.toLangChainTools)(supervisor.tools);
-      configuredModel = configuredModel.bindTools(langchainTools);
-    }
     supervisorConfig.model = configuredModel;
   }
   const supervisorNode = createSupervisorNode(supervisorConfig);
@@ -3082,46 +2921,46 @@ function createMultiAgentSystem(config) {
   });
   workflow.addNode("aggregator", aggregatorNode);
   const supervisorRouter = (state) => {
-    logger4.debug("Supervisor router executing", {
+    logger3.debug("Supervisor router executing", {
       status: state.status,
       currentAgent: state.currentAgent,
       iteration: state.iteration
     });
     if (state.status === "completed" || state.status === "failed") {
-      logger4.info("Supervisor router: ending workflow", { status: state.status });
+      logger3.info("Supervisor router: ending workflow", { status: state.status });
       return import_langgraph4.END;
     }
     if (state.status === "aggregating") {
-      logger4.info("Supervisor router: routing to aggregator");
+      logger3.info("Supervisor router: routing to aggregator");
       return "aggregator";
     }
     if (state.currentAgent && state.currentAgent !== "supervisor") {
       if (state.currentAgent.includes(",")) {
         const agents = state.currentAgent.split(",").map((a) => a.trim());
-        logger4.info("Supervisor router: parallel routing", {
+        logger3.info("Supervisor router: parallel routing", {
           agents,
           count: agents.length
         });
         return agents;
       }
-      logger4.info("Supervisor router: single agent routing", {
+      logger3.info("Supervisor router: single agent routing", {
         targetAgent: state.currentAgent
       });
       return state.currentAgent;
     }
-    logger4.debug("Supervisor router: staying at supervisor");
+    logger3.debug("Supervisor router: staying at supervisor");
     return "supervisor";
   };
   const workerRouter = (state) => {
-    logger4.debug("Worker router executing", {
+    logger3.debug("Worker router executing", {
       iteration: state.iteration,
       completedTasks: state.completedTasks.length
     });
-    logger4.debug("Worker router: returning to supervisor");
+    logger3.debug("Worker router: returning to supervisor");
     return "supervisor";
   };
   const aggregatorRouter = (state) => {
-    logger4.info("Aggregator router: ending workflow", {
+    logger3.info("Aggregator router: ending workflow", {
       completedTasks: state.completedTasks.length,
       status: state.status
     });