@agentforge/patterns 0.16.31 → 0.16.33

package/dist/index.cjs

@@ -411,9 +411,9 @@ function stringifyActionArguments(arguments_) {
 function getLatestThought(thoughts) {
   return thoughts[thoughts.length - 1]?.content ?? "";
 }
-function debugIfVerbose(logger4, verbose, message, data) {
+function debugIfVerbose(logger5, verbose, message, data) {
   if (verbose) {
-    logger4.debug(message, data);
+    logger5.debug(message, data);
   }
 }
 
@@ -2391,8 +2391,9 @@ var MultiAgentStateConfig = {
 };
 var MultiAgentState = (0, import_core7.createStateAnnotation)(MultiAgentStateConfig);
 
-// src/multi-agent/routing.ts
+// src/multi-agent/routing-internal/llm-routing.ts
 var import_messages5 = require("@langchain/core/messages");
+var logger = createPatternLogger("agentforge:patterns:multi-agent:routing");
 var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
 
 Your job is to:
@@ -2425,6 +2426,84 @@ For PARALLEL multi-worker routing:
 }
 
 Choose parallel routing when the task benefits from multiple perspectives or data sources.`;
+function hasStructuredOutput(model) {
+  return typeof model.withStructuredOutput === "function";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isContentCarrier(value) {
+  return isRecord(value) && "content" in value;
+}
+function serializeRoutingContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const textParts = content.flatMap((part) => {
+      if (typeof part === "string") {
+        return [part];
+      }
+      if (isRecord(part) && typeof part.text === "string") {
+        return [part.text];
+      }
+      return [];
+    });
+    if (textParts.length > 0) {
+      return textParts.join("\n");
+    }
+    return JSON.stringify(content);
+  }
+  return JSON.stringify(content);
+}
+function normalizeRoutingDecisionInput(decision) {
+  if (isContentCarrier(decision)) {
+    return JSON.parse(serializeRoutingContent(decision.content));
+  }
+  return decision;
+}
+function parseRoutingDecision(decision) {
+  try {
+    return RoutingDecisionSchema.parse(normalizeRoutingDecisionInput(decision));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid LLM routing decision: ${message}`);
+  }
+}
+function finalizeLlmRoutingDecision(decision) {
+  const parsed = parseRoutingDecision(decision);
+  return {
+    targetAgent: parsed.targetAgent,
+    targetAgents: parsed.targetAgents,
+    reasoning: parsed.reasoning,
+    confidence: parsed.confidence,
+    strategy: "llm-based",
+    timestamp: Date.now()
+  };
+}
+async function invokeStructuredRoutingDecision(model, messages) {
+  let structuredModel;
+  try {
+    structuredModel = model.withStructuredOutput(RoutingDecisionSchema);
+  } catch (error) {
+    logger.warn("Structured output unavailable, using direct routing fallback", {
+      strategy: "llm-based",
+      fallback: "direct-model-invoke",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    const decision2 = await model.invoke(messages);
+    return finalizeLlmRoutingDecision(decision2);
+  }
+  const decision = await structuredModel.invoke(messages);
+  return finalizeLlmRoutingDecision(decision);
+}
+async function invokeRoutingDecision(model, messages) {
+  if (hasStructuredOutput(model)) {
+    return invokeStructuredRoutingDecision(model, messages);
+  }
+  const decision = await model.invoke(messages);
+  return finalizeLlmRoutingDecision(decision);
+}
 var llmBasedRouting = {
   name: "llm-based",
   async route(state, config) {
@@ -2450,64 +2529,119 @@ Select the best worker(s) for this task and explain your reasoning.`;
       new import_messages5.SystemMessage(systemPrompt),
       new import_messages5.HumanMessage(userPrompt)
     ];
-    const decision = await config.model.invoke(messages);
+    return invokeRoutingDecision(config.model, messages);
+  }
+};
+
+// src/multi-agent/routing-internal/load-balanced-routing.ts
+function getAvailableWorkerLoads(state) {
+  return Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => ({ id, workload: caps.currentWorkload })).sort((a, b) => a.workload - b.workload);
+}
+var loadBalancedRouting = {
+  name: "load-balanced",
+  async route(state, _config) {
+    const availableWorkers = getAvailableWorkerLoads(state);
+    if (availableWorkers.length === 0) {
+      throw new Error("No available workers for load-balanced routing");
+    }
+    const targetWorker = availableWorkers[0];
+    const avgWorkload = availableWorkers.reduce((sum, worker) => sum + worker.workload, 0) / availableWorkers.length;
+    const confidence = targetWorker.workload === 0 ? 1 : Math.max(0.5, 1 - targetWorker.workload / (avgWorkload * 2));
     return {
-      targetAgent: decision.targetAgent,
-      targetAgents: decision.targetAgents,
-      reasoning: decision.reasoning,
-      confidence: decision.confidence,
-      strategy: "llm-based",
+      targetAgent: targetWorker.id,
+      targetAgents: null,
+      reasoning: `Lowest workload: ${targetWorker.workload} tasks (avg: ${avgWorkload.toFixed(1)})`,
+      confidence,
+      strategy: "load-balanced",
       timestamp: Date.now()
     };
   }
 };
+
+// src/multi-agent/routing-internal/worker-selection.ts
+function getAvailableWorkerIds(state) {
+  return Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id]) => id);
+}
+function getTaskContent(state) {
+  const lastMessage = state.messages[state.messages.length - 1];
+  return String(lastMessage?.content || state.input);
+}
+
+// src/multi-agent/routing-internal/round-robin-routing.ts
+function createRoundRobinDecision(targetAgent, position, workerCount) {
+  return {
+    targetAgent,
+    targetAgents: null,
+    reasoning: `Round-robin selection: worker ${position} of ${workerCount}`,
+    confidence: 1,
+    strategy: "round-robin",
+    timestamp: Date.now()
+  };
+}
 var roundRobinRouting = {
   name: "round-robin",
-  async route(state, config) {
-    const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id]) => id);
+  async route(state, _config) {
+    const availableWorkers = getAvailableWorkerIds(state);
     if (availableWorkers.length === 0) {
       throw new Error("No available workers for round-robin routing");
     }
     const lastRoutingIndex = state.routingHistory.length % availableWorkers.length;
-    const targetAgent = availableWorkers[lastRoutingIndex];
+    return createRoundRobinDecision(
+      availableWorkers[lastRoutingIndex],
+      lastRoutingIndex + 1,
+      availableWorkers.length
+    );
+  }
+};
+
+// src/multi-agent/routing-internal/rule-based-routing.ts
+var ruleBasedRouting = {
+  name: "rule-based",
+  async route(state, config) {
+    if (!config.routingFn) {
+      throw new Error("Rule-based routing requires a custom routing function");
+    }
+    return config.routingFn(state);
+  }
+};
+
+// src/multi-agent/routing-internal/skill-based-routing.ts
+function scoreWorkers(state, taskContent) {
+  return Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => {
+    const skillMatches = caps.skills.filter(
+      (skill) => taskContent.includes(skill.toLowerCase())
+    ).length;
+    const toolMatches = caps.tools.filter(
+      (tool) => taskContent.includes(tool.toLowerCase())
+    ).length;
     return {
-      targetAgent,
-      targetAgents: null,
-      reasoning: `Round-robin selection: worker ${lastRoutingIndex + 1} of ${availableWorkers.length}`,
-      confidence: 1,
-      strategy: "round-robin",
-      timestamp: Date.now()
+      id,
+      score: skillMatches * 2 + toolMatches,
+      skills: caps.skills
     };
+  }).filter((worker) => worker.score > 0).sort((a, b) => b.score - a.score);
+}
+function createFallbackDecision(state) {
+  const firstAvailable = Object.entries(state.workers).find(([_, caps]) => caps.available);
+  if (!firstAvailable) {
+    throw new Error("No available workers for skill-based routing");
   }
-};
+  return {
+    targetAgent: firstAvailable[0],
+    targetAgents: null,
+    reasoning: "No skill matches found, using first available worker",
+    confidence: 0.5,
+    strategy: "skill-based",
+    timestamp: Date.now()
+  };
+}
 var skillBasedRouting = {
   name: "skill-based",
-  async route(state, config) {
-    const lastMessage = state.messages[state.messages.length - 1];
-    const taskContent = (lastMessage?.content || state.input).toLowerCase();
-    const workerScores = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => {
-      const skillMatches = caps.skills.filter(
-        (skill) => taskContent.includes(skill.toLowerCase())
-      ).length;
-      const toolMatches = caps.tools.filter(
-        (tool) => taskContent.includes(tool.toLowerCase())
-      ).length;
-      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);
+  async route(state, _config) {
+    const taskContent = getTaskContent(state).toLowerCase();
+    const workerScores = scoreWorkers(state, taskContent);
     if (workerScores.length === 0) {
-      const firstAvailable = Object.entries(state.workers).find(([_, caps]) => caps.available);
-      if (!firstAvailable) {
-        throw new Error("No available workers for skill-based routing");
-      }
-      return {
-        targetAgent: firstAvailable[0],
-        targetAgents: null,
-        reasoning: "No skill matches found, using first available worker",
-        confidence: 0.5,
-        strategy: "skill-based",
-        timestamp: Date.now()
-      };
+      return createFallbackDecision(state);
     }
     const best = workerScores[0];
     const confidence = Math.min(best.score / 5, 1);
@@ -2521,69 +2655,39 @@ var skillBasedRouting = {
     };
   }
 };
-var loadBalancedRouting = {
-  name: "load-balanced",
-  async route(state, config) {
-    const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => ({ id, workload: caps.currentWorkload })).sort((a, b) => a.workload - b.workload);
-    if (availableWorkers.length === 0) {
-      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));
-    return {
-      targetAgent: targetWorker.id,
-      targetAgents: null,
-      reasoning: `Lowest workload: ${targetWorker.workload} tasks (avg: ${avgWorkload.toFixed(1)})`,
-      confidence,
-      strategy: "load-balanced",
-      timestamp: Date.now()
-    };
-  }
-};
-var ruleBasedRouting = {
-  name: "rule-based",
-  async route(state, config) {
-    if (!config.routingFn) {
-      throw new Error("Rule-based routing requires a custom routing function");
-    }
-    return await config.routingFn(state);
-  }
+
+// src/multi-agent/routing.ts
+var routingStrategies = {
+  "llm-based": llmBasedRouting,
+  "round-robin": roundRobinRouting,
+  "skill-based": skillBasedRouting,
+  "load-balanced": loadBalancedRouting,
+  "rule-based": ruleBasedRouting
 };
 function getRoutingStrategy(name) {
-  switch (name) {
-    case "llm-based":
-      return llmBasedRouting;
-    case "round-robin":
-      return roundRobinRouting;
-    case "skill-based":
-      return skillBasedRouting;
-    case "load-balanced":
-      return loadBalancedRouting;
-    case "rule-based":
-      return ruleBasedRouting;
-    default:
-      throw new Error(`Unknown routing strategy: ${name}`);
+  if (!Object.hasOwn(routingStrategies, name)) {
+    throw new Error(`Unknown routing strategy: ${name}`);
   }
+  return routingStrategies[name];
 }
 
 // src/multi-agent/utils.ts
-var logger = createPatternLogger("agentforge:patterns:multi-agent:utils");
-function isRecord(value) {
+var logger2 = createPatternLogger("agentforge:patterns:multi-agent:utils");
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toRunnableConfig(config) {
-  if (!isRecord(config)) {
+  if (!isRecord2(config)) {
     return void 0;
   }
   return config;
 }
 function getReActResultShape(value) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     return {};
   }
-  const messages = Array.isArray(value.messages) ? value.messages.filter((message) => isRecord(message)) : void 0;
-  const actions = Array.isArray(value.actions) ? value.actions.filter((action) => isRecord(action)) : void 0;
+  const messages = Array.isArray(value.messages) ? value.messages.filter((message) => isRecord2(message)) : void 0;
+  const actions = Array.isArray(value.actions) ? value.actions.filter((action) => isRecord2(action)) : void 0;
   return {
     messages,
     actions,
@@ -2602,7 +2706,7 @@ function safeSerializeContent(content) {
       if (typeof part === "string") {
         return part;
       }
-      if (isRecord(part) && typeof part.text === "string" && part.text.length > 0) {
+      if (isRecord2(part) && typeof part.text === "string" && part.text.length > 0) {
         return part.text;
       }
       try {
@@ -2647,17 +2751,17 @@ function isReActAgent(obj) {
 function wrapReActAgent(workerId, agent, verbose = false) {
   return async (state, config) => {
     try {
-      logger.debug("Wrapping ReAct agent execution", { workerId });
+      logger2.debug("Wrapping ReAct agent execution", { workerId });
       const runnableConfig = toRunnableConfig(config);
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === workerId && !state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
       );
       if (!currentAssignment) {
-        logger.debug("No active assignment found", { workerId });
+        logger2.debug("No active assignment found", { workerId });
         return {};
       }
       const task = currentAssignment.task;
-      logger.debug("Extracted task from assignment", {
+      logger2.debug("Extracted task from assignment", {
         workerId,
         assignmentId: currentAssignment.id,
         taskPreview: task.substring(0, 100) + (task.length > 100 ? "..." : "")
@@ -2670,7 +2774,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
           thread_id: workerThreadId
         }
       } : runnableConfig;
-      logger.debug("Invoking ReAct agent with worker-specific config", {
+      logger2.debug("Invoking ReAct agent with worker-specific config", {
         workerId,
         ...runnableConfig?.configurable?.thread_id !== void 0 ? { parentThreadId: String(runnableConfig.configurable.thread_id) } : {},
         ...workerThreadId ? { workerThreadId } : {},
@@ -2685,13 +2789,13 @@ function wrapReActAgent(workerId, agent, verbose = false) {
       );
       const resultShape = getReActResultShape(result);
       const response = extractResponse(resultShape);
-      logger.debug("Received response from ReAct agent", {
+      logger2.debug("Received response from ReAct agent", {
         workerId,
         responsePreview: response.substring(0, 100) + (response.length > 100 ? "..." : "")
       });
       const uniqueTools = extractToolsUsed(resultShape);
       if (uniqueTools.length > 0) {
-        logger.debug("Tools used by ReAct agent", { workerId, tools: uniqueTools });
+        logger2.debug("Tools used by ReAct agent", { workerId, tools: uniqueTools });
       }
       const taskResult = {
         assignmentId: currentAssignment.id,
@@ -2710,7 +2814,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
       };
     } catch (error) {
       const errorMessage = handleNodeError(error, `react-agent:${workerId}`, verbose);
-      logger.error("Error in ReAct agent execution", {
+      logger2.error("Error in ReAct agent execution", {
         workerId,
         error: errorMessage
       });
@@ -2743,7 +2847,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
 // src/multi-agent/nodes/shared.ts
 var import_messages6 = require("@langchain/core/messages");
 var import_core8 = require("@agentforge/core");
-var logger2 = createPatternLogger("agentforge:patterns:multi-agent:nodes");
+var logger3 = createPatternLogger("agentforge:patterns:multi-agent:nodes");
 function createGeneratedId(prefix) {
   return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
 }
@@ -2795,7 +2899,7 @@ function serializeModelContent(content) {
       const error = new Error(
         "Failed to serialize model content: JSON.stringify returned undefined"
       );
-      logger2.error("Model content serialization failed", {
+      logger3.error("Model content serialization failed", {
         errorMessage: error.message,
         contentType: content === null ? "null" : typeof content
       });
@@ -2804,7 +2908,7 @@ function serializeModelContent(content) {
     return serialized;
   } catch (error) {
     const normalizedError = error instanceof Error ? error : new Error("Unknown error during model content serialization");
-    logger2.error("Model content serialization threw an error", {
+    logger3.error("Model content serialization threw an error", {
       errorMessage: normalizedError.message,
       contentType: content === null ? "null" : typeof content
     });
@@ -2847,16 +2951,16 @@ function createAggregatorNode(config = {}) {
   } = config;
   return async (state) => {
     try {
-      logger2.info("Aggregator node executing", {
+      logger3.info("Aggregator node executing", {
         completedTasks: state.completedTasks.length,
         successfulTasks: state.completedTasks.filter((task) => task.success).length,
         failedTasks: state.completedTasks.filter((task) => !task.success).length
       });
-      logger2.debug("Combining results from workers");
+      logger3.debug("Combining results from workers");
       if (aggregateFn) {
-        logger2.debug("Using custom aggregation function");
+        logger3.debug("Using custom aggregation function");
         const response2 = await aggregateFn(state);
-        logger2.info("Custom aggregation complete", {
+        logger3.info("Custom aggregation complete", {
           responseLength: response2.length
         });
         return {
@@ -2865,16 +2969,16 @@ function createAggregatorNode(config = {}) {
         };
       }
       if (state.completedTasks.length === 0) {
-        logger2.warn("No completed tasks to aggregate");
+        logger3.warn("No completed tasks to aggregate");
         return {
           response: "No tasks were completed.",
           status: "completed"
         };
       }
       if (!model) {
-        logger2.debug("No model provided, concatenating results");
+        logger3.debug("No model provided, concatenating results");
         const combinedResults = state.completedTasks.filter((task) => task.success).map((task) => task.result).join("\n\n");
-        logger2.info("Simple concatenation complete", {
+        logger3.info("Simple concatenation complete", {
           resultLength: combinedResults.length
         });
         return {
@@ -2882,27 +2986,27 @@ function createAggregatorNode(config = {}) {
           status: "completed"
         };
       }
-      logger2.debug("Using LLM for intelligent aggregation", {
+      logger3.debug("Using LLM for intelligent aggregation", {
         taskCount: state.completedTasks.length
       });
       const messages = createPromptMessages(systemPrompt, createAggregationPrompt(state));
-      logger2.debug("Invoking aggregation LLM");
+      logger3.debug("Invoking aggregation LLM");
       const response = await model.invoke(messages);
       const aggregatedResponse = serializeModelContent(response.content);
-      logger2.info("Aggregation complete", {
+      logger3.info("Aggregation complete", {
         responseLength: aggregatedResponse.length
       });
-      logger2.debug("Aggregation response details", {
+      logger3.debug("Aggregation response details", {
         responseLength: aggregatedResponse.length
       });
-      logger2.debug("Aggregation complete");
+      logger3.debug("Aggregation complete");
       return {
         response: aggregatedResponse,
         status: "completed"
       };
     } catch (error) {
       const errorMessage = handleNodeError(error, "aggregator", false);
-      logger2.error("Aggregator node error", {
+      logger3.error("Aggregator node error", {
         error: errorMessage,
         ...error instanceof Error && error.stack ? { stack: error.stack } : {},
         completedTasks: state.completedTasks.length
@@ -2926,7 +3030,7 @@ function incrementAssignedWorkerLoads(state, assignments) {
   for (const assignment of assignments) {
     const worker = updatedWorkers[assignment.workerId];
     if (!worker) {
-      logger2.error("Worker not found in state", {
+      logger3.error("Worker not found in state", {
         workerId: assignment.workerId,
         availableWorkers: Object.keys(updatedWorkers)
       });
@@ -2945,45 +3049,45 @@ function createSupervisorNode(config) {
   const { strategy, maxIterations = 10 } = config;
   return async (state) => {
     try {
-      logger2.info("Supervisor node executing", {
+      logger3.info("Supervisor node executing", {
         iteration: state.iteration,
         maxIterations,
         activeAssignments: state.activeAssignments.length,
         completedTasks: state.completedTasks.length
       });
-      logger2.debug(`Routing iteration ${state.iteration}/${maxIterations}`);
+      logger3.debug(`Routing iteration ${state.iteration}/${maxIterations}`);
       if (state.iteration >= maxIterations) {
-        logger2.warn("Max iterations reached", {
+        logger3.warn("Max iterations reached", {
           iteration: state.iteration,
           maxIterations
         });
-        logger2.debug("Max iterations reached, moving to aggregation");
+        logger3.debug("Max iterations reached, moving to aggregation");
         return {
           status: "aggregating",
           currentAgent: "aggregator"
         };
       }
       const allCompleted = allAssignmentsCompleted(state);
-      logger2.debug("Checking task completion", {
+      logger3.debug("Checking task completion", {
         activeAssignments: state.activeAssignments.length,
         completedTasks: state.completedTasks.length,
         allCompleted
       });
       if (allCompleted && state.activeAssignments.length > 0) {
-        logger2.info("All tasks completed, moving to aggregation", {
+        logger3.info("All tasks completed, moving to aggregation", {
           completedCount: state.completedTasks.length
         });
-        logger2.debug("All tasks completed, moving to aggregation");
+        logger3.debug("All tasks completed, moving to aggregation");
         return {
           status: "aggregating",
           currentAgent: "aggregator"
         };
       }
-      logger2.debug("Getting routing strategy", { strategy });
+      logger3.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] : [];
-      logger2.debug("Target agents determined", {
+      logger3.debug("Target agents determined", {
         targetAgents,
         isParallel: targetAgents.length > 1,
         decision: {
@@ -2992,30 +3096,30 @@ function createSupervisorNode(config) {
         }
       });
       if (targetAgents.length === 0) {
-        logger2.error("No target agents specified in routing decision");
+        logger3.error("No target agents specified in routing decision");
         throw new Error("Routing decision must specify at least one target agent");
       }
       if (targetAgents.length === 1) {
-        logger2.info("Routing to single agent", {
+        logger3.info("Routing to single agent", {
           targetAgent: targetAgents[0],
           reasoning: decision.reasoning,
           confidence: decision.confidence
         });
-        logger2.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
+        logger3.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
       } else {
-        logger2.info("Routing to multiple agents in parallel", {
+        logger3.info("Routing to multiple agents in parallel", {
           targetAgents,
           count: targetAgents.length,
           reasoning: decision.reasoning,
           confidence: decision.confidence
         });
-        logger2.debug(
+        logger3.debug(
           `Routing to ${targetAgents.length} agents in parallel [${targetAgents.join(", ")}]: ${decision.reasoning}`
         );
       }
       const task = getLatestTaskContent(state);
       const assignments = createTaskAssignments(targetAgents, task);
-      logger2.debug("Created task assignments", {
+      logger3.debug("Created task assignments", {
         assignmentCount: assignments.length,
         assignments: assignments.map((assignment) => ({
           id: assignment.id,
@@ -3025,7 +3129,7 @@ function createSupervisorNode(config) {
       });
       const messages = createAssignmentMessages(assignments);
       const updatedWorkers = incrementAssignedWorkerLoads(state, assignments);
-      logger2.info("Supervisor routing complete", {
+      logger3.info("Supervisor routing complete", {
         currentAgent: targetAgents.join(","),
         status: "executing",
         assignmentCount: assignments.length,
@@ -3043,7 +3147,7 @@ function createSupervisorNode(config) {
       };
     } catch (error) {
       const errorMessage = handleNodeError(error, "supervisor", false);
-      logger2.error("Supervisor node error", {
+      logger3.error("Supervisor node error", {
         error: errorMessage,
         ...error instanceof Error && error.stack ? { stack: error.stack } : {},
         iteration: state.iteration
@@ -3071,7 +3175,7 @@ async function invokeWorkerModel(model, config, assignment) {
   );
   let modelToUse = model;
   if (config.tools && config.tools.length > 0 && model.bindTools) {
-    logger2.debug("Binding tools to model", {
+    logger3.debug("Binding tools to model", {
       workerId: config.id,
       toolCount: config.tools.length,
       toolNames: config.tools.map((tool) => tool.metadata.name)
@@ -3080,15 +3184,15 @@ async function invokeWorkerModel(model, config, assignment) {
       convertWorkerToolsForLangChain(config.tools)
     );
   }
-  logger2.debug("Invoking LLM", { workerId: config.id });
+  logger3.debug("Invoking LLM", { workerId: config.id });
   const response = await modelToUse.invoke(messages);
   const result = serializeModelContent(response.content);
-  logger2.info("Worker task completed", {
+  logger3.info("Worker task completed", {
     workerId: config.id,
     assignmentId: assignment.id,
     resultLength: result.length
   });
-  logger2.debug("Worker result details", {
+  logger3.debug("Worker result details", {
     workerId: config.id,
     assignmentId: assignment.id,
     resultLength: result.length
@@ -3123,7 +3227,7 @@ async function invokeWorkerModel(model, config, assignment) {
 function getStateWorkerOrThrow(state, workerId) {
   const currentWorker = state.workers[workerId];
   if (!currentWorker) {
-    logger2.error("Attempted to decrement workload for unknown worker", {
+    logger3.error("Attempted to decrement workload for unknown worker", {
       workerId,
       availableWorkers: Object.keys(state.workers)
     });
@@ -3139,7 +3243,7 @@ function resolvePreviousWorkload(workerId, currentWorker, workerFromExecution) {
   if (typeof currentWorker.currentWorkload === "number" && Number.isFinite(currentWorker.currentWorkload)) {
     return currentWorker.currentWorkload;
   }
-  logger2.error("Worker workload is not a valid number; cannot decrement", {
+  logger3.error("Worker workload is not a valid number; cannot decrement", {
     workerId,
     workloadFromState: currentWorker.currentWorkload,
     ...typeof workloadFromWorker === "number" ? { workloadFromWorker } : {}
@@ -3174,7 +3278,7 @@ function mergeWorkersWithDecrement(state, workerId, executionResult) {
     ...baseWorkers,
     [workerId]: updatedWorker
   };
-  logger2.debug("Worker workload decremented", {
+  logger3.debug("Worker workload decremented", {
     workerId,
     previousWorkload,
     newWorkload: updatedWorkers[workerId].currentWorkload,
@@ -3192,7 +3296,7 @@ function decrementWorkerOnError(state, workerId) {
       currentWorkload: Math.max(0, previousWorkload - 1)
     }
   };
-  logger2.debug("Worker workload decremented (error path)", {
+  logger3.debug("Worker workload decremented (error path)", {
     workerId,
     previousWorkload,
     newWorkload: updatedWorkers[workerId].currentWorkload
@@ -3200,7 +3304,7 @@ function decrementWorkerOnError(state, workerId) {
   return updatedWorkers;
 }
 function createErrorTaskResult(assignment, workerId, errorMessage) {
-  logger2.warn("Creating error result for assignment", {
+  logger3.warn("Creating error result for assignment", {
     workerId,
     assignmentId: assignment.id
   });
@@ -3217,47 +3321,47 @@ function createWorkerNode(config) {
   const { id, model, executeFn, agent } = config;
   return async (state, runConfig) => {
     try {
-      logger2.info("Worker node executing", {
+      logger3.info("Worker node executing", {
         workerId: id,
         iteration: state.iteration,
         activeAssignments: state.activeAssignments.length
       });
       const currentAssignment = findCurrentAssignment(state, id);
       if (!currentAssignment) {
-        logger2.debug("No active assignment found for worker", {
+        logger3.debug("No active assignment found for worker", {
           workerId: id,
           totalActiveAssignments: state.activeAssignments.length,
           completedTasks: state.completedTasks.length
         });
         return {};
       }
-      logger2.info("Worker processing assignment", {
+      logger3.info("Worker processing assignment", {
         workerId: id,
         assignmentId: currentAssignment.id,
         taskLength: currentAssignment.task.length
       });
-      logger2.debug("Worker assignment details", {
+      logger3.debug("Worker assignment details", {
         workerId: id,
         assignmentId: currentAssignment.id,
         taskLength: currentAssignment.task.length
       });
       let executionResult;
       if (executeFn) {
-        logger2.debug("Using custom execution function", { workerId: id });
+        logger3.debug("Using custom execution function", { workerId: id });
         executionResult = await executeFn(state, runConfig);
       } else if (agent && isReActAgent(agent)) {
-        logger2.debug("Using ReAct agent", { workerId: id });
+        logger3.debug("Using ReAct agent", { workerId: id });
         const wrappedFn = wrapReActAgent(id, agent, config.verbose ?? false);
         executionResult = await wrappedFn(state, runConfig);
       } else if (model) {
-        logger2.debug("Using default LLM execution", {
+        logger3.debug("Using default LLM execution", {
           workerId: id,
           hasTools: (config.tools ?? []).length > 0,
           toolCount: (config.tools ?? []).length
         });
         executionResult = await invokeWorkerModel(model, config, currentAssignment);
       } else {
-        logger2.error("Worker missing required configuration", { workerId: id });
+        logger3.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`
         );
@@ -3269,7 +3373,7 @@ function createWorkerNode(config) {
       };
     } catch (error) {
       const errorMessage = handleNodeError(error, `worker:${id}`, false);
-      logger2.error("Worker node error", {
+      logger3.error("Worker node error", {
         workerId: id,
         error: errorMessage
       });
@@ -3278,7 +3382,7 @@ function createWorkerNode(config) {
         updatedWorkers = decrementWorkerOnError(state, id);
       } catch (workloadError) {
         const workloadErrorMessage = workloadError instanceof Error ? workloadError.message : String(workloadError);
-        logger2.error("Worker error handling failed", {
+        logger3.error("Worker error handling failed", {
           workerId: id,
           error: workloadErrorMessage
         });
@@ -3298,7 +3402,7 @@ function createWorkerNode(config) {
           workers: updatedWorkers
         };
       }
-      logger2.error("No assignment found for error handling", { workerId: id });
+      logger3.error("No assignment found for error handling", { workerId: id });
       return {
         status: "failed",
         error: errorMessage,
@@ -3310,7 +3414,7 @@ function createWorkerNode(config) {
 
 // src/multi-agent/agent.ts
 var import_langgraph4 = require("@langchain/langgraph");
-var logger3 = createPatternLogger("agentforge:patterns:multi-agent:system");
+var logger4 = createPatternLogger("agentforge:patterns:multi-agent:system");
 function getToolName(tool) {
   if (!tool || typeof tool !== "object") {
     return "unknown";
@@ -3335,13 +3439,6 @@ function createMultiAgentSystem(config) {
   } = config;
   const workflow = new import_langgraph4.StateGraph(MultiAgentState);
   const supervisorConfig = { ...supervisor, maxIterations, verbose };
-  if (supervisor.model) {
-    let configuredModel = supervisor.model;
-    if (supervisor.strategy === "llm-based") {
-      configuredModel = configuredModel.withStructuredOutput(RoutingDecisionSchema);
-    }
-    supervisorConfig.model = configuredModel;
-  }
   const supervisorNode = createSupervisorNode(supervisorConfig);
   workflow.addNode("supervisor", supervisorNode);
   const workerIds = [];
@@ -3361,46 +3458,46 @@ function createMultiAgentSystem(config) {
   });
   workflow.addNode("aggregator", aggregatorNode);
   const supervisorRouter = (state) => {
-    logger3.debug("Supervisor router executing", {
+    logger4.debug("Supervisor router executing", {
       status: state.status,
       ...state.currentAgent ? { currentAgent: state.currentAgent } : {},
       iteration: state.iteration
     });
     if (state.status === "completed" || state.status === "failed") {
-      logger3.info("Supervisor router: ending workflow", { status: state.status });
+      logger4.info("Supervisor router: ending workflow", { status: state.status });
       return import_langgraph4.END;
     }
     if (state.status === "aggregating") {
-      logger3.info("Supervisor router: routing to aggregator");
+      logger4.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());
-        logger3.info("Supervisor router: parallel routing", {
+        logger4.info("Supervisor router: parallel routing", {
           agents,
           count: agents.length
         });
         return agents;
       }
-      logger3.info("Supervisor router: single agent routing", {
+      logger4.info("Supervisor router: single agent routing", {
         targetAgent: state.currentAgent
       });
       return state.currentAgent;
     }
-    logger3.debug("Supervisor router: staying at supervisor");
+    logger4.debug("Supervisor router: staying at supervisor");
     return "supervisor";
   };
   const workerRouter = (state) => {
-    logger3.debug("Worker router executing", {
+    logger4.debug("Worker router executing", {
       iteration: state.iteration,
       completedTasks: state.completedTasks.length
     });
-    logger3.debug("Worker router: returning to supervisor");
+    logger4.debug("Worker router: returning to supervisor");
     return "supervisor";
   };
   const aggregatorRouter = (state) => {
-    logger3.info("Aggregator router: ending workflow", {
+    logger4.info("Aggregator router: ending workflow", {
       completedTasks: state.completedTasks.length,
       status: state.status
     });