@agentforge/patterns 0.1.0

package/dist/index.js

@@ -0,0 +1,2464 @@
+// src/react/schemas.ts
+import { z } from "zod";
+var MessageRoleSchema = z.enum(["system", "user", "assistant", "tool"]);
+var MessageSchema = z.object({
+  role: MessageRoleSchema,
+  content: z.string(),
+  name: z.string().optional(),
+  metadata: z.record(z.any()).optional()
+});
+var ThoughtSchema = z.object({
+  content: z.string(),
+  timestamp: z.number().optional(),
+  metadata: z.record(z.any()).optional()
+});
+var ToolCallSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  arguments: z.record(z.any()),
+  timestamp: z.number().optional()
+});
+var ToolResultSchema = z.object({
+  toolCallId: z.string(),
+  result: z.any(),
+  error: z.string().optional(),
+  timestamp: z.number().optional()
+});
+var ScratchpadEntrySchema = z.object({
+  step: z.number(),
+  thought: z.string().optional(),
+  action: z.string().optional(),
+  observation: z.string().optional(),
+  timestamp: z.number().optional()
+});
+
+// src/react/state.ts
+import { z as z2 } from "zod";
+import { createStateAnnotation } from "@agentforge/core";
+var ReActStateConfig = {
+  /**
+   * Conversation messages
+   * Accumulates all messages in the conversation
+   */
+  messages: {
+    schema: z2.array(MessageSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Conversation message history"
+  },
+  /**
+   * Reasoning thoughts
+   * Accumulates all reasoning steps the agent takes
+   */
+  thoughts: {
+    schema: z2.array(ThoughtSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Agent reasoning steps"
+  },
+  /**
+   * Tool calls (actions)
+   * Accumulates all tool calls made by the agent
+   */
+  actions: {
+    schema: z2.array(ToolCallSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Tool calls made by the agent"
+  },
+  /**
+   * Tool results (observations)
+   * Accumulates all observations from tool executions
+   */
+  observations: {
+    schema: z2.array(ToolResultSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Results from tool executions"
+  },
+  /**
+   * Scratchpad for intermediate reasoning
+   * Accumulates step-by-step reasoning process
+   */
+  scratchpad: {
+    schema: z2.array(ScratchpadEntrySchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Intermediate reasoning scratchpad"
+  },
+  /**
+   * 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"
+  },
+  /**
+   * Whether the agent should continue iterating
+   */
+  shouldContinue: {
+    schema: z2.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"
+  }
+};
+var ReActState = createStateAnnotation(ReActStateConfig);
+
+// src/react/prompts.ts
+var DEFAULT_REACT_SYSTEM_PROMPT = `You are a helpful assistant that uses tools to solve problems.
+
+You follow the ReAct (Reasoning and Action) pattern:
+1. THINK: Reason about what to do next
+2. ACT: Use a tool or provide a final answer
+3. OBSERVE: Examine the tool's result
+4. REPEAT: Continue until you can answer the user's question
+
+When you need to use a tool:
+- Think carefully about which tool to use
+- Provide the correct arguments
+- Wait for the observation before proceeding
+
+When you have enough information:
+- Provide a clear, complete answer
+- Cite the tools you used if relevant`;
+function formatScratchpad(scratchpad) {
+  if (scratchpad.length === 0) {
+    return "No previous steps.";
+  }
+  return scratchpad.map((entry) => {
+    const parts = [`Step ${entry.step}:`];
+    if (entry.thought) parts.push(`  Thought: ${entry.thought}`);
+    if (entry.action) parts.push(`  Action: ${entry.action}`);
+    if (entry.observation) parts.push(`  Observation: ${entry.observation}`);
+    return parts.join("\n");
+  }).join("\n\n");
+}
+
+// src/react/nodes.ts
+import { HumanMessage, AIMessage, SystemMessage } from "@langchain/core/messages";
+import { toLangChainTools } from "@agentforge/core";
+function createReasoningNode(llm, tools, systemPrompt, maxIterations, verbose = false) {
+  const langchainTools = toLangChainTools(tools);
+  const llmWithTools = llm.bindTools ? llm.bindTools(langchainTools) : llm;
+  return async (state) => {
+    if (verbose) {
+      console.log(`[reasoning] Iteration ${state.iteration + 1}/${maxIterations}`);
+    }
+    const stateMessages = state.messages || [];
+    const messages = [
+      new SystemMessage(systemPrompt),
+      ...stateMessages.map((msg) => {
+        if (msg.role === "user") return new HumanMessage(msg.content);
+        if (msg.role === "assistant") return new AIMessage(msg.content);
+        if (msg.role === "system") return new SystemMessage(msg.content);
+        return new HumanMessage(msg.content);
+      })
+    ];
+    const scratchpad = state.scratchpad || [];
+    if (scratchpad.length > 0) {
+      const scratchpadText = formatScratchpad(scratchpad);
+      messages.push(new SystemMessage(`Previous steps:
+${scratchpadText}`));
+    }
+    const response = await llmWithTools.invoke(messages);
+    const thought = typeof response.content === "string" ? response.content : "";
+    const toolCalls = [];
+    if (response.tool_calls && response.tool_calls.length > 0) {
+      for (const toolCall of response.tool_calls) {
+        toolCalls.push({
+          id: toolCall.id || `call_${Date.now()}_${Math.random()}`,
+          name: toolCall.name,
+          arguments: toolCall.args || {},
+          timestamp: Date.now()
+        });
+      }
+    }
+    const currentIteration = state.iteration || 0;
+    const shouldContinue = toolCalls.length > 0 && currentIteration + 1 < maxIterations;
+    return {
+      messages: [{ role: "assistant", content: thought }],
+      thoughts: thought ? [{ content: thought, timestamp: Date.now() }] : [],
+      actions: toolCalls,
+      iteration: 1,
+      // Increment iteration
+      shouldContinue,
+      response: toolCalls.length === 0 ? thought : void 0
+      // Final response if no tool calls
+    };
+  };
+}
+function createActionNode(tools, verbose = false) {
+  const toolMap = new Map(tools.map((tool) => [tool.metadata.name, tool]));
+  return async (state) => {
+    const actions = state.actions || [];
+    if (verbose) {
+      console.log(`[action] Executing ${actions.length} tool calls`);
+    }
+    const recentActions = actions.slice(-10);
+    const observations = [];
+    for (const action of recentActions) {
+      const tool = toolMap.get(action.name);
+      if (!tool) {
+        observations.push({
+          toolCallId: action.id,
+          result: null,
+          error: `Tool '${action.name}' not found`,
+          timestamp: Date.now()
+        });
+        continue;
+      }
+      try {
+        const result = await tool.execute(action.arguments);
+        observations.push({
+          toolCallId: action.id,
+          result,
+          timestamp: Date.now()
+        });
+        if (verbose) {
+          console.log(`[action] Tool '${action.name}' executed successfully`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        observations.push({
+          toolCallId: action.id,
+          result: null,
+          error: errorMessage,
+          timestamp: Date.now()
+        });
+        if (verbose) {
+          console.error(`[action] Tool '${action.name}' failed:`, errorMessage);
+        }
+      }
+    }
+    return {
+      observations
+    };
+  };
+}
+function createObservationNode(verbose = false) {
+  return async (state) => {
+    const observations = state.observations || [];
+    const thoughts = state.thoughts || [];
+    const actions = state.actions || [];
+    if (verbose) {
+      console.log(`[observation] Processing ${observations.length} observations`);
+    }
+    const recentObservations = observations.slice(-10);
+    const currentStep = state.iteration;
+    const latestThought = thoughts[thoughts.length - 1]?.content || "";
+    const latestActions = actions.slice(-10);
+    const latestObservations = recentObservations;
+    const scratchpadEntry = {
+      step: currentStep,
+      thought: latestThought,
+      action: latestActions.map((a) => `${a.name}(${JSON.stringify(a.arguments)})`).join(", "),
+      observation: latestObservations.map((obs) => {
+        if (obs.error) {
+          return `Error: ${obs.error}`;
+        }
+        return typeof obs.result === "string" ? obs.result : JSON.stringify(obs.result);
+      }).join("; "),
+      timestamp: Date.now()
+    };
+    const observationMessages = latestObservations.map((obs) => {
+      const content = obs.error ? `Error: ${obs.error}` : typeof obs.result === "string" ? obs.result : JSON.stringify(obs.result, null, 2);
+      return {
+        role: "tool",
+        content,
+        name: latestActions.find((a) => a.id === obs.toolCallId)?.name
+      };
+    });
+    return {
+      scratchpad: [scratchpadEntry],
+      messages: observationMessages
+    };
+  };
+}
+
+// src/react/agent.ts
+import { StateGraph, END } from "@langchain/langgraph";
+import { ToolRegistry } from "@agentforge/core";
+function createReActAgent(config, options) {
+  const {
+    llm,
+    tools,
+    systemPrompt = DEFAULT_REACT_SYSTEM_PROMPT,
+    maxIterations = 10,
+    returnIntermediateSteps = false,
+    stopCondition
+  } = config;
+  const {
+    verbose = false,
+    nodeNames = {}
+  } = options || {};
+  const toolArray = tools instanceof ToolRegistry ? tools.getAll() : tools;
+  const REASONING_NODE = nodeNames.reasoning || "reasoning";
+  const ACTION_NODE = nodeNames.action || "action";
+  const OBSERVATION_NODE = nodeNames.observation || "observation";
+  const reasoningNode = createReasoningNode(
+    llm,
+    toolArray,
+    systemPrompt,
+    maxIterations,
+    verbose
+  );
+  const actionNode = createActionNode(toolArray, verbose);
+  const observationNode = createObservationNode(verbose);
+  const shouldContinue = (state) => {
+    if (stopCondition && stopCondition(state)) {
+      return END;
+    }
+    if (state.iteration >= maxIterations) {
+      return END;
+    }
+    if (state.response) {
+      return END;
+    }
+    if (state.shouldContinue === false) {
+      return END;
+    }
+    return ACTION_NODE;
+  };
+  const workflow = new StateGraph(ReActState).addNode(REASONING_NODE, reasoningNode).addNode(ACTION_NODE, actionNode).addNode(OBSERVATION_NODE, observationNode).addEdge("__start__", REASONING_NODE).addConditionalEdges(REASONING_NODE, shouldContinue).addEdge(ACTION_NODE, OBSERVATION_NODE).addEdge(OBSERVATION_NODE, REASONING_NODE);
+  return workflow.compile();
+}
+
+// src/react/builder.ts
+var ReActAgentBuilder = class {
+  config = {};
+  options = {};
+  /**
+   * Set the language model (required)
+   *
+   * @param llm - LangChain chat model to use for reasoning
+   */
+  withLLM(llm) {
+    this.config.llm = llm;
+    return this;
+  }
+  /**
+   * Set the tools (required)
+   *
+   * @param tools - Tool registry or array of tools
+   */
+  withTools(tools) {
+    this.config.tools = tools;
+    return this;
+  }
+  /**
+   * Set the system prompt (optional)
+   *
+   * @param systemPrompt - System prompt for the agent
+   */
+  withSystemPrompt(systemPrompt) {
+    this.config.systemPrompt = systemPrompt;
+    return this;
+  }
+  /**
+   * Set the maximum iterations (optional, default: 10)
+   *
+   * @param maxIterations - Maximum number of thought-action loops
+   */
+  withMaxIterations(maxIterations) {
+    this.config.maxIterations = maxIterations;
+    return this;
+  }
+  /**
+   * Set whether to return intermediate steps (optional, default: false)
+   *
+   * @param returnIntermediateSteps - Whether to include reasoning steps in output
+   */
+  withReturnIntermediateSteps(returnIntermediateSteps) {
+    this.config.returnIntermediateSteps = returnIntermediateSteps;
+    return this;
+  }
+  /**
+   * Set a custom stop condition (optional)
+   *
+   * @param stopCondition - Function that determines when to stop the agent
+   */
+  withStopCondition(stopCondition) {
+    this.config.stopCondition = stopCondition;
+    return this;
+  }
+  /**
+   * Enable verbose logging (optional, default: false)
+   *
+   * @param verbose - Whether to enable verbose logging
+   */
+  withVerbose(verbose) {
+    this.options.verbose = verbose;
+    return this;
+  }
+  /**
+   * Set custom node names (optional)
+   *
+   * @param nodeNames - Custom names for nodes (for debugging/observability)
+   */
+  withNodeNames(nodeNames) {
+    this.options.nodeNames = nodeNames;
+    return this;
+  }
+  /**
+   * Build the ReAct agent
+   *
+   * @returns A compiled LangGraph StateGraph
+   * @throws Error if required configuration is missing
+   */
+  build() {
+    if (!this.config.llm) {
+      throw new Error("ReActAgentBuilder: llm is required. Use withLLM() to set it.");
+    }
+    if (!this.config.tools) {
+      throw new Error("ReActAgentBuilder: tools are required. Use withTools() to set them.");
+    }
+    const finalConfig = {
+      llm: this.config.llm,
+      tools: this.config.tools,
+      systemPrompt: this.config.systemPrompt || DEFAULT_REACT_SYSTEM_PROMPT,
+      maxIterations: this.config.maxIterations ?? 10,
+      returnIntermediateSteps: this.config.returnIntermediateSteps ?? false,
+      stopCondition: this.config.stopCondition
+    };
+    return createReActAgent(finalConfig, this.options);
+  }
+};
+function createReActAgentBuilder() {
+  return new ReActAgentBuilder();
+}
+
+// src/plan-execute/agent.ts
+import { StateGraph as StateGraph2, END as END2 } from "@langchain/langgraph";
+
+// src/plan-execute/state.ts
+import { z as z4 } from "zod";
+import { createStateAnnotation as createStateAnnotation2 } from "@agentforge/core";
+
+// src/plan-execute/schemas.ts
+import { z as z3 } from "zod";
+var PlanStepSchema = z3.object({
+  /**
+   * Unique identifier for the step
+   */
+  id: z3.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"),
+  /**
+   * Optional dependencies on other steps (by ID)
+   */
+  dependencies: z3.array(z3.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"),
+  /**
+   * Optional arguments for the tool
+   */
+  args: z3.record(z3.any()).optional().describe("Arguments to pass to the tool")
+});
+var CompletedStepSchema = z3.object({
+  /**
+   * The step that was executed
+   */
+  step: PlanStepSchema.describe("The step that was executed"),
+  /**
+   * The result of executing the step
+   */
+  result: z3.any().describe("The result of executing the step"),
+  /**
+   * Whether the step succeeded
+   */
+  success: z3.boolean().describe("Whether the step succeeded"),
+  /**
+   * Optional error message if the step failed
+   */
+  error: z3.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")
+});
+var PlanSchema = z3.object({
+  /**
+   * List of steps in the plan
+   */
+  steps: z3.array(PlanStepSchema).describe("List of steps in the plan"),
+  /**
+   * Overall goal of the plan
+   */
+  goal: z3.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"),
+  /**
+   * Optional confidence score (0-1)
+   */
+  confidence: z3.number().min(0).max(1).optional().describe("Confidence score for the plan (0-1)")
+});
+var ReplanDecisionSchema = z3.object({
+  /**
+   * Whether to replan
+   */
+  shouldReplan: z3.boolean().describe("Whether to replan based on current results"),
+  /**
+   * Reason for the decision
+   */
+  reason: z3.string().describe("Reason for the replan decision"),
+  /**
+   * Optional new goal if replanning
+   */
+  newGoal: z3.string().optional().describe("Updated goal if replanning")
+});
+var ExecutionStatusSchema = z3.enum([
+  "planning",
+  "executing",
+  "replanning",
+  "completed",
+  "failed"
+]).describe("Current status of the plan execution");
+
+// src/plan-execute/state.ts
+var PlanExecuteStateConfig = {
+  /**
+   * Original user input/query
+   */
+  input: {
+    schema: z4.string(),
+    default: () => "",
+    description: "Original user input or query"
+  },
+  /**
+   * The current plan
+   */
+  plan: {
+    schema: PlanSchema.optional(),
+    description: "The current execution plan"
+  },
+  /**
+   * Completed steps with their results
+   * Accumulates all completed steps
+   */
+  pastSteps: {
+    schema: z4.array(CompletedStepSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Completed steps with their results"
+  },
+  /**
+   * Index of the current step being executed
+   */
+  currentStepIndex: {
+    schema: z4.number().int().nonnegative().optional(),
+    description: "Index of the current step being executed"
+  },
+  /**
+   * Current execution status
+   */
+  status: {
+    schema: ExecutionStatusSchema,
+    default: () => "planning",
+    description: "Current execution status"
+  },
+  /**
+   * Final response
+   */
+  response: {
+    schema: z4.string().optional(),
+    description: "Final response after plan execution"
+  },
+  /**
+   * Error message if execution failed
+   */
+  error: {
+    schema: z4.string().optional(),
+    description: "Error message if execution failed"
+  },
+  /**
+   * Iteration counter for replanning
+   */
+  iteration: {
+    schema: z4.number().int().nonnegative(),
+    reducer: (left, right) => left + right,
+    default: () => 0,
+    description: "Number of planning iterations"
+  },
+  /**
+   * Maximum iterations allowed
+   */
+  maxIterations: {
+    schema: z4.number().int().positive(),
+    default: () => 5,
+    description: "Maximum number of planning iterations allowed"
+  }
+};
+var PlanExecuteState = createStateAnnotation2(PlanExecuteStateConfig);
+
+// src/plan-execute/nodes.ts
+import { HumanMessage as HumanMessage2, SystemMessage as SystemMessage2 } from "@langchain/core/messages";
+
+// src/plan-execute/prompts.ts
+var DEFAULT_PLANNER_SYSTEM_PROMPT = `You are an expert planning assistant. Your job is to create a detailed, step-by-step plan to accomplish the user's goal.
+
+Guidelines for creating plans:
+1. Break down complex tasks into clear, actionable steps
+2. Each step should have a specific, measurable outcome
+3. Identify dependencies between steps
+4. Consider which tools are needed for each step
+5. Keep the plan focused and efficient
+6. Aim for 3-7 steps for most tasks
+
+Output your plan as a JSON object with the following structure:
+{
+  "goal": "The overall goal",
+  "steps": [
+    {
+      "id": "step-1",
+      "description": "What this step accomplishes",
+      "tool": "tool_name (optional)",
+      "args": {"key": "value (optional)"},
+      "dependencies": ["step-id (optional)"]
+    }
+  ],
+  "confidence": 0.9
+}`;
+var DEFAULT_REPLANNER_SYSTEM_PROMPT = `You are an expert replanning assistant. Your job is to decide whether the current plan needs to be adjusted based on the results so far.
+
+Consider:
+1. Have the completed steps achieved their intended outcomes?
+2. Are there any unexpected results that require plan changes?
+3. Is the original goal still achievable with the current plan?
+4. Would a different approach be more effective?
+
+Output your decision as a JSON object:
+{
+  "shouldReplan": true/false,
+  "reason": "Explanation for the decision",
+  "newGoal": "Updated goal if replanning (optional)"
+}`;
+var PLANNING_PROMPT_TEMPLATE = `User Goal: {input}
+
+{toolDescriptions}
+
+Create a step-by-step plan to accomplish this goal.`;
+var REPLANNING_PROMPT_TEMPLATE = `Original Goal: {goal}
+
+Completed Steps:
+{completedSteps}
+
+Current Plan:
+{remainingSteps}
+
+Based on the results so far, should we continue with the current plan or replan?`;
+var COMPLETED_STEP_TEMPLATE = `Step {stepNumber}: {description}
+Result: {result}
+Status: {status}`;
+var REMAINING_STEP_TEMPLATE = `Step {stepNumber}: {description}
+{dependencies}`;
+
+// src/plan-execute/nodes.ts
+function createPlannerNode(config) {
+  const {
+    llm,
+    systemPrompt = DEFAULT_PLANNER_SYSTEM_PROMPT,
+    maxSteps = 7,
+    includeToolDescriptions = false
+  } = config;
+  return async (state) => {
+    try {
+      let toolDescriptions = "";
+      if (includeToolDescriptions) {
+        toolDescriptions = "";
+      }
+      const userPrompt = PLANNING_PROMPT_TEMPLATE.replace("{input}", state.input || "").replace("{toolDescriptions}", toolDescriptions);
+      const messages = [
+        new SystemMessage2(systemPrompt),
+        new HumanMessage2(userPrompt)
+      ];
+      const response = await llm.invoke(messages);
+      const content = response.content.toString();
+      let plan;
+      try {
+        const parsed = JSON.parse(content);
+        plan = {
+          steps: parsed.steps.slice(0, maxSteps),
+          // Limit to maxSteps
+          goal: parsed.goal || state.input || "",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          confidence: parsed.confidence
+        };
+      } catch (parseError) {
+        throw new Error(`Failed to parse plan from LLM response: ${parseError}`);
+      }
+      return {
+        plan,
+        status: "executing",
+        currentStepIndex: 0,
+        iteration: 1
+      };
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in planner"
+      };
+    }
+  };
+}
+function createExecutorNode(config) {
+  const {
+    tools,
+    llm,
+    parallel = false,
+    stepTimeout = 3e4
+  } = config;
+  return async (state) => {
+    try {
+      const { plan, currentStepIndex = 0, pastSteps = [] } = state;
+      if (!plan || !plan.steps || plan.steps.length === 0) {
+        return {
+          status: "completed"
+        };
+      }
+      if (currentStepIndex >= plan.steps.length) {
+        return {
+          status: "completed"
+        };
+      }
+      const currentStep = plan.steps[currentStepIndex];
+      if (currentStep.dependencies && currentStep.dependencies.length > 0) {
+        const completedStepIds = new Set(pastSteps.map((ps) => ps.step.id));
+        const unmetDependencies = currentStep.dependencies.filter((dep) => !completedStepIds.has(dep));
+        if (unmetDependencies.length > 0) {
+          throw new Error(`Unmet dependencies for step ${currentStep.id}: ${unmetDependencies.join(", ")}`);
+        }
+      }
+      let result;
+      let success = true;
+      let error;
+      try {
+        if (currentStep.tool) {
+          const tool = tools.find((t) => t.metadata.name === currentStep.tool);
+          if (!tool) {
+            throw new Error(`Tool not found: ${currentStep.tool}`);
+          }
+          const timeoutPromise = new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Step execution timeout")), stepTimeout)
+          );
+          result = await Promise.race([
+            tool.execute(currentStep.args || {}),
+            timeoutPromise
+          ]);
+        } else {
+          result = { message: "Step completed without tool execution" };
+        }
+      } catch (execError) {
+        success = false;
+        error = execError instanceof Error ? execError.message : "Unknown execution error";
+        result = null;
+      }
+      const completedStep = {
+        step: currentStep,
+        result,
+        success,
+        error,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return {
+        pastSteps: [completedStep],
+        currentStepIndex: currentStepIndex + 1
+      };
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in executor"
+      };
+    }
+  };
+}
+function createReplannerNode(config) {
+  const {
+    llm,
+    replanThreshold = 0.7,
+    systemPrompt = DEFAULT_REPLANNER_SYSTEM_PROMPT
+  } = config;
+  return async (state) => {
+    try {
+      const { plan, pastSteps = [], currentStepIndex = 0 } = state;
+      if (!plan) {
+        return { status: "failed", error: "No plan available for replanning" };
+      }
+      const completedStepsText = pastSteps.map(
+        (ps, idx) => COMPLETED_STEP_TEMPLATE.replace("{stepNumber}", String(idx + 1)).replace("{description}", ps.step.description).replace("{result}", JSON.stringify(ps.result)).replace("{status}", ps.success ? "Success" : `Failed: ${ps.error}`)
+      ).join("\n\n");
+      const remainingSteps = plan.steps.slice(currentStepIndex);
+      const remainingStepsText = remainingSteps.map(
+        (step, idx) => REMAINING_STEP_TEMPLATE.replace("{stepNumber}", String(currentStepIndex + idx + 1)).replace("{description}", step.description).replace("{dependencies}", step.dependencies ? `Dependencies: ${step.dependencies.join(", ")}` : "")
+      ).join("\n\n");
+      const userPrompt = REPLANNING_PROMPT_TEMPLATE.replace("{goal}", plan.goal).replace("{completedSteps}", completedStepsText || "None").replace("{remainingSteps}", remainingStepsText || "None");
+      const messages = [
+        new SystemMessage2(systemPrompt),
+        new HumanMessage2(userPrompt)
+      ];
+      const response = await llm.invoke(messages);
+      const content = response.content.toString();
+      let decision;
+      try {
+        decision = JSON.parse(content);
+      } catch (parseError) {
+        throw new Error(`Failed to parse replan decision from LLM response: ${parseError}`);
+      }
+      if (decision.shouldReplan) {
+        return {
+          status: "planning",
+          input: decision.newGoal || plan.goal,
+          iteration: 1
+        };
+      } else {
+        return {
+          status: "executing"
+        };
+      }
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in replanner"
+      };
+    }
+  };
+}
+function createFinisherNode() {
+  return async (state) => {
+    const results = state.pastSteps?.map((ps) => ({
+      step: ps.step.description,
+      result: ps.result,
+      success: ps.success
+    })) || [];
+    const response = JSON.stringify({
+      goal: state.plan?.goal || state.input,
+      results,
+      totalSteps: state.pastSteps?.length || 0,
+      successfulSteps: state.pastSteps?.filter((ps) => ps.success).length || 0
+    }, null, 2);
+    return {
+      status: "completed",
+      response
+    };
+  };
+}
+
+// src/plan-execute/agent.ts
+function createPlanExecuteAgent(config) {
+  const {
+    planner,
+    executor,
+    replanner,
+    maxIterations = 5,
+    verbose = false
+  } = config;
+  const plannerNode = createPlannerNode(planner);
+  const executorNode = createExecutorNode(executor);
+  const finisherNode = createFinisherNode();
+  const replannerNode = replanner ? createReplannerNode(replanner) : async (state) => ({ status: "executing" });
+  const workflow = new StateGraph2(PlanExecuteState).addNode("planner", plannerNode).addNode("executor", executorNode).addNode("finisher", finisherNode).addNode("replanner", replannerNode);
+  const routeAfterExecutor = (state) => {
+    if (state.status === "failed") {
+      return "error";
+    }
+    if (state.status === "completed") {
+      return "finish";
+    }
+    const allStepsCompleted = state.currentStepIndex !== void 0 && state.plan?.steps && state.currentStepIndex >= state.plan.steps.length;
+    if (allStepsCompleted) {
+      return "finish";
+    }
+    if (replanner && state.iteration < maxIterations) {
+      const recentSteps = state.pastSteps?.slice(-3) || [];
+      const hasFailures = recentSteps.some((step) => !step.success);
+      if (hasFailures) {
+        return "replan";
+      }
+    }
+    return "execute";
+  };
+  const routeAfterReplanner = (state) => {
+    if (state.status === "failed") {
+      return "error";
+    }
+    if (state.status === "planning") {
+      return "replan";
+    }
+    return "execute";
+  };
+  workflow.addEdge("__start__", "planner");
+  workflow.addEdge("planner", "executor");
+  workflow.addConditionalEdges(
+    "executor",
+    routeAfterExecutor,
+    {
+      execute: "executor",
+      // Loop back to execute next step
+      replan: "replanner",
+      finish: "finisher",
+      error: END2
+    }
+  );
+  workflow.addEdge("finisher", END2);
+  workflow.addConditionalEdges(
+    "replanner",
+    routeAfterReplanner,
+    {
+      replan: "planner",
+      execute: "executor",
+      error: END2,
+      finish: END2
+    }
+  );
+  return workflow.compile();
+}
+
+// src/reflection/state.ts
+import { z as z6 } from "zod";
+import { createStateAnnotation as createStateAnnotation3 } from "@agentforge/core";
+
+// src/reflection/schemas.ts
+import { z as z5 } from "zod";
+var ReflectionSchema = z5.object({
+  /**
+   * The critique or feedback on the current response
+   */
+  critique: z5.string().describe("Critique or feedback on the current response"),
+  /**
+   * Specific issues identified
+   */
+  issues: z5.array(z5.string()).describe("Specific issues or problems identified"),
+  /**
+   * Suggestions for improvement
+   */
+  suggestions: z5.array(z5.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"),
+  /**
+   * Whether the response meets quality standards
+   */
+  meetsStandards: z5.boolean().describe("Whether the response meets quality standards"),
+  /**
+   * Timestamp of the reflection
+   */
+  timestamp: z5.date().optional().describe("When this reflection was created")
+});
+var RevisionSchema = z5.object({
+  /**
+   * The revised content
+   */
+  content: z5.string().describe("The revised content"),
+  /**
+   * Which iteration this revision is from
+   */
+  iteration: z5.number().int().nonnegative().describe("Iteration number"),
+  /**
+   * The reflection that prompted this revision
+   */
+  basedOn: ReflectionSchema.optional().describe("The reflection that prompted this revision"),
+  /**
+   * Timestamp of the revision
+   */
+  timestamp: z5.date().optional().describe("When this revision was created")
+});
+var ReflectionStatusSchema = z5.enum([
+  "generating",
+  // Initial generation
+  "reflecting",
+  // Critiquing current response
+  "revising",
+  // Improving based on critique
+  "completed",
+  // Quality threshold met
+  "failed"
+  // Max iterations reached without meeting standards
+]);
+var QualityCriteriaSchema = z5.object({
+  /**
+   * Minimum quality score required (0-10)
+   */
+  minScore: z5.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"),
+  /**
+   * Whether all criteria must be met
+   */
+  requireAll: z5.boolean().default(true).describe("Whether all criteria must be met")
+});
+var ReflectionConfigSchema = z5.object({
+  /**
+   * Maximum number of reflection iterations
+   */
+  maxIterations: z5.number().int().positive().default(3).describe("Maximum reflection iterations"),
+  /**
+   * Quality criteria for completion
+   */
+  qualityCriteria: QualityCriteriaSchema.optional().describe("Quality criteria for completion"),
+  /**
+   * Whether to include previous reflections in context
+   */
+  includeHistory: z5.boolean().default(true).describe("Include previous reflections in context")
+});
+
+// src/reflection/state.ts
+var ReflectionStateConfig = {
+  /**
+   * Original user input/task
+   */
+  input: {
+    schema: z6.string(),
+    default: () => "",
+    description: "Original user input or task"
+  },
+  /**
+   * Current response/output
+   */
+  currentResponse: {
+    schema: z6.string().optional(),
+    description: "Current response or output"
+  },
+  /**
+   * History of all reflections/critiques
+   * Accumulates all reflections
+   */
+  reflections: {
+    schema: z6.array(ReflectionSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "History of all reflections and critiques"
+  },
+  /**
+   * History of all revisions
+   * Accumulates all revisions
+   */
+  revisions: {
+    schema: z6.array(RevisionSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "History of all revisions"
+  },
+  /**
+   * Current iteration number
+   */
+  iteration: {
+    schema: z6.number().int().nonnegative(),
+    reducer: (left, right) => left + right,
+    default: () => 0,
+    description: "Current iteration number"
+  },
+  /**
+   * Current status
+   */
+  status: {
+    schema: ReflectionStatusSchema,
+    default: () => "generating",
+    description: "Current reflection status"
+  },
+  /**
+   * Quality criteria for completion
+   */
+  qualityCriteria: {
+    schema: QualityCriteriaSchema.optional(),
+    description: "Quality criteria for determining completion"
+  },
+  /**
+   * Maximum iterations allowed
+   */
+  maxIterations: {
+    schema: z6.number().int().positive(),
+    default: () => 3,
+    description: "Maximum number of reflection iterations allowed"
+  },
+  /**
+   * Final response (when completed)
+   */
+  response: {
+    schema: z6.string().optional(),
+    description: "Final response after reflection process"
+  },
+  /**
+   * Error message if failed
+   */
+  error: {
+    schema: z6.string().optional(),
+    description: "Error message if reflection failed"
+  }
+};
+var ReflectionState = createStateAnnotation3(ReflectionStateConfig);
+
+// src/reflection/prompts.ts
+var DEFAULT_GENERATOR_SYSTEM_PROMPT = `You are an expert content generator. Your task is to create high-quality responses to user requests.
+
+Focus on:
+- Clarity and coherence
+- Accuracy and correctness
+- Completeness and thoroughness
+- Appropriate tone and style
+
+Generate the best possible response to the user's request.`;
+var DEFAULT_REFLECTOR_SYSTEM_PROMPT = `You are an expert critic and reviewer. Your task is to provide constructive feedback on responses.
+
+Evaluate the response based on:
+- Clarity: Is it easy to understand?
+- Accuracy: Is the information correct?
+- Completeness: Does it fully address the request?
+- Quality: Is it well-written and professional?
+
+Provide specific, actionable feedback for improvement.`;
+var DEFAULT_REVISER_SYSTEM_PROMPT = `You are an expert editor and reviser. Your task is to improve responses based on feedback.
+
+Focus on:
+- Addressing all identified issues
+- Implementing suggested improvements
+- Maintaining the core message
+- Enhancing overall quality
+
+Create an improved version that addresses the critique.`;
+var GENERATION_PROMPT_TEMPLATE = `Please generate a response to the following request:
+
+{input}
+
+{context}
+
+Provide a high-quality, complete response.`;
+var REFLECTION_PROMPT_TEMPLATE = `Please review and critique the following response:
+
+Original Request:
+{input}
+
+Current Response:
+{currentResponse}
+
+{criteria}
+
+{history}
+
+Provide a detailed critique including:
+1. What works well
+2. Specific issues or problems
+3. Suggestions for improvement
+4. A quality score (0-10)
+5. Whether it meets quality standards
+
+Format your response as JSON with the following structure:
+{
+  "critique": "overall assessment",
+  "issues": ["issue 1", "issue 2"],
+  "suggestions": ["suggestion 1", "suggestion 2"],
+  "score": 8,
+  "meetsStandards": true
+}`;
+var REVISION_PROMPT_TEMPLATE = `Please revise the following response based on the critique:
+
+Original Request:
+{input}
+
+Current Response:
+{currentResponse}
+
+Critique:
+{critique}
+
+Issues to Address:
+{issues}
+
+Suggestions:
+{suggestions}
+
+{history}
+
+Create an improved version that addresses all the feedback while maintaining the core message.`;
+var QUALITY_CRITERIA_TEMPLATE = `Evaluate against these specific criteria:
+{criteria}
+
+Minimum required score: {minScore}/10
+{requireAll}`;
+var REFLECTION_HISTORY_TEMPLATE = `Previous Reflections:
+{reflections}
+
+Previous Revisions:
+{revisions}`;
+var REFLECTION_ENTRY_TEMPLATE = `Iteration {iteration}:
+Critique: {critique}
+Score: {score}/10
+Issues: {issues}
+Suggestions: {suggestions}`;
+var REVISION_ENTRY_TEMPLATE = `Iteration {iteration}:
+{content}`;
+
+// src/reflection/nodes.ts
+import { HumanMessage as HumanMessage3, SystemMessage as SystemMessage3 } from "@langchain/core/messages";
+function createGeneratorNode(config) {
+  const {
+    llm,
+    systemPrompt = DEFAULT_GENERATOR_SYSTEM_PROMPT,
+    verbose = false
+  } = config;
+  return async (state) => {
+    try {
+      if (verbose) {
+        console.log("[Generator] Generating initial response...");
+      }
+      let context = "";
+      if (state.iteration > 0 && state.reflections.length > 0) {
+        const lastReflection = state.reflections[state.reflections.length - 1];
+        context = `
+Previous feedback to consider:
+${lastReflection.critique}`;
+      }
+      const userPrompt = GENERATION_PROMPT_TEMPLATE.replace("{input}", state.input || "").replace("{context}", context);
+      const messages = [
+        new SystemMessage3(systemPrompt),
+        new HumanMessage3(userPrompt)
+      ];
+      const response = await llm.invoke(messages);
+      const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      if (verbose) {
+        console.log("[Generator] Generated response:", content.substring(0, 100) + "...");
+      }
+      return {
+        currentResponse: content,
+        status: "reflecting",
+        iteration: 1
+      };
+    } catch (error) {
+      console.error("[Generator] Error:", error);
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in generator"
+      };
+    }
+  };
+}
+function createReflectorNode(config) {
+  const {
+    llm,
+    systemPrompt = DEFAULT_REFLECTOR_SYSTEM_PROMPT,
+    qualityCriteria,
+    verbose = false
+  } = config;
+  return async (state) => {
+    try {
+      if (verbose) {
+        console.log("[Reflector] Reflecting on response...");
+      }
+      if (!state.currentResponse) {
+        throw new Error("No current response to reflect on");
+      }
+      let criteriaSection = "";
+      const criteria = qualityCriteria || state.qualityCriteria;
+      if (criteria) {
+        const criteriaList = criteria.criteria?.join("\n- ") || "";
+        criteriaSection = QUALITY_CRITERIA_TEMPLATE.replace("{criteria}", criteriaList ? `- ${criteriaList}` : "General quality standards").replace("{minScore}", criteria.minScore?.toString() || "7").replace("{requireAll}", criteria.requireAll ? "All criteria must be met." : "Meet as many criteria as possible.");
+      }
+      let historySection = "";
+      if (state.reflections.length > 0 || state.revisions.length > 0) {
+        const reflectionsText = state.reflections.map(
+          (r, idx) => REFLECTION_ENTRY_TEMPLATE.replace("{iteration}", (idx + 1).toString()).replace("{critique}", r.critique).replace("{score}", r.score?.toString() || "N/A").replace("{issues}", r.issues.join(", ")).replace("{suggestions}", r.suggestions.join(", "))
+        ).join("\n\n");
+        const revisionsText = state.revisions.map(
+          (r) => REVISION_ENTRY_TEMPLATE.replace("{iteration}", r.iteration.toString()).replace("{content}", r.content.substring(0, 200) + "...")
+        ).join("\n\n");
+        historySection = REFLECTION_HISTORY_TEMPLATE.replace("{reflections}", reflectionsText || "None").replace("{revisions}", revisionsText || "None");
+      }
+      const userPrompt = REFLECTION_PROMPT_TEMPLATE.replace("{input}", state.input || "").replace("{currentResponse}", state.currentResponse).replace("{criteria}", criteriaSection).replace("{history}", historySection);
+      const messages = [
+        new SystemMessage3(systemPrompt),
+        new HumanMessage3(userPrompt)
+      ];
+      const response = await llm.invoke(messages);
+      const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      let reflection;
+      try {
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          reflection = JSON.parse(jsonMatch[0]);
+        } else {
+          reflection = {
+            critique: content,
+            issues: [],
+            suggestions: [],
+            score: 5,
+            meetsStandards: false
+          };
+        }
+      } catch (parseError) {
+        reflection = {
+          critique: content,
+          issues: [],
+          suggestions: [],
+          score: 5,
+          meetsStandards: false
+        };
+      }
+      if (verbose) {
+        console.log("[Reflector] Reflection score:", reflection.score);
+        console.log("[Reflector] Meets standards:", reflection.meetsStandards);
+      }
+      return {
+        reflections: [reflection],
+        status: reflection.meetsStandards ? "completed" : "revising"
+      };
+    } catch (error) {
+      console.error("[Reflector] Error:", error);
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in reflector"
+      };
+    }
+  };
+}
+function createReviserNode(config) {
+  const {
+    llm,
+    systemPrompt = DEFAULT_REVISER_SYSTEM_PROMPT,
+    verbose = false
+  } = config;
+  return async (state) => {
+    try {
+      if (verbose) {
+        console.log("[Reviser] Revising response...");
+      }
+      if (!state.currentResponse) {
+        throw new Error("No current response to revise");
+      }
+      if (state.reflections.length === 0) {
+        throw new Error("No reflections to base revision on");
+      }
+      const lastReflection = state.reflections[state.reflections.length - 1];
+      let historySection = "";
+      if (state.revisions.length > 0) {
+        const revisionsText = state.revisions.map(
+          (r) => REVISION_ENTRY_TEMPLATE.replace("{iteration}", r.iteration.toString()).replace("{content}", r.content.substring(0, 200) + "...")
+        ).join("\n\n");
+        historySection = `
+Previous Revisions:
+${revisionsText}`;
+      }
+      const userPrompt = REVISION_PROMPT_TEMPLATE.replace("{input}", state.input || "").replace("{currentResponse}", state.currentResponse).replace("{critique}", lastReflection.critique).replace("{issues}", lastReflection.issues.join("\n- ")).replace("{suggestions}", lastReflection.suggestions.join("\n- ")).replace("{history}", historySection);
+      const messages = [
+        new SystemMessage3(systemPrompt),
+        new HumanMessage3(userPrompt)
+      ];
+      const response = await llm.invoke(messages);
+      const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      if (verbose) {
+        console.log("[Reviser] Created revision:", content.substring(0, 100) + "...");
+      }
+      const revision = {
+        content,
+        iteration: state.iteration,
+        basedOn: lastReflection
+      };
+      return {
+        currentResponse: content,
+        revisions: [revision],
+        status: "reflecting",
+        iteration: 1
+      };
+    } catch (error) {
+      console.error("[Reviser] Error:", error);
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in reviser"
+      };
+    }
+  };
+}
+function createFinisherNode2() {
+  return async (state) => {
+    return {
+      status: "completed",
+      response: state.currentResponse
+    };
+  };
+}
+
+// src/reflection/agent.ts
+import { StateGraph as StateGraph3, END as END3 } from "@langchain/langgraph";
+function createReflectionAgent(config) {
+  const {
+    generator,
+    reflector,
+    reviser,
+    maxIterations = 3,
+    qualityCriteria,
+    verbose = false
+  } = config;
+  const generatorNode = createGeneratorNode({ ...generator, verbose });
+  const reflectorNode = createReflectorNode({ ...reflector, qualityCriteria, verbose });
+  const reviserNode = createReviserNode({ ...reviser, verbose });
+  const finisherNode = createFinisherNode2();
+  const routeAfterGenerator = (state) => {
+    if (state.status === "failed") {
+      return "error";
+    }
+    return "reflect";
+  };
+  const routeAfterReflector = (state) => {
+    if (state.status === "failed") {
+      return "error";
+    }
+    if (state.status === "completed") {
+      return "finish";
+    }
+    if (state.iteration >= maxIterations) {
+      return "finish";
+    }
+    return "revise";
+  };
+  const routeAfterReviser = (state) => {
+    if (state.status === "failed") {
+      return "error";
+    }
+    if (state.iteration >= maxIterations) {
+      return "finish";
+    }
+    return "reflect";
+  };
+  const workflow = new StateGraph3(ReflectionState).addNode("generator", generatorNode).addNode("reflector", reflectorNode).addNode("reviser", reviserNode).addNode("finisher", finisherNode);
+  workflow.addEdge("__start__", "generator").addConditionalEdges(
+    "generator",
+    routeAfterGenerator,
+    {
+      reflect: "reflector",
+      error: END3
+    }
+  ).addConditionalEdges(
+    "reflector",
+    routeAfterReflector,
+    {
+      revise: "reviser",
+      finish: "finisher",
+      error: END3
+    }
+  ).addConditionalEdges(
+    "reviser",
+    routeAfterReviser,
+    {
+      reflect: "reflector",
+      finish: "finisher",
+      error: END3
+    }
+  ).addEdge("finisher", END3);
+  return workflow.compile();
+}
+
+// src/multi-agent/state.ts
+import { z as z8 } 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([
+  "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 = z7.object({
+  /**
+   * Unique identifier for the message
+   */
+  id: z7.string().describe("Unique message identifier"),
+  /**
+   * Type of message
+   */
+  type: MessageTypeSchema.describe("Type of message"),
+  /**
+   * Agent that sent the message
+   */
+  from: z7.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)"),
+  /**
+   * Message content
+   */
+  content: z7.string().describe("Message content"),
+  /**
+   * Optional metadata
+   */
+  metadata: z7.record(z7.any()).optional().describe("Additional message metadata"),
+  /**
+   * Timestamp when message was created
+   */
+  timestamp: z7.number().describe("Timestamp when message was created")
+});
+var RoutingStrategySchema = z7.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 = z7.object({
+  /**
+   * Target agent to route to
+   */
+  targetAgent: z7.string().describe("Agent to route the task to"),
+  /**
+   * Reasoning for the routing decision
+   */
+  reasoning: z7.string().optional().describe("Explanation for routing decision"),
+  /**
+   * Confidence in the routing decision (0-1)
+   */
+  confidence: z7.number().min(0).max(1).optional().describe("Confidence score"),
+  /**
+   * Strategy used for routing
+   */
+  strategy: RoutingStrategySchema.describe("Strategy used for this decision"),
+  /**
+   * Timestamp of the routing decision
+   */
+  timestamp: z7.number().optional().describe("Timestamp of the decision")
+});
+var WorkerCapabilitiesSchema = z7.object({
+  /**
+   * Skills/capabilities the agent has
+   */
+  skills: z7.array(z7.string()).describe("List of agent skills"),
+  /**
+   * Tools available to the agent
+   */
+  tools: z7.array(z7.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"),
+  /**
+   * Current workload (number of active tasks)
+   */
+  currentWorkload: z7.number().int().nonnegative().default(0).describe("Current number of active tasks")
+});
+var TaskAssignmentSchema = z7.object({
+  /**
+   * Unique assignment identifier
+   */
+  id: z7.string().describe("Unique assignment identifier"),
+  /**
+   * Worker ID assigned to the task
+   */
+  workerId: z7.string().describe("Worker identifier assigned to task"),
+  /**
+   * Task description
+   */
+  task: z7.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"),
+  /**
+   * Timestamp when task was assigned
+   */
+  assignedAt: z7.number().describe("Timestamp when task was assigned"),
+  /**
+   * Optional deadline for task completion
+   */
+  deadline: z7.number().optional().describe("Optional task deadline timestamp")
+});
+var TaskResultSchema = z7.object({
+  /**
+   * Assignment identifier
+   */
+  assignmentId: z7.string().describe("Assignment identifier"),
+  /**
+   * Worker that completed the task
+   */
+  workerId: z7.string().describe("Worker that completed the task"),
+  /**
+   * Whether the task succeeded
+   */
+  success: z7.boolean().describe("Whether the task succeeded"),
+  /**
+   * Task result/output
+   */
+  result: z7.string().describe("Task result or output"),
+  /**
+   * Optional error message if task failed
+   */
+  error: z7.string().optional().describe("Error message if task failed"),
+  /**
+   * Timestamp when task was completed
+   */
+  completedAt: z7.number().describe("Timestamp when task was completed"),
+  /**
+   * Optional metadata about execution
+   */
+  metadata: z7.record(z7.any()).optional().describe("Execution metadata")
+});
+var MultiAgentStatusSchema = z7.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 = z7.object({
+  /**
+   * Agent requesting the handoff
+   */
+  from: z7.string().describe("Agent requesting handoff"),
+  /**
+   * Target agent for handoff
+   */
+  to: z7.string().describe("Target agent for handoff"),
+  /**
+   * Reason for handoff
+   */
+  reason: z7.string().describe("Reason for requesting handoff"),
+  /**
+   * Context to pass to next agent
+   */
+  context: z7.any().describe("Context to pass to next agent"),
+  /**
+   * Timestamp of handoff request
+   */
+  timestamp: z7.string().datetime().describe("ISO timestamp of handoff request")
+});
+
+// src/multi-agent/state.ts
+var MultiAgentStateConfig = {
+  /**
+   * Original user input/query
+   */
+  input: {
+    schema: z8.string(),
+    default: () => "",
+    description: "Original user input or query"
+  },
+  /**
+   * All messages in the multi-agent conversation
+   * Accumulates all messages between agents
+   */
+  messages: {
+    schema: z8.array(AgentMessageSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "All messages in the multi-agent conversation"
+  },
+  /**
+   * Available worker agents and their capabilities
+   */
+  workers: {
+    schema: z8.record(z8.string(), WorkerCapabilitiesSchema),
+    reducer: (left, right) => ({
+      ...left,
+      ...right
+    }),
+    default: () => ({}),
+    description: "Available worker agents and their capabilities"
+  },
+  /**
+   * Current active agent
+   */
+  currentAgent: {
+    schema: z8.string().optional(),
+    description: "Identifier of the currently active agent"
+  },
+  /**
+   * Routing decisions made by the supervisor
+   * Accumulates all routing decisions
+   */
+  routingHistory: {
+    schema: z8.array(RoutingDecisionSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "History of routing decisions"
+  },
+  /**
+   * Active task assignments
+   */
+  activeAssignments: {
+    schema: z8.array(TaskAssignmentSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Currently active task assignments"
+  },
+  /**
+   * Completed task results
+   * Accumulates all completed tasks
+   */
+  completedTasks: {
+    schema: z8.array(TaskResultSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Completed task results"
+  },
+  /**
+   * Handoff requests between agents
+   * Accumulates all handoff requests
+   */
+  handoffs: {
+    schema: z8.array(HandoffRequestSchema),
+    reducer: (left, right) => [...left, ...right],
+    default: () => [],
+    description: "Handoff requests between agents"
+  },
+  /**
+   * Current execution status
+   */
+  status: {
+    schema: MultiAgentStatusSchema,
+    default: () => "initializing",
+    description: "Current multi-agent execution status"
+  },
+  /**
+   * Iteration counter
+   */
+  iteration: {
+    schema: z8.number().int().nonnegative(),
+    reducer: (left, right) => left + right,
+    default: () => 0,
+    description: "Current iteration number"
+  },
+  /**
+   * Maximum iterations allowed
+   */
+  maxIterations: {
+    schema: z8.number().int().positive(),
+    default: () => 10,
+    description: "Maximum number of iterations allowed"
+  },
+  /**
+   * Final aggregated response
+   */
+  response: {
+    schema: z8.string().optional(),
+    description: "Final aggregated response"
+  },
+  /**
+   * Error message if execution failed
+   */
+  error: {
+    schema: z8.string().optional(),
+    description: "Error message if execution failed"
+  }
+};
+var MultiAgentState = createStateAnnotation4(MultiAgentStateConfig);
+
+// src/multi-agent/routing.ts
+import { HumanMessage as HumanMessage4, SystemMessage as SystemMessage4 } from "@langchain/core/messages";
+var DEFAULT_SUPERVISOR_SYSTEM_PROMPT = `You are a supervisor agent responsible for routing tasks to specialized worker agents.
+
+Your job is to:
+1. Analyze the current task and context
+2. Review available worker capabilities
+3. Select the most appropriate worker for the task
+4. Provide clear reasoning for your decision
+
+Respond with a JSON object containing:
+{
+  "targetAgent": "worker_id",
+  "reasoning": "explanation of why this worker is best suited",
+  "confidence": 0.0-1.0,
+  "strategy": "llm-based"
+}`;
+var llmBasedRouting = {
+  name: "llm-based",
+  async route(state, config) {
+    if (!config.llm) {
+      throw new Error("LLM-based routing requires an LLM to be configured");
+    }
+    const systemPrompt = config.systemPrompt || DEFAULT_SUPERVISOR_SYSTEM_PROMPT;
+    const workerInfo = Object.entries(state.workers).map(([id, caps]) => {
+      const skills = caps.skills.join(", ");
+      const tools = caps.tools.join(", ");
+      const available = caps.available ? "available" : "busy";
+      return `- ${id}: Skills: [${skills}], Tools: [${tools}], Status: ${available}, Workload: ${caps.currentWorkload}`;
+    }).join("\n");
+    const lastMessage = state.messages[state.messages.length - 1];
+    const taskContext = lastMessage?.content || state.input;
+    const userPrompt = `Current task: ${taskContext}
+
+Available workers:
+${workerInfo}
+
+Select the best worker for this task and explain your reasoning.`;
+    const messages = [
+      new SystemMessage4(systemPrompt),
+      new HumanMessage4(userPrompt)
+    ];
+    const response = await config.llm.invoke(messages);
+    const content = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+    try {
+      const decision = JSON.parse(content);
+      return {
+        targetAgent: decision.targetAgent,
+        reasoning: decision.reasoning,
+        confidence: decision.confidence,
+        strategy: "llm-based",
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      throw new Error(`Failed to parse routing decision from LLM: ${error}`);
+    }
+  }
+};
+var roundRobinRouting = {
+  name: "round-robin",
+  async route(state, config) {
+    const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id]) => id);
+    if (availableWorkers.length === 0) {
+      throw new Error("No available workers for round-robin routing");
+    }
+    const lastRoutingIndex = state.routingHistory.length % availableWorkers.length;
+    const targetAgent = availableWorkers[lastRoutingIndex];
+    return {
+      targetAgent,
+      reasoning: `Round-robin selection: worker ${lastRoutingIndex + 1} of ${availableWorkers.length}`,
+      confidence: 1,
+      strategy: "round-robin",
+      timestamp: Date.now()
+    };
+  }
+};
+var skillBasedRouting = {
+  name: "skill-based",
+  async route(state, config) {
+    const lastMessage = state.messages[state.messages.length - 1];
+    const taskContent = (lastMessage?.content || state.input).toLowerCase();
+    const workerScores = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => {
+      const skillMatches = caps.skills.filter(
+        (skill) => taskContent.includes(skill.toLowerCase())
+      ).length;
+      const toolMatches = caps.tools.filter(
+        (tool) => taskContent.includes(tool.toLowerCase())
+      ).length;
+      const score = skillMatches * 2 + toolMatches;
+      return { id, score, skills: caps.skills, tools: caps.tools };
+    }).filter((w) => w.score > 0).sort((a, b) => b.score - a.score);
+    if (workerScores.length === 0) {
+      const firstAvailable = Object.entries(state.workers).find(([_, caps]) => caps.available);
+      if (!firstAvailable) {
+        throw new Error("No available workers for skill-based routing");
+      }
+      return {
+        targetAgent: firstAvailable[0],
+        reasoning: "No skill matches found, using first available worker",
+        confidence: 0.5,
+        strategy: "skill-based",
+        timestamp: Date.now()
+      };
+    }
+    const best = workerScores[0];
+    const confidence = Math.min(best.score / 5, 1);
+    return {
+      targetAgent: best.id,
+      reasoning: `Best skill match with score ${best.score} (skills: ${best.skills.join(", ")})`,
+      confidence,
+      strategy: "skill-based",
+      timestamp: Date.now()
+    };
+  }
+};
+var loadBalancedRouting = {
+  name: "load-balanced",
+  async route(state, config) {
+    const availableWorkers = Object.entries(state.workers).filter(([_, caps]) => caps.available).map(([id, caps]) => ({ id, workload: caps.currentWorkload })).sort((a, b) => a.workload - b.workload);
+    if (availableWorkers.length === 0) {
+      throw new Error("No available workers for load-balanced routing");
+    }
+    const targetWorker = availableWorkers[0];
+    const avgWorkload = availableWorkers.reduce((sum, w) => sum + w.workload, 0) / availableWorkers.length;
+    const confidence = targetWorker.workload === 0 ? 1 : Math.max(0.5, 1 - targetWorker.workload / (avgWorkload * 2));
+    return {
+      targetAgent: targetWorker.id,
+      reasoning: `Lowest workload: ${targetWorker.workload} tasks (avg: ${avgWorkload.toFixed(1)})`,
+      confidence,
+      strategy: "load-balanced",
+      timestamp: Date.now()
+    };
+  }
+};
+var ruleBasedRouting = {
+  name: "rule-based",
+  async route(state, config) {
+    if (!config.routingFn) {
+      throw new Error("Rule-based routing requires a custom routing function");
+    }
+    return await config.routingFn(state);
+  }
+};
+function getRoutingStrategy(name) {
+  switch (name) {
+    case "llm-based":
+      return llmBasedRouting;
+    case "round-robin":
+      return roundRobinRouting;
+    case "skill-based":
+      return skillBasedRouting;
+    case "load-balanced":
+      return loadBalancedRouting;
+    case "rule-based":
+      return ruleBasedRouting;
+    default:
+      throw new Error(`Unknown routing strategy: ${name}`);
+  }
+}
+
+// src/multi-agent/nodes.ts
+import { HumanMessage as HumanMessage5, SystemMessage as SystemMessage5 } from "@langchain/core/messages";
+import { toLangChainTools as toLangChainTools2 } from "@agentforge/core";
+var DEFAULT_AGGREGATOR_SYSTEM_PROMPT = `You are an aggregator agent responsible for combining results from multiple worker agents.
+
+Your job is to:
+1. Review all completed task results
+2. Synthesize the information into a coherent response
+3. Ensure all aspects of the original query are addressed
+4. Provide a clear, comprehensive final answer
+
+Be concise but thorough in your aggregation.`;
+function createSupervisorNode(config) {
+  const {
+    strategy,
+    verbose = false,
+    maxIterations = 10
+  } = config;
+  return async (state) => {
+    try {
+      if (verbose) {
+        console.log(`[Supervisor] Routing iteration ${state.iteration}/${maxIterations}`);
+      }
+      if (state.iteration >= maxIterations) {
+        if (verbose) {
+          console.log("[Supervisor] Max iterations reached, moving to aggregation");
+        }
+        return {
+          status: "aggregating",
+          currentAgent: "aggregator"
+        };
+      }
+      const allCompleted = state.activeAssignments.every(
+        (assignment2) => state.completedTasks.some((task) => task.assignmentId === assignment2.id)
+      );
+      if (allCompleted && state.activeAssignments.length > 0) {
+        if (verbose) {
+          console.log("[Supervisor] All tasks completed, moving to aggregation");
+        }
+        return {
+          status: "aggregating",
+          currentAgent: "aggregator"
+        };
+      }
+      const routingImpl = getRoutingStrategy(strategy);
+      const decision = await routingImpl.route(state, config);
+      if (verbose) {
+        console.log(`[Supervisor] Routing to ${decision.targetAgent}: ${decision.reasoning}`);
+      }
+      const assignment = {
+        id: `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        workerId: decision.targetAgent,
+        task: state.messages[state.messages.length - 1]?.content || state.input,
+        priority: 5,
+        assignedAt: Date.now()
+      };
+      const message = {
+        id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        from: "supervisor",
+        to: [decision.targetAgent],
+        type: "task_assignment",
+        content: assignment.task,
+        timestamp: Date.now(),
+        metadata: {
+          assignmentId: assignment.id,
+          priority: assignment.priority
+        }
+      };
+      return {
+        currentAgent: decision.targetAgent,
+        status: "executing",
+        routingHistory: [decision],
+        activeAssignments: [assignment],
+        messages: [message],
+        iteration: state.iteration + 1
+      };
+    } catch (error) {
+      console.error("[Supervisor] Error:", error);
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in supervisor"
+      };
+    }
+  };
+}
+function createWorkerNode(config) {
+  const {
+    id,
+    capabilities,
+    llm,
+    tools = [],
+    systemPrompt,
+    verbose = false,
+    executeFn
+  } = config;
+  return async (state) => {
+    try {
+      if (verbose) {
+        console.log(`[Worker:${id}] Executing task`);
+      }
+      const currentAssignment = state.activeAssignments.find(
+        (assignment) => assignment.workerId === id && !state.completedTasks.some((task) => task.assignmentId === assignment.id)
+      );
+      if (!currentAssignment) {
+        if (verbose) {
+          console.log(`[Worker:${id}] No active assignment found`);
+        }
+        return {
+          currentAgent: "supervisor",
+          status: "routing"
+        };
+      }
+      if (executeFn) {
+        return await executeFn(state);
+      }
+      if (!llm) {
+        throw new Error(`Worker ${id} requires either an LLM or custom execution function`);
+      }
+      const defaultSystemPrompt = `You are a specialized worker agent with the following capabilities:
+Skills: ${capabilities.skills.join(", ")}
+Tools: ${capabilities.tools.join(", ")}
+
+Execute the assigned task using your skills and tools. Provide a clear, actionable result.`;
+      const messages = [
+        new SystemMessage5(systemPrompt || defaultSystemPrompt),
+        new HumanMessage5(currentAssignment.task)
+      ];
+      let llmToUse = llm;
+      if (tools.length > 0 && llm.bindTools) {
+        const langchainTools = toLangChainTools2(tools);
+        llmToUse = llm.bindTools(langchainTools);
+      }
+      const response = await llmToUse.invoke(messages);
+      const result = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      if (verbose) {
+        console.log(`[Worker:${id}] Task completed:`, result.substring(0, 100) + "...");
+      }
+      const taskResult = {
+        assignmentId: currentAssignment.id,
+        workerId: id,
+        success: true,
+        result,
+        completedAt: Date.now(),
+        metadata: {
+          skills_used: capabilities.skills
+        }
+      };
+      const message = {
+        id: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        from: id,
+        to: ["supervisor"],
+        type: "task_result",
+        content: result,
+        timestamp: Date.now(),
+        metadata: {
+          assignmentId: currentAssignment.id,
+          success: true
+        }
+      };
+      const updatedWorkers = {
+        ...state.workers,
+        [id]: {
+          ...capabilities,
+          currentWorkload: Math.max(0, capabilities.currentWorkload - 1)
+        }
+      };
+      return {
+        completedTasks: [taskResult],
+        messages: [message],
+        workers: updatedWorkers,
+        currentAgent: "supervisor",
+        status: "routing"
+      };
+    } catch (error) {
+      console.error(`[Worker:${id}] Error:`, error);
+      const currentAssignment = state.activeAssignments.find(
+        (assignment) => assignment.workerId === id
+      );
+      if (currentAssignment) {
+        const errorResult = {
+          assignmentId: currentAssignment.id,
+          workerId: id,
+          success: false,
+          result: "",
+          error: error instanceof Error ? error.message : "Unknown error",
+          completedAt: Date.now()
+        };
+        return {
+          completedTasks: [errorResult],
+          currentAgent: "supervisor",
+          status: "routing"
+        };
+      }
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : `Unknown error in worker ${id}`
+      };
+    }
+  };
+}
+function createAggregatorNode(config = {}) {
+  const {
+    llm,
+    systemPrompt = DEFAULT_AGGREGATOR_SYSTEM_PROMPT,
+    aggregateFn,
+    verbose = false
+  } = config;
+  return async (state) => {
+    try {
+      if (verbose) {
+        console.log("[Aggregator] Combining results from workers");
+      }
+      if (aggregateFn) {
+        const response2 = await aggregateFn(state);
+        return {
+          response: response2,
+          status: "completed"
+        };
+      }
+      if (state.completedTasks.length === 0) {
+        return {
+          response: "No tasks were completed.",
+          status: "completed"
+        };
+      }
+      if (!llm) {
+        const combinedResults = state.completedTasks.filter((task) => task.success).map((task) => task.result).join("\n\n");
+        return {
+          response: combinedResults || "No successful results to aggregate.",
+          status: "completed"
+        };
+      }
+      const taskResults = state.completedTasks.map((task, idx) => {
+        const status = task.success ? "\u2713" : "\u2717";
+        const result = task.success ? task.result : `Error: ${task.error}`;
+        return `${idx + 1}. [${status}] Worker ${task.workerId}:
+${result}`;
+      }).join("\n\n");
+      const userPrompt = `Original query: ${state.input}
+
+Worker results:
+${taskResults}
+
+Please synthesize these results into a comprehensive response that addresses the original query.`;
+      const messages = [
+        new SystemMessage5(systemPrompt),
+        new HumanMessage5(userPrompt)
+      ];
+      const response = await llm.invoke(messages);
+      const aggregatedResponse = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      if (verbose) {
+        console.log("[Aggregator] Aggregation complete");
+      }
+      return {
+        response: aggregatedResponse,
+        status: "completed"
+      };
+    } catch (error) {
+      console.error("[Aggregator] Error:", error);
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error in aggregator"
+      };
+    }
+  };
+}
+
+// src/multi-agent/agent.ts
+import { StateGraph as StateGraph4, END as END4 } from "@langchain/langgraph";
+function createMultiAgentSystem(config) {
+  const {
+    supervisor,
+    workers,
+    aggregator,
+    maxIterations = 10,
+    verbose = false
+  } = config;
+  const workflow = new StateGraph4(MultiAgentState);
+  const supervisorNode = createSupervisorNode({
+    ...supervisor,
+    maxIterations,
+    verbose
+  });
+  workflow.addNode("supervisor", supervisorNode);
+  const workerIds = [];
+  const workerCapabilities = {};
+  for (const workerConfig of workers) {
+    const workerNode = createWorkerNode({
+      ...workerConfig,
+      verbose
+    });
+    workflow.addNode(workerConfig.id, workerNode);
+    workerIds.push(workerConfig.id);
+    workerCapabilities[workerConfig.id] = workerConfig.capabilities;
+  }
+  const aggregatorNode = createAggregatorNode({
+    ...aggregator,
+    verbose
+  });
+  workflow.addNode("aggregator", aggregatorNode);
+  const supervisorRouter = (state) => {
+    if (state.status === "completed" || state.status === "failed") {
+      return END4;
+    }
+    if (state.status === "aggregating") {
+      return "aggregator";
+    }
+    if (state.currentAgent && state.currentAgent !== "supervisor") {
+      return state.currentAgent;
+    }
+    return "supervisor";
+  };
+  const workerRouter = (state) => {
+    return "supervisor";
+  };
+  const aggregatorRouter = (state) => {
+    return END4;
+  };
+  workflow.setEntryPoint("supervisor");
+  workflow.addConditionalEdges("supervisor", supervisorRouter, [
+    "aggregator",
+    END4,
+    ...workerIds
+  ]);
+  for (const workerId of workerIds) {
+    workflow.addConditionalEdges(workerId, workerRouter, ["supervisor"]);
+  }
+  workflow.addConditionalEdges("aggregator", aggregatorRouter, [END4]);
+  const compiled = workflow.compile();
+  const originalInvoke = compiled.invoke.bind(compiled);
+  compiled.invoke = async function(input, config2) {
+    const mergedInput = {
+      ...input,
+      workers: {
+        ...workerCapabilities,
+        ...input.workers || {}
+      }
+    };
+    return originalInvoke(mergedInput, config2);
+  };
+  return compiled;
+}
+var MultiAgentSystemBuilder = class {
+  config;
+  additionalWorkers = [];
+  compiled = false;
+  constructor(config) {
+    this.config = {
+      ...config,
+      workers: config.workers || []
+    };
+  }
+  /**
+   * Register workers with the system builder
+   *
+   * @param workers - Array of worker configurations
+   * @returns this builder for chaining
+   *
+   * @example
+   * ```typescript
+   * const builder = new MultiAgentSystemBuilder({
+   *   supervisor: { llm, strategy: 'skill-based' },
+   *   aggregator: { llm },
+   * });
+   *
+   * builder.registerWorkers([
+   *   {
+   *     name: 'math_worker',
+   *     capabilities: ['math', 'calculations'],
+   *     tools: [calculatorTool],
+   *   },
+   * ]);
+   *
+   * const system = builder.build();
+   * ```
+   */
+  registerWorkers(workers) {
+    if (this.compiled) {
+      throw new Error("Cannot register workers after the system has been compiled");
+    }
+    for (const worker of workers) {
+      this.additionalWorkers.push({
+        id: worker.name,
+        capabilities: {
+          skills: worker.capabilities,
+          tools: worker.tools?.map((t) => t.name || "unknown") || [],
+          available: true,
+          currentWorkload: 0
+        },
+        llm: worker.llm || this.config.supervisor.llm,
+        tools: worker.tools,
+        systemPrompt: worker.systemPrompt
+      });
+    }
+    return this;
+  }
+  /**
+   * Build and compile the multi-agent system
+   *
+   * @returns Compiled LangGraph workflow
+   */
+  build() {
+    if (this.compiled) {
+      throw new Error("System has already been compiled");
+    }
+    const allWorkers = [...this.config.workers, ...this.additionalWorkers];
+    if (allWorkers.length === 0) {
+      throw new Error("At least one worker must be registered before building the system");
+    }
+    this.compiled = true;
+    return createMultiAgentSystem({
+      ...this.config,
+      workers: allWorkers
+    });
+  }
+};
+function registerWorkers(system, workers) {
+  console.warn(
+    "[AgentForge] registerWorkers() on a compiled system only updates worker capabilities in state.\nIt does NOT add worker nodes to the graph. Use MultiAgentSystemBuilder for proper worker registration.\nSee: https://github.com/agentforge/agentforge/blob/main/packages/patterns/docs/multi-agent-pattern.md"
+  );
+  if (!system._workerRegistry) {
+    system._workerRegistry = {};
+  }
+  for (const worker of workers) {
+    system._workerRegistry[worker.name] = {
+      skills: worker.capabilities,
+      tools: worker.tools?.map((t) => t.name || "unknown") || [],
+      available: true,
+      currentWorkload: 0
+    };
+  }
+  if (!system._originalInvoke) {
+    system._originalInvoke = system.invoke.bind(system);
+    system.invoke = async function(input, config) {
+      const mergedInput = {
+        ...input,
+        workers: {
+          ...system._workerRegistry || {},
+          ...input.workers || {}
+        }
+      };
+      return system._originalInvoke(mergedInput, config);
+    };
+  }
+}
+export {
+  AgentMessageSchema,
+  AgentRoleSchema,
+  CompletedStepSchema,
+  DEFAULT_AGGREGATOR_SYSTEM_PROMPT,
+  DEFAULT_GENERATOR_SYSTEM_PROMPT,
+  DEFAULT_PLANNER_SYSTEM_PROMPT,
+  DEFAULT_REACT_SYSTEM_PROMPT,
+  DEFAULT_REFLECTOR_SYSTEM_PROMPT,
+  DEFAULT_REPLANNER_SYSTEM_PROMPT,
+  DEFAULT_REVISER_SYSTEM_PROMPT,
+  DEFAULT_SUPERVISOR_SYSTEM_PROMPT,
+  ExecutionStatusSchema,
+  GENERATION_PROMPT_TEMPLATE,
+  HandoffRequestSchema,
+  MessageSchema,
+  MessageTypeSchema,
+  MultiAgentState,
+  MultiAgentStateConfig,
+  MultiAgentStatusSchema,
+  MultiAgentSystemBuilder,
+  PLANNING_PROMPT_TEMPLATE,
+  PlanExecuteState,
+  PlanExecuteStateConfig,
+  PlanSchema,
+  PlanStepSchema,
+  QUALITY_CRITERIA_TEMPLATE,
+  QualityCriteriaSchema,
+  REFLECTION_ENTRY_TEMPLATE,
+  REFLECTION_HISTORY_TEMPLATE,
+  REFLECTION_PROMPT_TEMPLATE,
+  REPLANNING_PROMPT_TEMPLATE,
+  REVISION_ENTRY_TEMPLATE,
+  REVISION_PROMPT_TEMPLATE,
+  ReActAgentBuilder,
+  ReActState,
+  ReflectionConfigSchema,
+  ReflectionSchema,
+  ReflectionState,
+  ReflectionStateConfig,
+  ReflectionStatusSchema,
+  ReplanDecisionSchema,
+  RevisionSchema,
+  RoutingDecisionSchema,
+  RoutingStrategySchema,
+  ScratchpadEntrySchema,
+  TaskAssignmentSchema,
+  TaskResultSchema,
+  ThoughtSchema,
+  ToolCallSchema,
+  ToolResultSchema,
+  WorkerCapabilitiesSchema,
+  createAggregatorNode,
+  createExecutorNode,
+  createFinisherNode,
+  createGeneratorNode,
+  createMultiAgentSystem,
+  createPlanExecuteAgent,
+  createPlannerNode,
+  createReActAgent,
+  createReActAgentBuilder,
+  createReflectionAgent,
+  createFinisherNode2 as createReflectionFinisherNode,
+  createReflectorNode,
+  createReplannerNode,
+  createReviserNode,
+  createSupervisorNode,
+  createWorkerNode,
+  getRoutingStrategy,
+  llmBasedRouting,
+  loadBalancedRouting,
+  registerWorkers,
+  roundRobinRouting,
+  ruleBasedRouting,
+  skillBasedRouting
+};