@agentforge/patterns 0.16.0 → 0.16.2

package/dist/index.js

@@ -790,7 +790,7 @@ var PlanStepSchema = z4.object({
   /**
    * Optional arguments for the tool
    */
-  args: z4.record(z4.any()).optional().describe("Arguments to pass to the tool")
+  args: z4.record(z4.string(), z4.unknown()).optional().describe("Arguments to pass to the tool")
 });
 var CompletedStepSchema = z4.object({
   /**
@@ -800,7 +800,7 @@ var CompletedStepSchema = z4.object({
   /**
    * The result of executing the step
    */
-  result: z4.any().describe("The result of executing the step"),
+  result: z4.unknown().describe("The result of executing the step"),
   /**
    * Whether the step succeeded
    */
@@ -977,6 +977,9 @@ var REMAINING_STEP_TEMPLATE = `Step {stepNumber}: {description}
 var plannerLogger = createPatternLogger("agentforge:patterns:plan-execute:planner");
 var executorLogger = createPatternLogger("agentforge:patterns:plan-execute:executor");
 var replannerLogger = createPatternLogger("agentforge:patterns:plan-execute:replanner");
+function invokePlanExecuteTool(tool, args) {
+  return tool.invoke.call(tool, args);
+}
 function createPlannerNode(config) {
   const {
     model,
@@ -1044,10 +1047,18 @@ function createExecutorNode(config) {
   const {
     tools,
     model,
-    parallel = false,
+    parallel,
     stepTimeout = 3e4,
     enableDeduplication = true
   } = config;
+  if (typeof model !== "undefined") {
+    executorLogger.warn("ExecutorConfig.model is currently unsupported and will be ignored");
+  }
+  if (typeof parallel !== "undefined") {
+    executorLogger.warn("ExecutorConfig.parallel is currently unsupported and will be ignored", {
+      parallel
+    });
+  }
   return async (state) => {
     const { plan, currentStepIndex = 0, pastSteps = [], iteration = 0 } = state;
     try {
@@ -1124,13 +1135,20 @@ function createExecutorNode(config) {
               throw new Error(`Tool not found: ${currentStep.tool}`);
             }
             const startTime = Date.now();
-            const timeoutPromise = new Promise(
-              (_, reject) => setTimeout(() => reject(new Error("Step execution timeout")), stepTimeout)
-            );
-            result = await Promise.race([
-              tool.invoke(currentStep.args || {}),
-              timeoutPromise
-            ]);
+            let timeoutId;
+            try {
+              const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error("Step execution timeout")), stepTimeout);
+              });
+              result = await Promise.race([
+                invokePlanExecuteTool(tool, currentStep.args || {}),
+                timeoutPromise
+              ]);
+            } finally {
+              if (timeoutId !== void 0) {
+                clearTimeout(timeoutId);
+              }
+            }
             const executionTime = Date.now() - startTime;
             executorLogger.debug("Step executed successfully", {
               stepId: currentStep.id,
@@ -1187,9 +1205,14 @@ function createExecutorNode(config) {
 function createReplannerNode(config) {
   const {
     model,
-    replanThreshold = 0.7,
+    replanThreshold,
     systemPrompt = DEFAULT_REPLANNER_SYSTEM_PROMPT
   } = config;
+  if (typeof replanThreshold !== "undefined") {
+    replannerLogger.warn("ReplannerConfig.replanThreshold is currently unsupported and will be ignored", {
+      replanThreshold
+    });
+  }
   return async (state) => {
     const startTime = Date.now();
     try {
@@ -2558,16 +2581,82 @@ function wrapReActAgent(workerId, agent, verbose = false) {
   };
 }
 
-// src/multi-agent/nodes.ts
+// src/multi-agent/nodes/shared.ts
 import { HumanMessage as HumanMessage5, SystemMessage as SystemMessage5 } from "@langchain/core/messages";
 import { toLangChainTools as toLangChainTools2 } from "@agentforge/core";
 var logger2 = createPatternLogger("agentforge:patterns:multi-agent:nodes");
+function createGeneratedId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function createTaskAssignmentId() {
+  return `task_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function getLatestTaskContent(state) {
+  return state.messages[state.messages.length - 1]?.content || state.input;
+}
+function createTaskAssignments(workerIds, task) {
+  return workerIds.map((workerId) => ({
+    id: createTaskAssignmentId(),
+    workerId,
+    task,
+    priority: 5,
+    assignedAt: Date.now()
+  }));
+}
+function createAssignmentMessages(assignments) {
+  return assignments.map((assignment) => ({
+    id: createGeneratedId("msg"),
+    from: "supervisor",
+    to: [assignment.workerId],
+    type: "task_assignment",
+    content: assignment.task,
+    timestamp: Date.now(),
+    metadata: {
+      assignmentId: assignment.id,
+      priority: assignment.priority
+    }
+  }));
+}
+function findCurrentAssignment(state, workerId) {
+  return state.activeAssignments.find(
+    (assignment) => assignment.workerId === workerId && !state.completedTasks.some((task) => task.assignmentId === assignment.id)
+  );
+}
 function convertWorkerToolsForLangChain(tools) {
   const safeTools = tools ?? [];
-  return toLangChainTools2(
-    safeTools
-  );
+  return toLangChainTools2(safeTools);
 }
+function serializeModelContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  try {
+    const serialized = JSON.stringify(content);
+    if (typeof serialized !== "string") {
+      const error = new Error(
+        "Failed to serialize model content: JSON.stringify returned undefined"
+      );
+      logger2.error("Model content serialization failed", {
+        errorMessage: error.message,
+        contentType: content === null ? "null" : typeof content
+      });
+      throw error;
+    }
+    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", {
+      errorMessage: normalizedError.message,
+      contentType: content === null ? "null" : typeof content
+    });
+    throw normalizedError;
+  }
+}
+function createPromptMessages(systemPrompt, task) {
+  return [new SystemMessage5(systemPrompt), new HumanMessage5(task)];
+}
+
+// src/multi-agent/nodes/aggregator.ts
 var DEFAULT_AGGREGATOR_SYSTEM_PROMPT = `You are an aggregator agent responsible for combining results from multiple worker agents.
 
 Your job is to:
@@ -2577,12 +2666,124 @@ Your job is to:
 4. Provide a clear, comprehensive final answer
 
 Be concise but thorough in your aggregation.`;
-function createSupervisorNode(config) {
+function createAggregationPrompt(state) {
+  const taskResults = state.completedTasks.map((task, idx) => {
+    const status = task.success ? "\u2713" : "\u2717";
+    const result = task.success ? task.result : `Error: ${task.error}`;
+    return `${idx + 1}. [${status}] Worker ${task.workerId}:
+${result}`;
+  }).join("\n\n");
+  return `Original query: ${state.input}
+
+Worker results:
+${taskResults}
+
+Please synthesize these results into a comprehensive response that addresses the original query.`;
+}
+function createAggregatorNode(config = {}) {
   const {
-    strategy,
-    verbose = false,
-    maxIterations = 10
+    model,
+    systemPrompt = DEFAULT_AGGREGATOR_SYSTEM_PROMPT,
+    aggregateFn
   } = config;
+  return async (state) => {
+    try {
+      logger2.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");
+      if (aggregateFn) {
+        logger2.debug("Using custom aggregation function");
+        const response2 = await aggregateFn(state);
+        logger2.info("Custom aggregation complete", {
+          responseLength: response2.length
+        });
+        return {
+          response: response2,
+          status: "completed"
+        };
+      }
+      if (state.completedTasks.length === 0) {
+        logger2.warn("No completed tasks to aggregate");
+        return {
+          response: "No tasks were completed.",
+          status: "completed"
+        };
+      }
+      if (!model) {
+        logger2.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", {
+          resultLength: combinedResults.length
+        });
+        return {
+          response: combinedResults || "No successful results to aggregate.",
+          status: "completed"
+        };
+      }
+      logger2.debug("Using LLM for intelligent aggregation", {
+        taskCount: state.completedTasks.length
+      });
+      const messages = createPromptMessages(systemPrompt, createAggregationPrompt(state));
+      logger2.debug("Invoking aggregation LLM");
+      const response = await model.invoke(messages);
+      const aggregatedResponse = serializeModelContent(response.content);
+      logger2.info("Aggregation complete", {
+        responseLength: aggregatedResponse.length
+      });
+      logger2.debug("Aggregation response details", {
+        responseLength: aggregatedResponse.length
+      });
+      logger2.debug("Aggregation complete");
+      return {
+        response: aggregatedResponse,
+        status: "completed"
+      };
+    } catch (error) {
+      const errorMessage = handleNodeError(error, "aggregator", false);
+      logger2.error("Aggregator node error", {
+        error: errorMessage,
+        ...error instanceof Error && error.stack ? { stack: error.stack } : {},
+        completedTasks: state.completedTasks.length
+      });
+      return {
+        status: "failed",
+        error: errorMessage
+      };
+    }
+  };
+}
+
+// src/multi-agent/nodes/supervisor.ts
+function allAssignmentsCompleted(state) {
+  return state.activeAssignments.every(
+    (assignment) => state.completedTasks.some((task) => task.assignmentId === assignment.id)
+  );
+}
+function incrementAssignedWorkerLoads(state, assignments) {
+  const updatedWorkers = { ...state.workers };
+  for (const assignment of assignments) {
+    const worker = updatedWorkers[assignment.workerId];
+    if (!worker) {
+      logger2.error("Worker not found in state", {
+        workerId: assignment.workerId,
+        availableWorkers: Object.keys(updatedWorkers)
+      });
+      throw new Error(
+        `Worker ${assignment.workerId} not found in state.workers. Available workers: ${Object.keys(updatedWorkers).join(", ")}`
+      );
+    }
+    updatedWorkers[assignment.workerId] = {
+      ...worker,
+      currentWorkload: worker.currentWorkload + 1
+    };
+  }
+  return updatedWorkers;
+}
+function createSupervisorNode(config) {
+  const { strategy, maxIterations = 10 } = config;
   return async (state) => {
     try {
       logger2.info("Supervisor node executing", {
@@ -2603,9 +2804,7 @@ function createSupervisorNode(config) {
           currentAgent: "aggregator"
         };
       }
-      const allCompleted = state.activeAssignments.every(
-        (assignment) => state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
-      );
+      const allCompleted = allAssignmentsCompleted(state);
       logger2.debug("Checking task completion", {
         activeAssignments: state.activeAssignments.length,
         completedTasks: state.completedTasks.length,
@@ -2643,6 +2842,7 @@ function createSupervisorNode(config) {
           reasoning: decision.reasoning,
           confidence: decision.confidence
         });
+        logger2.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
       } else {
         logger2.info("Routing to multiple agents in parallel", {
           targetAgents,
@@ -2650,57 +2850,22 @@ function createSupervisorNode(config) {
           reasoning: decision.reasoning,
           confidence: decision.confidence
         });
+        logger2.debug(
+          `Routing to ${targetAgents.length} agents in parallel [${targetAgents.join(", ")}]: ${decision.reasoning}`
+        );
       }
-      if (targetAgents.length === 1) {
-        logger2.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
-      } else {
-        logger2.debug(`Routing to ${targetAgents.length} agents in parallel [${targetAgents.join(", ")}]: ${decision.reasoning}`);
-      }
-      const task = state.messages[state.messages.length - 1]?.content || state.input;
-      const assignments = targetAgents.map((workerId) => ({
-        id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-        workerId,
-        task,
-        priority: 5,
-        assignedAt: Date.now()
-      }));
+      const task = getLatestTaskContent(state);
+      const assignments = createTaskAssignments(targetAgents, task);
       logger2.debug("Created task assignments", {
         assignmentCount: assignments.length,
-        assignments: assignments.map((a) => ({
-          id: a.id,
-          workerId: a.workerId,
-          taskLength: a.task.length
+        assignments: assignments.map((assignment) => ({
+          id: assignment.id,
+          workerId: assignment.workerId,
+          taskLength: assignment.task.length
         }))
       });
-      const messages = assignments.map((assignment) => ({
-        id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        from: "supervisor",
-        to: [assignment.workerId],
-        type: "task_assignment",
-        content: assignment.task,
-        timestamp: Date.now(),
-        metadata: {
-          assignmentId: assignment.id,
-          priority: assignment.priority
-        }
-      }));
-      const updatedWorkers = { ...state.workers };
-      for (const assignment of assignments) {
-        const worker = updatedWorkers[assignment.workerId];
-        if (!worker) {
-          logger2.error("Worker not found in state", {
-            workerId: assignment.workerId,
-            availableWorkers: Object.keys(updatedWorkers)
-          });
-          throw new Error(
-            `Worker ${assignment.workerId} not found in state.workers. Available workers: ${Object.keys(updatedWorkers).join(", ")}`
-          );
-        }
-        updatedWorkers[assignment.workerId] = {
-          ...worker,
-          currentWorkload: worker.currentWorkload + 1
-        };
-      }
+      const messages = createAssignmentMessages(assignments);
+      const updatedWorkers = incrementAssignedWorkerLoads(state, assignments);
       logger2.info("Supervisor routing complete", {
         currentAgent: targetAgents.join(","),
         status: "executing",
@@ -2710,41 +2875,187 @@ function createSupervisorNode(config) {
       });
       return {
         currentAgent: targetAgents.join(","),
-        // Store all agents (for backward compat)
         status: "executing",
         routingHistory: [decision],
         activeAssignments: assignments,
-        // Multiple assignments for parallel execution!
         messages,
         workers: updatedWorkers,
-        // Include updated workload
-        // Add 1 to iteration counter (uses additive reducer)
         iteration: 1
       };
     } catch (error) {
+      const errorMessage = handleNodeError(error, "supervisor", false);
       logger2.error("Supervisor node error", {
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessage,
         ...error instanceof Error && error.stack ? { stack: error.stack } : {},
         iteration: state.iteration
       });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in supervisor"
+        error: errorMessage
       };
     }
   };
 }
+
+// src/multi-agent/nodes/worker.ts
+function buildDefaultSystemPrompt(config) {
+  return `You are a specialized worker agent with the following capabilities:
+Skills: ${config.capabilities.skills.join(", ")}
+Tools: ${config.capabilities.tools.join(", ")}
+
+Execute the assigned task using your skills and tools. Provide a clear, actionable result.`;
+}
+async function invokeWorkerModel(model, config, assignment) {
+  const messages = createPromptMessages(
+    config.systemPrompt || buildDefaultSystemPrompt(config),
+    assignment.task
+  );
+  let modelToUse = model;
+  if (config.tools && config.tools.length > 0 && model.bindTools) {
+    logger2.debug("Binding tools to model", {
+      workerId: config.id,
+      toolCount: config.tools.length,
+      toolNames: config.tools.map((tool) => tool.metadata.name)
+    });
+    modelToUse = model.bindTools(
+      convertWorkerToolsForLangChain(config.tools)
+    );
+  }
+  logger2.debug("Invoking LLM", { workerId: config.id });
+  const response = await modelToUse.invoke(messages);
+  const result = serializeModelContent(response.content);
+  logger2.info("Worker task completed", {
+    workerId: config.id,
+    assignmentId: assignment.id,
+    resultLength: result.length
+  });
+  logger2.debug("Worker result details", {
+    workerId: config.id,
+    assignmentId: assignment.id,
+    resultLength: result.length
+  });
+  const taskResult = {
+    assignmentId: assignment.id,
+    workerId: config.id,
+    success: true,
+    result,
+    completedAt: Date.now(),
+    metadata: {
+      skills_used: config.capabilities.skills
+    }
+  };
+  const message = {
+    id: createGeneratedId("msg"),
+    from: config.id,
+    to: ["supervisor"],
+    type: "task_result",
+    content: result,
+    timestamp: Date.now(),
+    metadata: {
+      assignmentId: assignment.id,
+      success: true
+    }
+  };
+  return {
+    completedTasks: [taskResult],
+    messages: [message]
+  };
+}
+function getStateWorkerOrThrow(state, workerId) {
+  const currentWorker = state.workers[workerId];
+  if (!currentWorker) {
+    logger2.error("Attempted to decrement workload for unknown worker", {
+      workerId,
+      availableWorkers: Object.keys(state.workers)
+    });
+    throw new Error(`Worker "${workerId}" not found when decrementing workload.`);
+  }
+  return currentWorker;
+}
+function resolvePreviousWorkload(workerId, currentWorker, workerFromExecution) {
+  const workloadFromWorker = workerFromExecution?.currentWorkload;
+  if (typeof workloadFromWorker === "number" && Number.isFinite(workloadFromWorker)) {
+    return workloadFromWorker;
+  }
+  if (typeof currentWorker.currentWorkload === "number" && Number.isFinite(currentWorker.currentWorkload)) {
+    return currentWorker.currentWorkload;
+  }
+  logger2.error("Worker workload is not a valid number; cannot decrement", {
+    workerId,
+    workloadFromState: currentWorker.currentWorkload,
+    ...typeof workloadFromWorker === "number" ? { workloadFromWorker } : {}
+  });
+  throw new Error(
+    `Worker "${workerId}" does not have a valid numeric currentWorkload to decrement.`
+  );
+}
+function mergeWorkersWithDecrement(state, workerId, executionResult) {
+  const currentWorker = getStateWorkerOrThrow(state, workerId);
+  const executionResultWorkers = executionResult.workers || {};
+  const baseWorkers = {
+    ...state.workers,
+    ...executionResultWorkers
+  };
+  const workerFromExecution = executionResultWorkers[workerId];
+  const previousWorkload = resolvePreviousWorkload(
+    workerId,
+    currentWorker,
+    workerFromExecution
+  );
+  const hasWorkerOverride = typeof workerFromExecution === "object" && workerFromExecution !== null;
+  const updatedWorker = hasWorkerOverride ? {
+    ...currentWorker,
+    ...workerFromExecution,
+    currentWorkload: Math.max(0, previousWorkload - 1)
+  } : {
+    ...currentWorker,
+    currentWorkload: Math.max(0, previousWorkload - 1)
+  };
+  const updatedWorkers = {
+    ...baseWorkers,
+    [workerId]: updatedWorker
+  };
+  logger2.debug("Worker workload decremented", {
+    workerId,
+    previousWorkload,
+    newWorkload: updatedWorkers[workerId].currentWorkload,
+    hadExecutionResultWorkers: !!executionResult.workers
+  });
+  return updatedWorkers;
+}
+function decrementWorkerOnError(state, workerId) {
+  const currentWorker = getStateWorkerOrThrow(state, workerId);
+  const previousWorkload = resolvePreviousWorkload(workerId, currentWorker);
+  const updatedWorkers = {
+    ...state.workers,
+    [workerId]: {
+      ...currentWorker,
+      currentWorkload: Math.max(0, previousWorkload - 1)
+    }
+  };
+  logger2.debug("Worker workload decremented (error path)", {
+    workerId,
+    previousWorkload,
+    newWorkload: updatedWorkers[workerId].currentWorkload
+  });
+  return updatedWorkers;
+}
+function createErrorTaskResult(assignment, workerId, errorMessage) {
+  logger2.warn("Creating error result for assignment", {
+    workerId,
+    assignmentId: assignment.id
+  });
+  return {
+    assignmentId: assignment.id,
+    workerId,
+    success: false,
+    result: "",
+    error: errorMessage,
+    completedAt: Date.now()
+  };
+}
 function createWorkerNode(config) {
-  const {
-    id,
-    capabilities,
-    model,
-    tools = [],
-    systemPrompt,
-    verbose = false,
-    executeFn,
-    agent
-  } = config;
+  const { id, model, executeFn, agent } = config;
   return async (state, runConfig) => {
     try {
       logger2.info("Worker node executing", {
@@ -2752,9 +3063,7 @@ function createWorkerNode(config) {
         iteration: state.iteration,
         activeAssignments: state.activeAssignments.length
       });
-      const currentAssignment = state.activeAssignments.find(
-        (assignment) => assignment.workerId === id && !state.completedTasks.some((task) => task.assignmentId === assignment.id)
-      );
+      const currentAssignment = findCurrentAssignment(state, id);
       if (!currentAssignment) {
         logger2.debug("No active assignment found for worker", {
           workerId: id,
@@ -2766,105 +3075,35 @@ function createWorkerNode(config) {
       logger2.info("Worker processing assignment", {
         workerId: id,
         assignmentId: currentAssignment.id,
-        taskLength: currentAssignment.task.length,
-        taskPreview: currentAssignment.task.substring(0, 100)
+        taskLength: currentAssignment.task.length
+      });
+      logger2.debug("Worker assignment details", {
+        workerId: id,
+        assignmentId: currentAssignment.id,
+        taskLength: currentAssignment.task.length
       });
-      async function executeWithLLM() {
-        logger2.debug("Using default LLM execution", {
-          workerId: id,
-          hasTools: tools.length > 0,
-          toolCount: tools.length
-        });
-        const defaultSystemPrompt = `You are a specialized worker agent with the following capabilities:
-Skills: ${capabilities.skills.join(", ")}
-Tools: ${capabilities.tools.join(", ")}
-
-Execute the assigned task using your skills and tools. Provide a clear, actionable result.`;
-        const messages = [
-          new SystemMessage5(systemPrompt || defaultSystemPrompt),
-          new HumanMessage5(currentAssignment.task)
-        ];
-        let modelToUse = model;
-        if (tools.length > 0 && model.bindTools) {
-          logger2.debug("Binding tools to model", {
-            workerId: id,
-            toolCount: tools.length,
-            toolNames: tools.map((t) => t.metadata.name)
-          });
-          const langchainTools = convertWorkerToolsForLangChain(tools);
-          modelToUse = model.bindTools(langchainTools);
-        }
-        logger2.debug("Invoking LLM", { workerId: id });
-        const response = await modelToUse.invoke(messages);
-        const result = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-        logger2.info("Worker task completed", {
-          workerId: id,
-          assignmentId: currentAssignment.id,
-          resultLength: result.length,
-          resultPreview: result.substring(0, 100)
-        });
-        const taskResult = {
-          assignmentId: currentAssignment.id,
-          workerId: id,
-          success: true,
-          result,
-          completedAt: Date.now(),
-          metadata: {
-            skills_used: capabilities.skills
-          }
-        };
-        const message = {
-          id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-          from: id,
-          to: ["supervisor"],
-          type: "task_result",
-          content: result,
-          timestamp: Date.now(),
-          metadata: {
-            assignmentId: currentAssignment.id,
-            success: true
-          }
-        };
-        return {
-          completedTasks: [taskResult],
-          messages: [message]
-        };
-      }
       let executionResult;
       if (executeFn) {
         logger2.debug("Using custom execution function", { workerId: id });
         executionResult = await executeFn(state, runConfig);
       } else if (agent && isReActAgent(agent)) {
         logger2.debug("Using ReAct agent", { workerId: id });
-        const wrappedFn = wrapReActAgent(id, agent, verbose);
+        const wrappedFn = wrapReActAgent(id, agent, config.verbose ?? false);
         executionResult = await wrappedFn(state, runConfig);
       } else if (model) {
-        executionResult = await executeWithLLM();
+        logger2.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 });
         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`
         );
       }
-      const currentWorker = state.workers[id];
-      const baseWorkers = {
-        ...state.workers,
-        ...executionResult.workers || {}
-      };
-      const workerToUpdate = baseWorkers[id] || currentWorker;
-      const updatedWorkers = {
-        ...baseWorkers,
-        [id]: {
-          ...workerToUpdate,
-          currentWorkload: Math.max(0, workerToUpdate.currentWorkload - 1)
-        }
-      };
-      logger2.debug("Worker workload decremented", {
-        workerId: id,
-        previousWorkload: workerToUpdate.currentWorkload,
-        newWorkload: updatedWorkers[id].currentWorkload,
-        hadExecutionResultWorkers: !!executionResult.workers
-      });
+      const updatedWorkers = mergeWorkersWithDecrement(state, id, executionResult);
       return {
         ...executionResult,
         workers: updatedWorkers
@@ -2875,41 +3114,29 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
         workerId: id,
         error: errorMessage
       });
-      const currentWorker = state.workers[id];
-      const updatedWorkers = {
-        ...state.workers,
-        [id]: {
-          ...currentWorker,
-          currentWorkload: Math.max(0, currentWorker.currentWorkload - 1)
-        }
-      };
-      logger2.debug("Worker workload decremented (error path)", {
-        workerId: id,
-        previousWorkload: currentWorker.currentWorkload,
-        newWorkload: updatedWorkers[id].currentWorkload
-      });
+      let updatedWorkers;
+      try {
+        updatedWorkers = decrementWorkerOnError(state, id);
+      } catch (workloadError) {
+        const workloadErrorMessage = workloadError instanceof Error ? workloadError.message : String(workloadError);
+        logger2.error("Worker error handling failed", {
+          workerId: id,
+          error: workloadErrorMessage
+        });
+        return {
+          status: "failed",
+          error: `${errorMessage}. ${workloadErrorMessage}`
+        };
+      }
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === id
       );
       if (currentAssignment) {
-        logger2.warn("Creating error result for assignment", {
-          workerId: id,
-          assignmentId: currentAssignment.id
-        });
-        const errorResult = {
-          assignmentId: currentAssignment.id,
-          workerId: id,
-          success: false,
-          result: "",
-          error: errorMessage,
-          completedAt: Date.now()
-        };
         return {
-          completedTasks: [errorResult],
+          completedTasks: [createErrorTaskResult(currentAssignment, id, errorMessage)],
           currentAgent: "supervisor",
           status: "routing",
           workers: updatedWorkers
-          // Include workload update
         };
       }
       logger2.error("No assignment found for error handling", { workerId: id });
@@ -2917,95 +3144,6 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
         status: "failed",
         error: errorMessage,
         workers: updatedWorkers
-        // Include workload update even on failure
-      };
-    }
-  };
-}
-function createAggregatorNode(config = {}) {
-  const {
-    model,
-    systemPrompt = DEFAULT_AGGREGATOR_SYSTEM_PROMPT,
-    aggregateFn,
-    verbose = false
-  } = config;
-  return async (state) => {
-    try {
-      logger2.info("Aggregator node executing", {
-        completedTasks: state.completedTasks.length,
-        successfulTasks: state.completedTasks.filter((t) => t.success).length,
-        failedTasks: state.completedTasks.filter((t) => !t.success).length
-      });
-      logger2.debug("Combining results from workers");
-      if (aggregateFn) {
-        logger2.debug("Using custom aggregation function");
-        const response2 = await aggregateFn(state);
-        logger2.info("Custom aggregation complete", {
-          responseLength: response2.length
-        });
-        return {
-          response: response2,
-          status: "completed"
-        };
-      }
-      if (state.completedTasks.length === 0) {
-        logger2.warn("No completed tasks to aggregate");
-        return {
-          response: "No tasks were completed.",
-          status: "completed"
-        };
-      }
-      if (!model) {
-        logger2.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", {
-          resultLength: combinedResults.length
-        });
-        return {
-          response: combinedResults || "No successful results to aggregate.",
-          status: "completed"
-        };
-      }
-      logger2.debug("Using LLM for intelligent aggregation", {
-        taskCount: state.completedTasks.length
-      });
-      const taskResults = state.completedTasks.map((task, idx) => {
-        const status = task.success ? "\u2713" : "\u2717";
-        const result = task.success ? task.result : `Error: ${task.error}`;
-        return `${idx + 1}. [${status}] Worker ${task.workerId}:
-${result}`;
-      }).join("\n\n");
-      const userPrompt = `Original query: ${state.input}
-
-Worker results:
-${taskResults}
-
-Please synthesize these results into a comprehensive response that addresses the original query.`;
-      const messages = [
-        new SystemMessage5(systemPrompt),
-        new HumanMessage5(userPrompt)
-      ];
-      logger2.debug("Invoking aggregation LLM");
-      const response = await model.invoke(messages);
-      const aggregatedResponse = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      logger2.info("Aggregation complete", {
-        responseLength: aggregatedResponse.length,
-        responsePreview: aggregatedResponse.substring(0, 100)
-      });
-      logger2.debug("Aggregation complete");
-      return {
-        response: aggregatedResponse,
-        status: "completed"
-      };
-    } catch (error) {
-      logger2.error("Aggregator node error", {
-        error: error instanceof Error ? error.message : String(error),
-        ...error instanceof Error && error.stack ? { stack: error.stack } : {},
-        completedTasks: state.completedTasks.length
-      });
-      return {
-        status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in aggregator"
       };
     }
   };