yaml-flow 2.4.0 → 2.5.0

package/README.md

@@ -983,6 +983,208 @@ const restored = restore(data);     // → LiveGraph (validates shape)
 
 ---
 
+## LLM Inference
+
+Pluggable AI-assisted completion detection. The caller provides the LLM via an `InferenceAdapter` — yaml-flow builds the prompt, parses the response, and applies the results. Core stays pure; inference is opt-in.
+
+```typescript
+import {
+  buildInferencePrompt, inferCompletions, applyInferences, inferAndApply,
+} from 'yaml-flow/inference';
+```
+
+### Inference Hints on Nodes
+
+Add optional `inference` metadata to any `TaskConfig`:
+
+```typescript
+const config = {
+  settings: { completion: 'all-tasks' },
+  tasks: {
+    'infra-provisioned': {
+      provides: ['infra-ready'],
+      inference: {
+        criteria: 'All Azure resources provisioned successfully',
+        keywords: ['azure', 'deployment', 'provisioning'],
+        suggestedChecks: ['scan logs for "Deployment Succeeded"'],
+        autoDetectable: true,   // LLM will analyze this node
+      },
+    },
+    'app-deployed': {
+      requires: ['infra-ready'],
+      provides: ['app-ready'],
+      inference: {
+        criteria: 'Health check returns HTTP 200',
+        autoDetectable: true,
+      },
+    },
+    'monitoring': {                         // no inference → LLM skips it
+      requires: ['app-ready'],
+      provides: ['monitored'],
+    },
+  },
+};
+```
+
+### Pluggable Adapter
+
+Implement one method — `analyze(prompt) → string`:
+
+```typescript
+import type { InferenceAdapter } from 'yaml-flow/inference';
+
+// OpenAI
+const openaiAdapter: InferenceAdapter = {
+  analyze: async (prompt) => {
+    const res = await openai.chat.completions.create({
+      model: 'gpt-4o', messages: [{ role: 'user', content: prompt }],
+    });
+    return res.choices[0].message.content ?? '[]';
+  },
+};
+
+// Anthropic
+const claudeAdapter: InferenceAdapter = {
+  analyze: async (prompt) => {
+    const res = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514', max_tokens: 1024,
+      messages: [{ role: 'user', content: prompt }],
+    });
+    return res.content[0].type === 'text' ? res.content[0].text : '[]';
+  },
+};
+
+// Any HTTP endpoint
+const customAdapter: InferenceAdapter = {
+  analyze: async (prompt) => {
+    const res = await fetch('https://my-llm/analyze', {
+      method: 'POST', body: JSON.stringify({ prompt }),
+    });
+    return (await res.json()).response;
+  },
+};
+```
+
+### Built-in Adapter Factories
+
+Zero-boilerplate adapters for common patterns:
+
+```typescript
+import { createCliAdapter, createHttpAdapter } from 'yaml-flow/inference';
+
+// Ollama via HTTP
+const ollama = createHttpAdapter({
+  url: 'http://localhost:11434/api/generate',
+  buildBody: (prompt) => ({ model: 'llama3', prompt, stream: false }),
+  extractResponse: (json) => json.response,
+});
+
+// Ollama via CLI
+const ollamaCli = createCliAdapter({
+  command: 'ollama',
+  args: (prompt) => ['run', 'llama3', prompt],
+});
+
+// Simon Willison's llm CLI (stdin mode for long prompts)
+const llm = createCliAdapter({
+  command: 'llm',
+  args: () => ['--no-stream'],
+  stdin: true,
+});
+
+// Custom Python script
+const custom = createCliAdapter({
+  command: 'python',
+  args: (prompt) => ['scripts/infer.py', '--json', prompt],
+  cwd: '/path/to/project',
+  env: { MODEL: 'gpt-4o' },
+  timeout: 60_000,
+});
+```
+
+**`createCliAdapter(options)`** — spawns a child process, captures stdout:
+| Option | Type | Description |
+|--------|------|-------------|
+| `command` | `string` | Executable to run (`ollama`, `llm`, `python`, `gh`, …) |
+| `args` | `(prompt) => string[]` | Build argument list from the prompt |
+| `stdin` | `boolean` | Pipe prompt via stdin instead of args (default: `false`) |
+| `timeout` | `number` | Kill after N ms (default: `30000`) |
+| `cwd` | `string` | Working directory |
+| `env` | `Record<string, string>` | Extra environment variables |
+
+**`createHttpAdapter(options)`** — POSTs to an HTTP endpoint:
+| Option | Type | Description |
+|--------|------|-------------|
+| `url` | `string` | Endpoint URL |
+| `headers` | `Record<string, string>` | Request headers |
+| `buildBody` | `(prompt) => object` | Build request body (default: `{ prompt }`) |
+| `extractResponse` | `(json) => string` | Extract text from response JSON |
+| `timeout` | `number` | Abort after N ms (default: `30000`) |
+```
+
+### Three APIs: Build → Suggest → Apply
+
+```typescript
+import { createLiveGraph } from 'yaml-flow/continuous-event-graph';
+import { buildInferencePrompt, inferCompletions, applyInferences } from 'yaml-flow/inference';
+
+let live = createLiveGraph(config);
+
+// 1. BUILD: Generate the prompt (pure, sync)
+const prompt = buildInferencePrompt(live, {
+  context: 'Deployment log: "Deployment Succeeded", health check: HTTP 200',
+});
+
+// 2. SUGGEST: Ask the LLM (async)
+const result = await inferCompletions(live, adapter, {
+  threshold: 0.8,
+  context: 'Deployment log: ...',
+});
+result.suggestions;  // [{ taskName, confidence, reasoning, detectionMethod }]
+
+// 3. APPLY: Accept high-confidence suggestions (pure, sync)
+live = applyInferences(live, result, 0.8);  // only applies >= 80% confidence
+```
+
+### One-Shot Convenience
+
+```typescript
+import { inferAndApply } from 'yaml-flow/inference';
+
+const { live: updated, applied, skipped, inference } = await inferAndApply(
+  live, adapter, { threshold: 0.8, context: 'deployment logs...' }
+);
+
+console.log('Auto-completed:', applied.map(s => s.taskName));
+console.log('Skipped (low confidence):', skipped.map(s => `${s.taskName} (${s.confidence})`));
+```
+
+### Inference API Reference
+
+| Function | Description |
+|---|---|
+| `buildInferencePrompt(live, opts?)` | Build LLM prompt from graph state (pure, sync) |
+| `inferCompletions(live, adapter, opts?)` | Ask LLM to suggest completions (async) |
+| `applyInferences(live, result, threshold?)` | Apply suggestions above threshold (pure, sync) |
+| `inferAndApply(live, adapter, opts?)` | Infer + apply in one step (async, convenience) |
+| `createCliAdapter(opts)` | Factory: adapter that spawns a CLI command |
+| `createHttpAdapter(opts)` | Factory: adapter that POSTs to an HTTP endpoint |
+
+### Inference Types
+
+| Type | Description |
+|---|---|
+| `InferenceAdapter` | `{ analyze(prompt: string): Promise<string> }` — pluggable LLM bridge |
+| `InferenceHints` | `criteria`, `keywords`, `suggestedChecks`, `autoDetectable` on a TaskConfig |
+| `InferenceOptions` | `threshold`, `scope`, `context`, `systemPrompt` |
+| `InferenceResult` | `suggestions[]`, `promptUsed`, `rawResponse`, `analyzedNodes` |
+| `InferredCompletion` | `taskName`, `confidence`, `reasoning`, `detectionMethod: 'llm-inferred'` |
+| `InferAndApplyResult` | `live`, `inference`, `applied[]`, `skipped[]` |
+| `CliAdapterOptions` | `command`, `args`, `stdin`, `timeout`, `cwd`, `env` |
+| `HttpAdapterOptions` | `url`, `headers`, `buildBody`, `extractResponse`, `timeout` |
+
+---
+
 ## Loading & Exporting Graph Configs
 
 ```typescript
@@ -1041,6 +1243,12 @@ import {
   getUpstream, getDownstream,
 } from 'yaml-flow/continuous-event-graph';
 
+// LLM Inference (AI-assisted completion detection)
+import {
+  buildInferencePrompt, inferCompletions, applyInferences, inferAndApply,
+} from 'yaml-flow/inference';
+import type { InferenceAdapter, InferenceResult, InferenceOptions } from 'yaml-flow/inference';
+
 // Backward compatibility (v1 names → v2)
 import { FlowEngine, createEngine } from 'yaml-flow';  // aliases for StepMachine, createStepMachine
 ```
@@ -1113,6 +1321,10 @@ See the [examples/](./examples) directory:
 | [URL Pipeline](./examples/graph-of-graphs/url-processing-pipeline.ts) | Graph-of-Graphs | Outer event-graph → batch × inner event-graph per item |
 | [Multi-Stage ETL](./examples/graph-of-graphs/multi-stage-etl.ts) | Graph-of-Graphs | Mixed modes: event-graph outer → step-machine + event-graph subs |
 | [Stock Dashboard](./examples/continuous-event-graph/stock-dashboard.ts) | Continuous Event Graph | Runtime mutations, token drain, upstream/downstream, snapshot |
+| [Azure Deployment](./examples/inference/azure-deployment.ts) | Inference | LLM analyzes deployment logs, auto-completes checkpoints |
+| [Data Pipeline](./examples/inference/data-pipeline.ts) | Inference | Iterative inference — evidence arrives in waves |
+| [Pluggable Adapters](./examples/inference/pluggable-adapters.ts) | Inference | OpenAI, Anthropic, Azure, CLI, HTTP adapter factories |
+| [Copilot CLI](./examples/inference/copilot-cli.ts) | Inference | GitHub Copilot CLI as inference adapter via `createCliAdapter` |
 | [Order Processing](./examples/flows/order-processing.yaml) | Step Machine | YAML flow definition |
 | [Browser Demo](./examples/browser/index.html) | Step Machine | In-browser usage |
 

package/dist/{constants-DcCDDQON.d.ts → constants-BEbO2_OK.d.ts}

@@ -1,4 +1,4 @@
-import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-CTu8RqY0.js';
+import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-DAI_a2as.js';
 import { e as StepFlowConfig } from './types-FZ_eyErS.js';
 
 /**

package/dist/{constants-Dbk6ArN5.d.cts → constants-BNjeIlZ8.d.cts}

@@ -1,4 +1,4 @@
-import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-CTu8RqY0.cjs';
+import { G as GraphConfig, c as ExecutionState, S as SchedulerResult, e as GraphEvent, T as TaskConfig, l as TaskState, g as StuckDetection, C as CompletionStrategy, a as ConflictStrategy, b as ExecutionMode, d as ExecutionStatus, m as TaskStatus } from './types-DAI_a2as.cjs';
 import { e as StepFlowConfig } from './types-FZ_eyErS.cjs';
 
 /**

package/dist/continuous-event-graph/index.d.cts

@@ -1,137 +1,7 @@
-import { G as GraphConfig, c as ExecutionState, T as TaskConfig, l as TaskState, e as GraphEvent } from '../types-CTu8RqY0.cjs';
-export { f as GraphSettings } from '../types-CTu8RqY0.cjs';
-
-/**
- * Continuous Event Graph — Types
- *
- * A long-lived, evolving event-graph where both config and state
- * mutate over time. The single `LiveGraph` type bundles them.
- *
- * Events are shared with event-graph (task-started, task-completed, etc.).
- * Graph mutations (addNode, removeNode, etc.) are unique to this mode.
- */
-
-/**
- * The single evolving object for a continuous-mode graph.
- * Bundles config + state so they can't get out of sync.
- */
-interface LiveGraph {
-    /** The current graph configuration (evolves as nodes are added/removed) */
-    config: GraphConfig;
-    /** The current execution state (evolves as events arrive) */
-    state: ExecutionState;
-}
-interface ScheduleResult {
-    /** Tasks ready to dispatch now — all requires satisfied */
-    eligible: string[];
-    /** Tasks waiting on tokens that some producer will eventually provide (normal) */
-    pending: PendingTask[];
-    /** Tasks waiting on tokens that NO task can produce (caller's problem) */
-    unresolved: UnresolvedDependency[];
-    /** Tasks waiting on tokens whose producer FAILED (caller's problem) */
-    blocked: BlockedTask[];
-    /** Token conflicts: multiple tasks produce the same token */
-    conflicts: Record<string, string[]>;
-}
-interface PendingTask {
-    taskName: string;
-    /** Tokens this task needs that haven't been produced yet but have a viable producer */
-    waitingOn: string[];
-}
-interface UnresolvedDependency {
-    taskName: string;
-    /** Tokens this task needs that no task in the graph can produce */
-    missingTokens: string[];
-}
-interface BlockedTask {
-    taskName: string;
-    /** Tokens this task needs whose only producer has failed */
-    failedTokens: string[];
-    /** The tasks that failed and would have produced those tokens */
-    failedProducers: string[];
-}
-interface LiveGraphHealth {
-    /** Total number of tasks in the graph */
-    totalNodes: number;
-    /** Task counts by status */
-    running: number;
-    completed: number;
-    failed: number;
-    waiting: number;
-    notStarted: number;
-    /** Number of disabled (inactivated) nodes */
-    disabled: number;
-    /** Number of tasks with unresolvable dependencies */
-    unresolvedCount: number;
-    /** Number of tasks whose producer has failed */
-    blockedCount: number;
-    /** Tokens that no task produces (open dependencies) */
-    openDependencies: string[];
-    /** Cycles detected in the current graph (if any) */
-    cycles: string[][];
-    /** Tokens produced by multiple tasks */
-    conflictTokens: string[];
-}
-interface NodeInfo {
-    /** Node name */
-    name: string;
-    /** The task configuration */
-    config: TaskConfig;
-    /** The current runtime state */
-    state: TaskState;
-}
-interface LiveGraphSnapshot {
-    /** Schema version for forward compatibility */
-    version: number;
-    /** The graph config at snapshot time */
-    config: GraphConfig;
-    /** The execution state at snapshot time */
-    state: ExecutionState;
-    /** ISO timestamp of when the snapshot was taken */
-    snapshotAt: string;
-}
-interface UnreachableTokensResult {
-    tokens: {
-        /** The token that cannot be produced */
-        token: string;
-        /** Why it's unreachable */
-        reason: 'no-producer' | 'all-producers-failed' | 'transitive';
-        /** Tasks that could produce it (but are themselves unreachable/failed) */
-        producers: string[];
-    }[];
-}
-interface UnreachableNodesResult {
-    nodes: {
-        /** The node that can never become eligible */
-        nodeName: string;
-        /** Unreachable tokens this node requires (empty if the node itself is failed/disabled) */
-        missingTokens: string[];
-    }[];
-}
-interface UpstreamResult {
-    /** The target node being inspected */
-    nodeName: string;
-    /** All upstream nodes that transitively feed into the target */
-    nodes: {
-        nodeName: string;
-        /** Tokens this node provides that are in the dependency chain */
-        providesTokens: string[];
-    }[];
-    /** All tokens in the upstream dependency chain */
-    tokens: string[];
-}
-interface DownstreamResult {
-    /** The target node being inspected */
-    nodeName: string;
-    /** All downstream nodes that transitively depend on the target */
-    nodes: {
-        nodeName: string;
-        /** Tokens this node requires that are in the dependency chain */
-        requiresTokens: string[];
-    }[];
-    /** All tokens in the downstream dependency chain */
-    tokens: string[];
-}
+import { L as LiveGraph, N as NodeInfo, b as LiveGraphSnapshot, S as ScheduleResult, D as DownstreamResult, U as UnreachableNodesResult, c as UnreachableTokensResult, e as UpstreamResult, a as LiveGraphHealth } from '../types-C2lOwquM.cjs';
+export { B as BlockedTask, P as PendingTask, d as UnresolvedDependency } from '../types-C2lOwquM.cjs';
+import { T as TaskConfig, e as GraphEvent, G as GraphConfig } from '../types-DAI_a2as.cjs';
+export { c as ExecutionState, f as GraphSettings, l as TaskState } from '../types-DAI_a2as.cjs';
 
 /**
  * Continuous Event Graph — Core
@@ -306,4 +176,4 @@ declare function getUpstream(live: LiveGraph, nodeName: string): UpstreamResult;
  */
 declare function getDownstream(live: LiveGraph, nodeName: string): DownstreamResult;
 
-export { type BlockedTask, type DownstreamResult, ExecutionState, GraphConfig, GraphEvent, type LiveGraph, type LiveGraphHealth, type LiveGraphSnapshot, type NodeInfo, type PendingTask, type ScheduleResult, TaskConfig, TaskState, type UnreachableNodesResult, type UnreachableTokensResult, type UnresolvedDependency, type UpstreamResult, addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot };
+export { DownstreamResult, GraphConfig, GraphEvent, LiveGraph, LiveGraphHealth, LiveGraphSnapshot, NodeInfo, ScheduleResult, TaskConfig, UnreachableNodesResult, UnreachableTokensResult, UpstreamResult, addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot };

package/dist/continuous-event-graph/index.d.ts

@@ -1,137 +1,7 @@
-import { G as GraphConfig, c as ExecutionState, T as TaskConfig, l as TaskState, e as GraphEvent } from '../types-CTu8RqY0.js';
-export { f as GraphSettings } from '../types-CTu8RqY0.js';
-
-/**
- * Continuous Event Graph — Types
- *
- * A long-lived, evolving event-graph where both config and state
- * mutate over time. The single `LiveGraph` type bundles them.
- *
- * Events are shared with event-graph (task-started, task-completed, etc.).
- * Graph mutations (addNode, removeNode, etc.) are unique to this mode.
- */
-
-/**
- * The single evolving object for a continuous-mode graph.
- * Bundles config + state so they can't get out of sync.
- */
-interface LiveGraph {
-    /** The current graph configuration (evolves as nodes are added/removed) */
-    config: GraphConfig;
-    /** The current execution state (evolves as events arrive) */
-    state: ExecutionState;
-}
-interface ScheduleResult {
-    /** Tasks ready to dispatch now — all requires satisfied */
-    eligible: string[];
-    /** Tasks waiting on tokens that some producer will eventually provide (normal) */
-    pending: PendingTask[];
-    /** Tasks waiting on tokens that NO task can produce (caller's problem) */
-    unresolved: UnresolvedDependency[];
-    /** Tasks waiting on tokens whose producer FAILED (caller's problem) */
-    blocked: BlockedTask[];
-    /** Token conflicts: multiple tasks produce the same token */
-    conflicts: Record<string, string[]>;
-}
-interface PendingTask {
-    taskName: string;
-    /** Tokens this task needs that haven't been produced yet but have a viable producer */
-    waitingOn: string[];
-}
-interface UnresolvedDependency {
-    taskName: string;
-    /** Tokens this task needs that no task in the graph can produce */
-    missingTokens: string[];
-}
-interface BlockedTask {
-    taskName: string;
-    /** Tokens this task needs whose only producer has failed */
-    failedTokens: string[];
-    /** The tasks that failed and would have produced those tokens */
-    failedProducers: string[];
-}
-interface LiveGraphHealth {
-    /** Total number of tasks in the graph */
-    totalNodes: number;
-    /** Task counts by status */
-    running: number;
-    completed: number;
-    failed: number;
-    waiting: number;
-    notStarted: number;
-    /** Number of disabled (inactivated) nodes */
-    disabled: number;
-    /** Number of tasks with unresolvable dependencies */
-    unresolvedCount: number;
-    /** Number of tasks whose producer has failed */
-    blockedCount: number;
-    /** Tokens that no task produces (open dependencies) */
-    openDependencies: string[];
-    /** Cycles detected in the current graph (if any) */
-    cycles: string[][];
-    /** Tokens produced by multiple tasks */
-    conflictTokens: string[];
-}
-interface NodeInfo {
-    /** Node name */
-    name: string;
-    /** The task configuration */
-    config: TaskConfig;
-    /** The current runtime state */
-    state: TaskState;
-}
-interface LiveGraphSnapshot {
-    /** Schema version for forward compatibility */
-    version: number;
-    /** The graph config at snapshot time */
-    config: GraphConfig;
-    /** The execution state at snapshot time */
-    state: ExecutionState;
-    /** ISO timestamp of when the snapshot was taken */
-    snapshotAt: string;
-}
-interface UnreachableTokensResult {
-    tokens: {
-        /** The token that cannot be produced */
-        token: string;
-        /** Why it's unreachable */
-        reason: 'no-producer' | 'all-producers-failed' | 'transitive';
-        /** Tasks that could produce it (but are themselves unreachable/failed) */
-        producers: string[];
-    }[];
-}
-interface UnreachableNodesResult {
-    nodes: {
-        /** The node that can never become eligible */
-        nodeName: string;
-        /** Unreachable tokens this node requires (empty if the node itself is failed/disabled) */
-        missingTokens: string[];
-    }[];
-}
-interface UpstreamResult {
-    /** The target node being inspected */
-    nodeName: string;
-    /** All upstream nodes that transitively feed into the target */
-    nodes: {
-        nodeName: string;
-        /** Tokens this node provides that are in the dependency chain */
-        providesTokens: string[];
-    }[];
-    /** All tokens in the upstream dependency chain */
-    tokens: string[];
-}
-interface DownstreamResult {
-    /** The target node being inspected */
-    nodeName: string;
-    /** All downstream nodes that transitively depend on the target */
-    nodes: {
-        nodeName: string;
-        /** Tokens this node requires that are in the dependency chain */
-        requiresTokens: string[];
-    }[];
-    /** All tokens in the downstream dependency chain */
-    tokens: string[];
-}
+import { L as LiveGraph, N as NodeInfo, b as LiveGraphSnapshot, S as ScheduleResult, D as DownstreamResult, U as UnreachableNodesResult, c as UnreachableTokensResult, e as UpstreamResult, a as LiveGraphHealth } from '../types-mS_pPftm.js';
+export { B as BlockedTask, P as PendingTask, d as UnresolvedDependency } from '../types-mS_pPftm.js';
+import { T as TaskConfig, e as GraphEvent, G as GraphConfig } from '../types-DAI_a2as.js';
+export { c as ExecutionState, f as GraphSettings, l as TaskState } from '../types-DAI_a2as.js';
 
 /**
  * Continuous Event Graph — Core
@@ -306,4 +176,4 @@ declare function getUpstream(live: LiveGraph, nodeName: string): UpstreamResult;
  */
 declare function getDownstream(live: LiveGraph, nodeName: string): DownstreamResult;
 
-export { type BlockedTask, type DownstreamResult, ExecutionState, GraphConfig, GraphEvent, type LiveGraph, type LiveGraphHealth, type LiveGraphSnapshot, type NodeInfo, type PendingTask, type ScheduleResult, TaskConfig, TaskState, type UnreachableNodesResult, type UnreachableTokensResult, type UnresolvedDependency, type UpstreamResult, addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot };
+export { DownstreamResult, GraphConfig, GraphEvent, LiveGraph, LiveGraphHealth, LiveGraphSnapshot, NodeInfo, ScheduleResult, TaskConfig, UnreachableNodesResult, UnreachableTokensResult, UpstreamResult, addNode, addProvides, addRequires, applyEvent, createLiveGraph, disableNode, drainTokens, enableNode, getDownstream, getNode, getUnreachableNodes, getUnreachableTokens, getUpstream, injectTokens, inspect, removeNode, removeProvides, removeRequires, resetNode, restore, schedule, snapshot };

package/dist/event-graph/index.d.cts

@@ -1,6 +1,6 @@
-export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, N as addKeyToProvides, O as addKeyToRequires, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, P as getRepeatableMax, t as getRequires, u as getTask, v as graphToMermaid, Q as groupTasksByProvides, R as hasOutputConflict, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, S as removeKeyFromProvides, U as removeKeyFromRequires, K as validateGraph, L as validateGraphConfig } from '../constants-Dbk6ArN5.cjs';
-import { T as TaskConfig, c as ExecutionState, a as ConflictStrategy, G as GraphConfig } from '../types-CTu8RqY0.cjs';
-export { A as AgentActionEvent, C as CompletionStrategy, E as ExecutionConfig, b as ExecutionMode, d as ExecutionStatus, e as GraphEvent, f as GraphSettings, I as InjectTokensEvent, R as RepeatableConfig, S as SchedulerResult, g as StuckDetection, n as TaskCircuitBreakerConfig, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, o as TaskMessage, p as TaskProgressEvent, q as TaskRetryConfig, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from '../types-CTu8RqY0.cjs';
+export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, N as addKeyToProvides, O as addKeyToRequires, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, P as getRepeatableMax, t as getRequires, u as getTask, v as graphToMermaid, Q as groupTasksByProvides, R as hasOutputConflict, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, S as removeKeyFromProvides, U as removeKeyFromRequires, K as validateGraph, L as validateGraphConfig } from '../constants-BNjeIlZ8.cjs';
+import { T as TaskConfig, c as ExecutionState, a as ConflictStrategy, G as GraphConfig } from '../types-DAI_a2as.cjs';
+export { A as AgentActionEvent, C as CompletionStrategy, E as ExecutionConfig, b as ExecutionMode, d as ExecutionStatus, e as GraphEvent, f as GraphSettings, I as InjectTokensEvent, R as RepeatableConfig, S as SchedulerResult, g as StuckDetection, n as TaskCircuitBreakerConfig, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, o as TaskMessage, p as TaskProgressEvent, q as TaskRetryConfig, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from '../types-DAI_a2as.cjs';
 import '../types-FZ_eyErS.cjs';
 
 /**

package/dist/event-graph/index.d.ts

@@ -1,6 +1,6 @@
-export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, N as addKeyToProvides, O as addKeyToRequires, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, P as getRepeatableMax, t as getRequires, u as getTask, v as graphToMermaid, Q as groupTasksByProvides, R as hasOutputConflict, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, S as removeKeyFromProvides, U as removeKeyFromRequires, K as validateGraph, L as validateGraphConfig } from '../constants-DcCDDQON.js';
-import { T as TaskConfig, c as ExecutionState, a as ConflictStrategy, G as GraphConfig } from '../types-CTu8RqY0.js';
-export { A as AgentActionEvent, C as CompletionStrategy, E as ExecutionConfig, b as ExecutionMode, d as ExecutionStatus, e as GraphEvent, f as GraphSettings, I as InjectTokensEvent, R as RepeatableConfig, S as SchedulerResult, g as StuckDetection, n as TaskCircuitBreakerConfig, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, o as TaskMessage, p as TaskProgressEvent, q as TaskRetryConfig, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from '../types-CTu8RqY0.js';
+export { C as COMPLETION_STRATEGIES, a as CONFLICT_STRATEGIES, b as CompletionResult, D as DEFAULTS, E as EXECUTION_MODES, c as EXECUTION_STATUS, d as ExecutionPlan, e as ExportOptions, G as GraphIssue, f as GraphValidationResult, I as IssueSeverity, M as MermaidOptions, T as TASK_STATUS, g as addDynamicTask, N as addKeyToProvides, O as addKeyToRequires, h as apply, i as applyAll, j as computeAvailableOutputs, k as createDefaultTaskState, l as createInitialExecutionState, m as detectStuckState, n as exportGraphConfig, o as exportGraphConfigToFile, p as flowToMermaid, q as getAllTasks, r as getCandidateTasks, s as getProvides, P as getRepeatableMax, t as getRequires, u as getTask, v as graphToMermaid, Q as groupTasksByProvides, R as hasOutputConflict, w as hasTask, x as isExecutionComplete, y as isNonActiveTask, z as isRepeatableTask, A as isTaskCompleted, B as isTaskRunning, F as loadGraphConfig, H as next, J as planExecution, S as removeKeyFromProvides, U as removeKeyFromRequires, K as validateGraph, L as validateGraphConfig } from '../constants-BEbO2_OK.js';
+import { T as TaskConfig, c as ExecutionState, a as ConflictStrategy, G as GraphConfig } from '../types-DAI_a2as.js';
+export { A as AgentActionEvent, C as CompletionStrategy, E as ExecutionConfig, b as ExecutionMode, d as ExecutionStatus, e as GraphEvent, f as GraphSettings, I as InjectTokensEvent, R as RepeatableConfig, S as SchedulerResult, g as StuckDetection, n as TaskCircuitBreakerConfig, h as TaskCompletedEvent, i as TaskCreationEvent, j as TaskFailedEvent, o as TaskMessage, p as TaskProgressEvent, q as TaskRetryConfig, k as TaskStartedEvent, l as TaskState, m as TaskStatus } from '../types-DAI_a2as.js';
 import '../types-FZ_eyErS.js';
 
 /**