@agentforge/patterns 0.16.46 → 0.16.48

package/dist/index.cjs

@@ -101,8 +101,12 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/react/schemas.ts
+// src/shared/json-schemas.ts
 var import_zod = require("zod");
+function isPlainJsonObject(value) {
+  const prototype = typeof value === "object" && value !== null ? Object.getPrototypeOf(value) : null;
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (prototype === Object.prototype || prototype === null);
+}
 var JsonValueSchema = import_zod.z.lazy(
   () => import_zod.z.union([
     import_zod.z.string(),
@@ -110,74 +114,79 @@ var JsonValueSchema = import_zod.z.lazy(
     import_zod.z.boolean(),
     import_zod.z.null(),
     import_zod.z.array(JsonValueSchema),
-    import_zod.z.record(JsonValueSchema)
+    JsonObjectSchema
   ])
 );
-var JsonObjectSchema = import_zod.z.record(JsonValueSchema);
-var MessageRoleSchema = import_zod.z.enum(["system", "user", "assistant", "tool"]);
-var MessageSchema = import_zod.z.object({
+var JsonObjectSchema = import_zod.z.custom(isPlainJsonObject, {
+  message: "Expected a plain JSON object"
+}).pipe(import_zod.z.record(JsonValueSchema));
+
+// src/react/schemas.ts
+var import_zod2 = require("zod");
+var MessageRoleSchema = import_zod2.z.enum(["system", "user", "assistant", "tool"]);
+var MessageSchema = import_zod2.z.object({
   role: MessageRoleSchema,
-  content: import_zod.z.string(),
-  name: import_zod.z.string().optional(),
-  tool_call_id: import_zod.z.string().optional(),
+  content: import_zod2.z.string(),
+  name: import_zod2.z.string().optional(),
+  tool_call_id: import_zod2.z.string().optional(),
   metadata: JsonObjectSchema.optional()
 });
-var ThoughtSchema = import_zod.z.object({
-  content: import_zod.z.string(),
-  timestamp: import_zod.z.number().optional(),
+var ThoughtSchema = import_zod2.z.object({
+  content: import_zod2.z.string(),
+  timestamp: import_zod2.z.number().optional(),
   metadata: JsonObjectSchema.optional()
 });
-var ToolCallSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string(),
-  arguments: import_zod.z.record(import_zod.z.unknown()),
-  timestamp: import_zod.z.number().optional()
+var ToolCallSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  arguments: import_zod2.z.record(import_zod2.z.unknown()),
+  timestamp: import_zod2.z.number().optional()
 });
-var ToolResultSchema = import_zod.z.object({
-  toolCallId: import_zod.z.string(),
-  result: import_zod.z.unknown(),
-  error: import_zod.z.string().optional(),
-  timestamp: import_zod.z.number().optional(),
-  isDuplicate: import_zod.z.boolean().optional()
+var ToolResultSchema = import_zod2.z.object({
+  toolCallId: import_zod2.z.string(),
+  result: import_zod2.z.unknown(),
+  error: import_zod2.z.string().optional(),
+  timestamp: import_zod2.z.number().optional(),
+  isDuplicate: import_zod2.z.boolean().optional()
   // Flag indicating this was a duplicate tool call
 });
-var ScratchpadEntrySchema = import_zod.z.object({
-  step: import_zod.z.number(),
-  thought: import_zod.z.string().optional(),
-  action: import_zod.z.string().optional(),
-  observation: import_zod.z.string().optional(),
-  timestamp: import_zod.z.number().optional()
+var ScratchpadEntrySchema = import_zod2.z.object({
+  step: import_zod2.z.number(),
+  thought: import_zod2.z.string().optional(),
+  action: import_zod2.z.string().optional(),
+  observation: import_zod2.z.string().optional(),
+  timestamp: import_zod2.z.number().optional()
 });
 
 // src/react/state.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 var import_core = require("@agentforge/core");
 
 // src/shared/state-fields.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var iterationField = {
-  schema: import_zod2.z.number().int().nonnegative(),
+  schema: import_zod3.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(),
+    schema: import_zod3.z.number().int().positive(),
     default: () => defaultValue,
     description: "Maximum number of iterations allowed"
   };
 }
 var errorField = {
-  schema: import_zod2.z.string().optional(),
+  schema: import_zod3.z.string().optional(),
   description: "Error message if execution failed"
 };
 var responseField = {
-  schema: import_zod2.z.string().optional(),
+  schema: import_zod3.z.string().optional(),
   description: "Final response after completion"
 };
 var inputField = {
-  schema: import_zod2.z.string(),
+  schema: import_zod3.z.string(),
   default: () => "",
   description: "Original user input or query"
 };
@@ -189,7 +198,7 @@ var ReActStateConfig = {
    * Accumulates all messages in the conversation
    */
   messages: {
-    schema: import_zod3.z.array(MessageSchema),
+    schema: import_zod4.z.array(MessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Conversation message history"
@@ -199,7 +208,7 @@ var ReActStateConfig = {
    * Accumulates all reasoning steps the agent takes
    */
   thoughts: {
-    schema: import_zod3.z.array(ThoughtSchema),
+    schema: import_zod4.z.array(ThoughtSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Agent reasoning steps"
@@ -209,7 +218,7 @@ var ReActStateConfig = {
    * Accumulates all tool calls made by the agent
    */
   actions: {
-    schema: import_zod3.z.array(ToolCallSchema),
+    schema: import_zod4.z.array(ToolCallSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Tool calls made by the agent"
@@ -219,7 +228,7 @@ var ReActStateConfig = {
    * Accumulates all observations from tool executions
    */
   observations: {
-    schema: import_zod3.z.array(ToolResultSchema),
+    schema: import_zod4.z.array(ToolResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Results from tool executions"
@@ -229,7 +238,7 @@ var ReActStateConfig = {
    * Accumulates step-by-step reasoning process
    */
   scratchpad: {
-    schema: import_zod3.z.array(ScratchpadEntrySchema),
+    schema: import_zod4.z.array(ScratchpadEntrySchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Intermediate reasoning scratchpad"
@@ -243,7 +252,7 @@ var ReActStateConfig = {
    * Whether the agent should continue iterating
    */
   shouldContinue: {
-    schema: import_zod3.z.boolean().optional(),
+    schema: import_zod4.z.boolean().optional(),
     default: () => true,
     description: "Whether to continue the ReAct loop"
   },
@@ -877,34 +886,34 @@ function createReActAgentBuilder() {
 var import_langgraph2 = require("@langchain/langgraph");
 
 // src/plan-execute/state.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var import_core5 = require("@agentforge/core");
 
 // src/plan-execute/schemas.ts
-var import_zod4 = require("zod");
-var PlanStepSchema = import_zod4.z.object({
+var import_zod5 = require("zod");
+var PlanStepSchema = import_zod5.z.object({
   /**
    * Unique identifier for the step
    */
-  id: import_zod4.z.string().describe("Unique identifier for the step"),
+  id: import_zod5.z.string().describe("Unique identifier for the step"),
   /**
    * Description of what this step should accomplish
    */
-  description: import_zod4.z.string().describe("Description of what this step should accomplish"),
+  description: import_zod5.z.string().describe("Description of what this step should accomplish"),
   /**
    * Optional dependencies on other steps (by ID)
    */
-  dependencies: import_zod4.z.array(import_zod4.z.string()).optional().describe("IDs of steps that must complete before this one"),
+  dependencies: import_zod5.z.array(import_zod5.z.string()).optional().describe("IDs of steps that must complete before this one"),
   /**
    * Optional tool to use for this step
    */
-  tool: import_zod4.z.string().optional().describe("Name of the tool to use for this step"),
+  tool: import_zod5.z.string().optional().describe("Name of the tool to use for this step"),
   /**
    * Optional arguments for the tool
    */
-  args: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional().describe("Arguments to pass to the tool")
+  args: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional().describe("Arguments to pass to the tool")
 });
-var CompletedStepSchema = import_zod4.z.object({
+var CompletedStepSchema = import_zod5.z.object({
   /**
    * The step that was executed
    */
@@ -912,53 +921,53 @@ var CompletedStepSchema = import_zod4.z.object({
   /**
    * The result of executing the step
    */
-  result: import_zod4.z.unknown().describe("The result of executing the step"),
+  result: import_zod5.z.unknown().describe("The result of executing the step"),
   /**
    * Whether the step succeeded
    */
-  success: import_zod4.z.boolean().describe("Whether the step succeeded"),
+  success: import_zod5.z.boolean().describe("Whether the step succeeded"),
   /**
    * Optional error message if the step failed
    */
-  error: import_zod4.z.string().optional().describe("Error message if the step failed"),
+  error: import_zod5.z.string().optional().describe("Error message if the step failed"),
   /**
    * Timestamp when the step was completed
    */
-  timestamp: import_zod4.z.string().datetime().describe("ISO timestamp when the step was completed")
+  timestamp: import_zod5.z.string().datetime().describe("ISO timestamp when the step was completed")
 });
-var PlanSchema = import_zod4.z.object({
+var PlanSchema = import_zod5.z.object({
   /**
    * List of steps in the plan
    */
-  steps: import_zod4.z.array(PlanStepSchema).describe("List of steps in the plan"),
+  steps: import_zod5.z.array(PlanStepSchema).describe("List of steps in the plan"),
   /**
    * Overall goal of the plan
    */
-  goal: import_zod4.z.string().describe("Overall goal of the plan"),
+  goal: import_zod5.z.string().describe("Overall goal of the plan"),
   /**
    * Timestamp when the plan was created
    */
-  createdAt: import_zod4.z.string().datetime().describe("ISO timestamp when the plan was created"),
+  createdAt: import_zod5.z.string().datetime().describe("ISO timestamp when the plan was created"),
   /**
    * Optional confidence score (0-1)
    */
-  confidence: import_zod4.z.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
+  confidence: import_zod5.z.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
 });
-var ReplanDecisionSchema = import_zod4.z.object({
+var ReplanDecisionSchema = import_zod5.z.object({
   /**
    * Whether to replan
    */
-  shouldReplan: import_zod4.z.boolean().describe("Whether to replan based on current results"),
+  shouldReplan: import_zod5.z.boolean().describe("Whether to replan based on current results"),
   /**
    * Reason for the decision
    */
-  reason: import_zod4.z.string().describe("Reason for the replan decision"),
+  reason: import_zod5.z.string().describe("Reason for the replan decision"),
   /**
    * Optional new goal if replanning
    */
-  newGoal: import_zod4.z.string().optional().describe("Updated goal if replanning")
+  newGoal: import_zod5.z.string().optional().describe("Updated goal if replanning")
 });
-var ExecutionStatusSchema = import_zod4.z.enum([
+var ExecutionStatusSchema = import_zod5.z.enum([
   "planning",
   "executing",
   "replanning",
@@ -984,7 +993,7 @@ var PlanExecuteStateConfig = {
    * Accumulates all completed steps
    */
   pastSteps: {
-    schema: import_zod5.z.array(CompletedStepSchema),
+    schema: import_zod6.z.array(CompletedStepSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed steps with their results"
@@ -993,7 +1002,7 @@ var PlanExecuteStateConfig = {
    * Index of the current step being executed
    */
   currentStepIndex: {
-    schema: import_zod5.z.number().int().nonnegative().optional(),
+    schema: import_zod6.z.number().int().nonnegative().optional(),
     description: "Index of the current step being executed"
   },
   /**
@@ -1537,46 +1546,46 @@ function createPlanExecuteAgent(config) {
 }
 
 // src/reflection/state.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var import_core6 = require("@agentforge/core");
 
 // src/reflection/schemas.ts
-var import_zod6 = require("zod");
-var ReflectionSchema = import_zod6.z.object({
+var import_zod7 = require("zod");
+var ReflectionSchema = import_zod7.z.object({
   /**
    * The critique or feedback on the current response
    */
-  critique: import_zod6.z.string().describe("Critique or feedback on the current response"),
+  critique: import_zod7.z.string().describe("Critique or feedback on the current response"),
   /**
    * Specific issues identified
    */
-  issues: import_zod6.z.array(import_zod6.z.string()).describe("Specific issues or problems identified"),
+  issues: import_zod7.z.array(import_zod7.z.string()).describe("Specific issues or problems identified"),
   /**
    * Suggestions for improvement
    */
-  suggestions: import_zod6.z.array(import_zod6.z.string()).describe("Suggestions for improving the response"),
+  suggestions: import_zod7.z.array(import_zod7.z.string()).describe("Suggestions for improving the response"),
   /**
    * Quality score (0-10)
    */
-  score: import_zod6.z.number().min(0).max(10).optional().describe("Quality score from 0 to 10"),
+  score: import_zod7.z.number().min(0).max(10).optional().describe("Quality score from 0 to 10"),
   /**
    * Whether the response meets quality standards
    */
-  meetsStandards: import_zod6.z.boolean().describe("Whether the response meets quality standards"),
+  meetsStandards: import_zod7.z.boolean().describe("Whether the response meets quality standards"),
   /**
    * Timestamp of the reflection
    */
-  timestamp: import_zod6.z.date().optional().describe("When this reflection was created")
+  timestamp: import_zod7.z.date().optional().describe("When this reflection was created")
 });
-var RevisionSchema = import_zod6.z.object({
+var RevisionSchema = import_zod7.z.object({
   /**
    * The revised content
    */
-  content: import_zod6.z.string().describe("The revised content"),
+  content: import_zod7.z.string().describe("The revised content"),
   /**
    * Which iteration this revision is from
    */
-  iteration: import_zod6.z.number().int().nonnegative().describe("Iteration number"),
+  iteration: import_zod7.z.number().int().nonnegative().describe("Iteration number"),
   /**
    * The reflection that prompted this revision
    */
@@ -1584,9 +1593,9 @@ var RevisionSchema = import_zod6.z.object({
   /**
    * Timestamp of the revision
    */
-  timestamp: import_zod6.z.date().optional().describe("When this revision was created")
+  timestamp: import_zod7.z.date().optional().describe("When this revision was created")
 });
-var ReflectionStatusSchema = import_zod6.z.enum([
+var ReflectionStatusSchema = import_zod7.z.enum([
   "generating",
   // Initial generation
   "reflecting",
@@ -1598,25 +1607,25 @@ var ReflectionStatusSchema = import_zod6.z.enum([
   "failed"
   // Max iterations reached without meeting standards
 ]);
-var QualityCriteriaSchema = import_zod6.z.object({
+var QualityCriteriaSchema = import_zod7.z.object({
   /**
    * Minimum quality score required (0-10)
    */
-  minScore: import_zod6.z.number().min(0).max(10).default(7).describe("Minimum quality score required"),
+  minScore: import_zod7.z.number().min(0).max(10).default(7).describe("Minimum quality score required"),
   /**
    * Specific criteria to evaluate
    */
-  criteria: import_zod6.z.array(import_zod6.z.string()).optional().describe("Specific criteria to evaluate"),
+  criteria: import_zod7.z.array(import_zod7.z.string()).optional().describe("Specific criteria to evaluate"),
   /**
    * Whether all criteria must be met
    */
-  requireAll: import_zod6.z.boolean().default(true).describe("Whether all criteria must be met")
+  requireAll: import_zod7.z.boolean().default(true).describe("Whether all criteria must be met")
 });
-var ReflectionConfigSchema = import_zod6.z.object({
+var ReflectionConfigSchema = import_zod7.z.object({
   /**
    * Maximum number of reflection iterations
    */
-  maxIterations: import_zod6.z.number().int().positive().default(3).describe("Maximum reflection iterations"),
+  maxIterations: import_zod7.z.number().int().positive().default(3).describe("Maximum reflection iterations"),
   /**
    * Quality criteria for completion
    */
@@ -1624,7 +1633,7 @@ var ReflectionConfigSchema = import_zod6.z.object({
   /**
    * Whether to include previous reflections in context
    */
-  includeHistory: import_zod6.z.boolean().default(true).describe("Include previous reflections in context")
+  includeHistory: import_zod7.z.boolean().default(true).describe("Include previous reflections in context")
 });
 
 // src/reflection/state.ts
@@ -1637,7 +1646,7 @@ var ReflectionStateConfig = {
    * Current response/output
    */
   currentResponse: {
-    schema: import_zod7.z.string().optional(),
+    schema: import_zod8.z.string().optional(),
     description: "Current response or output"
   },
   /**
@@ -1645,7 +1654,7 @@ var ReflectionStateConfig = {
    * Accumulates all reflections
    */
   reflections: {
-    schema: import_zod7.z.array(ReflectionSchema),
+    schema: import_zod8.z.array(ReflectionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of all reflections and critiques"
@@ -1655,7 +1664,7 @@ var ReflectionStateConfig = {
    * Accumulates all revisions
    */
   revisions: {
-    schema: import_zod7.z.array(RevisionSchema),
+    schema: import_zod8.z.array(RevisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of all revisions"
@@ -2095,13 +2104,13 @@ function createReflectionAgent(config) {
 }
 
 // src/multi-agent/state.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var import_core7 = require("@agentforge/core");
 
 // src/multi-agent/schemas.ts
-var import_zod8 = require("zod");
-var AgentRoleSchema = import_zod8.z.enum(["supervisor", "worker"]);
-var MessageTypeSchema = import_zod8.z.enum([
+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",
@@ -2115,11 +2124,11 @@ var MessageTypeSchema = import_zod8.z.enum([
   "completion"
   // Final completion message
 ]);
-var AgentMessageSchema = import_zod8.z.object({
+var AgentMessageSchema = import_zod9.z.object({
   /**
    * Unique identifier for the message
    */
-  id: import_zod8.z.string().describe("Unique message identifier"),
+  id: import_zod9.z.string().describe("Unique message identifier"),
   /**
    * Type of message
    */
@@ -2127,25 +2136,25 @@ var AgentMessageSchema = import_zod8.z.object({
   /**
    * Agent that sent the message
    */
-  from: import_zod8.z.string().describe("Agent identifier 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_zod8.z.union([import_zod8.z.string(), import_zod8.z.array(import_zod8.z.string())]).describe("Target agent(s)"),
+  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_zod8.z.string().describe("Message content"),
+  content: import_zod9.z.string().describe("Message content"),
   /**
    * Optional metadata
    */
-  metadata: import_zod8.z.record(import_zod8.z.any()).optional().describe("Additional message metadata"),
+  metadata: JsonObjectSchema.optional().describe("Additional message metadata"),
   /**
    * Timestamp when message was created
    */
-  timestamp: import_zod8.z.number().describe("Timestamp when message was created")
+  timestamp: import_zod9.z.number().describe("Timestamp when message was created")
 });
-var RoutingStrategySchema = import_zod8.z.enum([
+var RoutingStrategySchema = import_zod9.z.enum([
   "llm-based",
   // LLM decides which agent to route to
   "rule-based",
@@ -2157,25 +2166,25 @@ var RoutingStrategySchema = import_zod8.z.enum([
   "load-balanced"
   // Route based on agent workload
 ]);
-var RoutingDecisionSchema = import_zod8.z.object({
+var RoutingDecisionSchema = import_zod9.z.object({
   /**
    * Target agent to route to (single agent routing)
    * @deprecated Use targetAgents for parallel routing support
    */
-  targetAgent: import_zod8.z.string().nullable().default(null).describe("Agent to route the task to (single routing)"),
+  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_zod8.z.array(import_zod8.z.string()).nullable().default(null).describe("Agents to route the task to (parallel routing)"),
+  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_zod8.z.string().default("").describe("Explanation for routing decision"),
+  reasoning: import_zod9.z.string().default("").describe("Explanation for routing decision"),
   /**
    * Confidence in the routing decision (0-1)
    */
-  confidence: import_zod8.z.number().min(0).max(1).default(0.8).describe("Confidence score"),
+  confidence: import_zod9.z.number().min(0).max(1).default(0.8).describe("Confidence score"),
   /**
    * Strategy used for routing
    */
@@ -2183,86 +2192,86 @@ var RoutingDecisionSchema = import_zod8.z.object({
   /**
    * Timestamp of the routing decision
    */
-  timestamp: import_zod8.z.number().default(() => Date.now()).describe("Timestamp of the decision")
+  timestamp: import_zod9.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_zod8.z.object({
+var WorkerCapabilitiesSchema = import_zod9.z.object({
   /**
    * Skills/capabilities the agent has
    */
-  skills: import_zod8.z.array(import_zod8.z.string()).describe("List of agent skills"),
+  skills: import_zod9.z.array(import_zod9.z.string()).describe("List of agent skills"),
   /**
    * Tools available to the agent
    */
-  tools: import_zod8.z.array(import_zod8.z.string()).describe("List of tool names available to 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_zod8.z.boolean().default(true).describe("Whether agent is available"),
+  available: import_zod9.z.boolean().default(true).describe("Whether agent is available"),
   /**
    * Current workload (number of active tasks)
    */
-  currentWorkload: import_zod8.z.number().int().nonnegative().default(0).describe("Current number of active tasks")
+  currentWorkload: import_zod9.z.number().int().nonnegative().default(0).describe("Current number of active tasks")
 });
-var TaskAssignmentSchema = import_zod8.z.object({
+var TaskAssignmentSchema = import_zod9.z.object({
   /**
    * Unique assignment identifier
    */
-  id: import_zod8.z.string().describe("Unique assignment identifier"),
+  id: import_zod9.z.string().describe("Unique assignment identifier"),
   /**
    * Worker ID assigned to the task
    */
-  workerId: import_zod8.z.string().describe("Worker identifier assigned to task"),
+  workerId: import_zod9.z.string().describe("Worker identifier assigned to task"),
   /**
    * Task description
    */
-  task: import_zod8.z.string().describe("Description of the task"),
+  task: import_zod9.z.string().describe("Description of the task"),
   /**
    * Task priority (1-10, higher is more urgent)
    */
-  priority: import_zod8.z.number().int().min(1).max(10).default(5).describe("Task priority"),
+  priority: import_zod9.z.number().int().min(1).max(10).default(5).describe("Task priority"),
   /**
    * Timestamp when task was assigned
    */
-  assignedAt: import_zod8.z.number().describe("Timestamp when task was assigned"),
+  assignedAt: import_zod9.z.number().describe("Timestamp when task was assigned"),
   /**
    * Optional deadline for task completion
    */
-  deadline: import_zod8.z.number().optional().describe("Optional task deadline timestamp")
+  deadline: import_zod9.z.number().optional().describe("Optional task deadline timestamp")
 });
-var TaskResultSchema = import_zod8.z.object({
+var TaskResultSchema = import_zod9.z.object({
   /**
    * Assignment identifier
    */
-  assignmentId: import_zod8.z.string().describe("Assignment identifier"),
+  assignmentId: import_zod9.z.string().describe("Assignment identifier"),
   /**
    * Worker that completed the task
    */
-  workerId: import_zod8.z.string().describe("Worker that completed the task"),
+  workerId: import_zod9.z.string().describe("Worker that completed the task"),
   /**
    * Whether the task succeeded
    */
-  success: import_zod8.z.boolean().describe("Whether the task succeeded"),
+  success: import_zod9.z.boolean().describe("Whether the task succeeded"),
   /**
    * Task result/output
    */
-  result: import_zod8.z.string().describe("Task result or output"),
+  result: import_zod9.z.string().describe("Task result or output"),
   /**
    * Optional error message if task failed
    */
-  error: import_zod8.z.string().optional().describe("Error message if task failed"),
+  error: import_zod9.z.string().optional().describe("Error message if task failed"),
   /**
    * Timestamp when task was completed
    */
-  completedAt: import_zod8.z.number().describe("Timestamp when task was completed"),
+  completedAt: import_zod9.z.number().describe("Timestamp when task was completed"),
   /**
    * Optional metadata about execution
    */
-  metadata: import_zod8.z.record(import_zod8.z.any()).optional().describe("Execution metadata")
+  metadata: JsonObjectSchema.optional().describe("Execution metadata")
 });
-var MultiAgentStatusSchema = import_zod8.z.enum([
+var MultiAgentStatusSchema = import_zod9.z.enum([
   "initializing",
   // System is initializing
   "routing",
@@ -2278,27 +2287,27 @@ var MultiAgentStatusSchema = import_zod8.z.enum([
   "failed"
   // Task failed
 ]);
-var HandoffRequestSchema = import_zod8.z.object({
+var HandoffRequestSchema = import_zod9.z.object({
   /**
    * Agent requesting the handoff
    */
-  from: import_zod8.z.string().describe("Agent requesting handoff"),
+  from: import_zod9.z.string().describe("Agent requesting handoff"),
   /**
    * Target agent for handoff
    */
-  to: import_zod8.z.string().describe("Target agent for handoff"),
+  to: import_zod9.z.string().describe("Target agent for handoff"),
   /**
    * Reason for handoff
    */
-  reason: import_zod8.z.string().describe("Reason for requesting handoff"),
+  reason: import_zod9.z.string().describe("Reason for requesting handoff"),
   /**
    * Context to pass to next agent
    */
-  context: import_zod8.z.any().describe("Context to pass to next agent"),
+  context: import_zod9.z.unknown().describe("Context to pass to next agent"),
   /**
    * Timestamp of handoff request
    */
-  timestamp: import_zod8.z.string().datetime().describe("ISO timestamp of handoff request")
+  timestamp: import_zod9.z.string().datetime().describe("ISO timestamp of handoff request")
 });
 
 // src/multi-agent/state.ts
@@ -2312,7 +2321,7 @@ var MultiAgentStateConfig = {
    * Accumulates all messages between agents
    */
   messages: {
-    schema: import_zod9.z.array(AgentMessageSchema),
+    schema: import_zod10.z.array(AgentMessageSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "All messages in the multi-agent conversation"
@@ -2321,7 +2330,7 @@ var MultiAgentStateConfig = {
    * Available worker agents and their capabilities
    */
   workers: {
-    schema: import_zod9.z.record(import_zod9.z.string(), WorkerCapabilitiesSchema),
+    schema: import_zod10.z.record(import_zod10.z.string(), WorkerCapabilitiesSchema),
     reducer: (left, right) => ({
       ...left,
       ...right
@@ -2333,7 +2342,7 @@ var MultiAgentStateConfig = {
    * Current active agent
    */
   currentAgent: {
-    schema: import_zod9.z.string().optional(),
+    schema: import_zod10.z.string().optional(),
     description: "Identifier of the currently active agent"
   },
   /**
@@ -2341,7 +2350,7 @@ var MultiAgentStateConfig = {
    * Accumulates all routing decisions
    */
   routingHistory: {
-    schema: import_zod9.z.array(RoutingDecisionSchema),
+    schema: import_zod10.z.array(RoutingDecisionSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "History of routing decisions"
@@ -2350,7 +2359,7 @@ var MultiAgentStateConfig = {
    * Active task assignments
    */
   activeAssignments: {
-    schema: import_zod9.z.array(TaskAssignmentSchema),
+    schema: import_zod10.z.array(TaskAssignmentSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Currently active task assignments"
@@ -2360,7 +2369,7 @@ var MultiAgentStateConfig = {
    * Accumulates all completed tasks
    */
   completedTasks: {
-    schema: import_zod9.z.array(TaskResultSchema),
+    schema: import_zod10.z.array(TaskResultSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Completed task results"
@@ -2370,7 +2379,7 @@ var MultiAgentStateConfig = {
    * Accumulates all handoff requests
    */
   handoffs: {
-    schema: import_zod9.z.array(HandoffRequestSchema),
+    schema: import_zod10.z.array(HandoffRequestSchema),
     reducer: (left, right) => [...left, ...right],
     default: () => [],
     description: "Handoff requests between agents"