@agentforge/patterns 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2600 @@
+import { z } from 'zod';
+import * as _langchain_langgraph from '@langchain/langgraph';
+import { CompiledStateGraph } from '@langchain/langgraph';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ToolRegistry, Tool } from '@agentforge/core';
+
+/**
+ * Zod schemas for ReAct pattern state
+ *
+ * These schemas define the structure of messages, thoughts, actions, and observations
+ * used in the ReAct (Reasoning and Action) pattern.
+ *
+ * @module langgraph/patterns/react/schemas
+ */
+
+/**
+ * Base message schema
+ */
+declare const MessageSchema: z.ZodObject<{
+    role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+    content: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    name?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    name?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+type Message = z.infer<typeof MessageSchema>;
+/**
+ * Thought schema - represents a reasoning step
+ */
+declare const ThoughtSchema: z.ZodObject<{
+    content: z.ZodString;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    metadata?: Record<string, any> | undefined;
+    timestamp?: number | undefined;
+}, {
+    content: string;
+    metadata?: Record<string, any> | undefined;
+    timestamp?: number | undefined;
+}>;
+type Thought = z.infer<typeof ThoughtSchema>;
+/**
+ * Tool call schema - represents an action to take
+ */
+declare const ToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodRecord<z.ZodString, z.ZodAny>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    arguments: Record<string, any>;
+    timestamp?: number | undefined;
+}, {
+    name: string;
+    id: string;
+    arguments: Record<string, any>;
+    timestamp?: number | undefined;
+}>;
+type ToolCall = z.infer<typeof ToolCallSchema>;
+/**
+ * Tool result schema - represents an observation from a tool
+ */
+declare const ToolResultSchema: z.ZodObject<{
+    toolCallId: z.ZodString;
+    result: z.ZodAny;
+    error: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    toolCallId: string;
+    timestamp?: number | undefined;
+    result?: any;
+    error?: string | undefined;
+}, {
+    toolCallId: string;
+    timestamp?: number | undefined;
+    result?: any;
+    error?: string | undefined;
+}>;
+type ToolResult = z.infer<typeof ToolResultSchema>;
+/**
+ * Scratchpad entry schema - intermediate reasoning
+ */
+declare const ScratchpadEntrySchema: z.ZodObject<{
+    step: z.ZodNumber;
+    thought: z.ZodOptional<z.ZodString>;
+    action: z.ZodOptional<z.ZodString>;
+    observation: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    step: number;
+    timestamp?: number | undefined;
+    thought?: string | undefined;
+    action?: string | undefined;
+    observation?: string | undefined;
+}, {
+    step: number;
+    timestamp?: number | undefined;
+    thought?: string | undefined;
+    action?: string | undefined;
+    observation?: string | undefined;
+}>;
+type ScratchpadEntry = z.infer<typeof ScratchpadEntrySchema>;
+
+/**
+ * Create the ReAct state annotation
+ *
+ * This uses LangGraph's Annotation.Root() under the hood, with optional Zod validation.
+ */
+declare const ReActState: _langchain_langgraph.AnnotationRoot<_langchain_langgraph.StateDefinition>;
+/**
+ * TypeScript type for ReAct state
+ */
+type ReActStateType = typeof ReActState.State;
+
+/**
+ * ReAct pattern types and configuration
+ *
+ * @module langgraph/patterns/react/types
+ */
+
+/**
+ * Configuration for creating a ReAct agent
+ */
+interface ReActAgentConfig {
+    /**
+     * Language model to use for reasoning
+     */
+    llm: BaseChatModel;
+    /**
+     * Tools available to the agent
+     * Can be a ToolRegistry or an array of Tools
+     */
+    tools: ToolRegistry | Tool[];
+    /**
+     * System prompt for the agent
+     * @default "You are a helpful assistant that uses tools to solve problems."
+     */
+    systemPrompt?: string;
+    /**
+     * Maximum number of thought-action-observation iterations
+     * @default 10
+     */
+    maxIterations?: number;
+    /**
+     * Whether to return intermediate steps in the response
+     * @default false
+     */
+    returnIntermediateSteps?: boolean;
+    /**
+     * Custom stop condition function
+     * Return true to stop the ReAct loop
+     */
+    stopCondition?: (state: ReActStateType) => boolean;
+}
+/**
+ * Options for the ReAct agent builder
+ */
+interface ReActBuilderOptions {
+    /**
+     * Whether to enable verbose logging
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Custom node names (for debugging/observability)
+     */
+    nodeNames?: {
+        reasoning?: string;
+        action?: string;
+        observation?: string;
+    };
+}
+/**
+ * Type alias for ReAct agent options
+ */
+type ReActAgentOptions = ReActBuilderOptions;
+/**
+ * Stop condition function type
+ */
+type StopConditionFn = (state: ReActStateType) => boolean;
+
+/**
+ * Prompt templates for ReAct pattern
+ *
+ * @module langgraph/patterns/react/prompts
+ */
+/**
+ * Default system prompt for ReAct agents
+ */
+declare const DEFAULT_REACT_SYSTEM_PROMPT = "You are a helpful assistant that uses tools to solve problems.\n\nYou follow the ReAct (Reasoning and Action) pattern:\n1. THINK: Reason about what to do next\n2. ACT: Use a tool or provide a final answer\n3. OBSERVE: Examine the tool's result\n4. REPEAT: Continue until you can answer the user's question\n\nWhen you need to use a tool:\n- Think carefully about which tool to use\n- Provide the correct arguments\n- Wait for the observation before proceeding\n\nWhen you have enough information:\n- Provide a clear, complete answer\n- Cite the tools you used if relevant";
+
+/**
+ * ReAct agent builder
+ *
+ * Creates a ReAct (Reasoning and Action) agent using LangGraph.
+ *
+ * @module langgraph/patterns/react/agent
+ */
+
+/**
+ * Create a ReAct agent
+ *
+ * This function creates a compiled LangGraph StateGraph that implements the
+ * ReAct (Reasoning and Action) pattern.
+ *
+ * @param config - Configuration for the ReAct agent
+ * @param options - Optional builder options
+ * @returns A compiled LangGraph StateGraph
+ *
+ * @example
+ * ```typescript
+ * import { createReActAgent } from '@agentforge/patterns';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const agent = createReActAgent({
+ *   llm: new ChatOpenAI({ model: 'gpt-4' }),
+ *   tools: toolRegistry,
+ *   systemPrompt: 'You are a helpful assistant.',
+ *   maxIterations: 10
+ * });
+ *
+ * const result = await agent.invoke({
+ *   messages: [{ role: 'user', content: 'What is the weather?' }]
+ * });
+ * ```
+ */
+declare function createReActAgent(config: ReActAgentConfig, options?: ReActBuilderOptions): CompiledStateGraph<any, any>;
+
+/**
+ * ReAct Agent Builder
+ *
+ * Fluent API for building ReAct agents with automatic validation.
+ *
+ * @example
+ * ```ts
+ * const agent = new ReActAgentBuilder()
+ *   .withLLM(new ChatOpenAI({ model: 'gpt-4' }))
+ *   .withTools(toolRegistry)
+ *   .withSystemPrompt('You are a helpful assistant.')
+ *   .withMaxIterations(10)
+ *   .withReturnIntermediateSteps(true)
+ *   .build();
+ * ```
+ */
+
+/**
+ * Builder for creating ReAct agents with a fluent API
+ *
+ * This provides a more ergonomic way to create ReAct agents compared to
+ * manually constructing the configuration object.
+ */
+declare class ReActAgentBuilder {
+    private config;
+    private options;
+    /**
+     * Set the language model (required)
+     *
+     * @param llm - LangChain chat model to use for reasoning
+     */
+    withLLM(llm: BaseChatModel): this;
+    /**
+     * Set the tools (required)
+     *
+     * @param tools - Tool registry or array of tools
+     */
+    withTools(tools: ToolRegistry | Tool[]): this;
+    /**
+     * Set the system prompt (optional)
+     *
+     * @param systemPrompt - System prompt for the agent
+     */
+    withSystemPrompt(systemPrompt: string): this;
+    /**
+     * Set the maximum iterations (optional, default: 10)
+     *
+     * @param maxIterations - Maximum number of thought-action loops
+     */
+    withMaxIterations(maxIterations: number): this;
+    /**
+     * Set whether to return intermediate steps (optional, default: false)
+     *
+     * @param returnIntermediateSteps - Whether to include reasoning steps in output
+     */
+    withReturnIntermediateSteps(returnIntermediateSteps: boolean): this;
+    /**
+     * Set a custom stop condition (optional)
+     *
+     * @param stopCondition - Function that determines when to stop the agent
+     */
+    withStopCondition(stopCondition: StopConditionFn): this;
+    /**
+     * Enable verbose logging (optional, default: false)
+     *
+     * @param verbose - Whether to enable verbose logging
+     */
+    withVerbose(verbose: boolean): this;
+    /**
+     * Set custom node names (optional)
+     *
+     * @param nodeNames - Custom names for nodes (for debugging/observability)
+     */
+    withNodeNames(nodeNames: {
+        reasoning?: string;
+        action?: string;
+        observation?: string;
+    }): this;
+    /**
+     * Build the ReAct agent
+     *
+     * @returns A compiled LangGraph StateGraph
+     * @throws Error if required configuration is missing
+     */
+    build(): CompiledStateGraph<any, any>;
+}
+/**
+ * Create a new ReAct agent builder
+ *
+ * @returns A new ReActAgentBuilder instance
+ *
+ * @example
+ * ```typescript
+ * const agent = createReActAgentBuilder()
+ *   .withLLM(llm)
+ *   .withTools(tools)
+ *   .build();
+ * ```
+ */
+declare function createReActAgentBuilder(): ReActAgentBuilder;
+
+/**
+ * Zod Schemas for Plan-and-Execute Pattern
+ *
+ * This module defines the validation schemas for the Plan-and-Execute agent pattern.
+ * The pattern separates planning from execution for better performance on complex tasks.
+ *
+ * @module patterns/plan-execute/schemas
+ */
+
+/**
+ * Schema for a single step in the plan
+ */
+declare const PlanStepSchema: z.ZodObject<{
+    /**
+     * Unique identifier for the step
+     */
+    id: z.ZodString;
+    /**
+     * Description of what this step should accomplish
+     */
+    description: z.ZodString;
+    /**
+     * Optional dependencies on other steps (by ID)
+     */
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Optional tool to use for this step
+     */
+    tool: z.ZodOptional<z.ZodString>;
+    /**
+     * Optional arguments for the tool
+     */
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    tool?: string | undefined;
+    args?: Record<string, any> | undefined;
+    dependencies?: string[] | undefined;
+}, {
+    id: string;
+    description: string;
+    tool?: string | undefined;
+    args?: Record<string, any> | undefined;
+    dependencies?: string[] | undefined;
+}>;
+type PlanStep = z.infer<typeof PlanStepSchema>;
+/**
+ * Schema for a completed step with its result
+ */
+declare const CompletedStepSchema: z.ZodObject<{
+    /**
+     * The step that was executed
+     */
+    step: z.ZodObject<{
+        /**
+         * Unique identifier for the step
+         */
+        id: z.ZodString;
+        /**
+         * Description of what this step should accomplish
+         */
+        description: z.ZodString;
+        /**
+         * Optional dependencies on other steps (by ID)
+         */
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Optional tool to use for this step
+         */
+        tool: z.ZodOptional<z.ZodString>;
+        /**
+         * Optional arguments for the tool
+         */
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    }, {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    }>;
+    /**
+     * The result of executing the step
+     */
+    result: z.ZodAny;
+    /**
+     * Whether the step succeeded
+     */
+    success: z.ZodBoolean;
+    /**
+     * Optional error message if the step failed
+     */
+    error: z.ZodOptional<z.ZodString>;
+    /**
+     * Timestamp when the step was completed
+     */
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    step: {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    };
+    success: boolean;
+    result?: any;
+    error?: string | undefined;
+}, {
+    timestamp: string;
+    step: {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    };
+    success: boolean;
+    result?: any;
+    error?: string | undefined;
+}>;
+type CompletedStep = z.infer<typeof CompletedStepSchema>;
+/**
+ * Schema for the complete plan
+ */
+declare const PlanSchema: z.ZodObject<{
+    /**
+     * List of steps in the plan
+     */
+    steps: z.ZodArray<z.ZodObject<{
+        /**
+         * Unique identifier for the step
+         */
+        id: z.ZodString;
+        /**
+         * Description of what this step should accomplish
+         */
+        description: z.ZodString;
+        /**
+         * Optional dependencies on other steps (by ID)
+         */
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Optional tool to use for this step
+         */
+        tool: z.ZodOptional<z.ZodString>;
+        /**
+         * Optional arguments for the tool
+         */
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    }, {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    }>, "many">;
+    /**
+     * Overall goal of the plan
+     */
+    goal: z.ZodString;
+    /**
+     * Timestamp when the plan was created
+     */
+    createdAt: z.ZodString;
+    /**
+     * Optional confidence score (0-1)
+     */
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    }[];
+    goal: string;
+    createdAt: string;
+    confidence?: number | undefined;
+}, {
+    steps: {
+        id: string;
+        description: string;
+        tool?: string | undefined;
+        args?: Record<string, any> | undefined;
+        dependencies?: string[] | undefined;
+    }[];
+    goal: string;
+    createdAt: string;
+    confidence?: number | undefined;
+}>;
+type Plan = z.infer<typeof PlanSchema>;
+/**
+ * Schema for re-planning decision
+ */
+declare const ReplanDecisionSchema: z.ZodObject<{
+    /**
+     * Whether to replan
+     */
+    shouldReplan: z.ZodBoolean;
+    /**
+     * Reason for the decision
+     */
+    reason: z.ZodString;
+    /**
+     * Optional new goal if replanning
+     */
+    newGoal: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    shouldReplan: boolean;
+    reason: string;
+    newGoal?: string | undefined;
+}, {
+    shouldReplan: boolean;
+    reason: string;
+    newGoal?: string | undefined;
+}>;
+type ReplanDecision = z.infer<typeof ReplanDecisionSchema>;
+/**
+ * Schema for execution status
+ */
+declare const ExecutionStatusSchema: z.ZodEnum<["planning", "executing", "replanning", "completed", "failed"]>;
+type ExecutionStatus = z.infer<typeof ExecutionStatusSchema>;
+
+/**
+ * Plan-and-Execute state configuration
+ *
+ * This configuration is used with createStateAnnotation() to create a
+ * LangGraph Annotation.Root() with optional Zod validation.
+ */
+declare const PlanExecuteStateConfig: {
+    /**
+     * Original user input/query
+     */
+    input: {
+        schema: z.ZodString;
+        default: () => string;
+        description: string;
+    };
+    /**
+     * The current plan
+     */
+    plan: {
+        schema: z.ZodOptional<z.ZodObject<{
+            steps: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                tool: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            }, {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            }>, "many">;
+            goal: z.ZodString;
+            createdAt: z.ZodString;
+            confidence: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            steps: {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            }[];
+            goal: string;
+            createdAt: string;
+            confidence?: number | undefined;
+        }, {
+            steps: {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            }[];
+            goal: string;
+            createdAt: string;
+            confidence?: number | undefined;
+        }>>;
+        description: string;
+    };
+    /**
+     * Completed steps with their results
+     * Accumulates all completed steps
+     */
+    pastSteps: {
+        schema: z.ZodArray<z.ZodObject<{
+            step: z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                tool: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            }, {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            }>;
+            result: z.ZodAny;
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            step: {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            };
+            success: boolean;
+            result?: any;
+            error?: string | undefined;
+        }, {
+            timestamp: string;
+            step: {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            };
+            success: boolean;
+            result?: any;
+            error?: string | undefined;
+        }>, "many">;
+        reducer: (left: CompletedStep[], right: CompletedStep[]) => {
+            timestamp: string;
+            step: {
+                id: string;
+                description: string;
+                tool?: string | undefined;
+                args?: Record<string, any> | undefined;
+                dependencies?: string[] | undefined;
+            };
+            success: boolean;
+            result?: any;
+            error?: string | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Index of the current step being executed
+     */
+    currentStepIndex: {
+        schema: z.ZodOptional<z.ZodNumber>;
+        description: string;
+    };
+    /**
+     * Current execution status
+     */
+    status: {
+        schema: z.ZodEnum<["planning", "executing", "replanning", "completed", "failed"]>;
+        default: () => ExecutionStatus;
+        description: string;
+    };
+    /**
+     * Final response
+     */
+    response: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+    /**
+     * Error message if execution failed
+     */
+    error: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+    /**
+     * Iteration counter for replanning
+     */
+    iteration: {
+        schema: z.ZodNumber;
+        reducer: (left: number, right: number) => number;
+        default: () => number;
+        description: string;
+    };
+    /**
+     * Maximum iterations allowed
+     */
+    maxIterations: {
+        schema: z.ZodNumber;
+        default: () => number;
+        description: string;
+    };
+};
+/**
+ * Create the Plan-Execute state annotation
+ *
+ * This uses LangGraph's Annotation.Root() under the hood, with optional Zod validation.
+ */
+declare const PlanExecuteState: _langchain_langgraph.AnnotationRoot<_langchain_langgraph.StateDefinition>;
+/**
+ * TypeScript type for Plan-Execute state
+ *
+ * Manually defined to work around TypeScript's inability to infer the .State property
+ */
+type PlanExecuteStateType = {
+    input: string;
+    plan?: Plan;
+    pastSteps: CompletedStep[];
+    currentStepIndex?: number;
+    status: ExecutionStatus;
+    response?: string;
+    error?: string;
+    iteration: number;
+    maxIterations: number;
+};
+
+/**
+ * TypeScript Types for Plan-and-Execute Pattern
+ *
+ * This module defines the TypeScript types for the Plan-and-Execute agent pattern.
+ *
+ * @module patterns/plan-execute/types
+ */
+
+/**
+ * Configuration for the planner node
+ */
+interface PlannerConfig {
+    /**
+     * LLM to use for planning
+     */
+    llm: BaseChatModel;
+    /**
+     * System prompt for the planner
+     */
+    systemPrompt?: string;
+    /**
+     * Maximum number of steps in a plan
+     */
+    maxSteps?: number;
+    /**
+     * Whether to include tool descriptions in planning
+     */
+    includeToolDescriptions?: boolean;
+}
+/**
+ * Configuration for the executor node
+ */
+interface ExecutorConfig {
+    /**
+     * Available tools for execution
+     */
+    tools: Tool[];
+    /**
+     * Optional LLM for sub-tasks
+     */
+    llm?: BaseChatModel;
+    /**
+     * Enable parallel execution of independent steps
+     */
+    parallel?: boolean;
+    /**
+     * Timeout for each step execution (ms)
+     */
+    stepTimeout?: number;
+}
+/**
+ * Configuration for the replanner node
+ */
+interface ReplannerConfig {
+    /**
+     * LLM to use for replanning decisions
+     */
+    llm: BaseChatModel;
+    /**
+     * Confidence threshold for replanning (0-1)
+     * If confidence is below this, trigger replanning
+     */
+    replanThreshold?: number;
+    /**
+     * System prompt for replanning
+     */
+    systemPrompt?: string;
+}
+/**
+ * Configuration for creating a Plan-Execute agent
+ */
+interface PlanExecuteAgentConfig {
+    /**
+     * Planner configuration
+     */
+    planner: PlannerConfig;
+    /**
+     * Executor configuration
+     */
+    executor: ExecutorConfig;
+    /**
+     * Optional replanner configuration
+     * If not provided, no replanning will occur
+     */
+    replanner?: ReplannerConfig;
+    /**
+     * Maximum number of planning iterations
+     */
+    maxIterations?: number;
+    /**
+     * Whether to return intermediate steps
+     */
+    returnIntermediateSteps?: boolean;
+    /**
+     * Verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Node function type for Plan-Execute pattern
+ */
+type PlanExecuteNode = (state: PlanExecuteStateType) => Partial<PlanExecuteStateType> | Promise<Partial<PlanExecuteStateType>>;
+/**
+ * Routing decision for conditional edges
+ */
+type PlanExecuteRoute = 'execute' | 'replan' | 'finish' | 'error';
+/**
+ * Router function type
+ */
+type PlanExecuteRouter = (state: PlanExecuteStateType) => PlanExecuteRoute;
+
+/**
+ * Plan-and-Execute Agent Factory
+ *
+ * This module provides the main factory function for creating Plan-and-Execute agents.
+ *
+ * @module patterns/plan-execute/agent
+ */
+
+/**
+ * Create a Plan-and-Execute agent
+ *
+ * This agent separates planning from execution for better performance on complex tasks.
+ * It creates a plan, executes steps, and optionally replans based on results.
+ *
+ * @param config - Configuration for the agent
+ * @returns A compiled LangGraph StateGraph
+ *
+ * @example
+ * ```typescript
+ * import { createPlanExecuteAgent } from '@agentforge/patterns';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const agent = createPlanExecuteAgent({
+ *   planner: {
+ *     llm: new ChatOpenAI({ model: 'gpt-4' }),
+ *     maxSteps: 5
+ *   },
+ *   executor: {
+ *     tools: [searchTool, calculatorTool],
+ *     parallel: false
+ *   },
+ *   replanner: {
+ *     llm: new ChatOpenAI({ model: 'gpt-4' }),
+ *     replanThreshold: 0.7
+ *   }
+ * });
+ *
+ * const result = await agent.invoke({
+ *   input: 'Research the latest AI developments and summarize them'
+ * });
+ * ```
+ */
+declare function createPlanExecuteAgent(config: PlanExecuteAgentConfig): any;
+
+/**
+ * Node Implementations for Plan-and-Execute Pattern
+ *
+ * This module implements the core nodes for the Plan-and-Execute agent pattern.
+ *
+ * @module patterns/plan-execute/nodes
+ */
+
+/**
+ * Create a planner node that generates a multi-step plan
+ */
+declare function createPlannerNode(config: PlannerConfig): (state: PlanExecuteStateType) => Promise<Partial<PlanExecuteStateType>>;
+/**
+ * Create an executor node that executes plan steps
+ */
+declare function createExecutorNode(config: ExecutorConfig): (state: PlanExecuteStateType) => Promise<Partial<PlanExecuteStateType>>;
+/**
+ * Create a replanner node that decides whether to replan
+ */
+declare function createReplannerNode(config: ReplannerConfig): (state: PlanExecuteStateType) => Promise<Partial<PlanExecuteStateType>>;
+/**
+ * Create a finisher node that sets the final status and response
+ */
+declare function createFinisherNode$1(): (state: PlanExecuteStateType) => Promise<Partial<PlanExecuteStateType>>;
+
+/**
+ * Prompt Templates for Plan-and-Execute Pattern
+ *
+ * This module contains the prompt templates used by the Plan-and-Execute agent pattern.
+ *
+ * @module patterns/plan-execute/prompts
+ */
+/**
+ * Default system prompt for the planner
+ */
+declare const 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.\n\nGuidelines for creating plans:\n1. Break down complex tasks into clear, actionable steps\n2. Each step should have a specific, measurable outcome\n3. Identify dependencies between steps\n4. Consider which tools are needed for each step\n5. Keep the plan focused and efficient\n6. Aim for 3-7 steps for most tasks\n\nOutput your plan as a JSON object with the following structure:\n{\n  \"goal\": \"The overall goal\",\n  \"steps\": [\n    {\n      \"id\": \"step-1\",\n      \"description\": \"What this step accomplishes\",\n      \"tool\": \"tool_name (optional)\",\n      \"args\": {\"key\": \"value (optional)\"},\n      \"dependencies\": [\"step-id (optional)\"]\n    }\n  ],\n  \"confidence\": 0.9\n}";
+/**
+ * Default system prompt for the replanner
+ */
+declare const 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.\n\nConsider:\n1. Have the completed steps achieved their intended outcomes?\n2. Are there any unexpected results that require plan changes?\n3. Is the original goal still achievable with the current plan?\n4. Would a different approach be more effective?\n\nOutput your decision as a JSON object:\n{\n  \"shouldReplan\": true/false,\n  \"reason\": \"Explanation for the decision\",\n  \"newGoal\": \"Updated goal if replanning (optional)\"\n}";
+/**
+ * Template for formatting the planning prompt with context
+ */
+declare const PLANNING_PROMPT_TEMPLATE = "User Goal: {input}\n\n{toolDescriptions}\n\nCreate a step-by-step plan to accomplish this goal.";
+/**
+ * Template for formatting the replanning prompt with context
+ */
+declare const REPLANNING_PROMPT_TEMPLATE = "Original Goal: {goal}\n\nCompleted Steps:\n{completedSteps}\n\nCurrent Plan:\n{remainingSteps}\n\nBased on the results so far, should we continue with the current plan or replan?";
+
+/**
+ * Zod Schemas for Reflection Pattern
+ *
+ * This module defines the data structures used in the Reflection pattern.
+ * The pattern iteratively improves outputs through generation, reflection, and revision.
+ *
+ * @module patterns/reflection/schemas
+ */
+
+/**
+ * Schema for a reflection/critique
+ */
+declare const ReflectionSchema: z.ZodObject<{
+    /**
+     * The critique or feedback on the current response
+     */
+    critique: z.ZodString;
+    /**
+     * Specific issues identified
+     */
+    issues: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Suggestions for improvement
+     */
+    suggestions: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Quality score (0-10)
+     */
+    score: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Whether the response meets quality standards
+     */
+    meetsStandards: z.ZodBoolean;
+    /**
+     * Timestamp of the reflection
+     */
+    timestamp: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    issues: string[];
+    critique: string;
+    suggestions: string[];
+    meetsStandards: boolean;
+    timestamp?: Date | undefined;
+    score?: number | undefined;
+}, {
+    issues: string[];
+    critique: string;
+    suggestions: string[];
+    meetsStandards: boolean;
+    timestamp?: Date | undefined;
+    score?: number | undefined;
+}>;
+type Reflection = z.infer<typeof ReflectionSchema>;
+/**
+ * Schema for a revision entry
+ */
+declare const RevisionSchema: z.ZodObject<{
+    /**
+     * The revised content
+     */
+    content: z.ZodString;
+    /**
+     * Which iteration this revision is from
+     */
+    iteration: z.ZodNumber;
+    /**
+     * The reflection that prompted this revision
+     */
+    basedOn: z.ZodOptional<z.ZodObject<{
+        /**
+         * The critique or feedback on the current response
+         */
+        critique: z.ZodString;
+        /**
+         * Specific issues identified
+         */
+        issues: z.ZodArray<z.ZodString, "many">;
+        /**
+         * Suggestions for improvement
+         */
+        suggestions: z.ZodArray<z.ZodString, "many">;
+        /**
+         * Quality score (0-10)
+         */
+        score: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Whether the response meets quality standards
+         */
+        meetsStandards: z.ZodBoolean;
+        /**
+         * Timestamp of the reflection
+         */
+        timestamp: z.ZodOptional<z.ZodDate>;
+    }, "strip", z.ZodTypeAny, {
+        issues: string[];
+        critique: string;
+        suggestions: string[];
+        meetsStandards: boolean;
+        timestamp?: Date | undefined;
+        score?: number | undefined;
+    }, {
+        issues: string[];
+        critique: string;
+        suggestions: string[];
+        meetsStandards: boolean;
+        timestamp?: Date | undefined;
+        score?: number | undefined;
+    }>>;
+    /**
+     * Timestamp of the revision
+     */
+    timestamp: z.ZodOptional<z.ZodDate>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    iteration: number;
+    timestamp?: Date | undefined;
+    basedOn?: {
+        issues: string[];
+        critique: string;
+        suggestions: string[];
+        meetsStandards: boolean;
+        timestamp?: Date | undefined;
+        score?: number | undefined;
+    } | undefined;
+}, {
+    content: string;
+    iteration: number;
+    timestamp?: Date | undefined;
+    basedOn?: {
+        issues: string[];
+        critique: string;
+        suggestions: string[];
+        meetsStandards: boolean;
+        timestamp?: Date | undefined;
+        score?: number | undefined;
+    } | undefined;
+}>;
+type Revision = z.infer<typeof RevisionSchema>;
+/**
+ * Schema for reflection status
+ */
+declare const ReflectionStatusSchema: z.ZodEnum<["generating", "reflecting", "revising", "completed", "failed"]>;
+type ReflectionStatus = z.infer<typeof ReflectionStatusSchema>;
+/**
+ * Schema for quality criteria
+ */
+declare const QualityCriteriaSchema: z.ZodObject<{
+    /**
+     * Minimum quality score required (0-10)
+     */
+    minScore: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Specific criteria to evaluate
+     */
+    criteria: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Whether all criteria must be met
+     */
+    requireAll: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    minScore: number;
+    requireAll: boolean;
+    criteria?: string[] | undefined;
+}, {
+    minScore?: number | undefined;
+    criteria?: string[] | undefined;
+    requireAll?: boolean | undefined;
+}>;
+type QualityCriteria = z.infer<typeof QualityCriteriaSchema>;
+/**
+ * Schema for reflection configuration
+ */
+declare const ReflectionConfigSchema: z.ZodObject<{
+    /**
+     * Maximum number of reflection iterations
+     */
+    maxIterations: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Quality criteria for completion
+     */
+    qualityCriteria: z.ZodOptional<z.ZodObject<{
+        /**
+         * Minimum quality score required (0-10)
+         */
+        minScore: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Specific criteria to evaluate
+         */
+        criteria: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /**
+         * Whether all criteria must be met
+         */
+        requireAll: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        minScore: number;
+        requireAll: boolean;
+        criteria?: string[] | undefined;
+    }, {
+        minScore?: number | undefined;
+        criteria?: string[] | undefined;
+        requireAll?: boolean | undefined;
+    }>>;
+    /**
+     * Whether to include previous reflections in context
+     */
+    includeHistory: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    maxIterations: number;
+    includeHistory: boolean;
+    qualityCriteria?: {
+        minScore: number;
+        requireAll: boolean;
+        criteria?: string[] | undefined;
+    } | undefined;
+}, {
+    maxIterations?: number | undefined;
+    qualityCriteria?: {
+        minScore?: number | undefined;
+        criteria?: string[] | undefined;
+        requireAll?: boolean | undefined;
+    } | undefined;
+    includeHistory?: boolean | undefined;
+}>;
+type ReflectionConfig = z.infer<typeof ReflectionConfigSchema>;
+
+/**
+ * Reflection state configuration
+ *
+ * This configuration is used with createStateAnnotation() to create a
+ * LangGraph Annotation.Root() with optional Zod validation.
+ */
+declare const ReflectionStateConfig: {
+    /**
+     * Original user input/task
+     */
+    input: {
+        schema: z.ZodString;
+        default: () => string;
+        description: string;
+    };
+    /**
+     * Current response/output
+     */
+    currentResponse: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+    /**
+     * History of all reflections/critiques
+     * Accumulates all reflections
+     */
+    reflections: {
+        schema: z.ZodArray<z.ZodObject<{
+            critique: z.ZodString;
+            issues: z.ZodArray<z.ZodString, "many">;
+            suggestions: z.ZodArray<z.ZodString, "many">;
+            score: z.ZodOptional<z.ZodNumber>;
+            meetsStandards: z.ZodBoolean;
+            timestamp: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            issues: string[];
+            critique: string;
+            suggestions: string[];
+            meetsStandards: boolean;
+            timestamp?: Date | undefined;
+            score?: number | undefined;
+        }, {
+            issues: string[];
+            critique: string;
+            suggestions: string[];
+            meetsStandards: boolean;
+            timestamp?: Date | undefined;
+            score?: number | undefined;
+        }>, "many">;
+        reducer: (left: Reflection[], right: Reflection[]) => {
+            issues: string[];
+            critique: string;
+            suggestions: string[];
+            meetsStandards: boolean;
+            timestamp?: Date | undefined;
+            score?: number | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * History of all revisions
+     * Accumulates all revisions
+     */
+    revisions: {
+        schema: z.ZodArray<z.ZodObject<{
+            content: z.ZodString;
+            iteration: z.ZodNumber;
+            basedOn: z.ZodOptional<z.ZodObject<{
+                critique: z.ZodString;
+                issues: z.ZodArray<z.ZodString, "many">;
+                suggestions: z.ZodArray<z.ZodString, "many">;
+                score: z.ZodOptional<z.ZodNumber>;
+                meetsStandards: z.ZodBoolean;
+                timestamp: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                issues: string[];
+                critique: string;
+                suggestions: string[];
+                meetsStandards: boolean;
+                timestamp?: Date | undefined;
+                score?: number | undefined;
+            }, {
+                issues: string[];
+                critique: string;
+                suggestions: string[];
+                meetsStandards: boolean;
+                timestamp?: Date | undefined;
+                score?: number | undefined;
+            }>>;
+            timestamp: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            iteration: number;
+            timestamp?: Date | undefined;
+            basedOn?: {
+                issues: string[];
+                critique: string;
+                suggestions: string[];
+                meetsStandards: boolean;
+                timestamp?: Date | undefined;
+                score?: number | undefined;
+            } | undefined;
+        }, {
+            content: string;
+            iteration: number;
+            timestamp?: Date | undefined;
+            basedOn?: {
+                issues: string[];
+                critique: string;
+                suggestions: string[];
+                meetsStandards: boolean;
+                timestamp?: Date | undefined;
+                score?: number | undefined;
+            } | undefined;
+        }>, "many">;
+        reducer: (left: Revision[], right: Revision[]) => {
+            content: string;
+            iteration: number;
+            timestamp?: Date | undefined;
+            basedOn?: {
+                issues: string[];
+                critique: string;
+                suggestions: string[];
+                meetsStandards: boolean;
+                timestamp?: Date | undefined;
+                score?: number | undefined;
+            } | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Current iteration number
+     */
+    iteration: {
+        schema: z.ZodNumber;
+        reducer: (left: number, right: number) => number;
+        default: () => number;
+        description: string;
+    };
+    /**
+     * Current status
+     */
+    status: {
+        schema: z.ZodEnum<["generating", "reflecting", "revising", "completed", "failed"]>;
+        default: () => ReflectionStatus;
+        description: string;
+    };
+    /**
+     * Quality criteria for completion
+     */
+    qualityCriteria: {
+        schema: z.ZodOptional<z.ZodObject<{
+            minScore: z.ZodDefault<z.ZodNumber>;
+            criteria: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            requireAll: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            minScore: number;
+            requireAll: boolean;
+            criteria?: string[] | undefined;
+        }, {
+            minScore?: number | undefined;
+            criteria?: string[] | undefined;
+            requireAll?: boolean | undefined;
+        }>>;
+        description: string;
+    };
+    /**
+     * Maximum iterations allowed
+     */
+    maxIterations: {
+        schema: z.ZodNumber;
+        default: () => number;
+        description: string;
+    };
+    /**
+     * Final response (when completed)
+     */
+    response: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+    /**
+     * Error message if failed
+     */
+    error: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+};
+/**
+ * Create the Reflection state annotation
+ *
+ * This uses LangGraph's Annotation.Root() under the hood, with optional Zod validation.
+ */
+declare const ReflectionState: _langchain_langgraph.AnnotationRoot<_langchain_langgraph.StateDefinition>;
+/**
+ * TypeScript type for Reflection state
+ *
+ * Manually defined to work around TypeScript's inability to infer the .State property
+ */
+type ReflectionStateType = {
+    input: string;
+    currentResponse?: string;
+    reflections: Reflection[];
+    revisions: Revision[];
+    iteration: number;
+    status: ReflectionStatus;
+    qualityCriteria?: QualityCriteria;
+    maxIterations: number;
+    response?: string;
+    error?: string;
+};
+
+/**
+ * Type Definitions for Reflection Pattern
+ *
+ * This module defines TypeScript types for the Reflection pattern.
+ *
+ * @module patterns/reflection/types
+ */
+
+/**
+ * Configuration for the generator node
+ */
+interface GeneratorConfig {
+    /**
+     * Language model for generation
+     */
+    llm: BaseChatModel;
+    /**
+     * System prompt for the generator
+     */
+    systemPrompt?: string;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Configuration for the reflector node
+ */
+interface ReflectorConfig {
+    /**
+     * Language model for reflection
+     */
+    llm: BaseChatModel;
+    /**
+     * System prompt for the reflector
+     */
+    systemPrompt?: string;
+    /**
+     * Quality criteria to evaluate against
+     */
+    qualityCriteria?: QualityCriteria;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Configuration for the reviser node
+ */
+interface ReviserConfig {
+    /**
+     * Language model for revision
+     */
+    llm: BaseChatModel;
+    /**
+     * System prompt for the reviser
+     */
+    systemPrompt?: string;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Configuration for the reflection agent
+ */
+interface ReflectionAgentConfig {
+    /**
+     * Generator configuration
+     */
+    generator: GeneratorConfig;
+    /**
+     * Reflector configuration
+     */
+    reflector: ReflectorConfig;
+    /**
+     * Reviser configuration
+     */
+    reviser: ReviserConfig;
+    /**
+     * Maximum number of reflection iterations
+     */
+    maxIterations?: number;
+    /**
+     * Quality criteria for completion
+     */
+    qualityCriteria?: QualityCriteria;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Node function type for reflection pattern
+ */
+type ReflectionNode = (state: ReflectionStateType) => Promise<Partial<ReflectionStateType>>;
+/**
+ * Routing decision for reflection pattern
+ */
+type ReflectionRoute = 'generate' | 'reflect' | 'revise' | 'finish' | 'error';
+/**
+ * Router function type for reflection pattern
+ */
+type ReflectionRouter = (state: ReflectionStateType) => ReflectionRoute;
+
+/**
+ * Prompts for Reflection Pattern
+ *
+ * This module contains prompt templates for the Reflection pattern.
+ *
+ * @module patterns/reflection/prompts
+ */
+/**
+ * Default system prompt for the generator
+ */
+declare const DEFAULT_GENERATOR_SYSTEM_PROMPT = "You are an expert content generator. Your task is to create high-quality responses to user requests.\n\nFocus on:\n- Clarity and coherence\n- Accuracy and correctness\n- Completeness and thoroughness\n- Appropriate tone and style\n\nGenerate the best possible response to the user's request.";
+/**
+ * Default system prompt for the reflector
+ */
+declare const DEFAULT_REFLECTOR_SYSTEM_PROMPT = "You are an expert critic and reviewer. Your task is to provide constructive feedback on responses.\n\nEvaluate the response based on:\n- Clarity: Is it easy to understand?\n- Accuracy: Is the information correct?\n- Completeness: Does it fully address the request?\n- Quality: Is it well-written and professional?\n\nProvide specific, actionable feedback for improvement.";
+/**
+ * Default system prompt for the reviser
+ */
+declare const DEFAULT_REVISER_SYSTEM_PROMPT = "You are an expert editor and reviser. Your task is to improve responses based on feedback.\n\nFocus on:\n- Addressing all identified issues\n- Implementing suggested improvements\n- Maintaining the core message\n- Enhancing overall quality\n\nCreate an improved version that addresses the critique.";
+/**
+ * Template for generation prompt
+ */
+declare const GENERATION_PROMPT_TEMPLATE = "Please generate a response to the following request:\n\n{input}\n\n{context}\n\nProvide a high-quality, complete response.";
+/**
+ * Template for reflection prompt
+ */
+declare const REFLECTION_PROMPT_TEMPLATE = "Please review and critique the following response:\n\nOriginal Request:\n{input}\n\nCurrent Response:\n{currentResponse}\n\n{criteria}\n\n{history}\n\nProvide a detailed critique including:\n1. What works well\n2. Specific issues or problems\n3. Suggestions for improvement\n4. A quality score (0-10)\n5. Whether it meets quality standards\n\nFormat your response as JSON with the following structure:\n{\n  \"critique\": \"overall assessment\",\n  \"issues\": [\"issue 1\", \"issue 2\"],\n  \"suggestions\": [\"suggestion 1\", \"suggestion 2\"],\n  \"score\": 8,\n  \"meetsStandards\": true\n}";
+/**
+ * Template for revision prompt
+ */
+declare const REVISION_PROMPT_TEMPLATE = "Please revise the following response based on the critique:\n\nOriginal Request:\n{input}\n\nCurrent Response:\n{currentResponse}\n\nCritique:\n{critique}\n\nIssues to Address:\n{issues}\n\nSuggestions:\n{suggestions}\n\n{history}\n\nCreate an improved version that addresses all the feedback while maintaining the core message.";
+/**
+ * Template for quality criteria
+ */
+declare const QUALITY_CRITERIA_TEMPLATE = "Evaluate against these specific criteria:\n{criteria}\n\nMinimum required score: {minScore}/10\n{requireAll}";
+/**
+ * Template for reflection history
+ */
+declare const REFLECTION_HISTORY_TEMPLATE = "Previous Reflections:\n{reflections}\n\nPrevious Revisions:\n{revisions}";
+/**
+ * Template for formatting a single reflection
+ */
+declare const REFLECTION_ENTRY_TEMPLATE = "Iteration {iteration}:\nCritique: {critique}\nScore: {score}/10\nIssues: {issues}\nSuggestions: {suggestions}";
+/**
+ * Template for formatting a single revision
+ */
+declare const REVISION_ENTRY_TEMPLATE = "Iteration {iteration}:\n{content}";
+
+/**
+ * Node Implementations for Reflection Pattern
+ *
+ * This module implements the core nodes for the Reflection agent pattern.
+ *
+ * @module patterns/reflection/nodes
+ */
+
+/**
+ * Create a generator node that creates initial responses
+ */
+declare function createGeneratorNode(config: GeneratorConfig): (state: ReflectionStateType) => Promise<Partial<ReflectionStateType>>;
+/**
+ * Create a reflector node that critiques responses
+ */
+declare function createReflectorNode(config: ReflectorConfig): (state: ReflectionStateType) => Promise<Partial<ReflectionStateType>>;
+/**
+ * Create a reviser node that improves responses based on critiques
+ */
+declare function createReviserNode(config: ReviserConfig): (state: ReflectionStateType) => Promise<Partial<ReflectionStateType>>;
+/**
+ * Create a finisher node that marks the reflection as complete
+ */
+declare function createFinisherNode(): (state: ReflectionStateType) => Promise<Partial<ReflectionStateType>>;
+
+/**
+ * Reflection Agent Factory
+ *
+ * Creates a Reflection agent using LangGraph.
+ *
+ * @module patterns/reflection/agent
+ */
+
+/**
+ * Create a Reflection agent
+ *
+ * This function creates a compiled LangGraph StateGraph that implements the
+ * Reflection pattern for iterative improvement through generation, reflection, and revision.
+ *
+ * @param config - Configuration for the Reflection agent
+ * @returns A compiled LangGraph StateGraph
+ *
+ * @example
+ * ```typescript
+ * import { createReflectionAgent } from '@agentforge/patterns';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const llm = new ChatOpenAI({ model: 'gpt-4' });
+ *
+ * const agent = createReflectionAgent({
+ *   generator: { llm },
+ *   reflector: { llm },
+ *   reviser: { llm },
+ *   maxIterations: 3,
+ *   qualityCriteria: {
+ *     minScore: 8,
+ *     criteria: ['clarity', 'accuracy', 'completeness']
+ *   }
+ * });
+ *
+ * const result = await agent.invoke({
+ *   input: 'Write an essay about AI safety'
+ * });
+ * ```
+ */
+declare function createReflectionAgent(config: ReflectionAgentConfig): any;
+
+/**
+ * Zod Schemas for Multi-Agent Coordination Pattern
+ *
+ * This module defines the validation schemas for the Multi-Agent pattern.
+ * The pattern enables multiple specialized agents to collaborate on complex tasks
+ * through a supervisor that routes work and coordinates execution.
+ *
+ * @module patterns/multi-agent/schemas
+ */
+
+/**
+ * Schema for agent roles in the system
+ */
+declare const AgentRoleSchema: z.ZodEnum<["supervisor", "worker"]>;
+type AgentRole = z.infer<typeof AgentRoleSchema>;
+/**
+ * Schema for message types in multi-agent communication
+ */
+declare const MessageTypeSchema: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
+type MessageType = z.infer<typeof MessageTypeSchema>;
+/**
+ * Schema for a message in the multi-agent system
+ */
+declare const AgentMessageSchema: z.ZodObject<{
+    /**
+     * Unique identifier for the message
+     */
+    id: z.ZodString;
+    /**
+     * Type of message
+     */
+    type: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
+    /**
+     * Agent that sent the message
+     */
+    from: z.ZodString;
+    /**
+     * Agent(s) that should receive the message
+     */
+    to: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    /**
+     * Message content
+     */
+    content: z.ZodString;
+    /**
+     * Optional metadata
+     */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * Timestamp when message was created
+     */
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
+    timestamp: number;
+    id: string;
+    from: string;
+    to: string | string[];
+    metadata?: Record<string, any> | undefined;
+}, {
+    content: string;
+    type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
+    timestamp: number;
+    id: string;
+    from: string;
+    to: string | string[];
+    metadata?: Record<string, any> | undefined;
+}>;
+type AgentMessage = z.infer<typeof AgentMessageSchema>;
+/**
+ * Schema for routing strategies
+ */
+declare const RoutingStrategySchema: z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>;
+type RoutingStrategy = z.infer<typeof RoutingStrategySchema>;
+/**
+ * Schema for routing decision
+ */
+declare const RoutingDecisionSchema: z.ZodObject<{
+    /**
+     * Target agent to route to
+     */
+    targetAgent: z.ZodString;
+    /**
+     * Reasoning for the routing decision
+     */
+    reasoning: z.ZodOptional<z.ZodString>;
+    /**
+     * Confidence in the routing decision (0-1)
+     */
+    confidence: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Strategy used for routing
+     */
+    strategy: z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>;
+    /**
+     * Timestamp of the routing decision
+     */
+    timestamp: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    targetAgent: string;
+    strategy: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced";
+    timestamp?: number | undefined;
+    reasoning?: string | undefined;
+    confidence?: number | undefined;
+}, {
+    targetAgent: string;
+    strategy: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced";
+    timestamp?: number | undefined;
+    reasoning?: string | undefined;
+    confidence?: number | undefined;
+}>;
+type RoutingDecision = z.infer<typeof RoutingDecisionSchema>;
+/**
+ * Schema for worker agent capabilities
+ */
+declare const WorkerCapabilitiesSchema: z.ZodObject<{
+    /**
+     * Skills/capabilities the agent has
+     */
+    skills: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Tools available to the agent
+     */
+    tools: z.ZodArray<z.ZodString, "many">;
+    /**
+     * Whether the agent is currently available
+     */
+    available: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Current workload (number of active tasks)
+     */
+    currentWorkload: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    tools: string[];
+    skills: string[];
+    available: boolean;
+    currentWorkload: number;
+}, {
+    tools: string[];
+    skills: string[];
+    available?: boolean | undefined;
+    currentWorkload?: number | undefined;
+}>;
+type WorkerCapabilities = z.infer<typeof WorkerCapabilitiesSchema>;
+/**
+ * Schema for task assignment
+ */
+declare const TaskAssignmentSchema: z.ZodObject<{
+    /**
+     * Unique assignment identifier
+     */
+    id: z.ZodString;
+    /**
+     * Worker ID assigned to the task
+     */
+    workerId: z.ZodString;
+    /**
+     * Task description
+     */
+    task: z.ZodString;
+    /**
+     * Task priority (1-10, higher is more urgent)
+     */
+    priority: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Timestamp when task was assigned
+     */
+    assignedAt: z.ZodNumber;
+    /**
+     * Optional deadline for task completion
+     */
+    deadline: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    workerId: string;
+    task: string;
+    priority: number;
+    assignedAt: number;
+    deadline?: number | undefined;
+}, {
+    id: string;
+    workerId: string;
+    task: string;
+    assignedAt: number;
+    priority?: number | undefined;
+    deadline?: number | undefined;
+}>;
+type TaskAssignment = z.infer<typeof TaskAssignmentSchema>;
+/**
+ * Schema for task result
+ */
+declare const TaskResultSchema: z.ZodObject<{
+    /**
+     * Assignment identifier
+     */
+    assignmentId: z.ZodString;
+    /**
+     * Worker that completed the task
+     */
+    workerId: z.ZodString;
+    /**
+     * Whether the task succeeded
+     */
+    success: z.ZodBoolean;
+    /**
+     * Task result/output
+     */
+    result: z.ZodString;
+    /**
+     * Optional error message if task failed
+     */
+    error: z.ZodOptional<z.ZodString>;
+    /**
+     * Timestamp when task was completed
+     */
+    completedAt: z.ZodNumber;
+    /**
+     * Optional metadata about execution
+     */
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    result: string;
+    success: boolean;
+    workerId: string;
+    assignmentId: string;
+    completedAt: number;
+    metadata?: Record<string, any> | undefined;
+    error?: string | undefined;
+}, {
+    result: string;
+    success: boolean;
+    workerId: string;
+    assignmentId: string;
+    completedAt: number;
+    metadata?: Record<string, any> | undefined;
+    error?: string | undefined;
+}>;
+type TaskResult = z.infer<typeof TaskResultSchema>;
+/**
+ * Schema for multi-agent execution status
+ */
+declare const MultiAgentStatusSchema: z.ZodEnum<["initializing", "routing", "executing", "coordinating", "aggregating", "completed", "failed"]>;
+type MultiAgentStatus = z.infer<typeof MultiAgentStatusSchema>;
+/**
+ * Schema for handoff request
+ */
+declare const HandoffRequestSchema: z.ZodObject<{
+    /**
+     * Agent requesting the handoff
+     */
+    from: z.ZodString;
+    /**
+     * Target agent for handoff
+     */
+    to: z.ZodString;
+    /**
+     * Reason for handoff
+     */
+    reason: z.ZodString;
+    /**
+     * Context to pass to next agent
+     */
+    context: z.ZodAny;
+    /**
+     * Timestamp of handoff request
+     */
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    reason: string;
+    from: string;
+    to: string;
+    context?: any;
+}, {
+    timestamp: string;
+    reason: string;
+    from: string;
+    to: string;
+    context?: any;
+}>;
+type HandoffRequest = z.infer<typeof HandoffRequestSchema>;
+
+/**
+ * Multi-Agent state configuration
+ *
+ * This configuration is used with createStateAnnotation() to create a
+ * LangGraph Annotation.Root() with optional Zod validation.
+ */
+declare const MultiAgentStateConfig: {
+    /**
+     * Original user input/query
+     */
+    input: {
+        schema: z.ZodString;
+        default: () => string;
+        description: string;
+    };
+    /**
+     * All messages in the multi-agent conversation
+     * Accumulates all messages between agents
+     */
+    messages: {
+        schema: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<["user_input", "task_assignment", "task_result", "handoff", "error", "completion"]>;
+            from: z.ZodString;
+            to: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+            content: z.ZodString;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            timestamp: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
+            timestamp: number;
+            id: string;
+            from: string;
+            to: string | string[];
+            metadata?: Record<string, any> | undefined;
+        }, {
+            content: string;
+            type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
+            timestamp: number;
+            id: string;
+            from: string;
+            to: string | string[];
+            metadata?: Record<string, any> | undefined;
+        }>, "many">;
+        reducer: (left: AgentMessage[], right: AgentMessage[]) => {
+            content: string;
+            type: "error" | "user_input" | "task_assignment" | "task_result" | "handoff" | "completion";
+            timestamp: number;
+            id: string;
+            from: string;
+            to: string | string[];
+            metadata?: Record<string, any> | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Available worker agents and their capabilities
+     */
+    workers: {
+        schema: z.ZodRecord<z.ZodString, z.ZodObject<{
+            skills: z.ZodArray<z.ZodString, "many">;
+            tools: z.ZodArray<z.ZodString, "many">;
+            available: z.ZodDefault<z.ZodBoolean>;
+            currentWorkload: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            tools: string[];
+            skills: string[];
+            available: boolean;
+            currentWorkload: number;
+        }, {
+            tools: string[];
+            skills: string[];
+            available?: boolean | undefined;
+            currentWorkload?: number | undefined;
+        }>>;
+        reducer: (left: Record<string, WorkerCapabilities>, right: Record<string, WorkerCapabilities>) => {
+            [x: string]: {
+                tools: string[];
+                skills: string[];
+                available: boolean;
+                currentWorkload: number;
+            };
+        };
+        default: () => {};
+        description: string;
+    };
+    /**
+     * Current active agent
+     */
+    currentAgent: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+    /**
+     * Routing decisions made by the supervisor
+     * Accumulates all routing decisions
+     */
+    routingHistory: {
+        schema: z.ZodArray<z.ZodObject<{
+            targetAgent: z.ZodString;
+            reasoning: z.ZodOptional<z.ZodString>;
+            confidence: z.ZodOptional<z.ZodNumber>;
+            strategy: z.ZodEnum<["llm-based", "rule-based", "round-robin", "skill-based", "load-balanced"]>;
+            timestamp: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            targetAgent: string;
+            strategy: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced";
+            timestamp?: number | undefined;
+            reasoning?: string | undefined;
+            confidence?: number | undefined;
+        }, {
+            targetAgent: string;
+            strategy: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced";
+            timestamp?: number | undefined;
+            reasoning?: string | undefined;
+            confidence?: number | undefined;
+        }>, "many">;
+        reducer: (left: RoutingDecision[], right: RoutingDecision[]) => {
+            targetAgent: string;
+            strategy: "llm-based" | "rule-based" | "round-robin" | "skill-based" | "load-balanced";
+            timestamp?: number | undefined;
+            reasoning?: string | undefined;
+            confidence?: number | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Active task assignments
+     */
+    activeAssignments: {
+        schema: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            workerId: z.ZodString;
+            task: z.ZodString;
+            priority: z.ZodDefault<z.ZodNumber>;
+            assignedAt: z.ZodNumber;
+            deadline: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            workerId: string;
+            task: string;
+            priority: number;
+            assignedAt: number;
+            deadline?: number | undefined;
+        }, {
+            id: string;
+            workerId: string;
+            task: string;
+            assignedAt: number;
+            priority?: number | undefined;
+            deadline?: number | undefined;
+        }>, "many">;
+        reducer: (left: TaskAssignment[], right: TaskAssignment[]) => {
+            id: string;
+            workerId: string;
+            task: string;
+            priority: number;
+            assignedAt: number;
+            deadline?: number | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Completed task results
+     * Accumulates all completed tasks
+     */
+    completedTasks: {
+        schema: z.ZodArray<z.ZodObject<{
+            assignmentId: z.ZodString;
+            workerId: z.ZodString;
+            success: z.ZodBoolean;
+            result: z.ZodString;
+            error: z.ZodOptional<z.ZodString>;
+            completedAt: z.ZodNumber;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            result: string;
+            success: boolean;
+            workerId: string;
+            assignmentId: string;
+            completedAt: number;
+            metadata?: Record<string, any> | undefined;
+            error?: string | undefined;
+        }, {
+            result: string;
+            success: boolean;
+            workerId: string;
+            assignmentId: string;
+            completedAt: number;
+            metadata?: Record<string, any> | undefined;
+            error?: string | undefined;
+        }>, "many">;
+        reducer: (left: TaskResult[], right: TaskResult[]) => {
+            result: string;
+            success: boolean;
+            workerId: string;
+            assignmentId: string;
+            completedAt: number;
+            metadata?: Record<string, any> | undefined;
+            error?: string | undefined;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Handoff requests between agents
+     * Accumulates all handoff requests
+     */
+    handoffs: {
+        schema: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            reason: z.ZodString;
+            context: z.ZodAny;
+            timestamp: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            reason: string;
+            from: string;
+            to: string;
+            context?: any;
+        }, {
+            timestamp: string;
+            reason: string;
+            from: string;
+            to: string;
+            context?: any;
+        }>, "many">;
+        reducer: (left: HandoffRequest[], right: HandoffRequest[]) => {
+            timestamp: string;
+            reason: string;
+            from: string;
+            to: string;
+            context?: any;
+        }[];
+        default: () => never[];
+        description: string;
+    };
+    /**
+     * Current execution status
+     */
+    status: {
+        schema: z.ZodEnum<["initializing", "routing", "executing", "coordinating", "aggregating", "completed", "failed"]>;
+        default: () => MultiAgentStatus;
+        description: string;
+    };
+    /**
+     * Iteration counter
+     */
+    iteration: {
+        schema: z.ZodNumber;
+        reducer: (left: number, right: number) => number;
+        default: () => number;
+        description: string;
+    };
+    /**
+     * Maximum iterations allowed
+     */
+    maxIterations: {
+        schema: z.ZodNumber;
+        default: () => number;
+        description: string;
+    };
+    /**
+     * Final aggregated response
+     */
+    response: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+    /**
+     * Error message if execution failed
+     */
+    error: {
+        schema: z.ZodOptional<z.ZodString>;
+        description: string;
+    };
+};
+/**
+ * Create the Multi-Agent state annotation
+ *
+ * This uses LangGraph's Annotation.Root() under the hood, with optional Zod validation.
+ */
+declare const MultiAgentState: _langchain_langgraph.AnnotationRoot<_langchain_langgraph.StateDefinition>;
+/**
+ * TypeScript type for Multi-Agent state
+ *
+ * Manually defined to work around TypeScript's inability to infer the .State property
+ */
+type MultiAgentStateType = {
+    input: string;
+    messages: AgentMessage[];
+    workers: Record<string, WorkerCapabilities>;
+    currentAgent?: string;
+    routingHistory: RoutingDecision[];
+    activeAssignments: TaskAssignment[];
+    completedTasks: TaskResult[];
+    handoffs: HandoffRequest[];
+    status: MultiAgentStatus;
+    iteration: number;
+    maxIterations: number;
+    response?: string;
+    error?: string;
+};
+
+/**
+ * Type Definitions for Multi-Agent Coordination Pattern
+ *
+ * This module defines TypeScript types for the Multi-Agent pattern.
+ *
+ * @module patterns/multi-agent/types
+ */
+
+/**
+ * Configuration for the supervisor node
+ */
+interface SupervisorConfig {
+    /**
+     * Language model for routing decisions (used for LLM-based routing)
+     */
+    llm?: BaseChatModel;
+    /**
+     * Routing strategy to use
+     */
+    strategy: RoutingStrategy;
+    /**
+     * System prompt for the supervisor (LLM-based routing only)
+     */
+    systemPrompt?: string;
+    /**
+     * Custom routing function (for rule-based routing)
+     */
+    routingFn?: (state: MultiAgentStateType) => Promise<RoutingDecision>;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Maximum number of routing iterations
+     */
+    maxIterations?: number;
+}
+/**
+ * Configuration for a worker agent node
+ */
+interface WorkerConfig {
+    /**
+     * Unique identifier for this worker
+     */
+    id: string;
+    /**
+     * Worker capabilities
+     */
+    capabilities: WorkerCapabilities;
+    /**
+     * Language model for the worker
+     */
+    llm?: BaseChatModel;
+    /**
+     * Available tools for this worker
+     */
+    tools?: Tool[];
+    /**
+     * System prompt for the worker
+     */
+    systemPrompt?: string;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * Custom execution function
+     */
+    executeFn?: (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+}
+/**
+ * Configuration for the aggregator node
+ */
+interface AggregatorConfig {
+    /**
+     * Language model for aggregation (optional)
+     */
+    llm?: BaseChatModel;
+    /**
+     * System prompt for aggregation
+     */
+    systemPrompt?: string;
+    /**
+     * Custom aggregation function
+     */
+    aggregateFn?: (state: MultiAgentStateType) => Promise<string>;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Configuration for the multi-agent system
+ */
+interface MultiAgentSystemConfig {
+    /**
+     * Supervisor configuration
+     */
+    supervisor: SupervisorConfig;
+    /**
+     * Worker configurations
+     */
+    workers: WorkerConfig[];
+    /**
+     * Aggregator configuration (optional)
+     */
+    aggregator?: AggregatorConfig;
+    /**
+     * Maximum iterations for the entire system
+     */
+    maxIterations?: number;
+    /**
+     * Whether to include verbose logging
+     */
+    verbose?: boolean;
+}
+/**
+ * Node type for multi-agent graph
+ */
+type MultiAgentNode = 'supervisor' | 'aggregator' | string;
+/**
+ * Route type for multi-agent graph
+ */
+type MultiAgentRoute = 'continue' | 'aggregate' | 'end' | string;
+/**
+ * Router function type
+ */
+type MultiAgentRouter = (state: MultiAgentStateType) => MultiAgentRoute;
+/**
+ * Routing strategy implementation
+ */
+interface RoutingStrategyImpl {
+    /**
+     * Name of the strategy
+     */
+    name: RoutingStrategy;
+    /**
+     * Execute the routing strategy
+     */
+    route: (state: MultiAgentStateType, config: SupervisorConfig) => Promise<RoutingDecision>;
+}
+
+/**
+ * Routing Strategy Implementations for Multi-Agent Pattern
+ *
+ * This module implements various routing strategies for distributing tasks
+ * among worker agents.
+ *
+ * @module patterns/multi-agent/routing
+ */
+
+/**
+ * Default system prompt for LLM-based routing
+ */
+declare const DEFAULT_SUPERVISOR_SYSTEM_PROMPT = "You are a supervisor agent responsible for routing tasks to specialized worker agents.\n\nYour job is to:\n1. Analyze the current task and context\n2. Review available worker capabilities\n3. Select the most appropriate worker for the task\n4. Provide clear reasoning for your decision\n\nRespond with a JSON object containing:\n{\n  \"targetAgent\": \"worker_id\",\n  \"reasoning\": \"explanation of why this worker is best suited\",\n  \"confidence\": 0.0-1.0,\n  \"strategy\": \"llm-based\"\n}";
+/**
+ * LLM-based routing strategy
+ * Uses an LLM to intelligently route tasks based on worker capabilities
+ */
+declare const llmBasedRouting: RoutingStrategyImpl;
+/**
+ * Round-robin routing strategy
+ * Distributes tasks evenly across all available workers
+ */
+declare const roundRobinRouting: RoutingStrategyImpl;
+/**
+ * Skill-based routing strategy
+ * Routes tasks to workers based on matching skills
+ */
+declare const skillBasedRouting: RoutingStrategyImpl;
+/**
+ * Load-balanced routing strategy
+ * Routes tasks to workers with the lowest current workload
+ */
+declare const loadBalancedRouting: RoutingStrategyImpl;
+/**
+ * Rule-based routing strategy
+ * Uses custom routing function provided in config
+ */
+declare const ruleBasedRouting: RoutingStrategyImpl;
+/**
+ * Get routing strategy implementation by name
+ */
+declare function getRoutingStrategy(name: string): RoutingStrategyImpl;
+
+/**
+ * Node Implementations for Multi-Agent Coordination Pattern
+ *
+ * This module implements the core nodes for the Multi-Agent pattern.
+ *
+ * @module patterns/multi-agent/nodes
+ */
+
+/**
+ * Default system prompt for aggregator
+ */
+declare const DEFAULT_AGGREGATOR_SYSTEM_PROMPT = "You are an aggregator agent responsible for combining results from multiple worker agents.\n\nYour job is to:\n1. Review all completed task results\n2. Synthesize the information into a coherent response\n3. Ensure all aspects of the original query are addressed\n4. Provide a clear, comprehensive final answer\n\nBe concise but thorough in your aggregation.";
+/**
+ * Create a supervisor node that routes tasks to workers
+ */
+declare function createSupervisorNode(config: SupervisorConfig): (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+/**
+ * Create a worker agent node
+ */
+declare function createWorkerNode(config: WorkerConfig): (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+/**
+ * Create an aggregator node that combines worker results
+ */
+declare function createAggregatorNode(config?: AggregatorConfig): (state: MultiAgentStateType) => Promise<Partial<MultiAgentStateType>>;
+
+/**
+ * Create a multi-agent coordination system
+ *
+ * This factory function creates a complete multi-agent system with:
+ * - A supervisor agent that routes tasks to workers
+ * - Multiple specialized worker agents
+ * - An aggregator that combines worker results
+ *
+ * @param config - Configuration for the multi-agent system
+ * @returns Compiled LangGraph workflow
+ *
+ * @example
+ * ```typescript
+ * const system = createMultiAgentSystem({
+ *   supervisor: {
+ *     strategy: 'skill-based',
+ *     llm: chatModel,
+ *   },
+ *   workers: [
+ *     {
+ *       id: 'researcher',
+ *       capabilities: {
+ *         skills: ['research', 'analysis'],
+ *         tools: ['search', 'scrape'],
+ *         available: true,
+ *         currentWorkload: 0,
+ *       },
+ *       llm: chatModel,
+ *     },
+ *     {
+ *       id: 'writer',
+ *       capabilities: {
+ *         skills: ['writing', 'editing'],
+ *         tools: ['format', 'spell_check'],
+ *         available: true,
+ *         currentWorkload: 0,
+ *       },
+ *       llm: chatModel,
+ *     },
+ *   ],
+ *   aggregator: {
+ *     llm: chatModel,
+ *   },
+ * });
+ *
+ * const result = await system.invoke({
+ *   input: 'Research AI trends and write a summary',
+ * });
+ * ```
+ */
+declare function createMultiAgentSystem(config: MultiAgentSystemConfig): CompiledStateGraph<unknown, Partial<unknown>, "__start__", _langchain_langgraph.StateDefinition, _langchain_langgraph.StateDefinition, _langchain_langgraph.StateDefinition>;
+/**
+ * Multi-agent system builder for dynamic worker registration
+ *
+ * This builder allows you to register workers before compiling the graph.
+ * Once compiled, the graph is immutable and workers cannot be added.
+ */
+declare class MultiAgentSystemBuilder {
+    private config;
+    private additionalWorkers;
+    private compiled;
+    constructor(config: Omit<MultiAgentSystemConfig, 'workers'> & {
+        workers?: WorkerConfig[];
+    });
+    /**
+     * 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: Array<{
+        name: string;
+        description?: string;
+        capabilities: string[];
+        tools?: any[];
+        systemPrompt?: string;
+        llm?: any;
+    }>): this;
+    /**
+     * Build and compile the multi-agent system
+     *
+     * @returns Compiled LangGraph workflow
+     */
+    build(): CompiledStateGraph<unknown, Partial<unknown>, "__start__", _langchain_langgraph.StateDefinition, _langchain_langgraph.StateDefinition, _langchain_langgraph.StateDefinition>;
+}
+/**
+ * Extended multi-agent system with worker registration support
+ */
+interface MultiAgentSystemWithRegistry extends CompiledStateGraph<MultiAgentStateType, Partial<MultiAgentStateType>, '__start__' | 'supervisor' | 'aggregator' | string> {
+    _workerRegistry?: Record<string, WorkerCapabilities>;
+    _originalInvoke?: typeof CompiledStateGraph.prototype.invoke;
+}
+/**
+ * Register workers with a compiled multi-agent system
+ *
+ * **Important**: This function only registers worker *capabilities* in the state.
+ * It does NOT add worker nodes to the graph (which is impossible after compilation).
+ *
+ * This means:
+ * - Workers must already exist as nodes in the compiled graph
+ * - This function only updates their capabilities in the state
+ * - For true dynamic worker registration, use `MultiAgentSystemBuilder` instead
+ *
+ * **Recommended**: Use `MultiAgentSystemBuilder` for a cleaner approach:
+ * ```typescript
+ * const builder = new MultiAgentSystemBuilder({
+ *   supervisor: { llm, strategy: 'skill-based' },
+ *   aggregator: { llm },
+ * });
+ *
+ * builder.registerWorkers([...]);
+ * const system = builder.build();
+ * ```
+ *
+ * @param system - The compiled multi-agent system
+ * @param workers - Array of worker configurations
+ *
+ * @deprecated Use `MultiAgentSystemBuilder` instead for proper worker registration
+ */
+declare function registerWorkers(system: MultiAgentSystemWithRegistry, workers: Array<{
+    name: string;
+    description?: string;
+    capabilities: string[];
+    tools?: any[];
+    systemPrompt?: string;
+}>): void;
+
+export { type AgentMessage, AgentMessageSchema, type AgentRole, AgentRoleSchema, type AggregatorConfig, type CompletedStep, 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, type ExecutionStatus, ExecutionStatusSchema, type ExecutorConfig, GENERATION_PROMPT_TEMPLATE, type GeneratorConfig, type HandoffRequest, HandoffRequestSchema, type Message, MessageSchema, type MessageType, MessageTypeSchema, type MultiAgentNode, type MultiAgentRoute, type MultiAgentRouter, MultiAgentState, MultiAgentStateConfig, type MultiAgentStateType, type MultiAgentStatus, MultiAgentStatusSchema, MultiAgentSystemBuilder, type MultiAgentSystemConfig, PLANNING_PROMPT_TEMPLATE, type Plan, type PlanExecuteAgentConfig, type PlanExecuteNode, type PlanExecuteRoute, type PlanExecuteRouter, PlanExecuteState, PlanExecuteStateConfig, type PlanExecuteStateType, PlanSchema, type PlanStep, PlanStepSchema, type PlannerConfig, QUALITY_CRITERIA_TEMPLATE, type QualityCriteria, QualityCriteriaSchema, REFLECTION_ENTRY_TEMPLATE, REFLECTION_HISTORY_TEMPLATE, REFLECTION_PROMPT_TEMPLATE, REPLANNING_PROMPT_TEMPLATE, REVISION_ENTRY_TEMPLATE, REVISION_PROMPT_TEMPLATE, ReActAgentBuilder, type ReActAgentConfig, type ReActAgentOptions, type ReActBuilderOptions, ReActState, type ReActStateType, type Reflection, type ReflectionAgentConfig, type ReflectionConfig, ReflectionConfigSchema, type ReflectionNode, type ReflectionRoute, type ReflectionRouter, ReflectionSchema, ReflectionState, ReflectionStateConfig, type ReflectionStateType, type ReflectionStatus, ReflectionStatusSchema, type ReflectorConfig, type ReplanDecision, ReplanDecisionSchema, type ReplannerConfig, type ReviserConfig, type Revision, RevisionSchema, type RoutingDecision, RoutingDecisionSchema, type RoutingStrategy, type RoutingStrategyImpl, RoutingStrategySchema, type ScratchpadEntry, ScratchpadEntrySchema, type StopConditionFn, type SupervisorConfig, type TaskAssignment, TaskAssignmentSchema, type TaskResult, TaskResultSchema, type Thought, ThoughtSchema, type ToolCall, ToolCallSchema, type ToolResult, ToolResultSchema, type WorkerCapabilities, WorkerCapabilitiesSchema, type WorkerConfig, createAggregatorNode, createExecutorNode, createFinisherNode$1 as createFinisherNode, createGeneratorNode, createMultiAgentSystem, createPlanExecuteAgent, createPlannerNode, createReActAgent, createReActAgentBuilder, createReflectionAgent, createFinisherNode as createReflectionFinisherNode, createReflectorNode, createReplannerNode, createReviserNode, createSupervisorNode, createWorkerNode, getRoutingStrategy, llmBasedRouting, loadBalancedRouting, registerWorkers, roundRobinRouting, ruleBasedRouting, skillBasedRouting };