@directive-run/ai 0.4.1 → 0.5.0

package/dist/{multi-agent-orchestrator-CFOzWVNd.d.cts → multi-agent-orchestrator-kuAas1YW.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-D5veI9su.cjs';
+import { M as Message$1, k as RunResult, A as AgentLike, G as GuardrailFn, O as OutputGuardrailData, aX as StreamingCallbackRunner, n as DebugEvent, a7 as DebugEventType, b as AgentRunner, ay as OrchestratorState, at as NamedGuardrail, I as InputGuardrailData, N as Checkpoint, F as BreakpointModifications, H as BreakpointRequest, l as OrchestratorConstraint, aw as OrchestratorResolver, ai as GuardrailsConfig, w as ApprovalRequest, au as OrchestratorDebugConfig, t as AgentRetryConfig, av as OrchestratorLifecycleHooks, aU as SelfHealingConfig, Z as CheckpointStore, z as BreakpointConfig, al as HealthMonitorConfig, m as RunOptions, T as ToolCallGuardrailData, P as PatternCheckpointConfig, g as DagPattern, j as GoalPattern, h as GoalNode, e as AgentSelectionStrategy, R as RelaxationTier, o as GoalResult, aa as GoalCheckpointState, aV as SequentialCheckpointState, aY as SupervisorCheckpointState, aG as ReflectCheckpointState, a4 as DebateCheckpointState, a1 as DagCheckpointState, aS as Scratchpad, ar as MultiAgentLifecycleHooks, as as MultiAgentSelfHealingConfig, ap as MultiAgentBreakpointType, $ as CrossAgentDerivationFn, aA as PatternCheckpointState, U as CheckpointDiff, W as CheckpointProgress } from './types-BM-6xZf_.js';
 import { Plugin, System, Requirement } from '@directive-run/core';
 import { CircuitBreaker } from '@directive-run/core/plugins';
 
@@ -1902,652 +1902,5 @@ interface MultiAgentOrchestrator {
  * @public
  */
 declare function createMultiAgentOrchestrator(options: MultiAgentOrchestratorOptions): MultiAgentOrchestrator;
-/**
- * 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;
-/**
- * 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>>;
-/** 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>;
 
-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 };
+export { type SafeParseResult as $, type AgentRegistry as A, type BackpressureStrategy as B, type MessageSummarizer as C, type DebatePattern as D, type ExecutionPattern as E, type MultiAgentOrchestratorOptions as F, type GuardrailTriggeredChunk as G, type HealthMonitor as H, type MultiAgentRunCallOptions as I, type MultiAgentState as J, type MultiplexedStreamChunk as K, type MultiplexedStreamResult as L, type MultiAgentOrchestrator as M, type OrchestratorStreamChunk as N, type OrchestratorOptions as O, type ParallelPattern as P, type OrchestratorStreamResult as Q, type RacePattern as R, type SequentialPattern as S, type ProgressChunk as T, type RaceResult as U, type RaceSuccessEntry as V, type ReflectionConfig as W, type ReflectionContext as X, type ReflectionEvaluator as Y, ReflectionExhaustedError as Z, type RunCallOptions as _, type ReflectionEvaluation as a, type SafeParseable as a0, Semaphore as a1, type StreamChunk as a2, type StreamRunOptions as a3, type StreamRunner as a4, type StreamingGuardrail as a5, type StreamingGuardrailResult as a6, type StreamingRunResult as a7, type StructuredOutputConfig as a8, StructuredOutputError as a9, filterStream as aA, forkFromCheckpoint as aB, getCheckpointProgress as aC, getPatternStep as aD, mapStream as aE, mergeTaggedStreams as aF, tapStream as aG, withReflection as aH, withStructuredOutput as aI, type TaskContext as aa, type TaskRegistration as ab, type TokenChunk as ac, type ToolEndChunk as ad, type ToolStartChunk as ae, adaptOutputGuardrail as af, collectTokens as ag, combineStreamingGuardrails as ah, createAgentMemory as ai, createAgentOrchestrator as aj, createDebugTimeline as ak, createDebugTimelinePlugin as al, createHealthMonitor as am, createHybridStrategy as an, createKeyPointsSummarizer as ao, createLLMSummarizer as ap, createLengthStreamingGuardrail as aq, createMultiAgentOrchestrator as ar, createPatternStreamingGuardrail as as, createSlidingWindowStrategy as at, createStreamingRunner as au, createTokenBasedStrategy as av, createToxicityStreamingGuardrail as aw, createTruncationSummarizer as ax, diffCheckpoints as ay, extractJsonFromOutput as az, type ReflectIterationRecord as b, type ReflectPattern as c, type SupervisorPattern as d, type RunAgentRequirement as e, type DebateResult as f, type AgentHealthMetrics as g, type DebugTimeline as h, type AgentMemory as i, type AgentMemoryConfig as j, type AgentOrchestrator as k, type AgentRegistration as l, type DebugTimelineListener as m, type DebugTimelineOptions as n, type DoneChunk as o, type ErrorChunk as p, type HandoffRequest as q, type HandoffResult as r, type HealthCircuitState as s, type MemoryManageResult as t, type MemoryState as u, type MemoryStrategy as v, type MemoryStrategyConfig as w, type MemoryStrategyResult as x, type MergedTaggedStreamResult as y, type MessageChunk as z };

package/dist/ollama.d.cts

@@ -1,4 +1,4 @@
-import { a as AdapterHooks, b as AgentRunner } from './types-D5veI9su.cjs';
+import { a as AdapterHooks, b as AgentRunner } from './types-BM-6xZf_.cjs';
 import '@directive-run/core';
 
 /**