@directive-run/ai 0.4.2 → 0.7.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { G as GuardrailFn, I as InputGuardrailData, O as OutputGuardrailData, S as SchemaValidator, T as ToolCallGuardrailData, A as AgentLike, M as Message, a as AdapterHooks, b as AgentRunner, c as ApprovalState, d as AgentState, R as RunOptions, e as RunResult, D as DebugEvent, B as BreakpointState, f as GoalResult } from './types-D5veI9su.js';
-export { g as AgentCircuitBreakerConfig, h as AgentCompleteEvent, i as AgentErrorEvent, j as AgentHealthState, k as AgentRetryConfig, l as AgentRetryEvent, m as AgentSelectionStrategy, n as AgentStartEvent, o as ApprovalRequest, p as ApprovalRequestEvent, q as ApprovalResponseEvent, r as BreakpointConfig, s as BreakpointContext, t as BreakpointHitEvent, u as BreakpointModifications, v as BreakpointRequest, w as BreakpointResumedEvent, x as BreakpointState, y as BreakpointType, C as Checkpoint, z as CheckpointContext, E as CheckpointDiff, F as CheckpointLocalState, H as CheckpointProgress, J as CheckpointRestoreEvent, K as CheckpointSaveEvent, L as CheckpointStore, N as ConstraintEvaluateEvent, P as CrossAgentDerivationFn, Q as CrossAgentSnapshot, U as DagCheckpointState, V as DagExecutionContext, W as DagNode, X as DagNodeStatus, Y as DagNodeUpdateEvent, Z as DagPattern, _ as DebateCheckpointState, $ as DebateRoundEvent, a0 as DebugEventBase, a1 as DebugEventType, a2 as DerivationUpdateEvent, a3 as GoalCheckpointConfig, a4 as GoalCheckpointState, a5 as GoalMetrics, a6 as GoalNode, a7 as GoalPattern, a8 as GoalStepMetrics, a9 as GuardrailCheckEvent, aa as GuardrailContext, ab as GuardrailError, ac as GuardrailErrorCode, ad as GuardrailResult, ae as GuardrailRetryConfig, af as GuardrailsConfig, ag as HandoffCompleteEvent, ah as HandoffStartEvent, ai as HealthMonitorConfig, aj as InMemoryCheckpointStore, ak as InMemoryCheckpointStoreOptions, al as MAX_BREAKPOINT_HISTORY, am as MultiAgentBreakpointType, an as MultiAgentCheckpointLocalState, ao as MultiAgentLifecycleHooks, ap as MultiAgentSelfHealingConfig, aq as NamedGuardrail, ar as OrchestratorConstraint, as as OrchestratorDebugConfig, at as OrchestratorLifecycleHooks, au as OrchestratorResolver, av as OrchestratorResolverContext, aw as OrchestratorState, ax as PatternCheckpointBase, ay as PatternCheckpointConfig, az as PatternCheckpointState, aA as PatternCompleteEvent, aB as PatternStartEvent, aC as RaceCancelledEvent, aD as RaceStartEvent, aE as RaceWinnerEvent, aF as ReflectCheckpointState, aG as ReflectionIterationEvent, aH as RejectedRequest, aI as RelaxationContext, aJ as RelaxationRecord, aK as RelaxationStrategy, aL as RelaxationTier, aM as RerouteDebugEvent, aN as RerouteEvent, aO as ResolverCompleteEvent, aP as ResolverErrorEvent, aQ as ResolverStartEvent, aR as SchemaValidationResult, aS as Scratchpad, aT as ScratchpadUpdateEvent, aU as SelfHealingConfig, aV as SequentialCheckpointState, aW as SingleAgentCheckpointLocalState, aX as StreamingCallbackRunner, aY as SupervisorCheckpointState, aZ as TaskCompleteEvent, a_ as TaskErrorEvent, a$ as TaskProgressEvent, b0 as TaskStartEvent, b1 as TokenUsage, b2 as ToolCall, b3 as createBreakpointId, b4 as createCheckpointId, b5 as createInitialBreakpointState, b6 as isGuardrailError, b7 as matchBreakpoint, b8 as validateCheckpoint } from './types-D5veI9su.js';
-import { E as ExecutionPattern, S as SerializedPattern, A as AgentHealthMetrics, D as DebugTimeline, H as HealthMonitor } from './multi-agent-orchestrator-CH-4Fqzg.js';
-export { a as AgentMemory, b as AgentMemoryConfig, c as AgentOrchestrator, d as AgentRegistration, e as AgentRegistry, B as BackpressureStrategy, f as DebateConfig, g as DebatePattern, h as DebateResult, i as DebugTimelineListener, j as DebugTimelineOptions, k as DoneChunk, l as ErrorChunk, G as GuardrailTriggeredChunk, m as HandoffRequest, n as HandoffResult, o as HealthCircuitState, M as MemoryManageResult, p as MemoryState, q as MemoryStrategy, r as MemoryStrategyConfig, s as MemoryStrategyResult, t as MergedTaggedStreamResult, u as MessageChunk, v as MessageSummarizer, w as MultiAgentOrchestrator, x as MultiAgentOrchestratorOptions, y as MultiAgentRunCallOptions, z as MultiAgentState, C as MultiplexedStreamChunk, F as MultiplexedStreamResult, O as OrchestratorOptions, I as OrchestratorStreamChunk, J as OrchestratorStreamResult, P as ParallelPattern, K as ProgressChunk, R as RacePattern, L as RaceResult, N as RaceSuccessEntry, Q as ReflectIterationRecord, T as ReflectPattern, U as ReflectionConfig, V as ReflectionContext, W as ReflectionEvaluation, X as ReflectionEvaluator, Y as ReflectionExhaustedError, Z as RunAgentRequirement, _ as RunCallOptions, $ as SafeParseResult, a0 as SafeParseable, a1 as Semaphore, a2 as SequentialPattern, a3 as SerializedDagNode, a4 as SerializedGoalNode, a5 as SpawnOnConditionOptions, a6 as SpawnPoolConfig, a7 as StreamChunk, a8 as StreamRunOptions, a9 as StreamRunner, aa as StreamingGuardrail, ab as StreamingGuardrailResult, ac as StreamingRunResult, ad as StructuredOutputConfig, ae as StructuredOutputError, af as SupervisorPattern, ag as TaskContext, ah as TaskRegistration, ai as TokenChunk, aj as ToolEndChunk, ak as ToolStartChunk, al as adaptOutputGuardrail, am as aggregateTokens, an as allReadyStrategy, ao as capabilityRoute, ap as collectOutputs, aq as collectTokens, ar as combineStreamingGuardrails, as as composePatterns, at as concatResults, au as costEfficientStrategy, av as createAgentMemory, aw as createAgentOrchestrator, ax as createDebugTimeline, ay as createDebugTimelinePlugin, az as createHealthMonitor, aA as createHybridStrategy, aB as createKeyPointsSummarizer, aC as createLLMSummarizer, aD as createLengthStreamingGuardrail, aE as createMultiAgentOrchestrator, aF as createPatternStreamingGuardrail, aG as createSlidingWindowStrategy, aH as createStreamingRunner, aI as createTokenBasedStrategy, aJ as createToxicityStreamingGuardrail, aK as createTruncationSummarizer, aL as dag, aM as debate, aN as derivedConstraint, aO as diffCheckpoints, aP as extractJsonFromOutput, aQ as filterStream, aR as findAgentsByCapability, aS as forkFromCheckpoint, aT as getCheckpointProgress, aU as getPatternStep, aV as goal, aW as highestImpactStrategy, aX as mapStream, aY as mergeTaggedStreams, aZ as parallel, a_ as patternFromJSON, a$ as patternToJSON, b0 as pickBestResult, b1 as race, b2 as reflect, b3 as runAgentRequirement, b4 as runDebate, b5 as selectAgent, b6 as sequential, b7 as spawnOnCondition, b8 as spawnPool, b9 as supervisor, ba as tapStream, bb as withReflection, bc as withStructuredOutput } from './multi-agent-orchestrator-CH-4Fqzg.js';
-export { AggregatedMetric, AlertConfig, AlertEvent, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerOpenError, CircuitBreakerStats, CircuitState, DashboardData, MetricDataPoint, MetricType, OTLPExporter, OTLPExporterConfig, ObservabilityConfig, ObservabilityInstance, TraceSpan, createAgentMetrics, createCircuitBreaker, createOTLPExporter, createObservability } from '@directive-run/core/plugins';
+import { G as GuardrailFn, I as InputGuardrailData, O as OutputGuardrailData, S as SchemaValidator, T as ToolCallGuardrailData, A as AgentLike, M as Message, a as AdapterHooks, b as AgentRunner, c as ApprovalState, d as AgentState, e as AgentSelectionStrategy, D as DagNode, f as DagExecutionContext, g as DagPattern, h as GoalNode, R as RelaxationTier, i as GoalMetrics, P as PatternCheckpointConfig, j as GoalPattern, k as RunResult, l as OrchestratorConstraint, m as RunOptions, n as DebugEvent, B as BreakpointState, o as GoalResult } from './types-BM-6xZf_.js';
+export { p as AgentCircuitBreakerConfig, q as AgentCompleteEvent, r as AgentErrorEvent, s as AgentHealthState, t as AgentRetryConfig, u as AgentRetryEvent, v as AgentStartEvent, w as ApprovalRequest, x as ApprovalRequestEvent, y as ApprovalResponseEvent, z as BreakpointConfig, C as BreakpointContext, E as BreakpointHitEvent, F as BreakpointModifications, H as BreakpointRequest, J as BreakpointResumedEvent, K as BreakpointState, L as BreakpointType, N as Checkpoint, Q as CheckpointContext, U as CheckpointDiff, V as CheckpointLocalState, W as CheckpointProgress, X as CheckpointRestoreEvent, Y as CheckpointSaveEvent, Z as CheckpointStore, _ as ConstraintEvaluateEvent, $ as CrossAgentDerivationFn, a0 as CrossAgentSnapshot, a1 as DagCheckpointState, a2 as DagNodeStatus, a3 as DagNodeUpdateEvent, a4 as DebateCheckpointState, a5 as DebateRoundEvent, a6 as DebugEventBase, a7 as DebugEventType, a8 as DerivationUpdateEvent, a9 as GoalCheckpointConfig, aa as GoalCheckpointState, ab as GoalStepMetrics, ac as GuardrailCheckEvent, ad as GuardrailContext, ae as GuardrailError, af as GuardrailErrorCode, ag as GuardrailResult, ah as GuardrailRetryConfig, ai as GuardrailsConfig, aj as HandoffCompleteEvent, ak as HandoffStartEvent, al as HealthMonitorConfig, am as InMemoryCheckpointStore, an as InMemoryCheckpointStoreOptions, ao as MAX_BREAKPOINT_HISTORY, ap as MultiAgentBreakpointType, aq as MultiAgentCheckpointLocalState, ar as MultiAgentLifecycleHooks, as as MultiAgentSelfHealingConfig, at as NamedGuardrail, au as OrchestratorDebugConfig, av as OrchestratorLifecycleHooks, aw as OrchestratorResolver, ax as OrchestratorResolverContext, ay as OrchestratorState, az as PatternCheckpointBase, aA as PatternCheckpointState, aB as PatternCompleteEvent, aC as PatternStartEvent, aD as RaceCancelledEvent, aE as RaceStartEvent, aF as RaceWinnerEvent, aG as ReflectCheckpointState, aH as ReflectionIterationEvent, aI as RejectedRequest, aJ as RelaxationContext, aK as RelaxationRecord, aL as RelaxationStrategy, aM as RerouteDebugEvent, aN as RerouteEvent, aO as ResolverCompleteEvent, aP as ResolverErrorEvent, aQ as ResolverStartEvent, aR as SchemaValidationResult, aS as Scratchpad, aT as ScratchpadUpdateEvent, aU as SelfHealingConfig, aV as SequentialCheckpointState, aW as SingleAgentCheckpointLocalState, aX as StreamingCallbackRunner, aY as SupervisorCheckpointState, aZ as TaskCompleteEvent, a_ as TaskErrorEvent, a$ as TaskProgressEvent, b0 as TaskStartEvent, b1 as TokenUsage, b2 as ToolCall, b3 as createBreakpointId, b4 as createCheckpointId, b5 as createInitialBreakpointState, b6 as isGuardrailError, b7 as matchBreakpoint, b8 as validateCheckpoint } from './types-BM-6xZf_.js';
+import { P as ParallelPattern, R as RacePattern, a as ReflectionEvaluation, b as ReflectIterationRecord, c as ReflectPattern, S as SequentialPattern, d as SupervisorPattern, E as ExecutionPattern, D as DebatePattern, A as AgentRegistry, M as MultiAgentOrchestrator, e as RunAgentRequirement, f as DebateResult, g as AgentHealthMetrics, h as DebugTimeline, H as HealthMonitor } from './multi-agent-orchestrator-DHp8gHXi.js';
+export { i as AgentMemory, j as AgentMemoryConfig, k as AgentOrchestrator, l as AgentRegistration, B as BackpressureStrategy, m as DebugTimelineListener, n as DebugTimelineOptions, o as DoneChunk, p as ErrorChunk, G as GuardrailTriggeredChunk, q as HandoffRequest, r as HandoffResult, s as HealthCircuitState, t as MemoryManageResult, u as MemoryState, v as MemoryStrategy, w as MemoryStrategyConfig, x as MemoryStrategyResult, y as MergedTaggedStreamResult, z as MessageChunk, C as MessageSummarizer, F as MultiAgentOrchestratorOptions, I as MultiAgentRunCallOptions, J as MultiAgentState, K as MultiplexedStreamChunk, L as MultiplexedStreamResult, O as OrchestratorOptions, N as OrchestratorStreamChunk, Q as OrchestratorStreamResult, T as ProgressChunk, U as RaceResult, V as RaceSuccessEntry, W as ReflectionConfig, X as ReflectionContext, Y as ReflectionEvaluator, Z as ReflectionExhaustedError, _ as RunCallOptions, $ as SafeParseResult, a0 as SafeParseable, a1 as Semaphore, a2 as StreamChunk, a3 as StreamRunOptions, a4 as StreamRunner, a5 as StreamingGuardrail, a6 as StreamingGuardrailResult, a7 as StreamingRunResult, a8 as StructuredOutputConfig, a9 as StructuredOutputError, aa as TaskContext, ab as TaskRegistration, ac as TokenChunk, ad as ToolEndChunk, ae as ToolStartChunk, af as adaptOutputGuardrail, ag as collectTokens, ah as combineStreamingGuardrails, ai as createAgentMemory, aj as createAgentOrchestrator, ak as createDebugTimeline, al as createDebugTimelinePlugin, am as createHealthMonitor, an as createHybridStrategy, ao as createKeyPointsSummarizer, ap as createLLMSummarizer, aq as createLengthStreamingGuardrail, ar as createMultiAgentOrchestrator, as as createPatternStreamingGuardrail, at as createSlidingWindowStrategy, au as createStreamingRunner, av as createTokenBasedStrategy, aw as createToxicityStreamingGuardrail, ax as createTruncationSummarizer, ay as diffCheckpoints, az as extractJsonFromOutput, aA as filterStream, aB as forkFromCheckpoint, aC as getCheckpointProgress, aD as getPatternStep, aE as mapStream, aF as mergeTaggedStreams, aG as tapStream, aH as withReflection, aI as withStructuredOutput } from './multi-agent-orchestrator-DHp8gHXi.js';
+export { AggregatedMetric, AlertConfig, AlertEvent, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerOpenError, CircuitBreakerStats, CircuitState, DashboardData, MetricDataPoint, MetricType, OTLPExporter, OTLPExporterConfig, ObservabilityConfig, ObservabilityInstance, TraceSpan, createCircuitBreaker, createOTLPExporter } from '@directive-run/core/plugins';
 import { ModuleSchema, Plugin } from '@directive-run/core';
 import { E as Embedding, a as EmbedderFn } from './semantic-cache-F0psCRuz.js';
 export { B as BatchedEmbedder, C as CacheEntry, b as CacheLookupResult, c as CacheStats, S as SemanticCache, d as SemanticCacheConfig, e as SemanticCacheStorage, f as createBatchedEmbedder, g as createInMemoryStorage, h as createSemanticCache, i as createSemanticCacheGuardrail, j as createTestEmbedder } from './semantic-cache-F0psCRuz.js';
@@ -367,6 +367,656 @@ type RunnerMiddleware = (runner: AgentRunner) => AgentRunner;
  */
 declare function pipe(runner: AgentRunner, ...middlewares: RunnerMiddleware[]): AgentRunner;
 
+/**
+ * Create a parallel execution pattern that runs handlers concurrently and merges results.
+ *
+ * @param handlers - Handler IDs (agents or tasks) to run concurrently.
+ * @param merge - Combine all handler results into a single output (array may be shorter than handlers when `minSuccess` is set).
+ * @param options - Optional `minSuccess` and `timeout` overrides.
+ * @returns A {@link ParallelPattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const researchPattern = parallel(
+ *   ['researcher', 'researcher', 'researcher'],
+ *   (results) => results.map(r => r.output).join('\n'),
+ * );
+ * ```
+ */
+declare function parallel<T>(handlers: string[], merge: (results: RunResult<unknown>[]) => T | Promise<T>, options?: {
+    minSuccess?: number;
+    timeout?: number;
+}): ParallelPattern<T>;
+/**
+ * Create a sequential execution pattern that pipes output from one handler to the next.
+ *
+ * @param handlers - Handler IDs (agents or tasks) to run in order, where each handler's output feeds as input to the next.
+ * @param options - Optional `transform`, `extract`, and `continueOnError` overrides.
+ * @returns A {@link SequentialPattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const writeReviewPattern = sequential(
+ *   ['writer', 'reviewer'],
+ *   { transform: (output) => `Review this: ${output}` },
+ * );
+ * ```
+ */
+declare function sequential<T>(handlers: string[], options?: {
+    transform?: (output: unknown, handlerId: string, index: number) => string;
+    extract?: (output: unknown) => T;
+    continueOnError?: boolean;
+}): SequentialPattern<T>;
+/**
+ * Create a supervisor pattern where a coordinating agent delegates work to a pool of workers.
+ *
+ * The supervisor runs first, then dispatches tasks to workers based on its output.
+ * This repeats for up to `maxRounds` until the supervisor signals completion.
+ *
+ * @param supervisorAgent - Agent ID that coordinates the workers.
+ * @param workers - Agent IDs for the worker pool.
+ * @param options - Optional `maxRounds` and `extract` overrides.
+ * @returns A {@link SupervisorPattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const managedPattern = supervisor(
+ *   'manager',
+ *   ['worker1', 'worker2'],
+ *   { maxRounds: 3 },
+ * );
+ * ```
+ */
+declare function supervisor<T>(supervisorAgent: string, workers: string[], options?: {
+    maxRounds?: number;
+    extract?: (supervisorOutput: unknown, workerResults: RunResult<unknown>[]) => T;
+}): SupervisorPattern<T>;
+/**
+ * Create a directed acyclic graph (DAG) execution pattern.
+ *
+ * Nodes run concurrently when their dependencies are satisfied. The runtime
+ * validates the graph is acyclic and that all dependency references are valid.
+ *
+ * @param nodes - Node definitions keyed by ID, each with a `handler` and optional `deps` array.
+ * @param merge - Combine DAG outputs into a single result (defaults to `context.outputs`).
+ * @param options - Optional `timeout`, `maxConcurrent`, and `onNodeError` strategy.
+ * @returns A {@link DagPattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const researchPipeline = dag(
+ *   {
+ *     fetch: { handler: 'fetcher' },
+ *     analyze: { handler: 'analyzer', deps: ['fetch'] },
+ *     summarize: { handler: 'summarizer', deps: ['analyze'] },
+ *   },
+ *   (context) => context.outputs.summarize,
+ * );
+ * ```
+ */
+declare function dag<T = Record<string, unknown>>(nodes: Record<string, DagNode>, merge?: (context: DagExecutionContext) => T | Promise<T>, options?: {
+    /** Overall timeout in ms for the entire DAG. */
+    timeout?: number;
+    /** Max nodes running concurrently. Default: Infinity */
+    maxConcurrent?: number;
+    /**
+     * Error handling strategy.
+     * - `"fail"` — abort entire DAG on first node error (default)
+     * - `"skip-downstream"` — mark downstream nodes as skipped, other branches continue
+     * - `"continue"` — ignore errors, other branches continue
+     */
+    onNodeError?: "fail" | "skip-downstream" | "continue";
+}): DagPattern<T>;
+/**
+ * Create a reflect pattern that iterates between a producer and evaluator until quality is met.
+ *
+ * The producer generates output, then the evaluator scores it. If the score
+ * is below the threshold, the producer retries with evaluator feedback,
+ * up to `maxIterations` times.
+ *
+ * @param handler - Producer handler ID (agent or task) that generates output.
+ * @param evaluator - Evaluator handler ID that judges quality and provides feedback.
+ * @param options - Optional iteration, parsing, signal, and threshold configuration.
+ * @returns A {@link ReflectPattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const reviewPattern = reflect('writer', 'reviewer', { maxIterations: 2 });
+ * ```
+ */
+declare function reflect<T>(handler: string, evaluator: string, options?: {
+    maxIterations?: number;
+    parseEvaluation?: (output: unknown) => ReflectionEvaluation;
+    buildRetryInput?: (input: string, feedback: string, iteration: number) => string;
+    extract?: (output: unknown) => T;
+    onExhausted?: "accept-last" | "accept-best" | "throw";
+    onIteration?: (record: ReflectIterationRecord) => void;
+    signal?: AbortSignal;
+    timeout?: number;
+    threshold?: number | ((iteration: number) => number);
+}): ReflectPattern<T>;
+/**
+ * Create a race pattern that runs handlers concurrently and returns the first successful result.
+ *
+ * All handlers start simultaneously. The first to complete successfully wins;
+ * remaining handlers are aborted. Use `minSuccess` to wait for N results before picking.
+ *
+ * @param handlers - Handler IDs (agents or tasks) to race concurrently.
+ * @param options - Optional `extract`, `timeout`, `minSuccess`, and `signal` overrides.
+ * @returns A {@link RacePattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const fastest = race(['fast-model', 'smart-model'], { timeout: 5000 });
+ * ```
+ */
+declare function race<T>(handlers: string[], options?: {
+    extract?: (result: RunResult<unknown>) => T;
+    timeout?: number;
+    minSuccess?: number;
+    signal?: AbortSignal;
+}): RacePattern<T>;
+/**
+ * Create a goal-driven execution pattern where agents are selected and run
+ * until a goal condition is satisfied.
+ *
+ * Declare what each agent produces and requires. The runtime automatically
+ * infers the execution graph from dependency analysis and drives agents
+ * toward goal achievement, with optional satisfaction scoring and relaxation tiers.
+ *
+ * @param nodes - Goal node definitions keyed by ID, each declaring `produces`, `requires`, and a `handler`.
+ * @param when - Predicate that returns `true` when the goal is achieved.
+ * @param options - Optional `satisfaction`, `maxSteps`, `extract`, `timeout`, `selectionStrategy`, and `relaxation` config.
+ * @returns A {@link GoalPattern} configuration object.
+ *
+ * @example
+ * ```typescript
+ * const pipeline = goal(
+ *   {
+ *     researcher: {
+ *       handler: "researcher",
+ *       produces: ["research.findings"],
+ *       requires: ["research.topic"],
+ *       extractOutput: (r) => ({ "research.findings": r.output }),
+ *     },
+ *     writer: {
+ *       handler: "writer",
+ *       produces: ["article.draft"],
+ *       requires: ["research.findings"],
+ *       extractOutput: (r) => ({ "article.draft": r.output }),
+ *     },
+ *   },
+ *   (facts) => facts["article.draft"] != null,
+ *   { maxSteps: 10, extract: (facts) => facts["article.draft"] },
+ * );
+ * ```
+ */
+declare function goal<T = Record<string, unknown>>(nodes: Record<string, GoalNode>, when: (facts: Record<string, unknown>) => boolean, options?: {
+    satisfaction?: (facts: Record<string, unknown>) => number;
+    maxSteps?: number;
+    extract?: (facts: Record<string, unknown>) => T;
+    timeout?: number;
+    signal?: AbortSignal;
+    selectionStrategy?: AgentSelectionStrategy;
+    relaxation?: RelaxationTier[];
+    onStep?: (step: number, facts: Record<string, unknown>, readyNodes: string[]) => void;
+    onStall?: (step: number, metrics: GoalMetrics) => void;
+    checkpoint?: PatternCheckpointConfig;
+}): GoalPattern<T>;
+/**
+ * Create a selection strategy that runs all ready agents concurrently.
+ *
+ * This is the default strategy for {@link goal} patterns.
+ *
+ * @returns An {@link AgentSelectionStrategy} that selects every ready agent.
+ */
+declare function allReadyStrategy(): AgentSelectionStrategy;
+/**
+ * Create a selection strategy that picks agents with the highest historical impact.
+ *
+ * Sorts ready agents by average satisfaction delta (descending) and selects the top N.
+ *
+ * @param opts - Optional `topN` to limit how many agents are selected (default: 3).
+ * @returns An {@link AgentSelectionStrategy} that prioritizes high-impact agents.
+ */
+declare function highestImpactStrategy(opts?: {
+    topN?: number;
+}): AgentSelectionStrategy;
+/**
+ * Create a selection strategy that prefers agents with lower token cost per satisfaction delta.
+ *
+ * Agents without historical metrics are prioritized first (to gather data).
+ *
+ * @returns An {@link AgentSelectionStrategy} that optimizes for cost efficiency.
+ */
+declare function costEfficientStrategy(): AgentSelectionStrategy;
+
+/** Serialized DAG node (functions stripped) */
+interface SerializedDagNode {
+    handler: string;
+    agent?: string;
+    deps?: string[];
+    timeout?: number;
+    priority?: number;
+}
+/** JSON-safe representation of any execution pattern (all functions stripped) */
+type SerializedPattern = {
+    type: "parallel";
+    handlers: string[];
+    minSuccess?: number;
+    timeout?: number;
+} | {
+    type: "sequential";
+    handlers: string[];
+    continueOnError?: boolean;
+} | {
+    type: "supervisor";
+    supervisor: string;
+    workers: string[];
+    maxRounds?: number;
+} | {
+    type: "dag";
+    nodes: Record<string, SerializedDagNode>;
+    timeout?: number;
+    maxConcurrent?: number;
+    onNodeError?: "fail" | "skip-downstream" | "continue";
+} | {
+    type: "reflect";
+    handler: string;
+    evaluator: string;
+    maxIterations?: number;
+    onExhausted?: "accept-last" | "accept-best" | "throw";
+    timeout?: number;
+    threshold?: number;
+} | {
+    type: "race";
+    handlers: string[];
+    timeout?: number;
+    minSuccess?: number;
+} | {
+    type: "debate";
+    handlers: string[];
+    evaluator: string;
+    maxRounds?: number;
+    timeout?: number;
+} | {
+    type: "goal";
+    nodes: Record<string, SerializedGoalNode>;
+    maxSteps?: number;
+    timeout?: number;
+};
+/** Serialized goal node (functions stripped) */
+interface SerializedGoalNode {
+    handler: string;
+    agent?: string;
+    produces: string[];
+    requires?: string[];
+    allowRerun?: boolean;
+    priority?: number;
+}
+/**
+ * Serialize an execution pattern to a JSON-safe object.
+ *
+ * @remarks
+ * Strips all function callbacks and runtime objects (AbortSignal) while
+ * preserving the topology -- which agents, in what structure, with what
+ * numeric/string/boolean options.
+ *
+ * Use this for visual editors, LLM-generated plans, persistence, or
+ * debugging. Restore with {@link patternFromJSON}.
+ *
+ * Function-form `threshold` on reflect patterns is not serializable and will be dropped.
+ * Re-supply it via `overrides` when calling {@link patternFromJSON}.
+ *
+ * @param pattern - The execution pattern to serialize.
+ * @returns A {@link SerializedPattern} safe for `JSON.stringify`.
+ *
+ * @example
+ * ```typescript
+ * const p = parallel(['a', 'b'], (r) => r);
+ * const json = patternToJSON(p);
+ * // { type: "parallel", handlers: ["a", "b"] }
+ * localStorage.setItem("plan", JSON.stringify(json));
+ * ```
+ */
+declare function patternToJSON(pattern: ExecutionPattern<unknown>): SerializedPattern;
+/**
+ * Restore an execution pattern from its serialized JSON form.
+ *
+ * @remarks
+ * Returns the data structure with all function fields set to `undefined`.
+ * Supply callbacks via the optional `overrides` parameter to re-attach
+ * runtime behavior. Handles legacy field migrations (`agent` to `handler`,
+ * `agents` to `handlers`, `converge` to `goal`).
+ *
+ * @param json - The serialized pattern from {@link patternToJSON} or persisted storage.
+ * @param overrides - Optional partial pattern to re-attach function callbacks (e.g. `merge`, `extract`).
+ * @returns A fully typed {@link ExecutionPattern} ready for use with the imperative API.
+ * @throws If the pattern type is invalid or unknown.
+ *
+ * @example
+ * ```typescript
+ * const json = JSON.parse(localStorage.getItem("plan")!);
+ * const pattern = patternFromJSON<string[]>(json, {
+ *   merge: (results) => results.map(r => r.output as string),
+ * });
+ * if (pattern.type === "parallel") {
+ *   const result = await orchestrator.runParallel(pattern.handlers, input, pattern.merge);
+ * }
+ * ```
+ */
+declare function patternFromJSON<T = unknown>(json: SerializedPattern, overrides?: Partial<ExecutionPattern<T>>): ExecutionPattern<T>;
+
+/**
+ * Create a constraint that routes to a specific agent when a condition is met.
+ *
+ * @param when - Predicate that triggers the constraint (may be async).
+ * @param agent - Agent ID or function returning an agent ID to route to.
+ * @param input - Input string or function returning the input for the selected agent.
+ * @param priority - Optional constraint priority (higher = evaluated first).
+ * @returns An {@link OrchestratorConstraint} that emits a `RUN_AGENT` requirement.
+ *
+ * @example
+ * ```typescript
+ * const constraints = {
+ *   routeToExpert: selectAgent(
+ *     (facts) => facts.complexity > 0.8,
+ *     'expert',
+ *     (facts) => facts.query,
+ *   ),
+ * };
+ * ```
+ */
+declare function selectAgent(when: (facts: Record<string, unknown>) => boolean | Promise<boolean>, agent: string | ((facts: Record<string, unknown>) => string), input: string | ((facts: Record<string, unknown>) => string), priority?: number): OrchestratorConstraint<Record<string, unknown>>;
+/**
+ * Create a `RUN_AGENT` requirement object for use in constraint `require()` functions.
+ *
+ * @param agent - The agent ID to run.
+ * @param input - The input string for the agent.
+ * @param context - Optional additional context passed to the agent runner.
+ * @returns A `RUN_AGENT` {@link RunAgentRequirement} object.
+ *
+ * @example
+ * ```typescript
+ * constraints: {
+ *   needsResearch: {
+ *     when: (facts) => facts.hasUnknowns,
+ *     require: (facts) => runAgentRequirement('researcher', facts.query as string),
+ *   },
+ * }
+ * ```
+ */
+declare function runAgentRequirement(agent: string, input: string, context?: Record<string, unknown>): RunAgentRequirement;
+/**
+ * Merge run results by concatenating their outputs into a single string.
+ *
+ * @param results - Array of run results to concatenate.
+ * @param separator - String inserted between outputs (default: `"\n\n"`).
+ * @returns The concatenated output string.
+ */
+declare function concatResults(results: RunResult<unknown>[], separator?: string): string;
+/**
+ * Pick the highest-scoring result from an array using a scoring function.
+ *
+ * @param results - Array of run results to compare.
+ * @param score - Function that assigns a numeric score to each result (higher wins).
+ * @returns The {@link RunResult} with the highest score.
+ * @throws If the results array is empty.
+ */
+declare function pickBestResult<T>(results: RunResult<T>[], score: (result: RunResult<T>) => number): RunResult<T>;
+/**
+ * Extract the `output` value from each run result into an array.
+ *
+ * @param results - Array of run results to collect from.
+ * @returns An array of output values in the same order as the input results.
+ */
+declare function collectOutputs<T>(results: RunResult<T>[]): T[];
+/**
+ * Sum the total token counts from an array of run results.
+ *
+ * @param results - Array of run results to aggregate.
+ * @returns The total number of tokens consumed across all results.
+ */
+declare function aggregateTokens(results: RunResult<unknown>[]): number;
+/**
+ * Compose multiple execution patterns into a pipeline where each pattern's
+ * output feeds as input to the next.
+ *
+ * @remarks
+ * Between patterns, output is converted to a string input:
+ * - `string` output passes through directly
+ * - Objects are JSON-stringified
+ * - Optionally provide a `transform` to customize between steps
+ *
+ * @param patterns - One or more execution patterns to chain together.
+ * @returns An async function that runs the pipeline on a given orchestrator.
+ *
+ * @example
+ * ```typescript
+ * const workflow = composePatterns(
+ *   parallel(['researcher', 'researcher'], concatResults),
+ *   sequential(['writer', 'reviewer']),
+ * );
+ *
+ * const result = await workflow(orchestrator, 'Research topic X');
+ * ```
+ */
+declare function composePatterns(...patterns: ExecutionPattern[]): (orchestrator: MultiAgentOrchestrator, input: string) => Promise<unknown>;
+/**
+ * Find agents in a registry that match all required capabilities.
+ *
+ * @param registry - The agent registry to search.
+ * @param requiredCapabilities - Capabilities that each matching agent must have.
+ * @returns An array of agent IDs whose `capabilities` include every required capability.
+ *
+ * @example
+ * ```typescript
+ * const agents = {
+ *   researcher: { agent: researchAgent, capabilities: ['search', 'summarize'] },
+ *   coder: { agent: coderAgent, capabilities: ['code', 'debug'] },
+ *   writer: { agent: writerAgent, capabilities: ['write', 'edit'] },
+ * };
+ *
+ * const matches = findAgentsByCapability(agents, ['search']);
+ * // Returns ['researcher']
+ * ```
+ */
+declare function findAgentsByCapability(registry: AgentRegistry, requiredCapabilities: string[]): string[];
+/**
+ * Create a constraint that auto-routes to an agent based on required capabilities.
+ *
+ * When the condition fires, it finds agents matching the capabilities returned by
+ * `getCapabilities`, then emits a `RUN_AGENT` requirement for the best match.
+ *
+ * @param registry - The agent registry to search for matching capabilities.
+ * @param getCapabilities - Function that extracts required capabilities from facts.
+ * @param getInput - Function that extracts the input string from facts.
+ * @param options - Optional `priority` and custom `select` function.
+ * @returns An {@link OrchestratorConstraint} that routes to a capability-matched agent.
+ *
+ * @example
+ * ```typescript
+ * const routeByCapability = capabilityRoute(
+ *   agents,
+ *   (facts) => facts.requiredCapabilities as string[],
+ *   (facts) => facts.query as string,
+ * );
+ * ```
+ */
+declare function capabilityRoute(registry: AgentRegistry, getCapabilities: (facts: Record<string, unknown>) => string[], getInput: (facts: Record<string, unknown>) => string, options?: {
+    priority?: number;
+    select?: (matches: string[], registry: AgentRegistry) => string;
+}): OrchestratorConstraint<Record<string, unknown>>;
+/**
+ * Options for spawnOnCondition.
+ */
+interface SpawnOnConditionOptions {
+    /** Priority for the constraint (higher = evaluated first) */
+    priority?: number;
+    /** Additional context passed to the agent */
+    context?: Record<string, unknown>;
+}
+/**
+ * Create a constraint that auto-runs a single agent when a condition is met.
+ *
+ * The orchestrator's built-in `RUN_AGENT` resolver handles execution --
+ * you only need to add this to your `constraints` config.
+ *
+ * @param config - Condition, agent ID, input builder, and optional priority/context.
+ * @returns An {@link OrchestratorConstraint} that emits a `RUN_AGENT` requirement.
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = createMultiAgentOrchestrator({
+ *   agents: { reviewer: { agent: reviewerAgent } },
+ *   constraints: {
+ *     autoReview: spawnOnCondition({
+ *       when: (facts) => (facts.confidence as number) < 0.7,
+ *       agent: 'reviewer',
+ *       input: (facts) => `Review this: ${facts.lastOutput}`,
+ *     }),
+ *   },
+ * });
+ * ```
+ */
+declare function spawnOnCondition(config: {
+    when: (facts: Record<string, unknown>) => boolean;
+    agent: string;
+    input: (facts: Record<string, unknown>) => string;
+    /** Priority for the constraint (higher = evaluated first) */
+    priority?: number;
+    /** Additional context passed to the agent */
+    context?: Record<string, unknown>;
+    options?: SpawnOnConditionOptions;
+}): OrchestratorConstraint<Record<string, unknown>>;
+/** Configuration for the debate() factory and runDebate() imperative API. @see DebatePattern */
+type DebateConfig<T = unknown> = Omit<DebatePattern<T>, "type">;
+/**
+ * Create a debate pattern where agents compete and an evaluator picks the best.
+ *
+ * @remarks
+ * Flow:
+ * 1. All agents produce proposals in parallel
+ * 2. Evaluator receives all proposals and picks a winner
+ * 3. Optionally repeat with evaluator feedback for refinement
+ *
+ * @param config - Debate configuration with `handlers`, `evaluator`, and optional settings.
+ * @returns A {@link DebatePattern} configuration object.
+ * @see {@link runDebate} for the imperative API
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = createMultiAgentOrchestrator({
+ *   agents: {
+ *     optimist: { agent: optimistAgent },
+ *     pessimist: { agent: pessimistAgent },
+ *     judge: { agent: judgeAgent },
+ *   },
+ *   patterns: {
+ *     debate: debate({
+ *       handlers: ['optimist', 'pessimist'],
+ *       evaluator: 'judge',
+ *       maxRounds: 2,
+ *     }),
+ *   },
+ * });
+ *
+ * const result = await orchestrator.runPattern('debate', 'Should we invest in X?');
+ * ```
+ */
+declare function debate<T = unknown>(config: DebateConfig<T>): DebatePattern<T>;
+/**
+ * Run a debate imperatively on an orchestrator without pattern registration.
+ *
+ * Delegates to `orchestrator.runDebate()` so that lifecycle hooks, debug timeline,
+ * and signal propagation all work correctly.
+ *
+ * @param orchestrator - The multi-agent orchestrator instance to run the debate on.
+ * @param config - Debate configuration with agents, evaluator, and optional settings.
+ * @param input - The initial input/prompt for the debate.
+ * @returns The winning agent's output, the winner ID, and all proposals from each round.
+ * @see {@link debate} for the declarative pattern API
+ */
+declare function runDebate<T>(orchestrator: MultiAgentOrchestrator, config: DebateConfig<T>, input: string): Promise<DebateResult<T>>;
+/**
+ * Create a constraint that fires when a cross-agent derivation meets a condition.
+ *
+ * @remarks
+ * Wire this into the orchestrator's `derive` config and `constraints` config together.
+ * The constraint's `when()` reads the derivation value from the orchestrator's derived snapshot.
+ *
+ * @param derivationId - The ID of the cross-agent derivation to watch.
+ * @param condition - Predicate that receives the derivation value and returns `true` when the constraint should fire.
+ * @param action - Agent ID, input builder, and optional priority/context for the emitted requirement.
+ * @returns An {@link OrchestratorConstraint} that emits a `RUN_AGENT` requirement when the derivation condition is met.
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = createMultiAgentOrchestrator({
+ *   agents: { ... },
+ *   derive: {
+ *     totalCost: (snap) => snap.coordinator.globalTokens * 0.001,
+ *   },
+ *   constraints: {
+ *     budgetAlert: derivedConstraint('totalCost', (cost) => cost > 5.0, {
+ *       agent: 'budget-manager',
+ *       input: (value) => `Budget exceeded: $${value}`,
+ *     }),
+ *   },
+ * });
+ * ```
+ */
+declare function derivedConstraint(derivationId: string, condition: (value: unknown) => boolean, action: {
+    agent: string;
+    input: (value: unknown) => string;
+    priority?: number;
+    context?: Record<string, unknown>;
+}): OrchestratorConstraint<Record<string, unknown>>;
+/** Configuration for spawnPool constraint-driven auto-scaling */
+interface SpawnPoolConfig {
+    /** Agent ID to spawn (must be registered in the orchestrator) */
+    agent: string;
+    /** Build the input for each spawned agent. Receives current facts and spawn index (0-based). */
+    input: (facts: Record<string, unknown>, index: number) => string;
+    /** How many agents to spawn. Number or function of facts for dynamic scaling. */
+    count: number | ((facts: Record<string, unknown>) => number);
+    /** Priority for the constraint. @default undefined */
+    priority?: number;
+    /** Additional context passed to each spawned agent */
+    context?: Record<string, unknown>;
+}
+/**
+ * Create a constraint that spawns a pool of agent instances when a condition is met.
+ *
+ * @remarks
+ * Unlike {@link spawnOnCondition} (which spawns one agent), `spawnPool` can target N agents.
+ * However, only one requirement is emitted per constraint evaluation cycle -- the constraint
+ * re-fires on subsequent cycles as long as `when()` returns true, spawning one agent per cycle.
+ *
+ * @param when - Predicate that triggers the pool spawn.
+ * @param config - Pool configuration with agent ID, input builder, count, and optional priority/context.
+ * @returns An {@link OrchestratorConstraint} that emits `RUN_AGENT` requirements.
+ * @see {@link spawnOnCondition} for spawning a single agent
+ *
+ * @example
+ * ```typescript
+ * const orchestrator = createMultiAgentOrchestrator({
+ *   agents: { worker: { agent: workerAgent } },
+ *   constraints: {
+ *     scaleWorkers: spawnPool(
+ *       (facts) => (facts.pendingTasks as number) > 0,
+ *       {
+ *         agent: 'worker',
+ *         count: (facts) => Math.min(facts.pendingTasks as number, 5),
+ *         input: (facts, i) => `Process task ${i + 1}`,
+ *       },
+ *     ),
+ *   },
+ * });
+ * ```
+ */
+declare function spawnPool(when: (facts: Record<string, unknown>) => boolean, config: SpawnPoolConfig): OrchestratorConstraint<Record<string, unknown>>;
+
 type MermaidDirection = "LR" | "TD" | "TB" | "RL" | "BT";
 interface MermaidNodeShapes {
     /** Shape for agent nodes. @default "square" */
@@ -1896,6 +2546,8 @@ interface JSONFileStoreOptions {
     mapEntry?: (entry: Record<string, unknown>) => RAGChunk;
     /** Cache TTL in ms. 0 = cache forever (default) */
     ttlMs?: number;
+    /** Base directory to confine file access. Resolved paths must start with this. */
+    baseDir?: string;
 }
 /**
  * Create a RAGStorage backed by a JSON file (lazy-loaded, cached in memory).
@@ -3379,6 +4031,8 @@ interface MCPAdapterConfig {
     debug?: boolean;
     /** Approval timeout in milliseconds (default: 300000 = 5 minutes) */
     approvalTimeoutMs?: number;
+    /** Allow callToolDirect() which bypasses all constraints (default: false) */
+    allowDirectCalls?: boolean;
 }
 /** Requirement to call an MCP tool */
 interface MCPCallToolRequirement {
@@ -4068,4 +4722,4 @@ interface OtelPlugin {
  */
 declare function createOtelPlugin(config: OtelPluginConfig): OtelPlugin;
 
-export { type ANNIndex, type ANNSearchResult, AdapterHooks, AgentHealthMetrics, type AgentInfo, AgentLike, type AgentMessage, type AgentMessageType, type AgentNetwork, type AgentNetworkConfig, AgentRunner, AgentState, AllProvidersFailedError, ApprovalState, type AuditEventType, type AuditInstance, type AuditPluginConfig, type BatchQueue, type BatchQueueConfig, type BidirectionalStream, type BudgetConfig, type BudgetExceededDetails, BudgetExceededError, type BudgetRunner, type BudgetWindow, type ComplianceConfig, type ComplianceInstance, type ComplianceStorage, type ConnectDevToolsOptions, type ConstraintRouterConfig, type ConstraintRouterRunner, type CreateRunnerOptions, DEFAULT_INJECTION_PATTERNS, DebugEvent, DebugTimeline, type DelegationMessage, type DelegationResultMessage, type DevToolsClient, type DevToolsClientMessage, type DevToolsCompatibleOrchestrator, type DevToolsServer, type DevToolsServerConfig, type DevToolsServerMessage, type DevToolsSnapshot, type DevToolsTransport, EmbedderFn, Embedding, type EnhancedPIIGuardrailOptions, type EvalAgentSummary, type EvalAssertOptions, type EvalCase, type EvalCaseResult, type EvalContext, type EvalCostOptions, type EvalCriterion, type EvalCriterionFn, type EvalJudgeOptions, type EvalLatencyOptions, type EvalMatchOptions, type EvalOutputLengthOptions, type EvalResults, type EvalSafetyOptions, type EvalScore, type EvalSemanticOptions, type EvalStructureOptions, type EvalSuite, type EvalSuiteConfig, ExecutionPattern, type FallbackConfig, type GoalAgentDeclaration, type GoalDependencyEdge, type GoalDependencyGraph, type GoalExecutionPlan, type GoalExplanation, type GoalExplanationStep, type GoalPlanStep, GoalResult, type GoalValidationResult, GuardrailFn, HealthMonitor, type InformMessage, InputGuardrailData, type JSONFileStoreOptions, type MCPAdapter, type MCPAdapterConfig, type MCPApprovalRequest, type MCPCallToolRequirement, type MCPGetPromptRequirement, type MCPReadResourceRequirement, type MCPRequirement, type MCPResource, type MCPServerConfig, type MCPSyncResourcesRequirement, type MCPTool, type MCPToolConstraint, type MCPToolResult, type MermaidDirection, type MermaidNodeShapes, type MermaidOptions, Message, type MessageBus, type MessageBusConfig, type MessageFilter, type MessageHandler, type ModelRule, type ModelSelectionConfig, type OtelPlugin, type OtelPluginConfig, type OtelSpan, OtelStatusCode, type OtelTracer, OutputGuardrailData, type ParsedResponse, type PromptInjectionGuardrailOptions, type ProviderStats, type QueryMessage, type RAGChunk, type RAGEnrichOptions, type RAGEnricher, type RAGEnricherConfig, type RAGStorage, type RateLimitGuardrail, type RequestMessage, type ResponseMessage, type RetryConfig, RetryExhaustedError, type RoutingConstraint, type RoutingFacts, type RoutingProvider, RunOptions, RunResult, type RunnerMiddleware, type SSEEvent, type SSETransport, type SSETransportConfig, STRICT_INJECTION_PATTERNS, SchemaValidator, SerializedPattern, type SpanData, type StreamChannel, type StreamChannelConfig, type StreamChannelState, type Subscription, type TokenPricing, ToolCallGuardrailData, type TypedAgentMessage, type UpdateMessage, type VPTreeIndexConfig, type WsTransportConfig, byAgentName, byInputLength, byPattern, connectDevTools, convertToolsForLLM, createAgentAuditHandlers, createAgentNetwork, createAuditTrail, createBatchQueue, createBidirectionalStream, createBruteForceIndex, createCompliance, createConstraintRouter, createContentFilterGuardrail, createDelegator, createDevToolsServer, createEnhancedPIIGuardrail, createEvalSuite, createInMemoryComplianceStorage, createJSONFileStore, createLengthGuardrail, createMCPAdapter, createMessageBus, createModerationGuardrail, createOtelPlugin, createOutputPIIGuardrail, createOutputSchemaGuardrail, createOutputTypeGuardrail, createPIIGuardrail, createPromptInjectionGuardrail, createPubSub, createRAGEnricher, createRateLimitGuardrail, createResponder, createRunner, createSSETransport, createStreamChannel, createToolGuardrail, createUntrustedContentGuardrail, createVPTreeIndex, createWsTransport, detectPII, detectPromptInjection, estimateCost, evalAssert, evalCoherence, evalCost, evalFaithfulness, evalJudge, evalLatency, evalMatch, evalOutputLength, evalRelevance, evalSafety, evalStructure, explainGoal, getDependencyGraph, hasPendingApprovals, isAgentRunning, markUntrustedContent, mcpCallTool, mcpGetPrompt, mcpReadResource, mcpSyncResources, mergeStreams, parseHttpStatus, parseRetryAfter, patternToMermaid, pipe, pipeThrough, planGoal, redactPII, sanitizeInjection, validateBaseURL, validateGoal, withBudget, withFallback, withModelSelection, withRetry };
+export { type ANNIndex, type ANNSearchResult, AdapterHooks, AgentHealthMetrics, type AgentInfo, AgentLike, type AgentMessage, type AgentMessageType, type AgentNetwork, type AgentNetworkConfig, AgentRegistry, AgentRunner, AgentSelectionStrategy, AgentState, AllProvidersFailedError, ApprovalState, type AuditEventType, type AuditInstance, type AuditPluginConfig, type BatchQueue, type BatchQueueConfig, type BidirectionalStream, type BudgetConfig, type BudgetExceededDetails, BudgetExceededError, type BudgetRunner, type BudgetWindow, type ComplianceConfig, type ComplianceInstance, type ComplianceStorage, type ConnectDevToolsOptions, type ConstraintRouterConfig, type ConstraintRouterRunner, type CreateRunnerOptions, DEFAULT_INJECTION_PATTERNS, DagExecutionContext, DagNode, DagPattern, type DebateConfig, DebatePattern, DebateResult, DebugEvent, DebugTimeline, type DelegationMessage, type DelegationResultMessage, type DevToolsClient, type DevToolsClientMessage, type DevToolsCompatibleOrchestrator, type DevToolsServer, type DevToolsServerConfig, type DevToolsServerMessage, type DevToolsSnapshot, type DevToolsTransport, EmbedderFn, Embedding, type EnhancedPIIGuardrailOptions, type EvalAgentSummary, type EvalAssertOptions, type EvalCase, type EvalCaseResult, type EvalContext, type EvalCostOptions, type EvalCriterion, type EvalCriterionFn, type EvalJudgeOptions, type EvalLatencyOptions, type EvalMatchOptions, type EvalOutputLengthOptions, type EvalResults, type EvalSafetyOptions, type EvalScore, type EvalSemanticOptions, type EvalStructureOptions, type EvalSuite, type EvalSuiteConfig, ExecutionPattern, type FallbackConfig, type GoalAgentDeclaration, type GoalDependencyEdge, type GoalDependencyGraph, type GoalExecutionPlan, type GoalExplanation, type GoalExplanationStep, GoalMetrics, GoalNode, GoalPattern, type GoalPlanStep, GoalResult, type GoalValidationResult, GuardrailFn, HealthMonitor, type InformMessage, InputGuardrailData, type JSONFileStoreOptions, type MCPAdapter, type MCPAdapterConfig, type MCPApprovalRequest, type MCPCallToolRequirement, type MCPGetPromptRequirement, type MCPReadResourceRequirement, type MCPRequirement, type MCPResource, type MCPServerConfig, type MCPSyncResourcesRequirement, type MCPTool, type MCPToolConstraint, type MCPToolResult, type MermaidDirection, type MermaidNodeShapes, type MermaidOptions, Message, type MessageBus, type MessageBusConfig, type MessageFilter, type MessageHandler, type ModelRule, type ModelSelectionConfig, MultiAgentOrchestrator, OrchestratorConstraint, type OtelPlugin, type OtelPluginConfig, type OtelSpan, OtelStatusCode, type OtelTracer, OutputGuardrailData, ParallelPattern, type ParsedResponse, PatternCheckpointConfig, type PromptInjectionGuardrailOptions, type ProviderStats, type QueryMessage, type RAGChunk, type RAGEnrichOptions, type RAGEnricher, type RAGEnricherConfig, type RAGStorage, RacePattern, type RateLimitGuardrail, ReflectIterationRecord, ReflectPattern, ReflectionEvaluation, RelaxationTier, type RequestMessage, type ResponseMessage, type RetryConfig, RetryExhaustedError, type RoutingConstraint, type RoutingFacts, type RoutingProvider, RunAgentRequirement, RunOptions, RunResult, type RunnerMiddleware, type SSEEvent, type SSETransport, type SSETransportConfig, STRICT_INJECTION_PATTERNS, SchemaValidator, SequentialPattern, type SerializedDagNode, type SerializedGoalNode, type SerializedPattern, type SpanData, type SpawnOnConditionOptions, type SpawnPoolConfig, type StreamChannel, type StreamChannelConfig, type StreamChannelState, type Subscription, SupervisorPattern, type TokenPricing, ToolCallGuardrailData, type TypedAgentMessage, type UpdateMessage, type VPTreeIndexConfig, type WsTransportConfig, aggregateTokens, allReadyStrategy, byAgentName, byInputLength, byPattern, capabilityRoute, collectOutputs, composePatterns, concatResults, connectDevTools, convertToolsForLLM, costEfficientStrategy, createAgentAuditHandlers, createAgentNetwork, createAuditTrail, createBatchQueue, createBidirectionalStream, createBruteForceIndex, createCompliance, createConstraintRouter, createContentFilterGuardrail, createDelegator, createDevToolsServer, createEnhancedPIIGuardrail, createEvalSuite, createInMemoryComplianceStorage, createJSONFileStore, createLengthGuardrail, createMCPAdapter, createMessageBus, createModerationGuardrail, createOtelPlugin, createOutputPIIGuardrail, createOutputSchemaGuardrail, createOutputTypeGuardrail, createPIIGuardrail, createPromptInjectionGuardrail, createPubSub, createRAGEnricher, createRateLimitGuardrail, createResponder, createRunner, createSSETransport, createStreamChannel, createToolGuardrail, createUntrustedContentGuardrail, createVPTreeIndex, createWsTransport, dag, debate, derivedConstraint, detectPII, detectPromptInjection, estimateCost, evalAssert, evalCoherence, evalCost, evalFaithfulness, evalJudge, evalLatency, evalMatch, evalOutputLength, evalRelevance, evalSafety, evalStructure, explainGoal, findAgentsByCapability, getDependencyGraph, goal, hasPendingApprovals, highestImpactStrategy, isAgentRunning, markUntrustedContent, mcpCallTool, mcpGetPrompt, mcpReadResource, mcpSyncResources, mergeStreams, parallel, parseHttpStatus, parseRetryAfter, patternFromJSON, patternToJSON, patternToMermaid, pickBestResult, pipe, pipeThrough, planGoal, race, redactPII, reflect, runAgentRequirement, runDebate, sanitizeInjection, selectAgent, sequential, spawnOnCondition, spawnPool, supervisor, validateBaseURL, validateGoal, withBudget, withFallback, withModelSelection, withRetry };