@agentforge/patterns 0.16.32 → 0.16.34

package/dist/index.cjs

@@ -2391,9 +2391,41 @@ 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:
+1. Analyze the current task and context
+2. Review available worker capabilities
+3. Select the most appropriate worker(s) for the task
+4. Provide clear reasoning for your decision
+
+**IMPORTANT: You can route to MULTIPLE workers for parallel execution when:**
+- The task requires information from multiple domains (e.g., code + documentation)
+- Multiple workers have complementary expertise
+- Parallel execution would provide a more comprehensive answer
+
+**Response Format:**
+
+For SINGLE worker routing:
+{
+  "targetAgent": "worker_id",
+  "reasoning": "explanation of why this worker is best suited",
+  "confidence": 0.0-1.0,
+  "strategy": "llm-based"
+}
+
+For PARALLEL multi-worker routing:
+{
+  "targetAgents": ["worker_id_1", "worker_id_2", ...],
+  "reasoning": "explanation of why these workers should work in parallel",
+  "confidence": 0.0-1.0,
+  "strategy": "llm-based"
+}
+
+Choose parallel routing when the task benefits from multiple perspectives or data sources.`;
 function hasStructuredOutput(model) {
   return typeof model.withStructuredOutput === "function";
 }
@@ -2449,58 +2481,29 @@ function finalizeLlmRoutingDecision(decision) {
     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)) {
-    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);
+    return invokeStructuredRoutingDecision(model, messages);
   }
   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:
-1. Analyze the current task and context
-2. Review available worker capabilities
-3. Select the most appropriate worker(s) for the task
-4. Provide clear reasoning for your decision
-
-**IMPORTANT: You can route to MULTIPLE workers for parallel execution when:**
-- The task requires information from multiple domains (e.g., code + documentation)
-- Multiple workers have complementary expertise
-- Parallel execution would provide a more comprehensive answer
-
-**Response Format:**
-
-For SINGLE worker routing:
-{
-  "targetAgent": "worker_id",
-  "reasoning": "explanation of why this worker is best suited",
-  "confidence": 0.0-1.0,
-  "strategy": "llm-based"
-}
-
-For PARALLEL multi-worker routing:
-{
-  "targetAgents": ["worker_id_1", "worker_id_2", ...],
-  "reasoning": "explanation of why these workers should work in parallel",
-  "confidence": 0.0-1.0,
-  "strategy": "llm-based"
-}
-
-Choose parallel routing when the task benefits from multiple perspectives or data sources.`;
 var llmBasedRouting = {
   name: "llm-based",
   async route(state, config) {
@@ -2526,56 +2529,119 @@ Select the best worker(s) for this task and explain your reasoning.`;
       new import_messages5.SystemMessage(systemPrompt),
       new import_messages5.HumanMessage(userPrompt)
     ];
-    return await invokeRoutingDecision(config.model, 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: 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);
+    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);
+    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);
@@ -2589,50 +2655,20 @@ 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

package/dist/index.d.cts

@@ -3387,37 +3387,29 @@ interface RoutingStrategyImpl {
     route: (state: MultiAgentStateType, config: SupervisorConfig) => Promise<RoutingDecision>;
 }
 
-/**
- * Default system prompt for LLM-based routing
- */
 declare const DEFAULT_SUPERVISOR_SYSTEM_PROMPT = "You are a supervisor agent responsible for routing tasks to specialized worker agents.\n\nYour job is to:\n1. Analyze the current task and context\n2. Review available worker capabilities\n3. Select the most appropriate worker(s) for the task\n4. Provide clear reasoning for your decision\n\n**IMPORTANT: You can route to MULTIPLE workers for parallel execution when:**\n- The task requires information from multiple domains (e.g., code + documentation)\n- Multiple workers have complementary expertise\n- Parallel execution would provide a more comprehensive answer\n\n**Response Format:**\n\nFor SINGLE worker routing:\n{\n  \"targetAgent\": \"worker_id\",\n  \"reasoning\": \"explanation of why this worker is best suited\",\n  \"confidence\": 0.0-1.0,\n  \"strategy\": \"llm-based\"\n}\n\nFor PARALLEL multi-worker routing:\n{\n  \"targetAgents\": [\"worker_id_1\", \"worker_id_2\", ...],\n  \"reasoning\": \"explanation of why these workers should work in parallel\",\n  \"confidence\": 0.0-1.0,\n  \"strategy\": \"llm-based\"\n}\n\nChoose parallel routing when the task benefits from multiple perspectives or data sources.";
-/**
- * LLM-based routing strategy
- * Uses an LLM to intelligently route tasks based on worker capabilities
- */
 declare const llmBasedRouting: RoutingStrategyImpl;
-/**
- * Round-robin routing strategy
- * Distributes tasks evenly across all available workers
- */
+
+declare const loadBalancedRouting: RoutingStrategyImpl;
+
 declare const roundRobinRouting: RoutingStrategyImpl;
-/**
- * Skill-based routing strategy
- * Routes tasks to workers based on matching skills
- */
+
+declare const ruleBasedRouting: RoutingStrategyImpl;
+
 declare const skillBasedRouting: RoutingStrategyImpl;
+
 /**
- * Load-balanced routing strategy
- * Routes tasks to workers with the lowest current workload
- */
-declare const loadBalancedRouting: RoutingStrategyImpl;
-/**
- * Rule-based routing strategy
- * Uses custom routing function provided in config
+ * Routing Strategy Implementations for Multi-Agent Pattern
+ *
+ * This module is the thin public facade for multi-agent routing strategies.
+ * Concrete strategy logic lives in focused internal modules so behavior can be
+ * reviewed and extended without one oversized implementation file.
+ *
+ * @module patterns/multi-agent/routing
  */
-declare const ruleBasedRouting: RoutingStrategyImpl;
+
 /**
- * Get routing strategy implementation by name
+ * Get routing strategy implementation by name.
  */
 declare function getRoutingStrategy(name: string): RoutingStrategyImpl;
 

package/dist/index.d.ts

@@ -3387,37 +3387,29 @@ interface RoutingStrategyImpl {
     route: (state: MultiAgentStateType, config: SupervisorConfig) => Promise<RoutingDecision>;
 }
 
-/**
- * Default system prompt for LLM-based routing
- */
 declare const DEFAULT_SUPERVISOR_SYSTEM_PROMPT = "You are a supervisor agent responsible for routing tasks to specialized worker agents.\n\nYour job is to:\n1. Analyze the current task and context\n2. Review available worker capabilities\n3. Select the most appropriate worker(s) for the task\n4. Provide clear reasoning for your decision\n\n**IMPORTANT: You can route to MULTIPLE workers for parallel execution when:**\n- The task requires information from multiple domains (e.g., code + documentation)\n- Multiple workers have complementary expertise\n- Parallel execution would provide a more comprehensive answer\n\n**Response Format:**\n\nFor SINGLE worker routing:\n{\n  \"targetAgent\": \"worker_id\",\n  \"reasoning\": \"explanation of why this worker is best suited\",\n  \"confidence\": 0.0-1.0,\n  \"strategy\": \"llm-based\"\n}\n\nFor PARALLEL multi-worker routing:\n{\n  \"targetAgents\": [\"worker_id_1\", \"worker_id_2\", ...],\n  \"reasoning\": \"explanation of why these workers should work in parallel\",\n  \"confidence\": 0.0-1.0,\n  \"strategy\": \"llm-based\"\n}\n\nChoose parallel routing when the task benefits from multiple perspectives or data sources.";
-/**
- * LLM-based routing strategy
- * Uses an LLM to intelligently route tasks based on worker capabilities
- */
 declare const llmBasedRouting: RoutingStrategyImpl;
-/**
- * Round-robin routing strategy
- * Distributes tasks evenly across all available workers
- */
+
+declare const loadBalancedRouting: RoutingStrategyImpl;
+
 declare const roundRobinRouting: RoutingStrategyImpl;
-/**
- * Skill-based routing strategy
- * Routes tasks to workers based on matching skills
- */
+
+declare const ruleBasedRouting: RoutingStrategyImpl;
+
 declare const skillBasedRouting: RoutingStrategyImpl;
+
 /**
- * Load-balanced routing strategy
- * Routes tasks to workers with the lowest current workload
- */
-declare const loadBalancedRouting: RoutingStrategyImpl;
-/**
- * Rule-based routing strategy
- * Uses custom routing function provided in config
+ * Routing Strategy Implementations for Multi-Agent Pattern
+ *
+ * This module is the thin public facade for multi-agent routing strategies.
+ * Concrete strategy logic lives in focused internal modules so behavior can be
+ * reviewed and extended without one oversized implementation file.
+ *
+ * @module patterns/multi-agent/routing
  */
-declare const ruleBasedRouting: RoutingStrategyImpl;
+
 /**
- * Get routing strategy implementation by name
+ * Get routing strategy implementation by name.
  */
 declare function getRoutingStrategy(name: string): RoutingStrategyImpl;
 

package/dist/index.js

@@ -2293,9 +2293,41 @@ var MultiAgentStateConfig = {
 };
 var MultiAgentState = createStateAnnotation4(MultiAgentStateConfig);
 
-// src/multi-agent/routing.ts
+// src/multi-agent/routing-internal/llm-routing.ts
 import { HumanMessage as HumanMessage5, SystemMessage as SystemMessage5 } from "@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:
+1. Analyze the current task and context
+2. Review available worker capabilities
+3. Select the most appropriate worker(s) for the task
+4. Provide clear reasoning for your decision
+
+**IMPORTANT: You can route to MULTIPLE workers for parallel execution when:**
+- The task requires information from multiple domains (e.g., code + documentation)
+- Multiple workers have complementary expertise
+- Parallel execution would provide a more comprehensive answer
+
+**Response Format:**
+
+For SINGLE worker routing:
+{
+  "targetAgent": "worker_id",
+  "reasoning": "explanation of why this worker is best suited",
+  "confidence": 0.0-1.0,
+  "strategy": "llm-based"
+}
+
+For PARALLEL multi-worker routing:
+{
+  "targetAgents": ["worker_id_1", "worker_id_2", ...],
+  "reasoning": "explanation of why these workers should work in parallel",
+  "confidence": 0.0-1.0,
+  "strategy": "llm-based"
+}
+
+Choose parallel routing when the task benefits from multiple perspectives or data sources.`;
 function hasStructuredOutput(model) {
   return typeof model.withStructuredOutput === "function";
 }
@@ -2351,58 +2383,29 @@ function finalizeLlmRoutingDecision(decision) {
     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)) {
-    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);
+    return invokeStructuredRoutingDecision(model, messages);
   }
   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:
-1. Analyze the current task and context
-2. Review available worker capabilities
-3. Select the most appropriate worker(s) for the task
-4. Provide clear reasoning for your decision
-
-**IMPORTANT: You can route to MULTIPLE workers for parallel execution when:**
-- The task requires information from multiple domains (e.g., code + documentation)
-- Multiple workers have complementary expertise
-- Parallel execution would provide a more comprehensive answer
-
-**Response Format:**
-
-For SINGLE worker routing:
-{
-  "targetAgent": "worker_id",
-  "reasoning": "explanation of why this worker is best suited",
-  "confidence": 0.0-1.0,
-  "strategy": "llm-based"
-}
-
-For PARALLEL multi-worker routing:
-{
-  "targetAgents": ["worker_id_1", "worker_id_2", ...],
-  "reasoning": "explanation of why these workers should work in parallel",
-  "confidence": 0.0-1.0,
-  "strategy": "llm-based"
-}
-
-Choose parallel routing when the task benefits from multiple perspectives or data sources.`;
 var llmBasedRouting = {
   name: "llm-based",
   async route(state, config) {
@@ -2428,56 +2431,119 @@ Select the best worker(s) for this task and explain your reasoning.`;
       new SystemMessage5(systemPrompt),
       new HumanMessage5(userPrompt)
     ];
-    return await invokeRoutingDecision(config.model, 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: 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);
+    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);
+    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);
@@ -2491,50 +2557,20 @@ 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/patterns",
-  "version": "0.16.32",
+  "version": "0.16.34",
   "description": "Production-ready agent workflow patterns for TypeScript including ReAct and Planner-Executor, built on LangGraph.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,13 +41,13 @@
     "url": "https://github.com/TVScoundrel/agentforge/issues"
   },
   "dependencies": {
-    "@agentforge/core": "0.16.32",
+    "@agentforge/core": "0.16.34",
     "@langchain/core": "^1.1.17",
     "@langchain/langgraph": "^1.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@agentforge/testing": "0.16.32",
+    "@agentforge/testing": "0.16.34",
     "@eslint/js": "^9.17.0",
     "@types/node": "^22.10.2",
     "eslint": "^9.17.0",