@agentforge/patterns 0.16.65 → 0.16.67

package/dist/index.cjs

@@ -2104,210 +2104,94 @@ function createReflectionAgent(config) {
 }
 
 // src/multi-agent/state.ts
-var import_zod10 = require("zod");
+var import_zod13 = require("zod");
 var import_core7 = require("@agentforge/core");
 
-// src/multi-agent/schemas.ts
+// src/multi-agent/schemas-message.ts
 var import_zod9 = require("zod");
 var AgentRoleSchema = import_zod9.z.enum(["supervisor", "worker"]);
 var MessageTypeSchema = import_zod9.z.enum([
   "user_input",
-  // Initial user message
   "task_assignment",
-  // Supervisor assigns task to worker
   "task_result",
-  // Worker returns result to supervisor
   "handoff",
-  // Worker hands off to another worker
   "error",
-  // Error message
   "completion"
-  // Final completion message
 ]);
 var AgentMessageSchema = import_zod9.z.object({
-  /**
-   * Unique identifier for the message
-   */
   id: import_zod9.z.string().describe("Unique message identifier"),
-  /**
-   * Type of message
-   */
   type: MessageTypeSchema.describe("Type of message"),
-  /**
-   * Agent that sent the message
-   */
   from: import_zod9.z.string().describe("Agent identifier that sent the message"),
-  /**
-   * Agent(s) that should receive the message
-   */
   to: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.array(import_zod9.z.string())]).describe("Target agent(s)"),
-  /**
-   * Message content
-   */
   content: import_zod9.z.string().describe("Message content"),
-  /**
-   * Optional metadata
-   */
   metadata: JsonObjectSchema.optional().describe("Additional message metadata"),
-  /**
-   * Timestamp when message was created
-   */
   timestamp: import_zod9.z.number().describe("Timestamp when message was created")
 });
-var RoutingStrategySchema = import_zod9.z.enum([
+
+// src/multi-agent/schemas-routing.ts
+var import_zod10 = require("zod");
+var RoutingStrategySchema = import_zod10.z.enum([
   "llm-based",
-  // LLM decides which agent to route to
   "rule-based",
-  // Predefined rules determine routing
   "round-robin",
-  // Distribute tasks evenly across agents
   "skill-based",
-  // Route based on agent capabilities
   "load-balanced"
-  // Route based on agent workload
 ]);
-var RoutingDecisionSchema = import_zod9.z.object({
-  /**
-   * Target agent to route to (single agent routing)
-   * @deprecated Use targetAgents for parallel routing support
-   */
-  targetAgent: import_zod9.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_zod9.z.array(import_zod9.z.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
-  /**
-   * Reasoning for the routing decision
-   */
-  reasoning: import_zod9.z.string().default("").describe("Explanation for routing decision"),
-  /**
-   * Confidence in the routing decision (0-1)
-   */
-  confidence: import_zod9.z.number().min(0).max(1).default(0.8).describe("Confidence score"),
-  /**
-   * Strategy used for routing
-   */
+var RoutingDecisionSchema = import_zod10.z.object({
+  targetAgent: import_zod10.z.string().nullable().default(null).describe("Agent to route the task to (single routing)"),
+  targetAgents: import_zod10.z.array(import_zod10.z.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
+  reasoning: import_zod10.z.string().default("").describe("Explanation for routing decision"),
+  confidence: import_zod10.z.number().min(0).max(1).default(0.8).describe("Confidence score"),
   strategy: RoutingStrategySchema.default("llm-based").describe("Strategy used for this decision"),
-  /**
-   * Timestamp of the routing decision
-   */
-  timestamp: import_zod9.z.number().default(() => Date.now()).describe("Timestamp of the decision")
+  timestamp: import_zod10.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_zod9.z.object({
-  /**
-   * Skills/capabilities the agent has
-   */
-  skills: import_zod9.z.array(import_zod9.z.string()).describe("List of agent skills"),
-  /**
-   * Tools available to the agent
-   */
-  tools: import_zod9.z.array(import_zod9.z.string()).describe("List of tool names available to agent"),
-  /**
-   * Whether the agent is currently available
-   */
-  available: import_zod9.z.boolean().default(true).describe("Whether agent is available"),
-  /**
-   * Current workload (number of active tasks)
-   */
-  currentWorkload: import_zod9.z.number().int().nonnegative().default(0).describe("Current number of active tasks")
+
+// src/multi-agent/schemas-worker.ts
+var import_zod11 = require("zod");
+var WorkerCapabilitiesSchema = import_zod11.z.object({
+  skills: import_zod11.z.array(import_zod11.z.string()).describe("List of agent skills"),
+  tools: import_zod11.z.array(import_zod11.z.string()).describe("List of tool names available to agent"),
+  available: import_zod11.z.boolean().default(true).describe("Whether agent is available"),
+  currentWorkload: import_zod11.z.number().int().nonnegative().default(0).describe("Current number of active tasks")
 });
-var TaskAssignmentSchema = import_zod9.z.object({
-  /**
-   * Unique assignment identifier
-   */
-  id: import_zod9.z.string().describe("Unique assignment identifier"),
-  /**
-   * Worker ID assigned to the task
-   */
-  workerId: import_zod9.z.string().describe("Worker identifier assigned to task"),
-  /**
-   * Task description
-   */
-  task: import_zod9.z.string().describe("Description of the task"),
-  /**
-   * Task priority (1-10, higher is more urgent)
-   */
-  priority: import_zod9.z.number().int().min(1).max(10).default(5).describe("Task priority"),
-  /**
-   * Timestamp when task was assigned
-   */
-  assignedAt: import_zod9.z.number().describe("Timestamp when task was assigned"),
-  /**
-   * Optional deadline for task completion
-   */
-  deadline: import_zod9.z.number().optional().describe("Optional task deadline timestamp")
+var TaskAssignmentSchema = import_zod11.z.object({
+  id: import_zod11.z.string().describe("Unique assignment identifier"),
+  workerId: import_zod11.z.string().describe("Worker identifier assigned to task"),
+  task: import_zod11.z.string().describe("Description of the task"),
+  priority: import_zod11.z.number().int().min(1).max(10).default(5).describe("Task priority"),
+  assignedAt: import_zod11.z.number().describe("Timestamp when task was assigned"),
+  deadline: import_zod11.z.number().optional().describe("Optional task deadline timestamp")
 });
-var TaskResultSchema = import_zod9.z.object({
-  /**
-   * Assignment identifier
-   */
-  assignmentId: import_zod9.z.string().describe("Assignment identifier"),
-  /**
-   * Worker that completed the task
-   */
-  workerId: import_zod9.z.string().describe("Worker that completed the task"),
-  /**
-   * Whether the task succeeded
-   */
-  success: import_zod9.z.boolean().describe("Whether the task succeeded"),
-  /**
-   * Task result/output
-   */
-  result: import_zod9.z.string().describe("Task result or output"),
-  /**
-   * Optional error message if task failed
-   */
-  error: import_zod9.z.string().optional().describe("Error message if task failed"),
-  /**
-   * Timestamp when task was completed
-   */
-  completedAt: import_zod9.z.number().describe("Timestamp when task was completed"),
-  /**
-   * Optional metadata about execution
-   */
+var TaskResultSchema = import_zod11.z.object({
+  assignmentId: import_zod11.z.string().describe("Assignment identifier"),
+  workerId: import_zod11.z.string().describe("Worker that completed the task"),
+  success: import_zod11.z.boolean().describe("Whether the task succeeded"),
+  result: import_zod11.z.string().describe("Task result or output"),
+  error: import_zod11.z.string().optional().describe("Error message if task failed"),
+  completedAt: import_zod11.z.number().describe("Timestamp when task was completed"),
   metadata: JsonObjectSchema.optional().describe("Execution metadata")
 });
-var MultiAgentStatusSchema = import_zod9.z.enum([
+
+// src/multi-agent/schemas-handoff.ts
+var import_zod12 = require("zod");
+var MultiAgentStatusSchema = import_zod12.z.enum([
   "initializing",
-  // System is initializing
   "routing",
-  // Supervisor is routing the task
   "executing",
-  // Worker is executing the task
   "coordinating",
-  // Multiple workers are coordinating
   "aggregating",
-  // Results are being aggregated
   "completed",
-  // Task is completed
   "failed"
-  // Task failed
 ]);
-var HandoffRequestSchema = import_zod9.z.object({
-  /**
-   * Agent requesting the handoff
-   */
-  from: import_zod9.z.string().describe("Agent requesting handoff"),
-  /**
-   * Target agent for handoff
-   */
-  to: import_zod9.z.string().describe("Target agent for handoff"),
-  /**
-   * Reason for handoff
-   */
-  reason: import_zod9.z.string().describe("Reason for requesting handoff"),
-  /**
-   * Context to pass to next agent
-   */
-  context: import_zod9.z.unknown().describe("Context to pass to next agent"),
-  /**
-   * Timestamp of handoff request
-   */
-  timestamp: import_zod9.z.string().datetime().describe("ISO timestamp of handoff request")
+var HandoffRequestSchema = import_zod12.z.object({
+  from: import_zod12.z.string().describe("Agent requesting handoff"),
+  to: import_zod12.z.string().describe("Target agent for handoff"),
+  reason: import_zod12.z.string().describe("Reason for requesting handoff"),
+  context: import_zod12.z.unknown().describe("Context to pass to next agent"),
+  timestamp: import_zod12.z.string().datetime().describe("ISO timestamp of handoff request")
 });
 
 // src/multi-agent/state.ts
@@ -2321,7 +2205,7 @@ var MultiAgentStateConfig = {
    * Accumulates all messages between agents
    */
   messages: {
-    schema: import_zod10.z.array(AgentMessageSchema),
+    schema: import_zod13.z.array(AgentMessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "All messages in the multi-agent conversation"
@@ -2330,7 +2214,7 @@ var MultiAgentStateConfig = {
    * Available worker agents and their capabilities
    */
   workers: {
-    schema: import_zod10.z.record(import_zod10.z.string(), WorkerCapabilitiesSchema),
+    schema: import_zod13.z.record(import_zod13.z.string(), WorkerCapabilitiesSchema),
     reducer: (left, right) => ({
       ...left,
       ...right
@@ -2342,7 +2226,7 @@ var MultiAgentStateConfig = {
    * Current active agent
    */
   currentAgent: {
-    schema: import_zod10.z.string().optional(),
+    schema: import_zod13.z.string().optional(),
     description: "Identifier of the currently active agent"
   },
   /**
@@ -2350,7 +2234,7 @@ var MultiAgentStateConfig = {
    * Accumulates all routing decisions
    */
   routingHistory: {
-    schema: import_zod10.z.array(RoutingDecisionSchema),
+    schema: import_zod13.z.array(RoutingDecisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of routing decisions"
@@ -2359,7 +2243,7 @@ var MultiAgentStateConfig = {
    * Active task assignments
    */
   activeAssignments: {
-    schema: import_zod10.z.array(TaskAssignmentSchema),
+    schema: import_zod13.z.array(TaskAssignmentSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Currently active task assignments"
@@ -2369,7 +2253,7 @@ var MultiAgentStateConfig = {
    * Accumulates all completed tasks
    */
   completedTasks: {
-    schema: import_zod10.z.array(TaskResultSchema),
+    schema: import_zod13.z.array(TaskResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed task results"
@@ -2379,7 +2263,7 @@ var MultiAgentStateConfig = {
    * Accumulates all handoff requests
    */
   handoffs: {
-    schema: import_zod10.z.array(HandoffRequestSchema),
+    schema: import_zod13.z.array(HandoffRequestSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Handoff requests between agents"

package/dist/index.d.cts

@@ -2379,47 +2379,17 @@ declare function createReflectionAgent(config: ReflectionAgentConfig): _langchai
     finisher: Partial<ReflectionStateType>;
 }, unknown, unknown>;
 
-/**
- * Schema for agent roles in the system
- */
 declare const AgentRoleSchema: z.ZodEnum<["supervisor", "worker"]>;
 type AgentRole = z.infer<typeof AgentRoleSchema>;
-/**
- * Schema for message types in multi-agent communication
- */
 declare const MessageTypeSchema: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
 type MessageType = z.infer<typeof MessageTypeSchema>;
-/**
- * Schema for a message in the multi-agent system
- */
 declare const AgentMessageSchema: z.ZodObject<{
-    /**
-     * Unique identifier for the message
-     */
     id: z.ZodString;
-    /**
-     * Type of message
-     */
     type: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
-    /**
-     * Agent that sent the message
-     */
     from: z.ZodString;
-    /**
-     * Agent(s) that should receive the message
-     */
     to: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
-    /**
-     * Message content
-     */
     content: z.ZodString;
-    /**
-     * Optional metadata
-     */
     metadata: z.ZodOptional<z.ZodType<_agentforge_core.JsonObject, z.ZodTypeDef, _agentforge_core.JsonObject>>;
-    /**
-     * Timestamp when message was created
-     */
     timestamp: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
@@ -2439,48 +2409,15 @@ declare const AgentMessageSchema: z.ZodObject<{
     metadata?: _agentforge_core.JsonObject | undefined;
 }>;
 type AgentMessage = z.infer<typeof AgentMessageSchema>;
-/**
- * Schema for routing strategies
- */
+
 declare const RoutingStrategySchema: z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>;
 type RoutingStrategy = z.infer<typeof RoutingStrategySchema>;
-/**
- * Schema for routing decision
- *
- * Supports both single-agent and parallel multi-agent routing:
- * - Single: Use `targetAgent` field
- * - Parallel: Use `targetAgents` array field
- *
- * If both are provided, `targetAgents` takes precedence.
- *
- * Note: Uses .nullable() instead of .optional() for OpenAI structured output compatibility
- */
 declare const RoutingDecisionSchema: z.ZodEffects<z.ZodObject<{
-    /**
-     * Target agent to route to (single agent routing)
-     * @deprecated Use targetAgents for parallel routing support
-     */
     targetAgent: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    /**
-     * Target agents to route to (parallel routing)
-     * When multiple agents are specified, they execute in parallel
-     */
     targetAgents: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-    /**
-     * Reasoning for the routing decision
-     */
     reasoning: z.ZodDefault<z.ZodString>;
-    /**
-     * Confidence in the routing decision (0-1)
-     */
     confidence: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Strategy used for routing
-     */
     strategy: z.ZodDefault<z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>>;
-    /**
-     * Timestamp of the routing decision
-     */
     timestamp: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     timestamp: number;
@@ -2512,25 +2449,11 @@ declare const RoutingDecisionSchema: z.ZodEffects<z.ZodObject<{
     strategy?: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced" | undefined;
 }>;
 type RoutingDecision = z.infer<typeof RoutingDecisionSchema>;
-/**
- * Schema for worker agent capabilities
- */
+
 declare const WorkerCapabilitiesSchema: z.ZodObject<{
-    /**
-     * Skills/capabilities the agent has
-     */
     skills: z.ZodArray<z.ZodString, "many">;
-    /**
-     * Tools available to the agent
-     */
     tools: z.ZodArray<z.ZodString, "many">;
-    /**
-     * Whether the agent is currently available
-     */
     available: z.ZodDefault<z.ZodBoolean>;
-    /**
-     * Current workload (number of active tasks)
-     */
     currentWorkload: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     tools: string[];
@@ -2544,33 +2467,12 @@ declare const WorkerCapabilitiesSchema: z.ZodObject<{
     currentWorkload?: number | undefined;
 }>;
 type WorkerCapabilities = z.infer<typeof WorkerCapabilitiesSchema>;
-/**
- * Schema for task assignment
- */
 declare const TaskAssignmentSchema: z.ZodObject<{
-    /**
-     * Unique assignment identifier
-     */
     id: z.ZodString;
-    /**
-     * Worker ID assigned to the task
-     */
     workerId: z.ZodString;
-    /**
-     * Task description
-     */
     task: z.ZodString;
-    /**
-     * Task priority (1-10, higher is more urgent)
-     */
     priority: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Timestamp when task was assigned
-     */
     assignedAt: z.ZodNumber;
-    /**
-     * Optional deadline for task completion
-     */
     deadline: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     id: string;
@@ -2588,37 +2490,13 @@ declare const TaskAssignmentSchema: z.ZodObject<{
     deadline?: number | undefined;
 }>;
 type TaskAssignment = z.infer<typeof TaskAssignmentSchema>;
-/**
- * Schema for task result
- */
 declare const TaskResultSchema: z.ZodObject<{
-    /**
-     * Assignment identifier
-     */
     assignmentId: z.ZodString;
-    /**
-     * Worker that completed the task
-     */
     workerId: z.ZodString;
-    /**
-     * Whether the task succeeded
-     */
     success: z.ZodBoolean;
-    /**
-     * Task result/output
-     */
     result: z.ZodString;
-    /**
-     * Optional error message if task failed
-     */
     error: z.ZodOptional<z.ZodString>;
-    /**
-     * Timestamp when task was completed
-     */
     completedAt: z.ZodNumber;
-    /**
-     * Optional metadata about execution
-     */
     metadata: z.ZodOptional<z.ZodType<_agentforge_core.JsonObject, z.ZodTypeDef, _agentforge_core.JsonObject>>;
 }, "strip", z.ZodTypeAny, {
     result: string;
@@ -2638,34 +2516,14 @@ declare const TaskResultSchema: z.ZodObject<{
     error?: string | undefined;
 }>;
 type TaskResult = z.infer<typeof TaskResultSchema>;
-/**
- * Schema for multi-agent execution status
- */
+
 declare const MultiAgentStatusSchema: z.ZodEnum<["initializing", "routing", "executing", "coordinating", "aggregating", "completed", "failed"]>;
 type MultiAgentStatus = z.infer<typeof MultiAgentStatusSchema>;
-/**
- * Schema for handoff request
- */
 declare const HandoffRequestSchema: z.ZodObject<{
-    /**
-     * Agent requesting the handoff
-     */
     from: z.ZodString;
-    /**
-     * Target agent for handoff
-     */
     to: z.ZodString;
-    /**
-     * Reason for handoff
-     */
     reason: z.ZodString;
-    /**
-     * Context to pass to next agent
-     */
     context: z.ZodUnknown;
-    /**
-     * Timestamp of handoff request
-     */
     timestamp: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     timestamp: string;

package/dist/index.d.ts

@@ -2379,47 +2379,17 @@ declare function createReflectionAgent(config: ReflectionAgentConfig): _langchai
     finisher: Partial<ReflectionStateType>;
 }, unknown, unknown>;
 
-/**
- * Schema for agent roles in the system
- */
 declare const AgentRoleSchema: z.ZodEnum<["supervisor", "worker"]>;
 type AgentRole = z.infer<typeof AgentRoleSchema>;
-/**
- * Schema for message types in multi-agent communication
- */
 declare const MessageTypeSchema: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
 type MessageType = z.infer<typeof MessageTypeSchema>;
-/**
- * Schema for a message in the multi-agent system
- */
 declare const AgentMessageSchema: z.ZodObject<{
-    /**
-     * Unique identifier for the message
-     */
     id: z.ZodString;
-    /**
-     * Type of message
-     */
     type: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
-    /**
-     * Agent that sent the message
-     */
     from: z.ZodString;
-    /**
-     * Agent(s) that should receive the message
-     */
     to: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
-    /**
-     * Message content
-     */
     content: z.ZodString;
-    /**
-     * Optional metadata
-     */
     metadata: z.ZodOptional<z.ZodType<_agentforge_core.JsonObject, z.ZodTypeDef, _agentforge_core.JsonObject>>;
-    /**
-     * Timestamp when message was created
-     */
     timestamp: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
@@ -2439,48 +2409,15 @@ declare const AgentMessageSchema: z.ZodObject<{
     metadata?: _agentforge_core.JsonObject | undefined;
 }>;
 type AgentMessage = z.infer<typeof AgentMessageSchema>;
-/**
- * Schema for routing strategies
- */
+
 declare const RoutingStrategySchema: z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>;
 type RoutingStrategy = z.infer<typeof RoutingStrategySchema>;
-/**
- * Schema for routing decision
- *
- * Supports both single-agent and parallel multi-agent routing:
- * - Single: Use `targetAgent` field
- * - Parallel: Use `targetAgents` array field
- *
- * If both are provided, `targetAgents` takes precedence.
- *
- * Note: Uses .nullable() instead of .optional() for OpenAI structured output compatibility
- */
 declare const RoutingDecisionSchema: z.ZodEffects<z.ZodObject<{
-    /**
-     * Target agent to route to (single agent routing)
-     * @deprecated Use targetAgents for parallel routing support
-     */
     targetAgent: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    /**
-     * Target agents to route to (parallel routing)
-     * When multiple agents are specified, they execute in parallel
-     */
     targetAgents: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
-    /**
-     * Reasoning for the routing decision
-     */
     reasoning: z.ZodDefault<z.ZodString>;
-    /**
-     * Confidence in the routing decision (0-1)
-     */
     confidence: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Strategy used for routing
-     */
     strategy: z.ZodDefault<z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>>;
-    /**
-     * Timestamp of the routing decision
-     */
     timestamp: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     timestamp: number;
@@ -2512,25 +2449,11 @@ declare const RoutingDecisionSchema: z.ZodEffects<z.ZodObject<{
     strategy?: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced" | undefined;
 }>;
 type RoutingDecision = z.infer<typeof RoutingDecisionSchema>;
-/**
- * Schema for worker agent capabilities
- */
+
 declare const WorkerCapabilitiesSchema: z.ZodObject<{
-    /**
-     * Skills/capabilities the agent has
-     */
     skills: z.ZodArray<z.ZodString, "many">;
-    /**
-     * Tools available to the agent
-     */
     tools: z.ZodArray<z.ZodString, "many">;
-    /**
-     * Whether the agent is currently available
-     */
     available: z.ZodDefault<z.ZodBoolean>;
-    /**
-     * Current workload (number of active tasks)
-     */
     currentWorkload: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     tools: string[];
@@ -2544,33 +2467,12 @@ declare const WorkerCapabilitiesSchema: z.ZodObject<{
     currentWorkload?: number | undefined;
 }>;
 type WorkerCapabilities = z.infer<typeof WorkerCapabilitiesSchema>;
-/**
- * Schema for task assignment
- */
 declare const TaskAssignmentSchema: z.ZodObject<{
-    /**
-     * Unique assignment identifier
-     */
     id: z.ZodString;
-    /**
-     * Worker ID assigned to the task
-     */
     workerId: z.ZodString;
-    /**
-     * Task description
-     */
     task: z.ZodString;
-    /**
-     * Task priority (1-10, higher is more urgent)
-     */
     priority: z.ZodDefault<z.ZodNumber>;
-    /**
-     * Timestamp when task was assigned
-     */
     assignedAt: z.ZodNumber;
-    /**
-     * Optional deadline for task completion
-     */
     deadline: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     id: string;
@@ -2588,37 +2490,13 @@ declare const TaskAssignmentSchema: z.ZodObject<{
     deadline?: number | undefined;
 }>;
 type TaskAssignment = z.infer<typeof TaskAssignmentSchema>;
-/**
- * Schema for task result
- */
 declare const TaskResultSchema: z.ZodObject<{
-    /**
-     * Assignment identifier
-     */
     assignmentId: z.ZodString;
-    /**
-     * Worker that completed the task
-     */
     workerId: z.ZodString;
-    /**
-     * Whether the task succeeded
-     */
     success: z.ZodBoolean;
-    /**
-     * Task result/output
-     */
     result: z.ZodString;
-    /**
-     * Optional error message if task failed
-     */
     error: z.ZodOptional<z.ZodString>;
-    /**
-     * Timestamp when task was completed
-     */
     completedAt: z.ZodNumber;
-    /**
-     * Optional metadata about execution
-     */
     metadata: z.ZodOptional<z.ZodType<_agentforge_core.JsonObject, z.ZodTypeDef, _agentforge_core.JsonObject>>;
 }, "strip", z.ZodTypeAny, {
     result: string;
@@ -2638,34 +2516,14 @@ declare const TaskResultSchema: z.ZodObject<{
     error?: string | undefined;
 }>;
 type TaskResult = z.infer<typeof TaskResultSchema>;
-/**
- * Schema for multi-agent execution status
- */
+
 declare const MultiAgentStatusSchema: z.ZodEnum<["initializing", "routing", "executing", "coordinating", "aggregating", "completed", "failed"]>;
 type MultiAgentStatus = z.infer<typeof MultiAgentStatusSchema>;
-/**
- * Schema for handoff request
- */
 declare const HandoffRequestSchema: z.ZodObject<{
-    /**
-     * Agent requesting the handoff
-     */
     from: z.ZodString;
-    /**
-     * Target agent for handoff
-     */
     to: z.ZodString;
-    /**
-     * Reason for handoff
-     */
     reason: z.ZodString;
-    /**
-     * Context to pass to next agent
-     */
     context: z.ZodUnknown;
-    /**
-     * Timestamp of handoff request
-     */
     timestamp: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     timestamp: string;

package/dist/index.js

@@ -2006,210 +2006,94 @@ function createReflectionAgent(config) {
 }
 
 // src/multi-agent/state.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 import { createStateAnnotation as createStateAnnotation4 } from "@agentforge/core";
 
-// src/multi-agent/schemas.ts
+// src/multi-agent/schemas-message.ts
 import { z as z9 } from "zod";
 var AgentRoleSchema = z9.enum(["supervisor", "worker"]);
 var MessageTypeSchema = z9.enum([
   "user_input",
-  // Initial user message
   "task_assignment",
-  // Supervisor assigns task to worker
   "task_result",
-  // Worker returns result to supervisor
   "handoff",
-  // Worker hands off to another worker
   "error",
-  // Error message
   "completion"
-  // Final completion message
 ]);
 var AgentMessageSchema = z9.object({
-  /**
-   * Unique identifier for the message
-   */
   id: z9.string().describe("Unique message identifier"),
-  /**
-   * Type of message
-   */
   type: MessageTypeSchema.describe("Type of message"),
-  /**
-   * Agent that sent the message
-   */
   from: z9.string().describe("Agent identifier that sent the message"),
-  /**
-   * Agent(s) that should receive the message
-   */
   to: z9.union([z9.string(), z9.array(z9.string())]).describe("Target agent(s)"),
-  /**
-   * Message content
-   */
   content: z9.string().describe("Message content"),
-  /**
-   * Optional metadata
-   */
   metadata: JsonObjectSchema.optional().describe("Additional message metadata"),
-  /**
-   * Timestamp when message was created
-   */
   timestamp: z9.number().describe("Timestamp when message was created")
 });
-var RoutingStrategySchema = z9.enum([
+
+// src/multi-agent/schemas-routing.ts
+import { z as z10 } from "zod";
+var RoutingStrategySchema = z10.enum([
   "llm-based",
-  // LLM decides which agent to route to
   "rule-based",
-  // Predefined rules determine routing
   "round-robin",
-  // Distribute tasks evenly across agents
   "skill-based",
-  // Route based on agent capabilities
   "load-balanced"
-  // Route based on agent workload
 ]);
-var RoutingDecisionSchema = z9.object({
-  /**
-   * Target agent to route to (single agent routing)
-   * @deprecated Use targetAgents for parallel routing support
-   */
-  targetAgent: z9.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: z9.array(z9.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
-  /**
-   * Reasoning for the routing decision
-   */
-  reasoning: z9.string().default("").describe("Explanation for routing decision"),
-  /**
-   * Confidence in the routing decision (0-1)
-   */
-  confidence: z9.number().min(0).max(1).default(0.8).describe("Confidence score"),
-  /**
-   * Strategy used for routing
-   */
+var RoutingDecisionSchema = z10.object({
+  targetAgent: z10.string().nullable().default(null).describe("Agent to route the task to (single routing)"),
+  targetAgents: z10.array(z10.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
+  reasoning: z10.string().default("").describe("Explanation for routing decision"),
+  confidence: z10.number().min(0).max(1).default(0.8).describe("Confidence score"),
   strategy: RoutingStrategySchema.default("llm-based").describe("Strategy used for this decision"),
-  /**
-   * Timestamp of the routing decision
-   */
-  timestamp: z9.number().default(() => Date.now()).describe("Timestamp of the decision")
+  timestamp: z10.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 = z9.object({
-  /**
-   * Skills/capabilities the agent has
-   */
-  skills: z9.array(z9.string()).describe("List of agent skills"),
-  /**
-   * Tools available to the agent
-   */
-  tools: z9.array(z9.string()).describe("List of tool names available to agent"),
-  /**
-   * Whether the agent is currently available
-   */
-  available: z9.boolean().default(true).describe("Whether agent is available"),
-  /**
-   * Current workload (number of active tasks)
-   */
-  currentWorkload: z9.number().int().nonnegative().default(0).describe("Current number of active tasks")
+
+// src/multi-agent/schemas-worker.ts
+import { z as z11 } from "zod";
+var WorkerCapabilitiesSchema = z11.object({
+  skills: z11.array(z11.string()).describe("List of agent skills"),
+  tools: z11.array(z11.string()).describe("List of tool names available to agent"),
+  available: z11.boolean().default(true).describe("Whether agent is available"),
+  currentWorkload: z11.number().int().nonnegative().default(0).describe("Current number of active tasks")
 });
-var TaskAssignmentSchema = z9.object({
-  /**
-   * Unique assignment identifier
-   */
-  id: z9.string().describe("Unique assignment identifier"),
-  /**
-   * Worker ID assigned to the task
-   */
-  workerId: z9.string().describe("Worker identifier assigned to task"),
-  /**
-   * Task description
-   */
-  task: z9.string().describe("Description of the task"),
-  /**
-   * Task priority (1-10, higher is more urgent)
-   */
-  priority: z9.number().int().min(1).max(10).default(5).describe("Task priority"),
-  /**
-   * Timestamp when task was assigned
-   */
-  assignedAt: z9.number().describe("Timestamp when task was assigned"),
-  /**
-   * Optional deadline for task completion
-   */
-  deadline: z9.number().optional().describe("Optional task deadline timestamp")
+var TaskAssignmentSchema = z11.object({
+  id: z11.string().describe("Unique assignment identifier"),
+  workerId: z11.string().describe("Worker identifier assigned to task"),
+  task: z11.string().describe("Description of the task"),
+  priority: z11.number().int().min(1).max(10).default(5).describe("Task priority"),
+  assignedAt: z11.number().describe("Timestamp when task was assigned"),
+  deadline: z11.number().optional().describe("Optional task deadline timestamp")
 });
-var TaskResultSchema = z9.object({
-  /**
-   * Assignment identifier
-   */
-  assignmentId: z9.string().describe("Assignment identifier"),
-  /**
-   * Worker that completed the task
-   */
-  workerId: z9.string().describe("Worker that completed the task"),
-  /**
-   * Whether the task succeeded
-   */
-  success: z9.boolean().describe("Whether the task succeeded"),
-  /**
-   * Task result/output
-   */
-  result: z9.string().describe("Task result or output"),
-  /**
-   * Optional error message if task failed
-   */
-  error: z9.string().optional().describe("Error message if task failed"),
-  /**
-   * Timestamp when task was completed
-   */
-  completedAt: z9.number().describe("Timestamp when task was completed"),
-  /**
-   * Optional metadata about execution
-   */
+var TaskResultSchema = z11.object({
+  assignmentId: z11.string().describe("Assignment identifier"),
+  workerId: z11.string().describe("Worker that completed the task"),
+  success: z11.boolean().describe("Whether the task succeeded"),
+  result: z11.string().describe("Task result or output"),
+  error: z11.string().optional().describe("Error message if task failed"),
+  completedAt: z11.number().describe("Timestamp when task was completed"),
   metadata: JsonObjectSchema.optional().describe("Execution metadata")
 });
-var MultiAgentStatusSchema = z9.enum([
+
+// src/multi-agent/schemas-handoff.ts
+import { z as z12 } from "zod";
+var MultiAgentStatusSchema = z12.enum([
   "initializing",
-  // System is initializing
   "routing",
-  // Supervisor is routing the task
   "executing",
-  // Worker is executing the task
   "coordinating",
-  // Multiple workers are coordinating
   "aggregating",
-  // Results are being aggregated
   "completed",
-  // Task is completed
   "failed"
-  // Task failed
 ]);
-var HandoffRequestSchema = z9.object({
-  /**
-   * Agent requesting the handoff
-   */
-  from: z9.string().describe("Agent requesting handoff"),
-  /**
-   * Target agent for handoff
-   */
-  to: z9.string().describe("Target agent for handoff"),
-  /**
-   * Reason for handoff
-   */
-  reason: z9.string().describe("Reason for requesting handoff"),
-  /**
-   * Context to pass to next agent
-   */
-  context: z9.unknown().describe("Context to pass to next agent"),
-  /**
-   * Timestamp of handoff request
-   */
-  timestamp: z9.string().datetime().describe("ISO timestamp of handoff request")
+var HandoffRequestSchema = z12.object({
+  from: z12.string().describe("Agent requesting handoff"),
+  to: z12.string().describe("Target agent for handoff"),
+  reason: z12.string().describe("Reason for requesting handoff"),
+  context: z12.unknown().describe("Context to pass to next agent"),
+  timestamp: z12.string().datetime().describe("ISO timestamp of handoff request")
 });
 
 // src/multi-agent/state.ts
@@ -2223,7 +2107,7 @@ var MultiAgentStateConfig = {
    * Accumulates all messages between agents
    */
   messages: {
-    schema: z10.array(AgentMessageSchema),
+    schema: z13.array(AgentMessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "All messages in the multi-agent conversation"
@@ -2232,7 +2116,7 @@ var MultiAgentStateConfig = {
    * Available worker agents and their capabilities
    */
   workers: {
-    schema: z10.record(z10.string(), WorkerCapabilitiesSchema),
+    schema: z13.record(z13.string(), WorkerCapabilitiesSchema),
     reducer: (left, right) => ({
       ...left,
       ...right
@@ -2244,7 +2128,7 @@ var MultiAgentStateConfig = {
    * Current active agent
    */
   currentAgent: {
-    schema: z10.string().optional(),
+    schema: z13.string().optional(),
     description: "Identifier of the currently active agent"
   },
   /**
@@ -2252,7 +2136,7 @@ var MultiAgentStateConfig = {
    * Accumulates all routing decisions
    */
   routingHistory: {
-    schema: z10.array(RoutingDecisionSchema),
+    schema: z13.array(RoutingDecisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of routing decisions"
@@ -2261,7 +2145,7 @@ var MultiAgentStateConfig = {
    * Active task assignments
    */
   activeAssignments: {
-    schema: z10.array(TaskAssignmentSchema),
+    schema: z13.array(TaskAssignmentSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Currently active task assignments"
@@ -2271,7 +2155,7 @@ var MultiAgentStateConfig = {
    * Accumulates all completed tasks
    */
   completedTasks: {
-    schema: z10.array(TaskResultSchema),
+    schema: z13.array(TaskResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed task results"
@@ -2281,7 +2165,7 @@ var MultiAgentStateConfig = {
    * Accumulates all handoff requests
    */
   handoffs: {
-    schema: z10.array(HandoffRequestSchema),
+    schema: z13.array(HandoffRequestSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Handoff requests between agents"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/patterns",
-  "version": "0.16.65",
+  "version": "0.16.67",
   "description": "Production-ready agent workflow patterns for TypeScript including ReAct and Planner-Executor, built on LangGraph.",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -41,13 +41,13 @@
     "url": "https://github.com/TVScoundrel/agentforge/issues"
   },
   "dependencies": {
-    "@agentforge/core": "0.16.65",
+    "@agentforge/core": "0.16.67",
     "@langchain/core": "^1.1.17",
     "@langchain/langgraph": "^1.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@agentforge/testing": "0.16.65",
+    "@agentforge/testing": "0.16.67",
     "@eslint/js": "^9.17.0",
     "@types/node": "^22.10.2",
     "eslint": "^9.17.0",
@@ -60,8 +60,8 @@
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --dts --clean",
     "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
-    "test": "vitest",
-    "test:coverage": "vitest --coverage",
+    "test": "pnpm --dir ../.. exec vitest --config packages/patterns/vitest.config.ts",
+    "test:coverage": "pnpm --dir ../.. exec vitest --config packages/patterns/vitest.config.ts --coverage",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",