@agentforge/patterns 0.16.31 → 0.16.32

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);
   }
 }
 
@@ -2393,6 +2393,82 @@ var MultiAgentState = (0, import_core7.createStateAnnotation)(MultiAgentStateCon
 
 // src/multi-agent/routing.ts
 var import_messages5 = require("@langchain/core/messages");
+var logger = createPatternLogger("agentforge:patterns:multi-agent:routing");
+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 invokeRoutingDecision(model, messages) {
+  if (hasStructuredOutput(model)) {
+    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 decision3 = await model.invoke(messages);
+      return finalizeLlmRoutingDecision(decision3);
+    }
+    const decision2 = await structuredModel.invoke(messages);
+    return finalizeLlmRoutingDecision(decision2);
+  }
+  const decision = await model.invoke(messages);
+  return finalizeLlmRoutingDecision(decision);
+}
 var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
 
 Your job is to:
@@ -2450,20 +2526,12 @@ 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 {
-      targetAgent: decision.targetAgent,
-      targetAgents: decision.targetAgents,
-      reasoning: decision.reasoning,
-      confidence: decision.confidence,
-      strategy: "llm-based",
-      timestamp: Date.now()
-    };
+    return await invokeRoutingDecision(config.model, messages);
   }
 };
 var roundRobinRouting = {
   name: "round-robin",
-  async route(state, config) {
+  async route(state, _config) {
     const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id]) => id);
     if (availableWorkers.length === 0) {
       throw new Error("No available workers for round-robin routing");
@@ -2482,7 +2550,7 @@ var roundRobinRouting = {
 };
 var skillBasedRouting = {
   name: "skill-based",
-  async route(state, config) {
+  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]) => {
@@ -2523,7 +2591,7 @@ var skillBasedRouting = {
 };
 var loadBalancedRouting = {
   name: "load-balanced",
-  async route(state, config) {
+  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");
@@ -2568,22 +2636,22 @@ function getRoutingStrategy(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 +2670,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 +2715,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 +2738,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 +2753,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 +2778,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 +2811,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 +2863,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 +2872,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 +2915,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 +2933,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 +2950,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 +2994,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 +3013,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 +3060,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 +3093,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 +3111,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 +3139,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 +3148,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 +3191,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 +3207,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 +3242,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 +3260,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 +3268,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 +3285,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 +3337,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 +3346,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 +3366,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 +3378,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 +3403,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 +3422,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
     });