@agentforge/patterns 0.6.3 → 0.7.0

package/dist/index.cjs

@@ -71,11 +71,14 @@ __export(index_exports, {
   ToolCallSchema: () => ToolCallSchema,
   ToolResultSchema: () => ToolResultSchema,
   WorkerCapabilitiesSchema: () => WorkerCapabilitiesSchema,
+  buildDeduplicationMetrics: () => buildDeduplicationMetrics,
+  calculateDeduplicationSavings: () => calculateDeduplicationSavings,
   createAggregatorNode: () => createAggregatorNode,
   createExecutorNode: () => createExecutorNode,
   createFinisherNode: () => createFinisherNode,
   createGeneratorNode: () => createGeneratorNode,
   createMultiAgentSystem: () => createMultiAgentSystem,
+  createPatternLogger: () => createPatternLogger,
   createPlanExecuteAgent: () => createPlanExecuteAgent,
   createPlannerNode: () => createPlannerNode,
   createReActAgent: () => createReActAgent,
@@ -87,6 +90,7 @@ __export(index_exports, {
   createReviserNode: () => createReviserNode,
   createSupervisorNode: () => createSupervisorNode,
   createWorkerNode: () => createWorkerNode,
+  generateToolCallCacheKey: () => generateToolCallCacheKey,
   getRoutingStrategy: () => getRoutingStrategy,
   llmBasedRouting: () => llmBasedRouting,
   loadBalancedRouting: () => loadBalancedRouting,
@@ -121,7 +125,9 @@ var ToolResultSchema = import_zod.z.object({
   toolCallId: import_zod.z.string(),
   result: import_zod.z.any(),
   error: import_zod.z.string().optional(),
-  timestamp: import_zod.z.number().optional()
+  timestamp: import_zod.z.number().optional(),
+  isDuplicate: import_zod.z.boolean().optional()
+  // Flag indicating this was a duplicate tool call
 });
 var ScratchpadEntrySchema = import_zod.z.object({
   step: import_zod.z.number(),
@@ -132,15 +138,46 @@ var ScratchpadEntrySchema = import_zod.z.object({
 });
 
 // src/react/state.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var import_core = require("@agentforge/core");
+
+// src/shared/state-fields.ts
+var import_zod2 = require("zod");
+var iterationField = {
+  schema: import_zod2.z.number().int().nonnegative(),
+  reducer: (left, right) => left + right,
+  default: () => 0,
+  description: "Current iteration number"
+};
+function maxIterationsField(defaultValue) {
+  return {
+    schema: import_zod2.z.number().int().positive(),
+    default: () => defaultValue,
+    description: "Maximum number of iterations allowed"
+  };
+}
+var errorField = {
+  schema: import_zod2.z.string().optional(),
+  description: "Error message if execution failed"
+};
+var responseField = {
+  schema: import_zod2.z.string().optional(),
+  description: "Final response after completion"
+};
+var inputField = {
+  schema: import_zod2.z.string(),
+  default: () => "",
+  description: "Original user input or query"
+};
+
+// src/react/state.ts
 var ReActStateConfig = {
   /**
    * Conversation messages
    * Accumulates all messages in the conversation
    */
   messages: {
-    schema: import_zod2.z.array(MessageSchema),
+    schema: import_zod3.z.array(MessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Conversation message history"
@@ -150,7 +187,7 @@ var ReActStateConfig = {
    * Accumulates all reasoning steps the agent takes
    */
   thoughts: {
-    schema: import_zod2.z.array(ThoughtSchema),
+    schema: import_zod3.z.array(ThoughtSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Agent reasoning steps"
@@ -160,7 +197,7 @@ var ReActStateConfig = {
    * Accumulates all tool calls made by the agent
    */
   actions: {
-    schema: import_zod2.z.array(ToolCallSchema),
+    schema: import_zod3.z.array(ToolCallSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Tool calls made by the agent"
@@ -170,7 +207,7 @@ var ReActStateConfig = {
    * Accumulates all observations from tool executions
    */
   observations: {
-    schema: import_zod2.z.array(ToolResultSchema),
+    schema: import_zod3.z.array(ToolResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Results from tool executions"
@@ -180,7 +217,7 @@ var ReActStateConfig = {
    * Accumulates step-by-step reasoning process
    */
   scratchpad: {
-    schema: import_zod2.z.array(ScratchpadEntrySchema),
+    schema: import_zod3.z.array(ScratchpadEntrySchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Intermediate reasoning scratchpad"
@@ -189,27 +226,19 @@ var ReActStateConfig = {
    * Current iteration count
    * Tracks how many thought-action-observation loops have been executed
    */
-  iteration: {
-    schema: import_zod2.z.number(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Current iteration count"
-  },
+  iteration: iterationField,
   /**
    * Whether the agent should continue iterating
    */
   shouldContinue: {
-    schema: import_zod2.z.boolean().optional(),
+    schema: import_zod3.z.boolean().optional(),
     default: () => true,
     description: "Whether to continue the ReAct loop"
   },
   /**
    * Final response (if any)
    */
-  response: {
-    schema: import_zod2.z.string().optional(),
-    description: "Final response from the agent"
-  }
+  response: responseField
 };
 var ReActState = (0, import_core.createStateAnnotation)(ReActStateConfig);
 
@@ -245,14 +274,68 @@ function formatScratchpad(scratchpad) {
 
 // src/react/nodes.ts
 var import_messages = require("@langchain/core/messages");
+var import_core3 = require("@agentforge/core");
+
+// src/shared/deduplication.ts
 var import_core2 = require("@agentforge/core");
+function generateToolCallCacheKey(toolName, args) {
+  const sortedArgs = JSON.stringify(args, Object.keys(args || {}).sort());
+  return `${toolName}:${sortedArgs}`;
+}
+function createPatternLogger(name, defaultLevel = "info") {
+  const logLevel5 = process.env.LOG_LEVEL?.toLowerCase() || defaultLevel;
+  return (0, import_core2.createLogger)(name, { level: logLevel5 });
+}
+function calculateDeduplicationSavings(duplicatesSkipped, toolsExecuted) {
+  if (duplicatesSkipped === 0) {
+    return "0%";
+  }
+  const total = toolsExecuted + duplicatesSkipped;
+  return `${Math.round(duplicatesSkipped / total * 100)}%`;
+}
+function buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, totalObservations) {
+  return {
+    toolsExecuted,
+    duplicatesSkipped,
+    totalObservations,
+    deduplicationSavings: calculateDeduplicationSavings(duplicatesSkipped, toolsExecuted)
+  };
+}
+
+// src/shared/error-handling.ts
+function isGraphInterrupt(error) {
+  return error !== null && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt";
+}
+function handleNodeError(error, context, verbose = false) {
+  if (isGraphInterrupt(error)) {
+    throw error;
+  }
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (verbose) {
+    console.error(`[${context}] Error:`, errorMessage);
+    if (error instanceof Error && error.stack) {
+      console.error(`[${context}] Stack:`, error.stack);
+    }
+  }
+  return errorMessage;
+}
+
+// src/react/nodes.ts
+var reasoningLogger = createPatternLogger("agentforge:patterns:react:reasoning");
+var actionLogger = createPatternLogger("agentforge:patterns:react:action");
+var observationLogger = createPatternLogger("agentforge:patterns:react:observation");
 function createReasoningNode(llm, tools, systemPrompt, maxIterations, verbose = false) {
-  const langchainTools = (0, import_core2.toLangChainTools)(tools);
+  const langchainTools = (0, import_core3.toLangChainTools)(tools);
   const llmWithTools = llm.bindTools ? llm.bindTools(langchainTools) : llm;
   return async (state) => {
-    if (verbose) {
-      console.log(`[reasoning] Iteration ${state.iteration + 1}/${maxIterations}`);
-    }
+    const currentIteration = state.iteration || 0;
+    const startTime = Date.now();
+    reasoningLogger.debug("Reasoning iteration started", {
+      iteration: currentIteration + 1,
+      maxIterations,
+      observationCount: state.observations?.length || 0,
+      hasActions: !!state.actions?.length
+    });
     const stateMessages = state.messages || [];
     const messages = [
       new import_messages.SystemMessage(systemPrompt),
@@ -282,8 +365,15 @@ ${scratchpadText}`));
         });
       }
     }
-    const currentIteration = state.iteration || 0;
     const shouldContinue = toolCalls.length > 0 && currentIteration + 1 < maxIterations;
+    reasoningLogger.info("Reasoning complete", {
+      iteration: currentIteration + 1,
+      thoughtGenerated: !!thought,
+      actionCount: toolCalls.length,
+      shouldContinue,
+      isFinalResponse: toolCalls.length === 0,
+      duration: Date.now() - startTime
+    });
     return {
       messages: [{ role: "assistant", content: thought }],
       thoughts: thought ? [{ content: thought, timestamp: Date.now() }] : [],
@@ -296,16 +386,71 @@ ${scratchpadText}`));
     };
   };
 }
-function createActionNode(tools, verbose = false) {
+function createActionNode(tools, verbose = false, enableDeduplication = true) {
   const toolMap = new Map(tools.map((tool) => [tool.metadata.name, tool]));
   return async (state) => {
     const actions = state.actions || [];
-    if (verbose) {
-      console.log(`[action] Executing ${actions.length} tool calls`);
-    }
+    const allObservations = state.observations || [];
+    const iteration = state.iteration || 0;
+    const startTime = Date.now();
+    actionLogger.debug("Action node started", {
+      actionCount: actions.length,
+      iteration,
+      cacheEnabled: enableDeduplication
+    });
     const recentActions = actions.slice(-10);
     const observations = [];
+    const executionCache = /* @__PURE__ */ new Map();
+    let cacheSize = 0;
+    if (enableDeduplication) {
+      for (const observation of allObservations) {
+        const correspondingAction = actions.find((a) => a.id === observation.toolCallId);
+        if (correspondingAction) {
+          const cacheKey = generateToolCallCacheKey(correspondingAction.name, correspondingAction.arguments);
+          executionCache.set(cacheKey, observation);
+          cacheSize++;
+        }
+      }
+      if (cacheSize > 0) {
+        actionLogger.debug("Deduplication cache built", {
+          cacheSize,
+          totalObservations: allObservations.length
+        });
+      }
+    }
+    let duplicatesSkipped = 0;
+    let toolsExecuted = 0;
     for (const action of recentActions) {
+      const existingObservation = allObservations.find((obs) => obs.toolCallId === action.id);
+      if (existingObservation) {
+        actionLogger.debug("Skipping already-processed action", {
+          toolName: action.name,
+          toolCallId: action.id,
+          iteration
+        });
+        continue;
+      }
+      if (enableDeduplication) {
+        const cacheKey = generateToolCallCacheKey(action.name, action.arguments);
+        const cachedResult = executionCache.get(cacheKey);
+        if (cachedResult) {
+          duplicatesSkipped++;
+          actionLogger.info("Duplicate tool call prevented", {
+            toolName: action.name,
+            arguments: action.arguments,
+            iteration,
+            cacheHit: true
+          });
+          observations.push({
+            toolCallId: action.id,
+            result: cachedResult.result,
+            error: cachedResult.error,
+            timestamp: Date.now(),
+            isDuplicate: true
+          });
+          continue;
+        }
+      }
       const tool = toolMap.get(action.name);
       if (!tool) {
         observations.push({
@@ -317,31 +462,48 @@ function createActionNode(tools, verbose = false) {
         continue;
       }
       try {
+        const startTime2 = Date.now();
         const result = await tool.execute(action.arguments);
-        observations.push({
+        const executionTime = Date.now() - startTime2;
+        toolsExecuted++;
+        actionLogger.debug("Tool executed successfully", {
+          toolName: action.name,
+          executionTime,
+          iteration
+        });
+        const observation = {
           toolCallId: action.id,
           result,
           timestamp: Date.now()
-        });
-        if (verbose) {
-          console.log(`[action] Tool '${action.name}' executed successfully`);
+        };
+        observations.push(observation);
+        if (enableDeduplication) {
+          const cacheKey = generateToolCallCacheKey(action.name, action.arguments);
+          executionCache.set(cacheKey, observation);
         }
       } catch (error) {
-        if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
-          throw error;
-        }
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = handleNodeError(error, `action:${action.name}`, false);
+        actionLogger.error("Tool execution failed", {
+          toolName: action.name,
+          error: errorMessage,
+          iteration
+        });
         observations.push({
           toolCallId: action.id,
           result: null,
           error: errorMessage,
           timestamp: Date.now()
         });
-        if (verbose) {
-          console.error(`[action] Tool '${action.name}' failed:`, errorMessage);
-        }
       }
     }
+    if (duplicatesSkipped > 0 || toolsExecuted > 0) {
+      const metrics = buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, observations.length);
+      actionLogger.info("Action node complete", {
+        iteration,
+        ...metrics,
+        duration: Date.now() - startTime
+      });
+    }
     return {
       observations
     };
@@ -352,9 +514,11 @@ function createObservationNode(verbose = false) {
     const observations = state.observations || [];
     const thoughts = state.thoughts || [];
     const actions = state.actions || [];
-    if (verbose) {
-      console.log(`[observation] Processing ${observations.length} observations`);
-    }
+    const iteration = state.iteration || 0;
+    observationLogger.debug("Processing observations", {
+      observationCount: observations.length,
+      iteration
+    });
     const recentObservations = observations.slice(-10);
     const currentStep = state.iteration;
     const latestThought = thoughts[thoughts.length - 1]?.content || "";
@@ -380,6 +544,11 @@ function createObservationNode(verbose = false) {
         name: latestActions.find((a) => a.id === obs.toolCallId)?.name
       };
     });
+    observationLogger.debug("Observation node complete", {
+      iteration,
+      scratchpadUpdated: true,
+      messageCount: observationMessages.length
+    });
     return {
       scratchpad: [scratchpadEntry],
       messages: observationMessages
@@ -389,7 +558,7 @@ function createObservationNode(verbose = false) {
 
 // src/react/agent.ts
 var import_langgraph = require("@langchain/langgraph");
-var import_core3 = require("@agentforge/core");
+var import_core4 = require("@agentforge/core");
 function createReActAgent(config, options) {
   const {
     model,
@@ -398,13 +567,15 @@ function createReActAgent(config, options) {
     maxIterations = 10,
     returnIntermediateSteps = false,
     stopCondition,
-    checkpointer
+    checkpointer,
+    enableDeduplication = true
+    // Enable by default
   } = config;
   const {
     verbose = false,
     nodeNames = {}
   } = options || {};
-  const toolArray = tools instanceof import_core3.ToolRegistry ? tools.getAll() : tools;
+  const toolArray = tools instanceof import_core4.ToolRegistry ? tools.getAll() : tools;
   const REASONING_NODE = nodeNames.reasoning || "reasoning";
   const ACTION_NODE = nodeNames.action || "action";
   const OBSERVATION_NODE = nodeNames.observation || "observation";
@@ -415,7 +586,7 @@ function createReActAgent(config, options) {
     maxIterations,
     verbose
   );
-  const actionNode = createActionNode(toolArray, verbose);
+  const actionNode = createActionNode(toolArray, verbose, enableDeduplication);
   const observationNode = createObservationNode(verbose);
   const shouldContinue = (state) => {
     if (stopCondition && stopCondition(state)) {
@@ -550,34 +721,34 @@ function createReActAgentBuilder() {
 var import_langgraph2 = require("@langchain/langgraph");
 
 // src/plan-execute/state.ts
-var import_zod4 = require("zod");
-var import_core4 = require("@agentforge/core");
+var import_zod5 = require("zod");
+var import_core5 = require("@agentforge/core");
 
 // src/plan-execute/schemas.ts
-var import_zod3 = require("zod");
-var PlanStepSchema = import_zod3.z.object({
+var import_zod4 = require("zod");
+var PlanStepSchema = import_zod4.z.object({
   /**
    * Unique identifier for the step
    */
-  id: import_zod3.z.string().describe("Unique identifier for the step"),
+  id: import_zod4.z.string().describe("Unique identifier for the step"),
   /**
    * Description of what this step should accomplish
    */
-  description: import_zod3.z.string().describe("Description of what this step should accomplish"),
+  description: import_zod4.z.string().describe("Description of what this step should accomplish"),
   /**
    * Optional dependencies on other steps (by ID)
    */
-  dependencies: import_zod3.z.array(import_zod3.z.string()).optional().describe("IDs of steps that must complete before this one"),
+  dependencies: import_zod4.z.array(import_zod4.z.string()).optional().describe("IDs of steps that must complete before this one"),
   /**
    * Optional tool to use for this step
    */
-  tool: import_zod3.z.string().optional().describe("Name of the tool to use for this step"),
+  tool: import_zod4.z.string().optional().describe("Name of the tool to use for this step"),
   /**
    * Optional arguments for the tool
    */
-  args: import_zod3.z.record(import_zod3.z.any()).optional().describe("Arguments to pass to the tool")
+  args: import_zod4.z.record(import_zod4.z.any()).optional().describe("Arguments to pass to the tool")
 });
-var CompletedStepSchema = import_zod3.z.object({
+var CompletedStepSchema = import_zod4.z.object({
   /**
    * The step that was executed
    */
@@ -585,53 +756,53 @@ var CompletedStepSchema = import_zod3.z.object({
   /**
    * The result of executing the step
    */
-  result: import_zod3.z.any().describe("The result of executing the step"),
+  result: import_zod4.z.any().describe("The result of executing the step"),
   /**
    * Whether the step succeeded
    */
-  success: import_zod3.z.boolean().describe("Whether the step succeeded"),
+  success: import_zod4.z.boolean().describe("Whether the step succeeded"),
   /**
    * Optional error message if the step failed
    */
-  error: import_zod3.z.string().optional().describe("Error message if the step failed"),
+  error: import_zod4.z.string().optional().describe("Error message if the step failed"),
   /**
    * Timestamp when the step was completed
    */
-  timestamp: import_zod3.z.string().datetime().describe("ISO timestamp when the step was completed")
+  timestamp: import_zod4.z.string().datetime().describe("ISO timestamp when the step was completed")
 });
-var PlanSchema = import_zod3.z.object({
+var PlanSchema = import_zod4.z.object({
   /**
    * List of steps in the plan
    */
-  steps: import_zod3.z.array(PlanStepSchema).describe("List of steps in the plan"),
+  steps: import_zod4.z.array(PlanStepSchema).describe("List of steps in the plan"),
   /**
    * Overall goal of the plan
    */
-  goal: import_zod3.z.string().describe("Overall goal of the plan"),
+  goal: import_zod4.z.string().describe("Overall goal of the plan"),
   /**
    * Timestamp when the plan was created
    */
-  createdAt: import_zod3.z.string().datetime().describe("ISO timestamp when the plan was created"),
+  createdAt: import_zod4.z.string().datetime().describe("ISO timestamp when the plan was created"),
   /**
    * Optional confidence score (0-1)
    */
-  confidence: import_zod3.z.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
+  confidence: import_zod4.z.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
 });
-var ReplanDecisionSchema = import_zod3.z.object({
+var ReplanDecisionSchema = import_zod4.z.object({
   /**
    * Whether to replan
    */
-  shouldReplan: import_zod3.z.boolean().describe("Whether to replan based on current results"),
+  shouldReplan: import_zod4.z.boolean().describe("Whether to replan based on current results"),
   /**
    * Reason for the decision
    */
-  reason: import_zod3.z.string().describe("Reason for the replan decision"),
+  reason: import_zod4.z.string().describe("Reason for the replan decision"),
   /**
    * Optional new goal if replanning
    */
-  newGoal: import_zod3.z.string().optional().describe("Updated goal if replanning")
+  newGoal: import_zod4.z.string().optional().describe("Updated goal if replanning")
 });
-var ExecutionStatusSchema = import_zod3.z.enum([
+var ExecutionStatusSchema = import_zod4.z.enum([
   "planning",
   "executing",
   "replanning",
@@ -644,11 +815,7 @@ var PlanExecuteStateConfig = {
   /**
    * Original user input/query
    */
-  input: {
-    schema: import_zod4.z.string(),
-    default: () => "",
-    description: "Original user input or query"
-  },
+  input: inputField,
   /**
    * The current plan
    */
@@ -661,7 +828,7 @@ var PlanExecuteStateConfig = {
    * Accumulates all completed steps
    */
   pastSteps: {
-    schema: import_zod4.z.array(CompletedStepSchema),
+    schema: import_zod5.z.array(CompletedStepSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed steps with their results"
@@ -670,7 +837,7 @@ var PlanExecuteStateConfig = {
    * Index of the current step being executed
    */
   currentStepIndex: {
-    schema: import_zod4.z.number().int().nonnegative().optional(),
+    schema: import_zod5.z.number().int().nonnegative().optional(),
     description: "Index of the current step being executed"
   },
   /**
@@ -684,36 +851,21 @@ var PlanExecuteStateConfig = {
   /**
    * Final response
    */
-  response: {
-    schema: import_zod4.z.string().optional(),
-    description: "Final response after plan execution"
-  },
+  response: responseField,
   /**
    * Error message if execution failed
    */
-  error: {
-    schema: import_zod4.z.string().optional(),
-    description: "Error message if execution failed"
-  },
+  error: errorField,
   /**
    * Iteration counter for replanning
    */
-  iteration: {
-    schema: import_zod4.z.number().int().nonnegative(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Number of planning iterations"
-  },
+  iteration: iterationField,
   /**
    * Maximum iterations allowed
    */
-  maxIterations: {
-    schema: import_zod4.z.number().int().positive(),
-    default: () => 5,
-    description: "Maximum number of planning iterations allowed"
-  }
+  maxIterations: maxIterationsField(5)
 };
-var PlanExecuteState = (0, import_core4.createStateAnnotation)(PlanExecuteStateConfig);
+var PlanExecuteState = (0, import_core5.createStateAnnotation)(PlanExecuteStateConfig);
 
 // src/plan-execute/nodes.ts
 var import_messages2 = require("@langchain/core/messages");
@@ -778,6 +930,9 @@ var REMAINING_STEP_TEMPLATE = `Step {stepNumber}: {description}
 {dependencies}`;
 
 // src/plan-execute/nodes.ts
+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 createPlannerNode(config) {
   const {
     model,
@@ -786,7 +941,13 @@ function createPlannerNode(config) {
     includeToolDescriptions = false
   } = config;
   return async (state) => {
+    const startTime = Date.now();
     try {
+      plannerLogger.debug("Planning started", {
+        input: state.input?.substring(0, 100),
+        maxSteps,
+        includeToolDescriptions
+      });
       let toolDescriptions = "";
       if (includeToolDescriptions) {
         toolDescriptions = "";
@@ -811,6 +972,12 @@ function createPlannerNode(config) {
       } catch (parseError) {
         throw new Error(`Failed to parse plan from LLM response: ${parseError}`);
       }
+      plannerLogger.info("Plan created", {
+        stepCount: plan.steps.length,
+        goal: plan.goal.substring(0, 100),
+        confidence: plan.confidence,
+        duration: Date.now() - startTime
+      });
       return {
         plan,
         status: "executing",
@@ -818,6 +985,10 @@ function createPlannerNode(config) {
         iteration: 1
       };
     } catch (error) {
+      plannerLogger.error("Planning failed", {
+        error: error instanceof Error ? error.message : String(error),
+        duration: Date.now() - startTime
+      });
       return {
         status: "failed",
         error: error instanceof Error ? error.message : "Unknown error in planner"
@@ -830,11 +1001,18 @@ function createExecutorNode(config) {
     tools,
     model,
     parallel = false,
-    stepTimeout = 3e4
+    stepTimeout = 3e4,
+    enableDeduplication = true
   } = config;
   return async (state) => {
+    const { plan, currentStepIndex = 0, pastSteps = [], iteration = 0 } = state;
     try {
-      const { plan, currentStepIndex = 0, pastSteps = [] } = state;
+      executorLogger.debug("Executor node executing", {
+        currentStepIndex,
+        totalSteps: plan?.steps?.length || 0,
+        iteration,
+        deduplicationEnabled: enableDeduplication
+      });
       if (!plan || !plan.steps || plan.steps.length === 0) {
         return {
           status: "completed"
@@ -853,32 +1031,80 @@ function createExecutorNode(config) {
           throw new Error(`Unmet dependencies for step ${currentStep.id}: ${unmetDependencies.join(", ")}`);
         }
       }
+      const executionCache = /* @__PURE__ */ new Map();
+      let cacheSize = 0;
+      if (enableDeduplication && currentStep.tool) {
+        for (const pastStep of pastSteps) {
+          if (pastStep.step.tool) {
+            const cacheKey = generateToolCallCacheKey(pastStep.step.tool, pastStep.step.args || {});
+            executionCache.set(cacheKey, pastStep);
+            cacheSize++;
+          }
+        }
+        if (cacheSize > 0) {
+          executorLogger.debug("Deduplication cache built", {
+            cacheSize,
+            pastStepsCount: pastSteps.length
+          });
+        }
+      }
       let result;
       let success = true;
       let error;
+      let isDuplicate = false;
       try {
         if (currentStep.tool) {
-          const tool = tools.find((t) => t.metadata.name === currentStep.tool);
-          if (!tool) {
-            throw new Error(`Tool not found: ${currentStep.tool}`);
+          if (enableDeduplication) {
+            const cacheKey = generateToolCallCacheKey(currentStep.tool, currentStep.args || {});
+            const cachedStep = executionCache.get(cacheKey);
+            if (cachedStep) {
+              isDuplicate = true;
+              result = cachedStep.result;
+              success = cachedStep.success;
+              error = cachedStep.error;
+              executorLogger.info("Duplicate step execution prevented", {
+                stepId: currentStep.id,
+                toolName: currentStep.tool,
+                arguments: currentStep.args,
+                iteration,
+                cacheHit: true
+              });
+            }
+          }
+          if (!isDuplicate) {
+            const tool = tools.find((t) => t.metadata.name === currentStep.tool);
+            if (!tool) {
+              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.execute(currentStep.args || {}),
+              timeoutPromise
+            ]);
+            const executionTime = Date.now() - startTime;
+            executorLogger.debug("Step executed successfully", {
+              stepId: currentStep.id,
+              toolName: currentStep.tool,
+              executionTime,
+              iteration
+            });
           }
-          const timeoutPromise = new Promise(
-            (_, reject) => setTimeout(() => reject(new Error("Step execution timeout")), stepTimeout)
-          );
-          result = await Promise.race([
-            tool.execute(currentStep.args || {}),
-            timeoutPromise
-          ]);
         } else {
           result = { message: "Step completed without tool execution" };
         }
       } catch (execError) {
-        if (execError && typeof execError === "object" && "constructor" in execError && execError.constructor.name === "GraphInterrupt") {
-          throw execError;
-        }
+        error = handleNodeError(execError, `executor:${currentStep.description}`, false);
         success = false;
-        error = execError instanceof Error ? execError.message : "Unknown execution error";
         result = null;
+        executorLogger.warn("Step execution failed", {
+          stepId: currentStep.id,
+          toolName: currentStep.tool,
+          error,
+          iteration
+        });
       }
       const completedStep = {
         step: currentStep,
@@ -887,11 +1113,23 @@ function createExecutorNode(config) {
         error,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
+      executorLogger.info("Executor node complete", {
+        stepId: currentStep.id,
+        stepIndex: currentStepIndex,
+        totalSteps: plan.steps.length,
+        success,
+        isDuplicate,
+        iteration
+      });
       return {
         pastSteps: [completedStep],
         currentStepIndex: currentStepIndex + 1
       };
     } catch (error) {
+      executorLogger.error("Executor node failed", {
+        error: error instanceof Error ? error.message : "Unknown error",
+        iteration
+      });
       return {
         status: "failed",
         error: error instanceof Error ? error.message : "Unknown error in executor"
@@ -906,11 +1144,18 @@ function createReplannerNode(config) {
     systemPrompt = DEFAULT_REPLANNER_SYSTEM_PROMPT
   } = config;
   return async (state) => {
+    const startTime = Date.now();
     try {
       const { plan, pastSteps = [], currentStepIndex = 0 } = state;
       if (!plan) {
         return { status: "failed", error: "No plan available for replanning" };
       }
+      replannerLogger.debug("Evaluating replanning", {
+        completedSteps: pastSteps.length,
+        remainingSteps: plan.steps.length - currentStepIndex,
+        successfulSteps: pastSteps.filter((ps) => ps.success).length,
+        failedSteps: pastSteps.filter((ps) => !ps.success).length
+      });
       const completedStepsText = pastSteps.map(
         (ps, idx) => COMPLETED_STEP_TEMPLATE.replace("{stepNumber}", String(idx + 1)).replace("{description}", ps.step.description).replace("{result}", JSON.stringify(ps.result)).replace("{status}", ps.success ? "Success" : `Failed: ${ps.error}`)
       ).join("\n\n");
@@ -932,17 +1177,30 @@ function createReplannerNode(config) {
         throw new Error(`Failed to parse replan decision from LLM response: ${parseError}`);
       }
       if (decision.shouldReplan) {
+        replannerLogger.info("Replanning triggered", {
+          reason: decision.reason,
+          newGoal: decision.newGoal?.substring(0, 100),
+          duration: Date.now() - startTime
+        });
         return {
           status: "planning",
           input: decision.newGoal || plan.goal,
           iteration: 1
         };
       } else {
+        replannerLogger.info("Continuing with current plan", {
+          reason: decision.reason,
+          duration: Date.now() - startTime
+        });
         return {
           status: "executing"
         };
       }
     } catch (error) {
+      replannerLogger.error("Replanning evaluation failed", {
+        error: error instanceof Error ? error.message : String(error),
+        duration: Date.now() - startTime
+      });
       return {
         status: "failed",
         error: error instanceof Error ? error.message : "Unknown error in replanner"
@@ -1042,46 +1300,46 @@ function createPlanExecuteAgent(config) {
 }
 
 // src/reflection/state.ts
-var import_zod6 = require("zod");
-var import_core5 = require("@agentforge/core");
+var import_zod7 = require("zod");
+var import_core6 = require("@agentforge/core");
 
 // src/reflection/schemas.ts
-var import_zod5 = require("zod");
-var ReflectionSchema = import_zod5.z.object({
+var import_zod6 = require("zod");
+var ReflectionSchema = import_zod6.z.object({
   /**
    * The critique or feedback on the current response
    */
-  critique: import_zod5.z.string().describe("Critique or feedback on the current response"),
+  critique: import_zod6.z.string().describe("Critique or feedback on the current response"),
   /**
    * Specific issues identified
    */
-  issues: import_zod5.z.array(import_zod5.z.string()).describe("Specific issues or problems identified"),
+  issues: import_zod6.z.array(import_zod6.z.string()).describe("Specific issues or problems identified"),
   /**
    * Suggestions for improvement
    */
-  suggestions: import_zod5.z.array(import_zod5.z.string()).describe("Suggestions for improving the response"),
+  suggestions: import_zod6.z.array(import_zod6.z.string()).describe("Suggestions for improving the response"),
   /**
    * Quality score (0-10)
    */
-  score: import_zod5.z.number().min(0).max(10).optional().describe("Quality score from 0 to 10"),
+  score: import_zod6.z.number().min(0).max(10).optional().describe("Quality score from 0 to 10"),
   /**
    * Whether the response meets quality standards
    */
-  meetsStandards: import_zod5.z.boolean().describe("Whether the response meets quality standards"),
+  meetsStandards: import_zod6.z.boolean().describe("Whether the response meets quality standards"),
   /**
    * Timestamp of the reflection
    */
-  timestamp: import_zod5.z.date().optional().describe("When this reflection was created")
+  timestamp: import_zod6.z.date().optional().describe("When this reflection was created")
 });
-var RevisionSchema = import_zod5.z.object({
+var RevisionSchema = import_zod6.z.object({
   /**
    * The revised content
    */
-  content: import_zod5.z.string().describe("The revised content"),
+  content: import_zod6.z.string().describe("The revised content"),
   /**
    * Which iteration this revision is from
    */
-  iteration: import_zod5.z.number().int().nonnegative().describe("Iteration number"),
+  iteration: import_zod6.z.number().int().nonnegative().describe("Iteration number"),
   /**
    * The reflection that prompted this revision
    */
@@ -1089,9 +1347,9 @@ var RevisionSchema = import_zod5.z.object({
   /**
    * Timestamp of the revision
    */
-  timestamp: import_zod5.z.date().optional().describe("When this revision was created")
+  timestamp: import_zod6.z.date().optional().describe("When this revision was created")
 });
-var ReflectionStatusSchema = import_zod5.z.enum([
+var ReflectionStatusSchema = import_zod6.z.enum([
   "generating",
   // Initial generation
   "reflecting",
@@ -1103,25 +1361,25 @@ var ReflectionStatusSchema = import_zod5.z.enum([
   "failed"
   // Max iterations reached without meeting standards
 ]);
-var QualityCriteriaSchema = import_zod5.z.object({
+var QualityCriteriaSchema = import_zod6.z.object({
   /**
    * Minimum quality score required (0-10)
    */
-  minScore: import_zod5.z.number().min(0).max(10).default(7).describe("Minimum quality score required"),
+  minScore: import_zod6.z.number().min(0).max(10).default(7).describe("Minimum quality score required"),
   /**
    * Specific criteria to evaluate
    */
-  criteria: import_zod5.z.array(import_zod5.z.string()).optional().describe("Specific criteria to evaluate"),
+  criteria: import_zod6.z.array(import_zod6.z.string()).optional().describe("Specific criteria to evaluate"),
   /**
    * Whether all criteria must be met
    */
-  requireAll: import_zod5.z.boolean().default(true).describe("Whether all criteria must be met")
+  requireAll: import_zod6.z.boolean().default(true).describe("Whether all criteria must be met")
 });
-var ReflectionConfigSchema = import_zod5.z.object({
+var ReflectionConfigSchema = import_zod6.z.object({
   /**
    * Maximum number of reflection iterations
    */
-  maxIterations: import_zod5.z.number().int().positive().default(3).describe("Maximum reflection iterations"),
+  maxIterations: import_zod6.z.number().int().positive().default(3).describe("Maximum reflection iterations"),
   /**
    * Quality criteria for completion
    */
@@ -1129,7 +1387,7 @@ var ReflectionConfigSchema = import_zod5.z.object({
   /**
    * Whether to include previous reflections in context
    */
-  includeHistory: import_zod5.z.boolean().default(true).describe("Include previous reflections in context")
+  includeHistory: import_zod6.z.boolean().default(true).describe("Include previous reflections in context")
 });
 
 // src/reflection/state.ts
@@ -1137,16 +1395,12 @@ var ReflectionStateConfig = {
   /**
    * Original user input/task
    */
-  input: {
-    schema: import_zod6.z.string(),
-    default: () => "",
-    description: "Original user input or task"
-  },
+  input: inputField,
   /**
    * Current response/output
    */
   currentResponse: {
-    schema: import_zod6.z.string().optional(),
+    schema: import_zod7.z.string().optional(),
     description: "Current response or output"
   },
   /**
@@ -1154,7 +1408,7 @@ var ReflectionStateConfig = {
    * Accumulates all reflections
    */
   reflections: {
-    schema: import_zod6.z.array(ReflectionSchema),
+    schema: import_zod7.z.array(ReflectionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of all reflections and critiques"
@@ -1164,7 +1418,7 @@ var ReflectionStateConfig = {
    * Accumulates all revisions
    */
   revisions: {
-    schema: import_zod6.z.array(RevisionSchema),
+    schema: import_zod7.z.array(RevisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of all revisions"
@@ -1172,12 +1426,7 @@ var ReflectionStateConfig = {
   /**
    * Current iteration number
    */
-  iteration: {
-    schema: import_zod6.z.number().int().nonnegative(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Current iteration number"
-  },
+  iteration: iterationField,
   /**
    * Current status
    */
@@ -1196,27 +1445,17 @@ var ReflectionStateConfig = {
   /**
    * Maximum iterations allowed
    */
-  maxIterations: {
-    schema: import_zod6.z.number().int().positive(),
-    default: () => 3,
-    description: "Maximum number of reflection iterations allowed"
-  },
+  maxIterations: maxIterationsField(3),
   /**
    * Final response (when completed)
    */
-  response: {
-    schema: import_zod6.z.string().optional(),
-    description: "Final response after reflection process"
-  },
+  response: responseField,
   /**
    * Error message if failed
    */
-  error: {
-    schema: import_zod6.z.string().optional(),
-    description: "Error message if reflection failed"
-  }
+  error: errorField
 };
-var ReflectionState = (0, import_core5.createStateAnnotation)(ReflectionStateConfig);
+var ReflectionState = (0, import_core6.createStateAnnotation)(ReflectionStateConfig);
 
 // src/reflection/prompts.ts
 var DEFAULT_GENERATOR_SYSTEM_PROMPT = `You are an expert content generator. Your task is to create high-quality responses to user requests.
@@ -1320,6 +1559,9 @@ var REVISION_ENTRY_TEMPLATE = `Iteration {iteration}:
 
 // src/reflection/nodes.ts
 var import_messages3 = require("@langchain/core/messages");
+var generatorLogger = createPatternLogger("agentforge:patterns:reflection:generator");
+var reflectorLogger = createPatternLogger("agentforge:patterns:reflection:reflector");
+var reviserLogger = createPatternLogger("agentforge:patterns:reflection:reviser");
 function createGeneratorNode(config) {
   const {
     model,
@@ -1327,10 +1569,13 @@ function createGeneratorNode(config) {
     verbose = false
   } = config;
   return async (state) => {
+    const startTime = Date.now();
     try {
-      if (verbose) {
-        console.log("[Generator] Generating initial response...");
-      }
+      generatorLogger.debug("Generating response", {
+        attempt: state.iteration + 1,
+        hasFeedback: state.reflections.length > 0,
+        hasExistingResponse: !!state.currentResponse
+      });
       let context = "";
       if (state.iteration > 0 && state.reflections.length > 0) {
         const lastReflection = state.reflections[state.reflections.length - 1];
@@ -1345,19 +1590,27 @@ ${lastReflection.critique}`;
       ];
       const response = await model.invoke(messages);
       const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      if (verbose) {
-        console.log("[Generator] Generated response:", content.substring(0, 100) + "...");
-      }
+      generatorLogger.info("Response generated", {
+        attempt: state.iteration + 1,
+        responseLength: content.length,
+        isRevision: state.iteration > 0,
+        duration: Date.now() - startTime
+      });
       return {
         currentResponse: content,
         status: "reflecting",
         iteration: 1
       };
     } catch (error) {
-      console.error("[Generator] Error:", error);
+      const errorMessage = handleNodeError(error, "generator", false);
+      generatorLogger.error("Response generation failed", {
+        attempt: state.iteration + 1,
+        error: errorMessage,
+        duration: Date.now() - startTime
+      });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in generator"
+        error: errorMessage
       };
     }
   };
@@ -1370,10 +1623,13 @@ function createReflectorNode(config) {
     verbose = false
   } = config;
   return async (state) => {
+    const startTime = Date.now();
     try {
-      if (verbose) {
-        console.log("[Reflector] Reflecting on response...");
-      }
+      reflectorLogger.debug("Reflecting on response", {
+        attempt: state.iteration,
+        responseLength: state.currentResponse?.length || 0,
+        hasCriteria: !!(qualityCriteria || state.qualityCriteria)
+      });
       if (!state.currentResponse) {
         throw new Error("No current response to reflect on");
       }
@@ -1423,19 +1679,28 @@ function createReflectorNode(config) {
           meetsStandards: false
         };
       }
-      if (verbose) {
-        console.log("[Reflector] Reflection score:", reflection.score);
-        console.log("[Reflector] Meets standards:", reflection.meetsStandards);
-      }
+      reflectorLogger.info("Reflection complete", {
+        attempt: state.iteration,
+        score: reflection.score,
+        meetsStandards: reflection.meetsStandards,
+        issueCount: reflection.issues.length,
+        suggestionCount: reflection.suggestions.length,
+        duration: Date.now() - startTime
+      });
       return {
         reflections: [reflection],
         status: reflection.meetsStandards ? "completed" : "revising"
       };
     } catch (error) {
-      console.error("[Reflector] Error:", error);
+      const errorMessage = handleNodeError(error, "reflector", false);
+      reflectorLogger.error("Reflection failed", {
+        attempt: state.iteration,
+        error: errorMessage,
+        duration: Date.now() - startTime
+      });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in reflector"
+        error: errorMessage
       };
     }
   };
@@ -1447,10 +1712,8 @@ function createReviserNode(config) {
     verbose = false
   } = config;
   return async (state) => {
+    const startTime = Date.now();
     try {
-      if (verbose) {
-        console.log("[Reviser] Revising response...");
-      }
       if (!state.currentResponse) {
         throw new Error("No current response to revise");
       }
@@ -1458,6 +1721,12 @@ function createReviserNode(config) {
         throw new Error("No reflections to base revision on");
       }
       const lastReflection = state.reflections[state.reflections.length - 1];
+      reviserLogger.debug("Revising response", {
+        attempt: state.iteration,
+        previousScore: lastReflection.score,
+        issueCount: lastReflection.issues.length,
+        suggestionCount: lastReflection.suggestions.length
+      });
       let historySection = "";
       if (state.revisions.length > 0) {
         const revisionsText = state.revisions.map(
@@ -1474,14 +1743,17 @@ ${revisionsText}`;
       ];
       const response = await model.invoke(messages);
       const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      if (verbose) {
-        console.log("[Reviser] Created revision:", content.substring(0, 100) + "...");
-      }
       const revision = {
         content,
         iteration: state.iteration,
         basedOn: lastReflection
       };
+      reviserLogger.info("Revision complete", {
+        attempt: state.iteration,
+        revisionLength: content.length,
+        basedOnScore: lastReflection.score,
+        duration: Date.now() - startTime
+      });
       return {
         currentResponse: content,
         revisions: [revision],
@@ -1489,10 +1761,15 @@ ${revisionsText}`;
         iteration: 1
       };
     } catch (error) {
-      console.error("[Reviser] Error:", error);
+      const errorMessage = handleNodeError(error, "reviser", false);
+      reviserLogger.error("Revision failed", {
+        attempt: state.iteration,
+        error: errorMessage,
+        duration: Date.now() - startTime
+      });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in reviser"
+        error: errorMessage
       };
     }
   };
@@ -1578,13 +1855,13 @@ function createReflectionAgent(config) {
 }
 
 // src/multi-agent/state.ts
-var import_zod8 = require("zod");
-var import_core6 = require("@agentforge/core");
+var import_zod9 = require("zod");
+var import_core7 = require("@agentforge/core");
 
 // src/multi-agent/schemas.ts
-var import_zod7 = require("zod");
-var AgentRoleSchema = import_zod7.z.enum(["supervisor", "worker"]);
-var MessageTypeSchema = import_zod7.z.enum([
+var import_zod8 = require("zod");
+var AgentRoleSchema = import_zod8.z.enum(["supervisor", "worker"]);
+var MessageTypeSchema = import_zod8.z.enum([
   "user_input",
   // Initial user message
   "task_assignment",
@@ -1598,11 +1875,11 @@ var MessageTypeSchema = import_zod7.z.enum([
   "completion"
   // Final completion message
 ]);
-var AgentMessageSchema = import_zod7.z.object({
+var AgentMessageSchema = import_zod8.z.object({
   /**
    * Unique identifier for the message
    */
-  id: import_zod7.z.string().describe("Unique message identifier"),
+  id: import_zod8.z.string().describe("Unique message identifier"),
   /**
    * Type of message
    */
@@ -1610,25 +1887,25 @@ var AgentMessageSchema = import_zod7.z.object({
   /**
    * Agent that sent the message
    */
-  from: import_zod7.z.string().describe("Agent identifier that sent the message"),
+  from: import_zod8.z.string().describe("Agent identifier that sent the message"),
   /**
    * Agent(s) that should receive the message
    */
-  to: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.array(import_zod7.z.string())]).describe("Target agent(s)"),
+  to: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string())]).describe("Target agent(s)"),
   /**
    * Message content
    */
-  content: import_zod7.z.string().describe("Message content"),
+  content: import_zod8.z.string().describe("Message content"),
   /**
    * Optional metadata
    */
-  metadata: import_zod7.z.record(import_zod7.z.any()).optional().describe("Additional message metadata"),
+  metadata: import_zod8.z.record(import_zod8.z.any()).optional().describe("Additional message metadata"),
   /**
    * Timestamp when message was created
    */
-  timestamp: import_zod7.z.number().describe("Timestamp when message was created")
+  timestamp: import_zod8.z.number().describe("Timestamp when message was created")
 });
-var RoutingStrategySchema = import_zod7.z.enum([
+var RoutingStrategySchema = import_zod8.z.enum([
   "llm-based",
   // LLM decides which agent to route to
   "rule-based",
@@ -1640,25 +1917,25 @@ var RoutingStrategySchema = import_zod7.z.enum([
   "load-balanced"
   // Route based on agent workload
 ]);
-var RoutingDecisionSchema = import_zod7.z.object({
+var RoutingDecisionSchema = import_zod8.z.object({
   /**
    * Target agent to route to (single agent routing)
    * @deprecated Use targetAgents for parallel routing support
    */
-  targetAgent: import_zod7.z.string().nullable().default(null).describe("Agent to route the task to (single routing)"),
+  targetAgent: import_zod8.z.string().nullable().default(null).describe("Agent to route the task to (single routing)"),
   /**
    * Target agents to route to (parallel routing)
    * When multiple agents are specified, they execute in parallel
    */
-  targetAgents: import_zod7.z.array(import_zod7.z.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
+  targetAgents: import_zod8.z.array(import_zod8.z.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
   /**
    * Reasoning for the routing decision
    */
-  reasoning: import_zod7.z.string().default("").describe("Explanation for routing decision"),
+  reasoning: import_zod8.z.string().default("").describe("Explanation for routing decision"),
   /**
    * Confidence in the routing decision (0-1)
    */
-  confidence: import_zod7.z.number().min(0).max(1).default(0.8).describe("Confidence score"),
+  confidence: import_zod8.z.number().min(0).max(1).default(0.8).describe("Confidence score"),
   /**
    * Strategy used for routing
    */
@@ -1666,86 +1943,86 @@ var RoutingDecisionSchema = import_zod7.z.object({
   /**
    * Timestamp of the routing decision
    */
-  timestamp: import_zod7.z.number().default(() => Date.now()).describe("Timestamp of the decision")
+  timestamp: import_zod8.z.number().default(() => Date.now()).describe("Timestamp of the decision")
 }).refine(
   (data) => data.targetAgent || data.targetAgents && data.targetAgents.length > 0,
   { message: "Either targetAgent or targetAgents must be provided" }
 );
-var WorkerCapabilitiesSchema = import_zod7.z.object({
+var WorkerCapabilitiesSchema = import_zod8.z.object({
   /**
    * Skills/capabilities the agent has
    */
-  skills: import_zod7.z.array(import_zod7.z.string()).describe("List of agent skills"),
+  skills: import_zod8.z.array(import_zod8.z.string()).describe("List of agent skills"),
   /**
    * Tools available to the agent
    */
-  tools: import_zod7.z.array(import_zod7.z.string()).describe("List of tool names available to agent"),
+  tools: import_zod8.z.array(import_zod8.z.string()).describe("List of tool names available to agent"),
   /**
    * Whether the agent is currently available
    */
-  available: import_zod7.z.boolean().default(true).describe("Whether agent is available"),
+  available: import_zod8.z.boolean().default(true).describe("Whether agent is available"),
   /**
    * Current workload (number of active tasks)
    */
-  currentWorkload: import_zod7.z.number().int().nonnegative().default(0).describe("Current number of active tasks")
+  currentWorkload: import_zod8.z.number().int().nonnegative().default(0).describe("Current number of active tasks")
 });
-var TaskAssignmentSchema = import_zod7.z.object({
+var TaskAssignmentSchema = import_zod8.z.object({
   /**
    * Unique assignment identifier
    */
-  id: import_zod7.z.string().describe("Unique assignment identifier"),
+  id: import_zod8.z.string().describe("Unique assignment identifier"),
   /**
    * Worker ID assigned to the task
    */
-  workerId: import_zod7.z.string().describe("Worker identifier assigned to task"),
+  workerId: import_zod8.z.string().describe("Worker identifier assigned to task"),
   /**
    * Task description
    */
-  task: import_zod7.z.string().describe("Description of the task"),
+  task: import_zod8.z.string().describe("Description of the task"),
   /**
    * Task priority (1-10, higher is more urgent)
    */
-  priority: import_zod7.z.number().int().min(1).max(10).default(5).describe("Task priority"),
+  priority: import_zod8.z.number().int().min(1).max(10).default(5).describe("Task priority"),
   /**
    * Timestamp when task was assigned
    */
-  assignedAt: import_zod7.z.number().describe("Timestamp when task was assigned"),
+  assignedAt: import_zod8.z.number().describe("Timestamp when task was assigned"),
   /**
    * Optional deadline for task completion
    */
-  deadline: import_zod7.z.number().optional().describe("Optional task deadline timestamp")
+  deadline: import_zod8.z.number().optional().describe("Optional task deadline timestamp")
 });
-var TaskResultSchema = import_zod7.z.object({
+var TaskResultSchema = import_zod8.z.object({
   /**
    * Assignment identifier
    */
-  assignmentId: import_zod7.z.string().describe("Assignment identifier"),
+  assignmentId: import_zod8.z.string().describe("Assignment identifier"),
   /**
    * Worker that completed the task
    */
-  workerId: import_zod7.z.string().describe("Worker that completed the task"),
+  workerId: import_zod8.z.string().describe("Worker that completed the task"),
   /**
    * Whether the task succeeded
    */
-  success: import_zod7.z.boolean().describe("Whether the task succeeded"),
+  success: import_zod8.z.boolean().describe("Whether the task succeeded"),
   /**
    * Task result/output
    */
-  result: import_zod7.z.string().describe("Task result or output"),
+  result: import_zod8.z.string().describe("Task result or output"),
   /**
    * Optional error message if task failed
    */
-  error: import_zod7.z.string().optional().describe("Error message if task failed"),
+  error: import_zod8.z.string().optional().describe("Error message if task failed"),
   /**
    * Timestamp when task was completed
    */
-  completedAt: import_zod7.z.number().describe("Timestamp when task was completed"),
+  completedAt: import_zod8.z.number().describe("Timestamp when task was completed"),
   /**
    * Optional metadata about execution
    */
-  metadata: import_zod7.z.record(import_zod7.z.any()).optional().describe("Execution metadata")
+  metadata: import_zod8.z.record(import_zod8.z.any()).optional().describe("Execution metadata")
 });
-var MultiAgentStatusSchema = import_zod7.z.enum([
+var MultiAgentStatusSchema = import_zod8.z.enum([
   "initializing",
   // System is initializing
   "routing",
@@ -1761,27 +2038,27 @@ var MultiAgentStatusSchema = import_zod7.z.enum([
   "failed"
   // Task failed
 ]);
-var HandoffRequestSchema = import_zod7.z.object({
+var HandoffRequestSchema = import_zod8.z.object({
   /**
    * Agent requesting the handoff
    */
-  from: import_zod7.z.string().describe("Agent requesting handoff"),
+  from: import_zod8.z.string().describe("Agent requesting handoff"),
   /**
    * Target agent for handoff
    */
-  to: import_zod7.z.string().describe("Target agent for handoff"),
+  to: import_zod8.z.string().describe("Target agent for handoff"),
   /**
    * Reason for handoff
    */
-  reason: import_zod7.z.string().describe("Reason for requesting handoff"),
+  reason: import_zod8.z.string().describe("Reason for requesting handoff"),
   /**
    * Context to pass to next agent
    */
-  context: import_zod7.z.any().describe("Context to pass to next agent"),
+  context: import_zod8.z.any().describe("Context to pass to next agent"),
   /**
    * Timestamp of handoff request
    */
-  timestamp: import_zod7.z.string().datetime().describe("ISO timestamp of handoff request")
+  timestamp: import_zod8.z.string().datetime().describe("ISO timestamp of handoff request")
 });
 
 // src/multi-agent/state.ts
@@ -1789,17 +2066,13 @@ var MultiAgentStateConfig = {
   /**
    * Original user input/query
    */
-  input: {
-    schema: import_zod8.z.string(),
-    default: () => "",
-    description: "Original user input or query"
-  },
+  input: inputField,
   /**
    * All messages in the multi-agent conversation
    * Accumulates all messages between agents
    */
   messages: {
-    schema: import_zod8.z.array(AgentMessageSchema),
+    schema: import_zod9.z.array(AgentMessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "All messages in the multi-agent conversation"
@@ -1808,7 +2081,7 @@ var MultiAgentStateConfig = {
    * Available worker agents and their capabilities
    */
   workers: {
-    schema: import_zod8.z.record(import_zod8.z.string(), WorkerCapabilitiesSchema),
+    schema: import_zod9.z.record(import_zod9.z.string(), WorkerCapabilitiesSchema),
     reducer: (left, right) => ({
       ...left,
       ...right
@@ -1820,7 +2093,7 @@ var MultiAgentStateConfig = {
    * Current active agent
    */
   currentAgent: {
-    schema: import_zod8.z.string().optional(),
+    schema: import_zod9.z.string().optional(),
     description: "Identifier of the currently active agent"
   },
   /**
@@ -1828,7 +2101,7 @@ var MultiAgentStateConfig = {
    * Accumulates all routing decisions
    */
   routingHistory: {
-    schema: import_zod8.z.array(RoutingDecisionSchema),
+    schema: import_zod9.z.array(RoutingDecisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of routing decisions"
@@ -1837,7 +2110,7 @@ var MultiAgentStateConfig = {
    * Active task assignments
    */
   activeAssignments: {
-    schema: import_zod8.z.array(TaskAssignmentSchema),
+    schema: import_zod9.z.array(TaskAssignmentSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Currently active task assignments"
@@ -1847,7 +2120,7 @@ var MultiAgentStateConfig = {
    * Accumulates all completed tasks
    */
   completedTasks: {
-    schema: import_zod8.z.array(TaskResultSchema),
+    schema: import_zod9.z.array(TaskResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed task results"
@@ -1857,7 +2130,7 @@ var MultiAgentStateConfig = {
    * Accumulates all handoff requests
    */
   handoffs: {
-    schema: import_zod8.z.array(HandoffRequestSchema),
+    schema: import_zod9.z.array(HandoffRequestSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Handoff requests between agents"
@@ -1873,44 +2146,40 @@ var MultiAgentStateConfig = {
   /**
    * Iteration counter
    */
-  iteration: {
-    schema: import_zod8.z.number().int().nonnegative(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Current iteration number"
-  },
+  iteration: iterationField,
   /**
    * Maximum iterations allowed
    */
-  maxIterations: {
-    schema: import_zod8.z.number().int().positive(),
-    default: () => 10,
-    description: "Maximum number of iterations allowed"
-  },
+  maxIterations: maxIterationsField(10),
   /**
    * Final aggregated response
    */
-  response: {
-    schema: import_zod8.z.string().optional(),
-    description: "Final aggregated response"
-  },
+  response: responseField,
   /**
    * Error message if execution failed
    */
-  error: {
-    schema: import_zod8.z.string().optional(),
-    description: "Error message if execution failed"
-  }
+  error: errorField
 };
-var MultiAgentState = (0, import_core6.createStateAnnotation)(MultiAgentStateConfig);
+var MultiAgentState = (0, import_core7.createStateAnnotation)(MultiAgentStateConfig);
 
 // src/multi-agent/routing.ts
 var import_messages4 = require("@langchain/core/messages");
+var import_core8 = require("@agentforge/core");
+var logLevel = process.env.LOG_LEVEL?.toLowerCase() || import_core8.LogLevel.INFO;
+var logger = (0, import_core8.createLogger)("multi-agent:routing", { level: logLevel });
 async function executeTools(toolCalls, tools) {
   const results = [];
+  logger.debug("Executing tools", {
+    toolCallCount: toolCalls.length,
+    toolNames: toolCalls.map((tc) => tc.name)
+  });
   for (const toolCall of toolCalls) {
     const tool = tools.find((t) => t.metadata.name === toolCall.name);
     if (!tool) {
+      logger.warn("Tool not found", {
+        toolName: toolCall.name,
+        availableTools: tools.map((t) => t.metadata.name)
+      });
       results.push(new import_messages4.ToolMessage({
         content: `Error: Tool '${toolCall.name}' not found`,
         tool_call_id: toolCall.id
@@ -1918,19 +2187,41 @@ async function executeTools(toolCalls, tools) {
       continue;
     }
     try {
+      logger.debug("Executing tool", {
+        toolName: toolCall.name,
+        args: toolCall.args
+      });
       const result = await tool.execute(toolCall.args);
       const content = typeof result === "string" ? result : JSON.stringify(result);
+      logger.debug("Tool execution successful", {
+        toolName: toolCall.name,
+        resultLength: content.length
+      });
       results.push(new import_messages4.ToolMessage({
         content,
         tool_call_id: toolCall.id
       }));
     } catch (error) {
+      logger.error("Tool execution failed", {
+        toolName: toolCall.name,
+        error: error.message
+      });
       results.push(new import_messages4.ToolMessage({
         content: `Error executing tool: ${error.message}`,
         tool_call_id: toolCall.id
       }));
     }
   }
+  logger.debug("Tool execution complete", {
+    successCount: results.filter((r) => {
+      const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
+      return !content.startsWith("Error");
+    }).length,
+    errorCount: results.filter((r) => {
+      const content = typeof r.content === "string" ? r.content : JSON.stringify(r.content);
+      return content.startsWith("Error");
+    }).length
+  });
   return results;
 }
 var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
@@ -1968,6 +2259,10 @@ Choose parallel routing when the task benefits from multiple perspectives or dat
 var llmBasedRouting = {
   name: "llm-based",
   async route(state, config) {
+    logger.info("Starting LLM-based routing", {
+      iteration: state.iteration,
+      availableWorkers: Object.keys(state.workers).length
+    });
     if (!config.model) {
       throw new Error("LLM-based routing requires a model to be configured");
     }
@@ -1980,8 +2275,20 @@ var llmBasedRouting = {
       const available = caps.available ? "available" : "busy";
       return `- ${id}: Skills: [${skills}], Tools: [${tools2}], Status: ${available}, Workload: ${caps.currentWorkload}`;
     }).join("\n");
+    logger.debug("Worker capabilities", {
+      workers: Object.entries(state.workers).map(([id, caps]) => ({
+        id,
+        skills: caps.skills,
+        available: caps.available,
+        workload: caps.currentWorkload
+      }))
+    });
     const lastMessage = state.messages[state.messages.length - 1];
     const taskContext = lastMessage?.content || state.input;
+    logger.debug("Task context", {
+      taskLength: taskContext.length,
+      taskPreview: taskContext.substring(0, 100)
+    });
     const userPrompt = `Current task: ${taskContext}
 
 Available workers:
@@ -1991,6 +2298,11 @@ Select the best worker(s) for this task and explain your reasoning.`;
     const conversationHistory = [];
     let attempt = 0;
     while (attempt < maxRetries) {
+      logger.debug("LLM routing attempt", {
+        attempt: attempt + 1,
+        maxRetries,
+        conversationHistoryLength: conversationHistory.length
+      });
       const messages = [
         new import_messages4.SystemMessage(systemPrompt),
         new import_messages4.HumanMessage(userPrompt),
@@ -1998,6 +2310,10 @@ Select the best worker(s) for this task and explain your reasoning.`;
       ];
       const response = await config.model.invoke(messages);
       if (response.tool_calls && response.tool_calls.length > 0) {
+        logger.info("LLM requested tool calls", {
+          toolCount: response.tool_calls.length,
+          toolNames: response.tool_calls.map((tc) => tc.name)
+        });
         if (tools.length === 0) {
           throw new Error("LLM requested tool calls but no tools are configured");
         }
@@ -2007,24 +2323,42 @@ Select the best worker(s) for this task and explain your reasoning.`;
           ...toolResults
         );
         attempt++;
+        logger.debug("Retrying routing with tool results", { attempt });
         continue;
       }
+      logger.debug("Parsing routing decision from LLM response");
       let decision;
       if (response && typeof response === "object" && ("targetAgent" in response || "targetAgents" in response)) {
+        logger.debug("Response is structured output", {
+          hasTargetAgent: "targetAgent" in response,
+          hasTargetAgents: "targetAgents" in response
+        });
         decision = response;
       } else if (response.content) {
         if (typeof response.content === "string") {
           try {
             decision = JSON.parse(response.content);
+            logger.debug("Parsed JSON from string response");
           } catch (error) {
+            logger.error("Failed to parse routing decision", {
+              content: response.content,
+              error: error instanceof Error ? error.message : String(error)
+            });
             throw new Error(`Failed to parse routing decision from LLM. Expected JSON but got: ${response.content}`);
           }
         } else if (typeof response.content === "object") {
+          logger.debug("Response content is already an object");
           decision = response.content;
         } else {
+          logger.error("Unexpected response content type", {
+            type: typeof response.content
+          });
           throw new Error(`Unexpected response content type: ${typeof response.content}`);
         }
       } else {
+        logger.error("Unexpected response format", {
+          response: JSON.stringify(response)
+        });
         throw new Error(`Unexpected response format: ${JSON.stringify(response)}`);
       }
       const result = {
@@ -2035,20 +2369,41 @@ Select the best worker(s) for this task and explain your reasoning.`;
         strategy: "llm-based",
         timestamp: Date.now()
       };
+      logger.info("LLM routing decision made", {
+        targetAgent: result.targetAgent,
+        targetAgents: result.targetAgents,
+        isParallel: result.targetAgents && result.targetAgents.length > 1,
+        confidence: result.confidence,
+        reasoning: result.reasoning
+      });
       return result;
     }
+    logger.error("Max tool retries exceeded", { maxRetries });
     throw new Error(`Max tool retries (${maxRetries}) exceeded without routing decision`);
   }
 };
 var roundRobinRouting = {
   name: "round-robin",
   async route(state, config) {
+    logger.info("Starting round-robin routing", {
+      iteration: state.iteration
+    });
     const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id]) => id);
+    logger.debug("Available workers for round-robin", {
+      count: availableWorkers.length,
+      workers: availableWorkers
+    });
     if (availableWorkers.length === 0) {
+      logger.error("No available workers for round-robin routing");
       throw new Error("No available workers for round-robin routing");
     }
     const lastRoutingIndex = state.routingHistory.length % availableWorkers.length;
     const targetAgent = availableWorkers[lastRoutingIndex];
+    logger.info("Round-robin routing decision", {
+      targetAgent,
+      index: lastRoutingIndex + 1,
+      totalWorkers: availableWorkers.length
+    });
     return {
       targetAgent,
       targetAgents: null,
@@ -2062,8 +2417,15 @@ var roundRobinRouting = {
 var skillBasedRouting = {
   name: "skill-based",
   async route(state, config) {
+    logger.info("Starting skill-based routing", {
+      iteration: state.iteration
+    });
     const lastMessage = state.messages[state.messages.length - 1];
     const taskContent = (lastMessage?.content || state.input).toLowerCase();
+    logger.debug("Task content for skill matching", {
+      taskLength: taskContent.length,
+      taskPreview: taskContent.substring(0, 100)
+    });
     const workerScores = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => {
       const skillMatches = caps.skills.filter(
         (skill) => taskContent.includes(skill.toLowerCase())
@@ -2074,11 +2436,20 @@ var skillBasedRouting = {
       const score = skillMatches * 2 + toolMatches;
       return { id, score, skills: caps.skills, tools: caps.tools };
     }).filter((w) => w.score > 0).sort((a, b) => b.score - a.score);
+    logger.debug("Worker skill scores", {
+      scoredWorkers: workerScores.map((w) => ({ id: w.id, score: w.score }))
+    });
     if (workerScores.length === 0) {
+      logger.warn("No skill matches found, using fallback");
       const firstAvailable = Object.entries(state.workers).find(([_, caps]) => caps.available);
       if (!firstAvailable) {
+        logger.error("No available workers for skill-based routing");
         throw new Error("No available workers for skill-based routing");
       }
+      logger.info("Skill-based routing fallback decision", {
+        targetAgent: firstAvailable[0],
+        confidence: 0.5
+      });
       return {
         targetAgent: firstAvailable[0],
         targetAgents: null,
@@ -2090,6 +2461,12 @@ var skillBasedRouting = {
     }
     const best = workerScores[0];
     const confidence = Math.min(best.score / 5, 1);
+    logger.info("Skill-based routing decision", {
+      targetAgent: best.id,
+      score: best.score,
+      confidence,
+      matchedSkills: best.skills
+    });
     return {
       targetAgent: best.id,
       targetAgents: null,
@@ -2103,13 +2480,26 @@ var skillBasedRouting = {
 var loadBalancedRouting = {
   name: "load-balanced",
   async route(state, config) {
+    logger.info("Starting load-balanced routing", {
+      iteration: state.iteration
+    });
     const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => ({ id, workload: caps.currentWorkload })).sort((a, b) => a.workload - b.workload);
+    logger.debug("Worker workloads", {
+      workers: availableWorkers.map((w) => ({ id: w.id, workload: w.workload }))
+    });
     if (availableWorkers.length === 0) {
+      logger.error("No available workers for load-balanced routing");
       throw new Error("No available workers for load-balanced routing");
     }
     const targetWorker = availableWorkers[0];
     const avgWorkload = availableWorkers.reduce((sum, w) => sum + w.workload, 0) / availableWorkers.length;
     const confidence = targetWorker.workload === 0 ? 1 : Math.max(0.5, 1 - targetWorker.workload / (avgWorkload * 2));
+    logger.info("Load-balanced routing decision", {
+      targetAgent: targetWorker.id,
+      workload: targetWorker.workload,
+      avgWorkload: avgWorkload.toFixed(1),
+      confidence
+    });
     return {
       targetAgent: targetWorker.id,
       targetAgents: null,
@@ -2123,13 +2513,24 @@ var loadBalancedRouting = {
 var ruleBasedRouting = {
   name: "rule-based",
   async route(state, config) {
+    logger.info("Starting rule-based routing", {
+      iteration: state.iteration
+    });
     if (!config.routingFn) {
+      logger.error("Rule-based routing requires a custom routing function");
       throw new Error("Rule-based routing requires a custom routing function");
     }
-    return await config.routingFn(state);
+    const decision = await config.routingFn(state);
+    logger.info("Rule-based routing decision", {
+      targetAgent: decision.targetAgent,
+      targetAgents: decision.targetAgents,
+      confidence: decision.confidence
+    });
+    return decision;
   }
 };
 function getRoutingStrategy(name) {
+  logger.debug("Getting routing strategy", { name });
   switch (name) {
     case "llm-based":
       return llmBasedRouting;
@@ -2142,14 +2543,15 @@ function getRoutingStrategy(name) {
     case "rule-based":
       return ruleBasedRouting;
     default:
+      logger.error("Unknown routing strategy", { name });
       throw new Error(`Unknown routing strategy: ${name}`);
   }
 }
 
 // src/multi-agent/utils.ts
-var import_core7 = require("@agentforge/core");
-var logLevel = process.env.LOG_LEVEL?.toLowerCase() || import_core7.LogLevel.INFO;
-var logger = (0, import_core7.createLogger)("multi-agent", { level: logLevel });
+var import_core9 = require("@agentforge/core");
+var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || import_core9.LogLevel.INFO;
+var logger2 = (0, import_core9.createLogger)("multi-agent", { level: logLevel2 });
 function isReActAgent(obj) {
   return obj && typeof obj === "object" && typeof obj.invoke === "function" && typeof obj.stream === "function" && // Additional check to ensure it's not just any object with invoke/stream
   (obj.constructor?.name === "CompiledGraph" || obj.constructor?.name === "CompiledStateGraph");
@@ -2157,9 +2559,9 @@ 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 task = state.messages[state.messages.length - 1]?.content || state.input;
-      logger.debug("Extracted task", {
+      logger2.debug("Extracted task", {
         workerId,
         taskPreview: task.substring(0, 100) + (task.length > 100 ? "..." : "")
       });
@@ -2167,7 +2569,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         (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 result = await agent.invoke(
@@ -2178,14 +2580,14 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         // Pass through the config for checkpointing and interrupt support
       );
       const response = result.messages?.[result.messages.length - 1]?.content || "No response";
-      logger.debug("Received response from ReAct agent", {
+      logger2.debug("Received response from ReAct agent", {
         workerId,
         responsePreview: response.substring(0, 100) + (response.length > 100 ? "..." : "")
       });
       const toolsUsed = result.actions?.map((action) => action.name).filter(Boolean) || [];
       const uniqueTools = [...new Set(toolsUsed)];
       if (uniqueTools.length > 0) {
-        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,
@@ -2203,14 +2605,10 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         completedTasks: [taskResult]
       };
     } catch (error) {
-      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
-        logger.debug("GraphInterrupt detected - re-throwing", { workerId });
-        throw error;
-      }
-      logger.error("Error in ReAct agent execution", {
+      const errorMessage = handleNodeError(error, `react-agent:${workerId}`, false);
+      logger2.error("Error in ReAct agent execution", {
         workerId,
-        error: error instanceof Error ? error.message : String(error),
-        stack: error instanceof Error ? error.stack : void 0
+        error: errorMessage
       });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === workerId
@@ -2221,7 +2619,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
           workerId,
           success: false,
           result: "",
-          error: error instanceof Error ? error.message : "Unknown error in ReAct agent",
+          error: errorMessage,
           completedAt: Date.now()
         };
         return {
@@ -2232,7 +2630,7 @@ function wrapReActAgent(workerId, agent, verbose = false) {
       }
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : `Unknown error in ReAct wrapper for ${workerId}`
+        error: errorMessage
       };
     }
   };
@@ -2240,7 +2638,9 @@ function wrapReActAgent(workerId, agent, verbose = false) {
 
 // src/multi-agent/nodes.ts
 var import_messages5 = require("@langchain/core/messages");
-var import_core8 = require("@agentforge/core");
+var import_core10 = require("@agentforge/core");
+var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || import_core10.LogLevel.INFO;
+var logger3 = (0, import_core10.createLogger)("multi-agent:nodes", { level: logLevel3 });
 var DEFAULT_AGGREGATOR_SYSTEM_PROMPT = `You are an aggregator agent responsible for combining results from multiple worker agents.
 
 Your job is to:
@@ -2258,13 +2658,19 @@ function createSupervisorNode(config) {
   } = config;
   return async (state) => {
     try {
-      if (verbose) {
-        console.log(`[Supervisor] Routing iteration ${state.iteration}/${maxIterations}`);
-      }
+      logger3.info("Supervisor node executing", {
+        iteration: state.iteration,
+        maxIterations,
+        activeAssignments: state.activeAssignments.length,
+        completedTasks: state.completedTasks.length
+      });
+      logger3.debug(`Routing iteration ${state.iteration}/${maxIterations}`);
       if (state.iteration >= maxIterations) {
-        if (verbose) {
-          console.log("[Supervisor] Max iterations reached, moving to aggregation");
-        }
+        logger3.warn("Max iterations reached", {
+          iteration: state.iteration,
+          maxIterations
+        });
+        logger3.debug("Max iterations reached, moving to aggregation");
         return {
           status: "aggregating",
           currentAgent: "aggregator"
@@ -2273,27 +2679,55 @@ function createSupervisorNode(config) {
       const allCompleted = state.activeAssignments.every(
         (assignment) => state.completedTasks.some((task2) => task2.assignmentId === assignment.id)
       );
+      logger3.debug("Checking task completion", {
+        activeAssignments: state.activeAssignments.length,
+        completedTasks: state.completedTasks.length,
+        allCompleted
+      });
       if (allCompleted && state.activeAssignments.length > 0) {
-        if (verbose) {
-          console.log("[Supervisor] All tasks completed, moving to aggregation");
-        }
+        logger3.info("All tasks completed, moving to aggregation", {
+          completedCount: state.completedTasks.length
+        });
+        logger3.debug("All tasks completed, moving to aggregation");
         return {
           status: "aggregating",
           currentAgent: "aggregator"
         };
       }
+      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] : [];
+      logger3.debug("Target agents determined", {
+        targetAgents,
+        isParallel: targetAgents.length > 1,
+        decision: {
+          reasoning: decision.reasoning,
+          confidence: decision.confidence
+        }
+      });
       if (targetAgents.length === 0) {
+        logger3.error("No target agents specified in routing decision");
         throw new Error("Routing decision must specify at least one target agent");
       }
-      if (verbose) {
-        if (targetAgents.length === 1) {
-          console.log(`[Supervisor] Routing to ${targetAgents[0]}: ${decision.reasoning}`);
-        } else {
-          console.log(`[Supervisor] Routing to ${targetAgents.length} agents in parallel [${targetAgents.join(", ")}]: ${decision.reasoning}`);
-        }
+      if (targetAgents.length === 1) {
+        logger3.info("Routing to single agent", {
+          targetAgent: targetAgents[0],
+          reasoning: decision.reasoning,
+          confidence: decision.confidence
+        });
+      } else {
+        logger3.info("Routing to multiple agents in parallel", {
+          targetAgents,
+          count: targetAgents.length,
+          reasoning: decision.reasoning,
+          confidence: decision.confidence
+        });
+      }
+      if (targetAgents.length === 1) {
+        logger3.debug(`Routing to ${targetAgents[0]}: ${decision.reasoning}`);
+      } else {
+        logger3.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) => ({
@@ -2303,6 +2737,14 @@ function createSupervisorNode(config) {
         priority: 5,
         assignedAt: Date.now()
       }));
+      logger3.debug("Created task assignments", {
+        assignmentCount: assignments.length,
+        assignments: assignments.map((a) => ({
+          id: a.id,
+          workerId: a.workerId,
+          taskLength: a.task.length
+        }))
+      });
       const messages = assignments.map((assignment) => ({
         id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
         from: "supervisor",
@@ -2315,6 +2757,12 @@ function createSupervisorNode(config) {
           priority: assignment.priority
         }
       }));
+      logger3.info("Supervisor routing complete", {
+        currentAgent: targetAgents.join(","),
+        status: "executing",
+        assignmentCount: assignments.length,
+        nextIteration: state.iteration + 1
+      });
       return {
         currentAgent: targetAgents.join(","),
         // Store all agents (for backward compat)
@@ -2326,7 +2774,11 @@ function createSupervisorNode(config) {
         iteration: state.iteration + 1
       };
     } catch (error) {
-      console.error("[Supervisor] Error:", error);
+      logger3.error("Supervisor node error", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        iteration: state.iteration
+      });
       return {
         status: "failed",
         error: error instanceof Error ? error.message : "Unknown error in supervisor"
@@ -2347,40 +2799,52 @@ function createWorkerNode(config) {
   } = config;
   return async (state, runConfig) => {
     try {
-      if (verbose) {
-        console.log(`[Worker:${id}] Executing task`);
-      }
+      logger3.info("Worker node executing", {
+        workerId: id,
+        iteration: state.iteration,
+        activeAssignments: state.activeAssignments.length
+      });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === id && !state.completedTasks.some((task) => task.assignmentId === assignment.id)
       );
       if (!currentAssignment) {
-        if (verbose) {
-          console.log(`[Worker:${id}] No active assignment found`);
-        }
+        logger3.debug("No active assignment found for worker", {
+          workerId: id,
+          totalActiveAssignments: state.activeAssignments.length,
+          completedTasks: state.completedTasks.length
+        });
         return {};
       }
+      logger3.info("Worker processing assignment", {
+        workerId: id,
+        assignmentId: currentAssignment.id,
+        taskLength: currentAssignment.task.length,
+        taskPreview: currentAssignment.task.substring(0, 100)
+      });
       if (executeFn) {
-        if (verbose) {
-          console.log(`[Worker:${id}] Using custom executeFn`);
-        }
+        logger3.debug("Using custom execution function", { workerId: id });
         return await executeFn(state, runConfig);
       }
       if (agent) {
         if (isReActAgent(agent)) {
-          if (verbose) {
-            console.log(`[Worker:${id}] Using ReAct agent (auto-wrapped)`);
-          }
+          logger3.debug("Using ReAct agent", { workerId: id });
           const wrappedFn = wrapReActAgent(id, agent, verbose);
           return await wrappedFn(state, runConfig);
         } else {
-          console.warn(`[Worker:${id}] Agent provided but does not appear to be a ReAct agent. Falling back to default execution.`);
+          logger3.warn("Agent provided but not a ReAct agent, falling back", { workerId: id });
         }
       }
       if (!model) {
+        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`
         );
       }
+      logger3.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(", ")}
@@ -2392,14 +2856,23 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
       ];
       let modelToUse = model;
       if (tools.length > 0 && model.bindTools) {
-        const langchainTools = (0, import_core8.toLangChainTools)(tools);
+        logger3.debug("Binding tools to model", {
+          workerId: id,
+          toolCount: tools.length,
+          toolNames: tools.map((t) => t.metadata.name)
+        });
+        const langchainTools = (0, import_core10.toLangChainTools)(tools);
         modelToUse = model.bindTools(langchainTools);
       }
+      logger3.debug("Invoking LLM", { workerId: id });
       const response = await modelToUse.invoke(messages);
       const result = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      if (verbose) {
-        console.log(`[Worker:${id}] Task completed:`, result.substring(0, 100) + "...");
-      }
+      logger3.info("Worker task completed", {
+        workerId: id,
+        assignmentId: currentAssignment.id,
+        resultLength: result.length,
+        resultPreview: result.substring(0, 100)
+      });
       const taskResult = {
         assignmentId: currentAssignment.id,
         workerId: id,
@@ -2429,26 +2902,35 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
           currentWorkload: Math.max(0, capabilities.currentWorkload - 1)
         }
       };
+      logger3.debug("Worker state update", {
+        workerId: id,
+        newWorkload: updatedWorkers[id].currentWorkload
+      });
       return {
         completedTasks: [taskResult],
         messages: [message],
         workers: updatedWorkers
       };
     } catch (error) {
-      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
-        throw error;
-      }
-      console.error(`[Worker:${id}] Error:`, error);
+      const errorMessage = handleNodeError(error, `worker:${id}`, false);
+      logger3.error("Worker node error", {
+        workerId: id,
+        error: errorMessage
+      });
       const currentAssignment = state.activeAssignments.find(
         (assignment) => assignment.workerId === id
       );
       if (currentAssignment) {
+        logger3.warn("Creating error result for assignment", {
+          workerId: id,
+          assignmentId: currentAssignment.id
+        });
         const errorResult = {
           assignmentId: currentAssignment.id,
           workerId: id,
           success: false,
           result: "",
-          error: error instanceof Error ? error.message : "Unknown error",
+          error: errorMessage,
           completedAt: Date.now()
         };
         return {
@@ -2457,9 +2939,10 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
           status: "routing"
         };
       }
+      logger3.error("No assignment found for error handling", { workerId: id });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : `Unknown error in worker ${id}`
+        error: errorMessage
       };
     }
   };
@@ -2473,29 +2956,44 @@ function createAggregatorNode(config = {}) {
   } = config;
   return async (state) => {
     try {
-      if (verbose) {
-        console.log("[Aggregator] Combining results from workers");
-      }
+      logger3.info("Aggregator node executing", {
+        completedTasks: state.completedTasks.length,
+        successfulTasks: state.completedTasks.filter((t) => t.success).length,
+        failedTasks: state.completedTasks.filter((t) => !t.success).length
+      });
+      logger3.debug("Combining results from workers");
       if (aggregateFn) {
+        logger3.debug("Using custom aggregation function");
         const response2 = await aggregateFn(state);
+        logger3.info("Custom aggregation complete", {
+          responseLength: response2.length
+        });
         return {
           response: response2,
           status: "completed"
         };
       }
       if (state.completedTasks.length === 0) {
+        logger3.warn("No completed tasks to aggregate");
         return {
           response: "No tasks were completed.",
           status: "completed"
         };
       }
       if (!model) {
+        logger3.debug("No model provided, concatenating results");
         const combinedResults = state.completedTasks.filter((task) => task.success).map((task) => task.result).join("\n\n");
+        logger3.info("Simple concatenation complete", {
+          resultLength: combinedResults.length
+        });
         return {
           response: combinedResults || "No successful results to aggregate.",
           status: "completed"
         };
       }
+      logger3.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}`;
@@ -2512,17 +3010,24 @@ Please synthesize these results into a comprehensive response that addresses the
         new import_messages5.SystemMessage(systemPrompt),
         new import_messages5.HumanMessage(userPrompt)
       ];
+      logger3.debug("Invoking aggregation LLM");
       const response = await model.invoke(messages);
       const aggregatedResponse = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
-      if (verbose) {
-        console.log("[Aggregator] Aggregation complete");
-      }
+      logger3.info("Aggregation complete", {
+        responseLength: aggregatedResponse.length,
+        responsePreview: aggregatedResponse.substring(0, 100)
+      });
+      logger3.debug("Aggregation complete");
       return {
         response: aggregatedResponse,
         status: "completed"
       };
     } catch (error) {
-      console.error("[Aggregator] Error:", error);
+      logger3.error("Aggregator node error", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        completedTasks: state.completedTasks.length
+      });
       return {
         status: "failed",
         error: error instanceof Error ? error.message : "Unknown error in aggregator"
@@ -2533,7 +3038,9 @@ Please synthesize these results into a comprehensive response that addresses the
 
 // src/multi-agent/agent.ts
 var import_langgraph4 = require("@langchain/langgraph");
-var import_core9 = require("@agentforge/core");
+var import_core11 = require("@agentforge/core");
+var logLevel4 = process.env.LOG_LEVEL?.toLowerCase() || import_core11.LogLevel.INFO;
+var logger4 = (0, import_core11.createLogger)("multi-agent:system", { level: logLevel4 });
 function createMultiAgentSystem(config) {
   const {
     supervisor,
@@ -2551,7 +3058,7 @@ function createMultiAgentSystem(config) {
       configuredModel = configuredModel.withStructuredOutput(RoutingDecisionSchema);
     }
     if (supervisor.tools && supervisor.tools.length > 0) {
-      const langchainTools = (0, import_core9.toLangChainTools)(supervisor.tools);
+      const langchainTools = (0, import_core11.toLangChainTools)(supervisor.tools);
       configuredModel = configuredModel.bindTools(langchainTools);
     }
     supervisorConfig.model = configuredModel;
@@ -2575,25 +3082,49 @@ function createMultiAgentSystem(config) {
   });
   workflow.addNode("aggregator", aggregatorNode);
   const supervisorRouter = (state) => {
+    logger4.debug("Supervisor router executing", {
+      status: state.status,
+      currentAgent: state.currentAgent,
+      iteration: state.iteration
+    });
     if (state.status === "completed" || state.status === "failed") {
+      logger4.info("Supervisor router: ending workflow", { status: state.status });
       return import_langgraph4.END;
     }
     if (state.status === "aggregating") {
+      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());
+        logger4.info("Supervisor router: parallel routing", {
+          agents,
+          count: agents.length
+        });
         return agents;
       }
+      logger4.info("Supervisor router: single agent routing", {
+        targetAgent: state.currentAgent
+      });
       return state.currentAgent;
     }
+    logger4.debug("Supervisor router: staying at supervisor");
     return "supervisor";
   };
   const workerRouter = (state) => {
+    logger4.debug("Worker router executing", {
+      iteration: state.iteration,
+      completedTasks: state.completedTasks.length
+    });
+    logger4.debug("Worker router: returning to supervisor");
     return "supervisor";
   };
   const aggregatorRouter = (state) => {
+    logger4.info("Aggregator router: ending workflow", {
+      completedTasks: state.completedTasks.length,
+      status: state.status
+    });
     return import_langgraph4.END;
   };
   workflow.setEntryPoint("supervisor");
@@ -2787,11 +3318,14 @@ function registerWorkers(system, workers) {
   ToolCallSchema,
   ToolResultSchema,
   WorkerCapabilitiesSchema,
+  buildDeduplicationMetrics,
+  calculateDeduplicationSavings,
   createAggregatorNode,
   createExecutorNode,
   createFinisherNode,
   createGeneratorNode,
   createMultiAgentSystem,
+  createPatternLogger,
   createPlanExecuteAgent,
   createPlannerNode,
   createReActAgent,
@@ -2803,6 +3337,7 @@ function registerWorkers(system, workers) {
   createReviserNode,
   createSupervisorNode,
   createWorkerNode,
+  generateToolCallCacheKey,
   getRoutingStrategy,
   llmBasedRouting,
   loadBalancedRouting,