@agentforge/patterns 0.6.4 → 0.7.0

package/dist/index.js

@@ -35,15 +35,46 @@ var ScratchpadEntrySchema = z.object({
 });
 
 // src/react/state.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import { createStateAnnotation } from "@agentforge/core";
+
+// src/shared/state-fields.ts
+import { z as z2 } from "zod";
+var iterationField = {
+  schema: z2.number().int().nonnegative(),
+  reducer: (left, right) => left + right,
+  default: () => 0,
+  description: "Current iteration number"
+};
+function maxIterationsField(defaultValue) {
+  return {
+    schema: z2.number().int().positive(),
+    default: () => defaultValue,
+    description: "Maximum number of iterations allowed"
+  };
+}
+var errorField = {
+  schema: z2.string().optional(),
+  description: "Error message if execution failed"
+};
+var responseField = {
+  schema: z2.string().optional(),
+  description: "Final response after completion"
+};
+var inputField = {
+  schema: z2.string(),
+  default: () => "",
+  description: "Original user input or query"
+};
+
+// src/react/state.ts
 var ReActStateConfig = {
   /**
    * Conversation messages
    * Accumulates all messages in the conversation
    */
   messages: {
-    schema: z2.array(MessageSchema),
+    schema: z3.array(MessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Conversation message history"
@@ -53,7 +84,7 @@ var ReActStateConfig = {
    * Accumulates all reasoning steps the agent takes
    */
   thoughts: {
-    schema: z2.array(ThoughtSchema),
+    schema: z3.array(ThoughtSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Agent reasoning steps"
@@ -63,7 +94,7 @@ var ReActStateConfig = {
    * Accumulates all tool calls made by the agent
    */
   actions: {
-    schema: z2.array(ToolCallSchema),
+    schema: z3.array(ToolCallSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Tool calls made by the agent"
@@ -73,7 +104,7 @@ var ReActStateConfig = {
    * Accumulates all observations from tool executions
    */
   observations: {
-    schema: z2.array(ToolResultSchema),
+    schema: z3.array(ToolResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Results from tool executions"
@@ -83,7 +114,7 @@ var ReActStateConfig = {
    * Accumulates step-by-step reasoning process
    */
   scratchpad: {
-    schema: z2.array(ScratchpadEntrySchema),
+    schema: z3.array(ScratchpadEntrySchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Intermediate reasoning scratchpad"
@@ -92,27 +123,19 @@ var ReActStateConfig = {
    * Current iteration count
    * Tracks how many thought-action-observation loops have been executed
    */
-  iteration: {
-    schema: z2.number(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Current iteration count"
-  },
+  iteration: iterationField,
   /**
    * Whether the agent should continue iterating
    */
   shouldContinue: {
-    schema: z2.boolean().optional(),
+    schema: z3.boolean().optional(),
     default: () => true,
     description: "Whether to continue the ReAct loop"
   },
   /**
    * Final response (if any)
    */
-  response: {
-    schema: z2.string().optional(),
-    description: "Final response from the agent"
-  }
+  response: responseField
 };
 var ReActState = createStateAnnotation(ReActStateConfig);
 
@@ -176,6 +199,24 @@ function buildDeduplicationMetrics(toolsExecuted, duplicatesSkipped, totalObserv
   };
 }
 
+// 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");
@@ -338,10 +379,7 @@ function createActionNode(tools, verbose = false, enableDeduplication = true) {
           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,
@@ -580,34 +618,34 @@ function createReActAgentBuilder() {
 import { StateGraph as StateGraph2, END as END2 } from "@langchain/langgraph";
 
 // src/plan-execute/state.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import { createStateAnnotation as createStateAnnotation2 } from "@agentforge/core";
 
 // src/plan-execute/schemas.ts
-import { z as z3 } from "zod";
-var PlanStepSchema = z3.object({
+import { z as z4 } from "zod";
+var PlanStepSchema = z4.object({
   /**
    * Unique identifier for the step
    */
-  id: z3.string().describe("Unique identifier for the step"),
+  id: z4.string().describe("Unique identifier for the step"),
   /**
    * Description of what this step should accomplish
    */
-  description: z3.string().describe("Description of what this step should accomplish"),
+  description: z4.string().describe("Description of what this step should accomplish"),
   /**
    * Optional dependencies on other steps (by ID)
    */
-  dependencies: z3.array(z3.string()).optional().describe("IDs of steps that must complete before this one"),
+  dependencies: z4.array(z4.string()).optional().describe("IDs of steps that must complete before this one"),
   /**
    * Optional tool to use for this step
    */
-  tool: z3.string().optional().describe("Name of the tool to use for this step"),
+  tool: z4.string().optional().describe("Name of the tool to use for this step"),
   /**
    * Optional arguments for the tool
    */
-  args: z3.record(z3.any()).optional().describe("Arguments to pass to the tool")
+  args: z4.record(z4.any()).optional().describe("Arguments to pass to the tool")
 });
-var CompletedStepSchema = z3.object({
+var CompletedStepSchema = z4.object({
   /**
    * The step that was executed
    */
@@ -615,53 +653,53 @@ var CompletedStepSchema = z3.object({
   /**
    * The result of executing the step
    */
-  result: z3.any().describe("The result of executing the step"),
+  result: z4.any().describe("The result of executing the step"),
   /**
    * Whether the step succeeded
    */
-  success: z3.boolean().describe("Whether the step succeeded"),
+  success: z4.boolean().describe("Whether the step succeeded"),
   /**
    * Optional error message if the step failed
    */
-  error: z3.string().optional().describe("Error message if the step failed"),
+  error: z4.string().optional().describe("Error message if the step failed"),
   /**
    * Timestamp when the step was completed
    */
-  timestamp: z3.string().datetime().describe("ISO timestamp when the step was completed")
+  timestamp: z4.string().datetime().describe("ISO timestamp when the step was completed")
 });
-var PlanSchema = z3.object({
+var PlanSchema = z4.object({
   /**
    * List of steps in the plan
    */
-  steps: z3.array(PlanStepSchema).describe("List of steps in the plan"),
+  steps: z4.array(PlanStepSchema).describe("List of steps in the plan"),
   /**
    * Overall goal of the plan
    */
-  goal: z3.string().describe("Overall goal of the plan"),
+  goal: z4.string().describe("Overall goal of the plan"),
   /**
    * Timestamp when the plan was created
    */
-  createdAt: z3.string().datetime().describe("ISO timestamp when the plan was created"),
+  createdAt: z4.string().datetime().describe("ISO timestamp when the plan was created"),
   /**
    * Optional confidence score (0-1)
    */
-  confidence: z3.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
+  confidence: z4.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
 });
-var ReplanDecisionSchema = z3.object({
+var ReplanDecisionSchema = z4.object({
   /**
    * Whether to replan
    */
-  shouldReplan: z3.boolean().describe("Whether to replan based on current results"),
+  shouldReplan: z4.boolean().describe("Whether to replan based on current results"),
   /**
    * Reason for the decision
    */
-  reason: z3.string().describe("Reason for the replan decision"),
+  reason: z4.string().describe("Reason for the replan decision"),
   /**
    * Optional new goal if replanning
    */
-  newGoal: z3.string().optional().describe("Updated goal if replanning")
+  newGoal: z4.string().optional().describe("Updated goal if replanning")
 });
-var ExecutionStatusSchema = z3.enum([
+var ExecutionStatusSchema = z4.enum([
   "planning",
   "executing",
   "replanning",
@@ -674,11 +712,7 @@ var PlanExecuteStateConfig = {
   /**
    * Original user input/query
    */
-  input: {
-    schema: z4.string(),
-    default: () => "",
-    description: "Original user input or query"
-  },
+  input: inputField,
   /**
    * The current plan
    */
@@ -691,7 +725,7 @@ var PlanExecuteStateConfig = {
    * Accumulates all completed steps
    */
   pastSteps: {
-    schema: z4.array(CompletedStepSchema),
+    schema: z5.array(CompletedStepSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed steps with their results"
@@ -700,7 +734,7 @@ var PlanExecuteStateConfig = {
    * Index of the current step being executed
    */
   currentStepIndex: {
-    schema: z4.number().int().nonnegative().optional(),
+    schema: z5.number().int().nonnegative().optional(),
     description: "Index of the current step being executed"
   },
   /**
@@ -714,34 +748,19 @@ var PlanExecuteStateConfig = {
   /**
    * Final response
    */
-  response: {
-    schema: z4.string().optional(),
-    description: "Final response after plan execution"
-  },
+  response: responseField,
   /**
    * Error message if execution failed
    */
-  error: {
-    schema: z4.string().optional(),
-    description: "Error message if execution failed"
-  },
+  error: errorField,
   /**
    * Iteration counter for replanning
    */
-  iteration: {
-    schema: z4.number().int().nonnegative(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Number of planning iterations"
-  },
+  iteration: iterationField,
   /**
    * Maximum iterations allowed
    */
-  maxIterations: {
-    schema: z4.number().int().positive(),
-    default: () => 5,
-    description: "Maximum number of planning iterations allowed"
-  }
+  maxIterations: maxIterationsField(5)
 };
 var PlanExecuteState = createStateAnnotation2(PlanExecuteStateConfig);
 
@@ -974,11 +993,8 @@ function createExecutorNode(config) {
           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,
@@ -1181,46 +1197,46 @@ function createPlanExecuteAgent(config) {
 }
 
 // src/reflection/state.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 import { createStateAnnotation as createStateAnnotation3 } from "@agentforge/core";
 
 // src/reflection/schemas.ts
-import { z as z5 } from "zod";
-var ReflectionSchema = z5.object({
+import { z as z6 } from "zod";
+var ReflectionSchema = z6.object({
   /**
    * The critique or feedback on the current response
    */
-  critique: z5.string().describe("Critique or feedback on the current response"),
+  critique: z6.string().describe("Critique or feedback on the current response"),
   /**
    * Specific issues identified
    */
-  issues: z5.array(z5.string()).describe("Specific issues or problems identified"),
+  issues: z6.array(z6.string()).describe("Specific issues or problems identified"),
   /**
    * Suggestions for improvement
    */
-  suggestions: z5.array(z5.string()).describe("Suggestions for improving the response"),
+  suggestions: z6.array(z6.string()).describe("Suggestions for improving the response"),
   /**
    * Quality score (0-10)
    */
-  score: z5.number().min(0).max(10).optional().describe("Quality score from 0 to 10"),
+  score: z6.number().min(0).max(10).optional().describe("Quality score from 0 to 10"),
   /**
    * Whether the response meets quality standards
    */
-  meetsStandards: z5.boolean().describe("Whether the response meets quality standards"),
+  meetsStandards: z6.boolean().describe("Whether the response meets quality standards"),
   /**
    * Timestamp of the reflection
    */
-  timestamp: z5.date().optional().describe("When this reflection was created")
+  timestamp: z6.date().optional().describe("When this reflection was created")
 });
-var RevisionSchema = z5.object({
+var RevisionSchema = z6.object({
   /**
    * The revised content
    */
-  content: z5.string().describe("The revised content"),
+  content: z6.string().describe("The revised content"),
   /**
    * Which iteration this revision is from
    */
-  iteration: z5.number().int().nonnegative().describe("Iteration number"),
+  iteration: z6.number().int().nonnegative().describe("Iteration number"),
   /**
    * The reflection that prompted this revision
    */
@@ -1228,9 +1244,9 @@ var RevisionSchema = z5.object({
   /**
    * Timestamp of the revision
    */
-  timestamp: z5.date().optional().describe("When this revision was created")
+  timestamp: z6.date().optional().describe("When this revision was created")
 });
-var ReflectionStatusSchema = z5.enum([
+var ReflectionStatusSchema = z6.enum([
   "generating",
   // Initial generation
   "reflecting",
@@ -1242,25 +1258,25 @@ var ReflectionStatusSchema = z5.enum([
   "failed"
   // Max iterations reached without meeting standards
 ]);
-var QualityCriteriaSchema = z5.object({
+var QualityCriteriaSchema = z6.object({
   /**
    * Minimum quality score required (0-10)
    */
-  minScore: z5.number().min(0).max(10).default(7).describe("Minimum quality score required"),
+  minScore: z6.number().min(0).max(10).default(7).describe("Minimum quality score required"),
   /**
    * Specific criteria to evaluate
    */
-  criteria: z5.array(z5.string()).optional().describe("Specific criteria to evaluate"),
+  criteria: z6.array(z6.string()).optional().describe("Specific criteria to evaluate"),
   /**
    * Whether all criteria must be met
    */
-  requireAll: z5.boolean().default(true).describe("Whether all criteria must be met")
+  requireAll: z6.boolean().default(true).describe("Whether all criteria must be met")
 });
-var ReflectionConfigSchema = z5.object({
+var ReflectionConfigSchema = z6.object({
   /**
    * Maximum number of reflection iterations
    */
-  maxIterations: z5.number().int().positive().default(3).describe("Maximum reflection iterations"),
+  maxIterations: z6.number().int().positive().default(3).describe("Maximum reflection iterations"),
   /**
    * Quality criteria for completion
    */
@@ -1268,7 +1284,7 @@ var ReflectionConfigSchema = z5.object({
   /**
    * Whether to include previous reflections in context
    */
-  includeHistory: z5.boolean().default(true).describe("Include previous reflections in context")
+  includeHistory: z6.boolean().default(true).describe("Include previous reflections in context")
 });
 
 // src/reflection/state.ts
@@ -1276,16 +1292,12 @@ var ReflectionStateConfig = {
   /**
    * Original user input/task
    */
-  input: {
-    schema: z6.string(),
-    default: () => "",
-    description: "Original user input or task"
-  },
+  input: inputField,
   /**
    * Current response/output
    */
   currentResponse: {
-    schema: z6.string().optional(),
+    schema: z7.string().optional(),
     description: "Current response or output"
   },
   /**
@@ -1293,7 +1305,7 @@ var ReflectionStateConfig = {
    * Accumulates all reflections
    */
   reflections: {
-    schema: z6.array(ReflectionSchema),
+    schema: z7.array(ReflectionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of all reflections and critiques"
@@ -1303,7 +1315,7 @@ var ReflectionStateConfig = {
    * Accumulates all revisions
    */
   revisions: {
-    schema: z6.array(RevisionSchema),
+    schema: z7.array(RevisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of all revisions"
@@ -1311,12 +1323,7 @@ var ReflectionStateConfig = {
   /**
    * Current iteration number
    */
-  iteration: {
-    schema: z6.number().int().nonnegative(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Current iteration number"
-  },
+  iteration: iterationField,
   /**
    * Current status
    */
@@ -1335,25 +1342,15 @@ var ReflectionStateConfig = {
   /**
    * Maximum iterations allowed
    */
-  maxIterations: {
-    schema: z6.number().int().positive(),
-    default: () => 3,
-    description: "Maximum number of reflection iterations allowed"
-  },
+  maxIterations: maxIterationsField(3),
   /**
    * Final response (when completed)
    */
-  response: {
-    schema: z6.string().optional(),
-    description: "Final response after reflection process"
-  },
+  response: responseField,
   /**
    * Error message if failed
    */
-  error: {
-    schema: z6.string().optional(),
-    description: "Error message if reflection failed"
-  }
+  error: errorField
 };
 var ReflectionState = createStateAnnotation3(ReflectionStateConfig);
 
@@ -1502,14 +1499,15 @@ ${lastReflection.critique}`;
         iteration: 1
       };
     } catch (error) {
+      const errorMessage = handleNodeError(error, "generator", false);
       generatorLogger.error("Response generation failed", {
         attempt: state.iteration + 1,
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessage,
         duration: Date.now() - startTime
       });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in generator"
+        error: errorMessage
       };
     }
   };
@@ -1591,14 +1589,15 @@ function createReflectorNode(config) {
         status: reflection.meetsStandards ? "completed" : "revising"
       };
     } catch (error) {
+      const errorMessage = handleNodeError(error, "reflector", false);
       reflectorLogger.error("Reflection failed", {
         attempt: state.iteration,
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessage,
         duration: Date.now() - startTime
       });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in reflector"
+        error: errorMessage
       };
     }
   };
@@ -1659,14 +1658,15 @@ ${revisionsText}`;
         iteration: 1
       };
     } catch (error) {
+      const errorMessage = handleNodeError(error, "reviser", false);
       reviserLogger.error("Revision failed", {
         attempt: state.iteration,
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessage,
         duration: Date.now() - startTime
       });
       return {
         status: "failed",
-        error: error instanceof Error ? error.message : "Unknown error in reviser"
+        error: errorMessage
       };
     }
   };
@@ -1752,13 +1752,13 @@ function createReflectionAgent(config) {
 }
 
 // src/multi-agent/state.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 import { createStateAnnotation as createStateAnnotation4 } from "@agentforge/core";
 
 // src/multi-agent/schemas.ts
-import { z as z7 } from "zod";
-var AgentRoleSchema = z7.enum(["supervisor", "worker"]);
-var MessageTypeSchema = z7.enum([
+import { z as z8 } from "zod";
+var AgentRoleSchema = z8.enum(["supervisor", "worker"]);
+var MessageTypeSchema = z8.enum([
   "user_input",
   // Initial user message
   "task_assignment",
@@ -1772,11 +1772,11 @@ var MessageTypeSchema = z7.enum([
   "completion"
   // Final completion message
 ]);
-var AgentMessageSchema = z7.object({
+var AgentMessageSchema = z8.object({
   /**
    * Unique identifier for the message
    */
-  id: z7.string().describe("Unique message identifier"),
+  id: z8.string().describe("Unique message identifier"),
   /**
    * Type of message
    */
@@ -1784,25 +1784,25 @@ var AgentMessageSchema = z7.object({
   /**
    * Agent that sent the message
    */
-  from: z7.string().describe("Agent identifier that sent the message"),
+  from: z8.string().describe("Agent identifier that sent the message"),
   /**
    * Agent(s) that should receive the message
    */
-  to: z7.union([z7.string(), z7.array(z7.string())]).describe("Target agent(s)"),
+  to: z8.union([z8.string(), z8.array(z8.string())]).describe("Target agent(s)"),
   /**
    * Message content
    */
-  content: z7.string().describe("Message content"),
+  content: z8.string().describe("Message content"),
   /**
    * Optional metadata
    */
-  metadata: z7.record(z7.any()).optional().describe("Additional message metadata"),
+  metadata: z8.record(z8.any()).optional().describe("Additional message metadata"),
   /**
    * Timestamp when message was created
    */
-  timestamp: z7.number().describe("Timestamp when message was created")
+  timestamp: z8.number().describe("Timestamp when message was created")
 });
-var RoutingStrategySchema = z7.enum([
+var RoutingStrategySchema = z8.enum([
   "llm-based",
   // LLM decides which agent to route to
   "rule-based",
@@ -1814,25 +1814,25 @@ var RoutingStrategySchema = z7.enum([
   "load-balanced"
   // Route based on agent workload
 ]);
-var RoutingDecisionSchema = z7.object({
+var RoutingDecisionSchema = z8.object({
   /**
    * Target agent to route to (single agent routing)
    * @deprecated Use targetAgents for parallel routing support
    */
-  targetAgent: z7.string().nullable().default(null).describe("Agent to route the task to (single routing)"),
+  targetAgent: z8.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: z7.array(z7.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
+  targetAgents: z8.array(z8.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
   /**
    * Reasoning for the routing decision
    */
-  reasoning: z7.string().default("").describe("Explanation for routing decision"),
+  reasoning: z8.string().default("").describe("Explanation for routing decision"),
   /**
    * Confidence in the routing decision (0-1)
    */
-  confidence: z7.number().min(0).max(1).default(0.8).describe("Confidence score"),
+  confidence: z8.number().min(0).max(1).default(0.8).describe("Confidence score"),
   /**
    * Strategy used for routing
    */
@@ -1840,86 +1840,86 @@ var RoutingDecisionSchema = z7.object({
   /**
    * Timestamp of the routing decision
    */
-  timestamp: z7.number().default(() => Date.now()).describe("Timestamp of the decision")
+  timestamp: z8.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 = z7.object({
+var WorkerCapabilitiesSchema = z8.object({
   /**
    * Skills/capabilities the agent has
    */
-  skills: z7.array(z7.string()).describe("List of agent skills"),
+  skills: z8.array(z8.string()).describe("List of agent skills"),
   /**
    * Tools available to the agent
    */
-  tools: z7.array(z7.string()).describe("List of tool names available to agent"),
+  tools: z8.array(z8.string()).describe("List of tool names available to agent"),
   /**
    * Whether the agent is currently available
    */
-  available: z7.boolean().default(true).describe("Whether agent is available"),
+  available: z8.boolean().default(true).describe("Whether agent is available"),
   /**
    * Current workload (number of active tasks)
    */
-  currentWorkload: z7.number().int().nonnegative().default(0).describe("Current number of active tasks")
+  currentWorkload: z8.number().int().nonnegative().default(0).describe("Current number of active tasks")
 });
-var TaskAssignmentSchema = z7.object({
+var TaskAssignmentSchema = z8.object({
   /**
    * Unique assignment identifier
    */
-  id: z7.string().describe("Unique assignment identifier"),
+  id: z8.string().describe("Unique assignment identifier"),
   /**
    * Worker ID assigned to the task
    */
-  workerId: z7.string().describe("Worker identifier assigned to task"),
+  workerId: z8.string().describe("Worker identifier assigned to task"),
   /**
    * Task description
    */
-  task: z7.string().describe("Description of the task"),
+  task: z8.string().describe("Description of the task"),
   /**
    * Task priority (1-10, higher is more urgent)
    */
-  priority: z7.number().int().min(1).max(10).default(5).describe("Task priority"),
+  priority: z8.number().int().min(1).max(10).default(5).describe("Task priority"),
   /**
    * Timestamp when task was assigned
    */
-  assignedAt: z7.number().describe("Timestamp when task was assigned"),
+  assignedAt: z8.number().describe("Timestamp when task was assigned"),
   /**
    * Optional deadline for task completion
    */
-  deadline: z7.number().optional().describe("Optional task deadline timestamp")
+  deadline: z8.number().optional().describe("Optional task deadline timestamp")
 });
-var TaskResultSchema = z7.object({
+var TaskResultSchema = z8.object({
   /**
    * Assignment identifier
    */
-  assignmentId: z7.string().describe("Assignment identifier"),
+  assignmentId: z8.string().describe("Assignment identifier"),
   /**
    * Worker that completed the task
    */
-  workerId: z7.string().describe("Worker that completed the task"),
+  workerId: z8.string().describe("Worker that completed the task"),
   /**
    * Whether the task succeeded
    */
-  success: z7.boolean().describe("Whether the task succeeded"),
+  success: z8.boolean().describe("Whether the task succeeded"),
   /**
    * Task result/output
    */
-  result: z7.string().describe("Task result or output"),
+  result: z8.string().describe("Task result or output"),
   /**
    * Optional error message if task failed
    */
-  error: z7.string().optional().describe("Error message if task failed"),
+  error: z8.string().optional().describe("Error message if task failed"),
   /**
    * Timestamp when task was completed
    */
-  completedAt: z7.number().describe("Timestamp when task was completed"),
+  completedAt: z8.number().describe("Timestamp when task was completed"),
   /**
    * Optional metadata about execution
    */
-  metadata: z7.record(z7.any()).optional().describe("Execution metadata")
+  metadata: z8.record(z8.any()).optional().describe("Execution metadata")
 });
-var MultiAgentStatusSchema = z7.enum([
+var MultiAgentStatusSchema = z8.enum([
   "initializing",
   // System is initializing
   "routing",
@@ -1935,27 +1935,27 @@ var MultiAgentStatusSchema = z7.enum([
   "failed"
   // Task failed
 ]);
-var HandoffRequestSchema = z7.object({
+var HandoffRequestSchema = z8.object({
   /**
    * Agent requesting the handoff
    */
-  from: z7.string().describe("Agent requesting handoff"),
+  from: z8.string().describe("Agent requesting handoff"),
   /**
    * Target agent for handoff
    */
-  to: z7.string().describe("Target agent for handoff"),
+  to: z8.string().describe("Target agent for handoff"),
   /**
    * Reason for handoff
    */
-  reason: z7.string().describe("Reason for requesting handoff"),
+  reason: z8.string().describe("Reason for requesting handoff"),
   /**
    * Context to pass to next agent
    */
-  context: z7.any().describe("Context to pass to next agent"),
+  context: z8.any().describe("Context to pass to next agent"),
   /**
    * Timestamp of handoff request
    */
-  timestamp: z7.string().datetime().describe("ISO timestamp of handoff request")
+  timestamp: z8.string().datetime().describe("ISO timestamp of handoff request")
 });
 
 // src/multi-agent/state.ts
@@ -1963,17 +1963,13 @@ var MultiAgentStateConfig = {
   /**
    * Original user input/query
    */
-  input: {
-    schema: z8.string(),
-    default: () => "",
-    description: "Original user input or query"
-  },
+  input: inputField,
   /**
    * All messages in the multi-agent conversation
    * Accumulates all messages between agents
    */
   messages: {
-    schema: z8.array(AgentMessageSchema),
+    schema: z9.array(AgentMessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "All messages in the multi-agent conversation"
@@ -1982,7 +1978,7 @@ var MultiAgentStateConfig = {
    * Available worker agents and their capabilities
    */
   workers: {
-    schema: z8.record(z8.string(), WorkerCapabilitiesSchema),
+    schema: z9.record(z9.string(), WorkerCapabilitiesSchema),
     reducer: (left, right) => ({
       ...left,
       ...right
@@ -1994,7 +1990,7 @@ var MultiAgentStateConfig = {
    * Current active agent
    */
   currentAgent: {
-    schema: z8.string().optional(),
+    schema: z9.string().optional(),
     description: "Identifier of the currently active agent"
   },
   /**
@@ -2002,7 +1998,7 @@ var MultiAgentStateConfig = {
    * Accumulates all routing decisions
    */
   routingHistory: {
-    schema: z8.array(RoutingDecisionSchema),
+    schema: z9.array(RoutingDecisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of routing decisions"
@@ -2011,7 +2007,7 @@ var MultiAgentStateConfig = {
    * Active task assignments
    */
   activeAssignments: {
-    schema: z8.array(TaskAssignmentSchema),
+    schema: z9.array(TaskAssignmentSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Currently active task assignments"
@@ -2021,7 +2017,7 @@ var MultiAgentStateConfig = {
    * Accumulates all completed tasks
    */
   completedTasks: {
-    schema: z8.array(TaskResultSchema),
+    schema: z9.array(TaskResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed task results"
@@ -2031,7 +2027,7 @@ var MultiAgentStateConfig = {
    * Accumulates all handoff requests
    */
   handoffs: {
-    schema: z8.array(HandoffRequestSchema),
+    schema: z9.array(HandoffRequestSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Handoff requests between agents"
@@ -2047,34 +2043,19 @@ var MultiAgentStateConfig = {
   /**
    * Iteration counter
    */
-  iteration: {
-    schema: z8.number().int().nonnegative(),
-    reducer: (left, right) => left + right,
-    default: () => 0,
-    description: "Current iteration number"
-  },
+  iteration: iterationField,
   /**
    * Maximum iterations allowed
    */
-  maxIterations: {
-    schema: z8.number().int().positive(),
-    default: () => 10,
-    description: "Maximum number of iterations allowed"
-  },
+  maxIterations: maxIterationsField(10),
   /**
    * Final aggregated response
    */
-  response: {
-    schema: z8.string().optional(),
-    description: "Final aggregated response"
-  },
+  response: responseField,
   /**
    * Error message if execution failed
    */
-  error: {
-    schema: z8.string().optional(),
-    description: "Error message if execution failed"
-  }
+  error: errorField
 };
 var MultiAgentState = createStateAnnotation4(MultiAgentStateConfig);
 
@@ -2521,14 +2502,10 @@ function wrapReActAgent(workerId, agent, verbose = false) {
         completedTasks: [taskResult]
       };
     } catch (error) {
-      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
-        logger2.debug("GraphInterrupt detected - re-throwing", { workerId });
-        throw error;
-      }
+      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
@@ -2539,7 +2516,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 {
@@ -2550,7 +2527,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
       };
     }
   };
@@ -2832,14 +2809,10 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
         workers: updatedWorkers
       };
     } catch (error) {
-      if (error && typeof error === "object" && "constructor" in error && error.constructor.name === "GraphInterrupt") {
-        logger3.info("GraphInterrupt detected, re-throwing", { workerId: id });
-        throw error;
-      }
+      const errorMessage = handleNodeError(error, `worker:${id}`, false);
       logger3.error("Worker node error", {
         workerId: id,
-        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 === id
@@ -2854,7 +2827,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
           workerId: id,
           success: false,
           result: "",
-          error: error instanceof Error ? error.message : "Unknown error",
+          error: errorMessage,
           completedAt: Date.now()
         };
         return {
@@ -2866,7 +2839,7 @@ Execute the assigned task using your skills and tools. Provide a clear, actionab
       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
       };
     }
   };