@directive-run/ai 0.3.0 → 0.4.0

package/dist/{multi-agent-orchestrator-CxL8ycw_.d.cts → multi-agent-orchestrator-D-WuP4jP.d.ts}

@@ -1,4 +1,4 @@
-import { M as Message$1, e as RunResult, A as AgentLike, G as GuardrailFn, O as OutputGuardrailData, aX as StreamingCallbackRunner, D as DebugEvent, a1 as DebugEventType, b as AgentRunner, aw as OrchestratorState, aq as NamedGuardrail, I as InputGuardrailData, C as Checkpoint, u as BreakpointModifications, v as BreakpointRequest, ar as OrchestratorConstraint, au as OrchestratorResolver, af as GuardrailsConfig, o as ApprovalRequest, as as OrchestratorDebugConfig, k as AgentRetryConfig, at as OrchestratorLifecycleHooks, aU as SelfHealingConfig, L as CheckpointStore, r as BreakpointConfig, ai as HealthMonitorConfig, R as RunOptions, T as ToolCallGuardrailData, ay as PatternCheckpointConfig, Z as DagPattern, a7 as GoalPattern, a6 as GoalNode, m as AgentSelectionStrategy, aL as RelaxationTier, f as GoalResult, a4 as GoalCheckpointState, aV as SequentialCheckpointState, aY as SupervisorCheckpointState, aF as ReflectCheckpointState, _ as DebateCheckpointState, U as DagCheckpointState, aS as Scratchpad, ao as MultiAgentLifecycleHooks, ap as MultiAgentSelfHealingConfig, am as MultiAgentBreakpointType, P as CrossAgentDerivationFn, W as DagNode, V as DagExecutionContext, az as PatternCheckpointState, E as CheckpointDiff, H as CheckpointProgress, a5 as GoalMetrics } from './types-Co4BzMiH.cjs';
+import { M as Message$1, e as RunResult, A as AgentLike, G as GuardrailFn, O as OutputGuardrailData, aX as StreamingCallbackRunner, D as DebugEvent, a1 as DebugEventType, b as AgentRunner, aw as OrchestratorState, aq as NamedGuardrail, I as InputGuardrailData, C as Checkpoint, u as BreakpointModifications, v as BreakpointRequest, ar as OrchestratorConstraint, au as OrchestratorResolver, af as GuardrailsConfig, o as ApprovalRequest, as as OrchestratorDebugConfig, k as AgentRetryConfig, at as OrchestratorLifecycleHooks, aU as SelfHealingConfig, L as CheckpointStore, r as BreakpointConfig, ai as HealthMonitorConfig, R as RunOptions, T as ToolCallGuardrailData, ay as PatternCheckpointConfig, Z as DagPattern, a7 as GoalPattern, a6 as GoalNode, m as AgentSelectionStrategy, aL as RelaxationTier, f as GoalResult, a4 as GoalCheckpointState, aV as SequentialCheckpointState, aY as SupervisorCheckpointState, aF as ReflectCheckpointState, _ as DebateCheckpointState, U as DagCheckpointState, aS as Scratchpad, ao as MultiAgentLifecycleHooks, ap as MultiAgentSelfHealingConfig, am as MultiAgentBreakpointType, P as CrossAgentDerivationFn, W as DagNode, V as DagExecutionContext, az as PatternCheckpointState, E as CheckpointDiff, H as CheckpointProgress, a5 as GoalMetrics } from './types-D5veI9su.js';
 import { Plugin, System, Requirement } from '@directive-run/core';
 import { CircuitBreaker } from '@directive-run/core/plugins';
 
@@ -998,6 +998,58 @@ interface AgentOrchestrator<F extends Record<string, unknown>> {
  */
 declare function createAgentOrchestrator<F extends Record<string, unknown> = Record<string, never>>(options: OrchestratorOptions<F>): AgentOrchestrator<F>;
 
+/**
+ * Health Monitor — tracks per-agent health metrics for self-healing networks.
+ *
+ * Pure computation module with zero Directive dependency.
+ * Maintains a rolling window of success/failure events and computes a health
+ * score from 0-100 based on configurable weights.
+ *
+ * @module
+ */
+
+/** Circuit state values */
+type HealthCircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
+/** Per-agent health metrics */
+interface AgentHealthMetrics {
+    agentId: string;
+    circuitState: HealthCircuitState;
+    successRate: number;
+    avgLatencyMs: number;
+    recentFailures: number;
+    recentSuccesses: number;
+    healthScore: number;
+    /** Last N error messages (most recent last) */
+    lastErrors: string[];
+}
+/** Health monitor instance */
+interface HealthMonitor {
+    recordSuccess(agentId: string, latencyMs: number): void;
+    recordFailure(agentId: string, latencyMs: number, error?: Error): void;
+    getMetrics(agentId: string): AgentHealthMetrics;
+    getAllMetrics(): Record<string, AgentHealthMetrics>;
+    /** Returns a 0-100 health score. Returns 50 (neutral) when no data is available for the agent. */
+    getHealthScore(agentId: string): number;
+    updateCircuitState(agentId: string, state: HealthCircuitState): void;
+    /** Reset all metrics. Useful for testing. */
+    reset(): void;
+}
+/**
+ * Create a health monitor that tracks per-agent metrics.
+ *
+ * @example
+ * ```typescript
+ * const monitor = createHealthMonitor({ windowMs: 30000 });
+ *
+ * monitor.recordSuccess("agent-a", 120);
+ * monitor.recordFailure("agent-a", 5000, new Error("timeout"));
+ *
+ * const score = monitor.getHealthScore("agent-a");
+ * console.log(score); // 0-100
+ * ```
+ */
+declare function createHealthMonitor(config?: HealthMonitorConfig): HealthMonitor;
+
 /**
  * Agent Reflection / Self-Improvement
  *
@@ -1098,58 +1150,6 @@ declare class ReflectionExhaustedError extends Error {
  */
 declare function withReflection<T = unknown>(runner: AgentRunner, config: ReflectionConfig<T>): AgentRunner;
 
-/**
- * Health Monitor — tracks per-agent health metrics for self-healing networks.
- *
- * Pure computation module with zero Directive dependency.
- * Maintains a rolling window of success/failure events and computes a health
- * score from 0-100 based on configurable weights.
- *
- * @module
- */
-
-/** Circuit state values */
-type HealthCircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
-/** Per-agent health metrics */
-interface AgentHealthMetrics {
-    agentId: string;
-    circuitState: HealthCircuitState;
-    successRate: number;
-    avgLatencyMs: number;
-    recentFailures: number;
-    recentSuccesses: number;
-    healthScore: number;
-    /** Last N error messages (most recent last) */
-    lastErrors: string[];
-}
-/** Health monitor instance */
-interface HealthMonitor {
-    recordSuccess(agentId: string, latencyMs: number): void;
-    recordFailure(agentId: string, latencyMs: number, error?: Error): void;
-    getMetrics(agentId: string): AgentHealthMetrics;
-    getAllMetrics(): Record<string, AgentHealthMetrics>;
-    /** Returns a 0-100 health score. Returns 50 (neutral) when no data is available for the agent. */
-    getHealthScore(agentId: string): number;
-    updateCircuitState(agentId: string, state: HealthCircuitState): void;
-    /** Reset all metrics. Useful for testing. */
-    reset(): void;
-}
-/**
- * Create a health monitor that tracks per-agent metrics.
- *
- * @example
- * ```typescript
- * const monitor = createHealthMonitor({ windowMs: 30000 });
- *
- * monitor.recordSuccess("agent-a", 120);
- * monitor.recordFailure("agent-a", 5000, new Error("timeout"));
- *
- * const score = monitor.getHealthScore("agent-a");
- * console.log(score); // 0-100
- * ```
- */
-declare function createHealthMonitor(config?: HealthMonitorConfig): HealthMonitor;
-
 /** Get the current step/round/iteration count from a pattern checkpoint state */
 declare function getPatternStep(state: PatternCheckpointState): number;
 /** Compute progress from a pattern checkpoint state */
@@ -1256,25 +1256,25 @@ interface AgentRegistration {
 interface AgentRegistry {
     [agentId: string]: AgentRegistration;
 }
-/** Parallel execution pattern - run agents concurrently and merge results */
+/** Parallel execution pattern - run handlers concurrently and merge results */
 interface ParallelPattern<T = unknown> {
     type: "parallel";
-    /** Agent IDs to run in parallel (can repeat for multiple instances) */
-    agents: string[];
-    /** Function to merge results from all agents */
+    /** Handler IDs (agents or tasks) to run in parallel (can repeat for multiple instances) */
+    handlers: string[];
+    /** Function to merge results from all handlers */
     merge: (results: RunResult<unknown>[]) => T | Promise<T>;
-    /** Minimum successful results required. @default agents.length */
+    /** Minimum successful results required. @default handlers.length */
     minSuccess?: number;
     /** Overall timeout (ms) */
     timeout?: number;
 }
-/** Sequential execution pattern - pipeline of agents */
+/** Sequential execution pattern - pipeline of handlers */
 interface SequentialPattern<T = unknown> {
     type: "sequential";
-    /** Agent IDs in execution order */
-    agents: string[];
+    /** Handler IDs (agents or tasks) in execution order */
+    handlers: string[];
     /** Transform output to next input. @default JSON.stringify */
-    transform?: (output: unknown, agentId: string, index: number) => string;
+    transform?: (output: unknown, handlerId: string, index: number) => string;
     /** Final result extractor */
     extract?: (output: unknown) => T;
     /** Continue on error. @default false */
@@ -1313,8 +1313,8 @@ interface ReflectIterationRecord {
  */
 interface ReflectPattern<T = unknown> {
     type: "reflect";
-    /** Producer agent ID */
-    agent: string;
+    /** Producer handler ID (agent or task) */
+    handler: string;
     /** Evaluator agent ID (receives output as input) */
     evaluator: string;
     /** Maximum iterations. @default 2 */
@@ -1345,8 +1345,8 @@ interface ReflectPattern<T = unknown> {
  */
 interface RacePattern<T = unknown> {
     type: "race";
-    /** Agent IDs to race */
-    agents: string[];
+    /** Handler IDs (agents or tasks) to race */
+    handlers: string[];
     /** Extract result from winning RunResult (receives full RunResult for access to tokens/metadata). @default output field */
     extract?: (result: RunResult<unknown>) => T;
     /** Overall timeout (ms) */
@@ -1391,8 +1391,8 @@ interface RaceResult<T = unknown> {
  */
 interface DebatePattern<T = unknown> {
     type: "debate";
-    /** Agent IDs that will generate competing proposals */
-    agents: string[];
+    /** Handler IDs (agents or tasks) that will generate competing proposals */
+    handlers: string[];
     /** Evaluator agent ID that judges proposals */
     evaluator: string;
     /** Maximum rounds of debate. @default 2 */
@@ -1437,12 +1437,57 @@ interface RunAgentRequirement extends Requirement {
     input: string;
     context?: Record<string, unknown>;
 }
+/** Read-only context passed to task functions */
+interface TaskContext {
+    /** The ID of this task */
+    taskId: string;
+    /** Conversation history from orchestrator memory (read-only deep copy) */
+    memory: ReadonlyArray<{
+        role: string;
+        content: string;
+    }>;
+    /** Current scratchpad state (read-only deep copy) */
+    scratchpad: Readonly<Record<string, unknown>>;
+    /** Read the state of any registered agent or task (status, lastOutput, lastError, totalTokens) */
+    readAgentState: (nodeId: string) => Readonly<{
+        status: string;
+        lastOutput?: string;
+        lastError?: string;
+        totalTokens: number;
+    }> | undefined;
+    /** Report intermediate progress (0-100) for DevTools timeline */
+    reportProgress: (percent: number, message?: string) => void;
+}
+/** Configuration for a registered task (imperative code) */
+interface TaskRegistration {
+    /** The function to execute. Receives input, abort signal, and context. */
+    run: (input: string, signal: AbortSignal, context: TaskContext) => unknown | Promise<unknown>;
+    /** Display label for DevTools graph. Defaults to task ID. */
+    label?: string;
+    /** Description for DevTools tooltip/detail panel. */
+    description?: string;
+    /** Timeout (ms) */
+    timeout?: number;
+    /** Max concurrent executions of this task. @default 1 */
+    maxConcurrent?: number;
+    /** Optional retry configuration for transient failures */
+    retry?: {
+        /** Max number of attempts (including the first try) */
+        attempts: number;
+        /** Backoff strategy between retries. @default 'fixed' */
+        backoff?: "fixed" | "exponential";
+        /** Base delay between retries (ms). @default 1000 */
+        delayMs?: number;
+    };
+}
 /** Multi-agent orchestrator options */
 interface MultiAgentOrchestratorOptions {
     /** Base run function */
     runner: AgentRunner;
     /** Registered agents */
     agents: AgentRegistry;
+    /** Imperative code tasks, referenced by ID in patterns (same namespace as agents) */
+    tasks?: Record<string, TaskRegistration>;
     /** Execution patterns */
     patterns?: Record<string, ExecutionPattern>;
     /** Handoff callbacks */
@@ -1524,6 +1569,8 @@ interface MultiAgentRunCallOptions extends RunOptions {
     outputSchema?: SafeParseable<unknown> | null;
     /** Override max schema retries for this call. */
     maxSchemaRetries?: number;
+    /** Pattern ID that initiated this run (for lifecycle hooks). Set internally by pattern executors. */
+    patternId?: string;
 }
 /** Multi-agent orchestrator instance */
 interface MultiAgentOrchestrator {
@@ -1579,6 +1626,35 @@ interface MultiAgentOrchestrator {
     unregisterAgent(agentId: string): void;
     /** Get registered agent IDs */
     getAgentIds(): string[];
+    /** Register a new task dynamically */
+    registerTask(taskId: string, registration: TaskRegistration): void;
+    /** Unregister a task */
+    unregisterTask(taskId: string): void;
+    /** Get registered task IDs */
+    getTaskIds(): string[];
+    /** Get task registry info (labels + descriptions) */
+    getTaskRegistry(): Record<string, {
+        label?: string;
+        description?: string;
+    }>;
+    /** Get task state */
+    getTaskState(taskId: string): {
+        status: string;
+        lastOutput?: unknown;
+        lastError?: string;
+        startTime?: number;
+        durationMs?: number;
+    } | undefined;
+    /** Get all task states */
+    getAllTaskStates(): Record<string, {
+        status: string;
+        lastOutput?: unknown;
+        lastError?: string;
+        startTime?: number;
+        durationMs?: number;
+    }>;
+    /** Get all handler IDs (agents + tasks combined) */
+    getNodeIds(): string[];
     /** Get agent state */
     getAgentState(agentId: string): MultiAgentState["__agents"][string] | undefined;
     /** Get all agent states */
@@ -1684,7 +1760,6 @@ interface MultiAgentOrchestrator {
     }): Promise<T>;
     /**
      * Get reflection iteration history from last runReflectPattern call.
-     * @deprecated Use the `history` field on the return value from `runReflect()` instead.
      */
     getLastReflectionHistory(): ReflectIterationRecord[] | null;
     /** Cross-agent derived values (frozen snapshot). Empty when derive not configured. */
@@ -1740,9 +1815,8 @@ declare function createMultiAgentOrchestrator(options: MultiAgentOrchestratorOpt
 /**
  * Create a parallel pattern configuration.
  *
- * @param agents - Agent IDs to run concurrently
- * @param merge - Combine all agent results into a single output
- * @param config.merge - Receives all successful RunResults (array may be shorter than agents.length when minSuccess is set). Returns the merged result.
+ * @param handlers - Handler IDs (agents or tasks) to run concurrently
+ * @param merge - Combine all handler results into a single output. Receives all successful RunResults (array may be shorter than handlers.length when minSuccess is set).
  * @param options - Optional `minSuccess` and `timeout` overrides
  *
  * @example
@@ -1753,14 +1827,14 @@ declare function createMultiAgentOrchestrator(options: MultiAgentOrchestratorOpt
  * );
  * ```
  */
-declare function parallel<T>(agents: string[], merge: (results: RunResult<unknown>[]) => T | Promise<T>, options?: {
+declare function parallel<T>(handlers: string[], merge: (results: RunResult<unknown>[]) => T | Promise<T>, options?: {
     minSuccess?: number;
     timeout?: number;
 }): ParallelPattern<T>;
 /**
  * Create a sequential pattern configuration.
  *
- * @param agents - Agent IDs to run in order (output of each feeds into the next)
+ * @param handlers - Handler IDs (agents or tasks) to run in order (output of each feeds into the next)
  * @param options - Optional `transform`, `extract`, `continueOnError`
  *
  * @example
@@ -1771,8 +1845,8 @@ declare function parallel<T>(agents: string[], merge: (results: RunResult<unknow
  * );
  * ```
  */
-declare function sequential<T>(agents: string[], options?: {
-    transform?: (output: unknown, agentId: string, index: number) => string;
+declare function sequential<T>(handlers: string[], options?: {
+    transform?: (output: unknown, handlerId: string, index: number) => string;
     extract?: (output: unknown) => T;
     continueOnError?: boolean;
 }): SequentialPattern<T>;
@@ -1799,7 +1873,7 @@ declare function supervisor<T>(supervisorAgent: string, workers: string[], optio
 /**
  * Create a DAG execution pattern.
  *
- * @param nodes - Node definitions keyed by ID, each with `agent` and optional `deps`
+ * @param nodes - Node definitions keyed by ID, each with `handler` and optional `deps`
  * @param merge - Combine DAG outputs into a single result (defaults to `context.outputs`)
  * @param options - Optional `timeout`, `maxConcurrent`, `onNodeError`
  *
@@ -1807,9 +1881,9 @@ declare function supervisor<T>(supervisorAgent: string, workers: string[], optio
  * ```typescript
  * const researchPipeline = dag(
  *   {
- *     fetch: { agent: 'fetcher' },
- *     analyze: { agent: 'analyzer', deps: ['fetch'] },
- *     summarize: { agent: 'summarizer', deps: ['analyze'] },
+ *     fetch: { handler: 'fetcher' },
+ *     analyze: { handler: 'analyzer', deps: ['fetch'] },
+ *     summarize: { handler: 'summarizer', deps: ['analyze'] },
  *   },
  *   (context) => context.outputs.summarize,
  * );
@@ -1831,8 +1905,8 @@ declare function dag<T = Record<string, unknown>>(nodes: Record<string, DagNode>
 /**
  * Create a reflect pattern configuration.
  *
- * @param agent - Producer agent ID that generates output
- * @param evaluator - Evaluator agent ID that judges quality
+ * @param handler - Producer handler ID (agent or task) that generates output
+ * @param evaluator - Evaluator handler ID that judges quality
  * @param options - Optional iteration, parsing, signal, and threshold config
  *
  * @example
@@ -1840,7 +1914,7 @@ declare function dag<T = Record<string, unknown>>(nodes: Record<string, DagNode>
  * const reviewPattern = reflect('writer', 'reviewer', { maxIterations: 2 });
  * ```
  */
-declare function reflect<T>(agent: string, evaluator: string, options?: {
+declare function reflect<T>(handler: string, evaluator: string, options?: {
     maxIterations?: number;
     parseEvaluation?: (output: unknown) => ReflectionEvaluation;
     buildRetryInput?: (input: string, feedback: string, iteration: number) => string;
@@ -1854,7 +1928,7 @@ declare function reflect<T>(agent: string, evaluator: string, options?: {
 /**
  * Create a race pattern configuration.
  *
- * @param agents - Agent IDs to race concurrently
+ * @param handlers - Handler IDs (agents or tasks) to race concurrently
  * @param options - Optional `extract`, `timeout`, `minSuccess`, `signal`
  *
  * @example
@@ -1862,7 +1936,7 @@ declare function reflect<T>(agent: string, evaluator: string, options?: {
  * const fastest = race(['fast-model', 'smart-model'], { timeout: 5000 });
  * ```
  */
-declare function race<T>(agents: string[], options?: {
+declare function race<T>(handlers: string[], options?: {
     extract?: (result: RunResult<unknown>) => T;
     timeout?: number;
     minSuccess?: number;
@@ -1880,13 +1954,13 @@ declare function race<T>(agents: string[], options?: {
  * const pipeline = goal(
  *   {
  *     researcher: {
- *       agent: "researcher",
+ *       handler: "researcher",
  *       produces: ["research.findings"],
  *       requires: ["research.topic"],
  *       extractOutput: (r) => ({ "research.findings": r.output }),
  *     },
  *     writer: {
- *       agent: "writer",
+ *       handler: "writer",
  *       produces: ["article.draft"],
  *       requires: ["research.findings"],
  *       extractOutput: (r) => ({ "article.draft": r.output }),
@@ -2066,7 +2140,6 @@ declare function spawnOnCondition(config: {
     priority?: number;
     /** Additional context passed to the agent */
     context?: Record<string, unknown>;
-    /** @deprecated Use top-level `priority` and `context` instead */
     options?: SpawnOnConditionOptions;
 }): OrchestratorConstraint<Record<string, unknown>>;
 /** Configuration for the debate() factory and runDebate() imperative API. @see DebatePattern */
@@ -2079,7 +2152,7 @@ type DebateConfig<T = unknown> = Omit<DebatePattern<T>, "type">;
  * 2. Evaluator receives all proposals and picks a winner
  * 3. Optionally repeat with evaluator feedback for refinement
  *
- * @param config - Debate configuration with `agents`, `evaluator`, and optional settings
+ * @param config - Debate configuration with `handlers`, `evaluator`, and optional settings
  * @see runDebate for the imperative API
  *
  * @example
@@ -2092,7 +2165,7 @@ type DebateConfig<T = unknown> = Omit<DebatePattern<T>, "type">;
  *   },
  *   patterns: {
  *     debate: debate({
- *       agents: ['optimist', 'pessimist'],
+ *       handlers: ['optimist', 'pessimist'],
  *       evaluator: 'judge',
  *       maxRounds: 2,
  *     }),
@@ -2185,7 +2258,8 @@ interface SpawnPoolConfig {
 declare function spawnPool(when: (facts: Record<string, unknown>) => boolean, config: SpawnPoolConfig): OrchestratorConstraint<Record<string, unknown>>;
 /** Serialized DAG node (functions stripped) */
 interface SerializedDagNode {
-    agent: string;
+    handler: string;
+    agent?: string;
     deps?: string[];
     timeout?: number;
     priority?: number;
@@ -2193,12 +2267,12 @@ interface SerializedDagNode {
 /** JSON-safe representation of any execution pattern (all functions stripped) */
 type SerializedPattern = {
     type: "parallel";
-    agents: string[];
+    handlers: string[];
     minSuccess?: number;
     timeout?: number;
 } | {
     type: "sequential";
-    agents: string[];
+    handlers: string[];
     continueOnError?: boolean;
 } | {
     type: "supervisor";
@@ -2213,7 +2287,7 @@ type SerializedPattern = {
     onNodeError?: "fail" | "skip-downstream" | "continue";
 } | {
     type: "reflect";
-    agent: string;
+    handler: string;
     evaluator: string;
     maxIterations?: number;
     onExhausted?: "accept-last" | "accept-best" | "throw";
@@ -2221,12 +2295,12 @@ type SerializedPattern = {
     threshold?: number;
 } | {
     type: "race";
-    agents: string[];
+    handlers: string[];
     timeout?: number;
     minSuccess?: number;
 } | {
     type: "debate";
-    agents: string[];
+    handlers: string[];
     evaluator: string;
     maxRounds?: number;
     timeout?: number;
@@ -2238,7 +2312,8 @@ type SerializedPattern = {
 };
 /** Serialized goal node (functions stripped) */
 interface SerializedGoalNode {
-    agent: string;
+    handler: string;
+    agent?: string;
     produces: string[];
     requires?: string[];
     allowRerun?: boolean;
@@ -2259,9 +2334,9 @@ interface SerializedGoalNode {
  *
  * @example
  * ```typescript
- * const p = parallel({ agents: ["a", "b"], merge: (r) => r });
+ * const p = parallel({ handlers: ["a", "b"], merge: (r) => r });
  * const json = patternToJSON(p);
- * // { type: "parallel", agents: ["a", "b"] }
+ * // { type: "parallel", handlers: ["a", "b"] }
  * localStorage.setItem("plan", JSON.stringify(json));
  * ```
  */
@@ -2281,10 +2356,10 @@ declare function patternToJSON(pattern: ExecutionPattern<unknown>): SerializedPa
  * });
  * // Use the imperative API — runPattern takes a registered pattern ID, not an object
  * if (pattern.type === "parallel") {
- *   const result = await orchestrator.runParallel(pattern.agents, input, pattern.merge);
+ *   const result = await orchestrator.runParallel(pattern.handlers, input, pattern.merge);
  * }
  * ```
  */
 declare function patternFromJSON<T = unknown>(json: SerializedPattern, overrides?: Partial<ExecutionPattern<T>>): ExecutionPattern<T>;
 
-export { type SafeParseResult as $, type AgentHealthMetrics as A, type BackpressureStrategy as B, type MultiplexedStreamChunk as C, type DebugTimeline as D, type ExecutionPattern as E, type MultiplexedStreamResult as F, type GuardrailTriggeredChunk as G, type HealthMonitor as H, type OrchestratorStreamChunk as I, type OrchestratorStreamResult as J, type ProgressChunk as K, type RaceResult as L, type MemoryManageResult as M, type RaceSuccessEntry as N, type OrchestratorOptions as O, type ParallelPattern as P, type ReflectIterationRecord as Q, type RacePattern as R, type SerializedPattern as S, type ReflectPattern as T, type ReflectionConfig as U, type ReflectionContext as V, type ReflectionEvaluation as W, type ReflectionEvaluator as X, ReflectionExhaustedError as Y, type RunAgentRequirement as Z, type RunCallOptions as _, type AgentMemory as a, race as a$, type SafeParseable as a0, Semaphore as a1, type SequentialPattern as a2, type SerializedDagNode as a3, type SerializedGoalNode as a4, type SpawnOnConditionOptions as a5, type SpawnPoolConfig as a6, type StreamChunk as a7, type StreamRunOptions as a8, type StreamRunner as a9, createLLMSummarizer as aA, createLengthStreamingGuardrail as aB, createMultiAgentOrchestrator as aC, createPatternStreamingGuardrail as aD, createSlidingWindowStrategy as aE, createStreamingRunner as aF, createTokenBasedStrategy as aG, createToxicityStreamingGuardrail as aH, createTruncationSummarizer as aI, dag as aJ, debate as aK, derivedConstraint as aL, diffCheckpoints as aM, extractJsonFromOutput as aN, filterStream as aO, findAgentsByCapability as aP, forkFromCheckpoint as aQ, getCheckpointProgress as aR, getPatternStep as aS, goal as aT, highestImpactStrategy as aU, mapStream as aV, mergeTaggedStreams as aW, parallel as aX, patternFromJSON as aY, patternToJSON as aZ, pickBestResult as a_, type StreamingGuardrail as aa, type StreamingGuardrailResult as ab, type StreamingRunResult as ac, type StructuredOutputConfig as ad, StructuredOutputError as ae, type SupervisorPattern as af, type TokenChunk as ag, type ToolEndChunk as ah, type ToolStartChunk as ai, adaptOutputGuardrail as aj, aggregateTokens as ak, allReadyStrategy as al, capabilityRoute as am, collectOutputs as an, collectTokens as ao, combineStreamingGuardrails as ap, composePatterns as aq, concatResults as ar, costEfficientStrategy as as, createAgentMemory as at, createAgentOrchestrator as au, createDebugTimeline as av, createDebugTimelinePlugin as aw, createHealthMonitor as ax, createHybridStrategy as ay, createKeyPointsSummarizer as az, type AgentMemoryConfig as b, reflect as b0, runAgentRequirement as b1, runDebate as b2, selectAgent as b3, sequential as b4, spawnOnCondition as b5, spawnPool as b6, supervisor as b7, tapStream as b8, withReflection as b9, withStructuredOutput as ba, type AgentOrchestrator as c, type AgentRegistration as d, type AgentRegistry as e, type DebateConfig as f, type DebatePattern as g, type DebateResult as h, type DebugTimelineListener as i, type DebugTimelineOptions as j, type DoneChunk as k, type ErrorChunk as l, type HandoffRequest as m, type HandoffResult as n, type HealthCircuitState as o, type MemoryState as p, type MemoryStrategy as q, type MemoryStrategyConfig as r, type MemoryStrategyResult as s, type MergedTaggedStreamResult as t, type MessageChunk as u, type MessageSummarizer as v, type MultiAgentOrchestrator as w, type MultiAgentOrchestratorOptions as x, type MultiAgentRunCallOptions as y, type MultiAgentState as z };
+export { type SafeParseResult as $, type AgentHealthMetrics as A, type BackpressureStrategy as B, type MultiplexedStreamChunk as C, type DebugTimeline as D, type ExecutionPattern as E, type MultiplexedStreamResult as F, type GuardrailTriggeredChunk as G, type HealthMonitor as H, type OrchestratorStreamChunk as I, type OrchestratorStreamResult as J, type ProgressChunk as K, type RaceResult as L, type MemoryManageResult as M, type RaceSuccessEntry as N, type OrchestratorOptions as O, type ParallelPattern as P, type ReflectIterationRecord as Q, type RacePattern as R, type SerializedPattern as S, type ReflectPattern as T, type ReflectionConfig as U, type ReflectionContext as V, type ReflectionEvaluation as W, type ReflectionEvaluator as X, ReflectionExhaustedError as Y, type RunAgentRequirement as Z, type RunCallOptions as _, type AgentMemory as a, patternToJSON as a$, type SafeParseable as a0, Semaphore as a1, type SequentialPattern as a2, type SerializedDagNode as a3, type SerializedGoalNode as a4, type SpawnOnConditionOptions as a5, type SpawnPoolConfig as a6, type StreamChunk as a7, type StreamRunOptions as a8, type StreamRunner as a9, createHybridStrategy as aA, createKeyPointsSummarizer as aB, createLLMSummarizer as aC, createLengthStreamingGuardrail as aD, createMultiAgentOrchestrator as aE, createPatternStreamingGuardrail as aF, createSlidingWindowStrategy as aG, createStreamingRunner as aH, createTokenBasedStrategy as aI, createToxicityStreamingGuardrail as aJ, createTruncationSummarizer as aK, dag as aL, debate as aM, derivedConstraint as aN, diffCheckpoints as aO, extractJsonFromOutput as aP, filterStream as aQ, findAgentsByCapability as aR, forkFromCheckpoint as aS, getCheckpointProgress as aT, getPatternStep as aU, goal as aV, highestImpactStrategy as aW, mapStream as aX, mergeTaggedStreams as aY, parallel as aZ, patternFromJSON as a_, type StreamingGuardrail as aa, type StreamingGuardrailResult as ab, type StreamingRunResult as ac, type StructuredOutputConfig as ad, StructuredOutputError as ae, type SupervisorPattern as af, type TaskContext as ag, type TaskRegistration as ah, type TokenChunk as ai, type ToolEndChunk as aj, type ToolStartChunk as ak, adaptOutputGuardrail as al, aggregateTokens as am, allReadyStrategy as an, capabilityRoute as ao, collectOutputs as ap, collectTokens as aq, combineStreamingGuardrails as ar, composePatterns as as, concatResults as at, costEfficientStrategy as au, createAgentMemory as av, createAgentOrchestrator as aw, createDebugTimeline as ax, createDebugTimelinePlugin as ay, createHealthMonitor as az, type AgentMemoryConfig as b, pickBestResult as b0, race as b1, reflect as b2, runAgentRequirement as b3, runDebate as b4, selectAgent as b5, sequential as b6, spawnOnCondition as b7, spawnPool as b8, supervisor as b9, tapStream as ba, withReflection as bb, withStructuredOutput as bc, type AgentOrchestrator as c, type AgentRegistration as d, type AgentRegistry as e, type DebateConfig as f, type DebatePattern as g, type DebateResult as h, type DebugTimelineListener as i, type DebugTimelineOptions as j, type DoneChunk as k, type ErrorChunk as l, type HandoffRequest as m, type HandoffResult as n, type HealthCircuitState as o, type MemoryState as p, type MemoryStrategy as q, type MemoryStrategyConfig as r, type MemoryStrategyResult as s, type MergedTaggedStreamResult as t, type MessageChunk as u, type MessageSummarizer as v, type MultiAgentOrchestrator as w, type MultiAgentOrchestratorOptions as x, type MultiAgentRunCallOptions as y, type MultiAgentState as z };