yaml-flow 2.4.0 → 2.6.0

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var child_process = require('child_process');
+
 // src/step-machine/reducer.ts
 function applyStepResult(flow, state, stepName, stepResult) {
   const stepConfig = flow.steps[stepName];
@@ -253,7 +255,7 @@ var StepMachine = class {
     }
   }
   sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
   async run(initialData) {
     const runId = generateRunId();
@@ -2155,7 +2157,7 @@ async function batch(items, options) {
   if (total === 0) {
     return { items: [], completed: 0, failed: 0, total: 0, durationMs: 0 };
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let active = 0;
     function tryStartNext() {
       while (active < concurrency && nextIndex < total) {
@@ -2172,7 +2174,7 @@ async function batch(items, options) {
             failed++;
           }
           if (active === 0 && completed + failed === total) {
-            resolve({
+            resolve2({
               items: results,
               completed,
               failed,
@@ -2211,7 +2213,7 @@ async function batch(items, options) {
           active--;
           onProgress?.(makeProgress(active));
           if (completed + failed === total) {
-            resolve({
+            resolve2({
               items: results,
               completed,
               failed,
@@ -3029,8 +3031,575 @@ function getDownstream(live, nodeName) {
   return { nodeName, nodes, tokens: [...tokenSet] };
 }
 
+// src/inference/core.ts
+var DEFAULT_THRESHOLD = 0.5;
+var DEFAULT_SYSTEM_PROMPT = `You are a workflow completion analyzer. Given a graph of tasks with their current states, evidence, and inference hints, determine which tasks appear to be completed based on the available evidence.
+
+For each task you analyze, provide a JSON response. Be conservative \u2014 only mark tasks as completed when the evidence strongly supports it.`;
+function buildInferencePrompt(live, options = {}) {
+  const { scope, context, systemPrompt } = options;
+  const graphTasks = getAllTasks(live.config);
+  const { state } = live;
+  const candidates = getAnalyzableCandidates(live, scope);
+  if (candidates.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push(systemPrompt || DEFAULT_SYSTEM_PROMPT);
+  lines.push("");
+  lines.push("## Graph State");
+  lines.push("");
+  lines.push(`Available tokens: ${state.availableOutputs.length > 0 ? state.availableOutputs.join(", ") : "(none)"}`);
+  lines.push("");
+  const completedTasks = Object.entries(state.tasks).filter(([_, ts]) => ts.status === "completed").map(([name]) => name);
+  if (completedTasks.length > 0) {
+    lines.push(`Completed tasks: ${completedTasks.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("## Tasks to Analyze");
+  lines.push("");
+  for (const taskName of candidates) {
+    const taskConfig = graphTasks[taskName];
+    const taskState = state.tasks[taskName];
+    lines.push(`### ${taskName}`);
+    if (taskConfig.description) {
+      lines.push(`Description: ${taskConfig.description}`);
+    }
+    const requires = getRequires(taskConfig);
+    const provides = getProvides(taskConfig);
+    if (requires.length > 0) lines.push(`Requires: ${requires.join(", ")}`);
+    if (provides.length > 0) lines.push(`Provides: ${provides.join(", ")}`);
+    lines.push(`Current status: ${taskState?.status || "not-started"}`);
+    const hints = taskConfig.inference;
+    if (hints) {
+      if (hints.criteria) lines.push(`Completion criteria: ${hints.criteria}`);
+      if (hints.keywords?.length) lines.push(`Keywords: ${hints.keywords.join(", ")}`);
+      if (hints.suggestedChecks?.length) lines.push(`Suggested checks: ${hints.suggestedChecks.join("; ")}`);
+    }
+    lines.push("");
+  }
+  if (context) {
+    lines.push("## Additional Context / Evidence");
+    lines.push("");
+    lines.push(context);
+    lines.push("");
+  }
+  lines.push("## Response Format");
+  lines.push("");
+  lines.push("Respond with a JSON array of objects, one per task you have evidence for:");
+  lines.push("```json");
+  lines.push("[");
+  lines.push("  {");
+  lines.push('    "taskName": "task-name",');
+  lines.push('    "confidence": 0.0 to 1.0,');
+  lines.push('    "reasoning": "explanation of why you believe this task is complete or not"');
+  lines.push("  }");
+  lines.push("]");
+  lines.push("```");
+  lines.push("");
+  lines.push("Rules:");
+  lines.push('- Only include tasks from the "Tasks to Analyze" section');
+  lines.push("- confidence 0.0 = no evidence of completion, 1.0 = certain it is complete");
+  lines.push("- If you have no evidence for a task, omit it from the array");
+  lines.push("- Be conservative \u2014 require clear evidence before high confidence");
+  lines.push("- Respond ONLY with the JSON array, no additional text");
+  return lines.join("\n");
+}
+async function inferCompletions(live, adapter, options = {}) {
+  options.threshold ?? DEFAULT_THRESHOLD;
+  const analyzedNodes = getAnalyzableCandidates(live, options.scope);
+  if (analyzedNodes.length === 0) {
+    return { suggestions: [], promptUsed: "", rawResponse: "", analyzedNodes: [] };
+  }
+  const prompt = buildInferencePrompt(live, options);
+  const rawResponse = await adapter.analyze(prompt);
+  const suggestions = parseInferenceResponse(rawResponse, analyzedNodes);
+  return {
+    suggestions,
+    promptUsed: prompt,
+    rawResponse,
+    analyzedNodes
+  };
+}
+function applyInferences(live, result, threshold = DEFAULT_THRESHOLD) {
+  let current = live;
+  for (const suggestion of result.suggestions) {
+    if (suggestion.confidence < threshold) continue;
+    const taskState = current.state.tasks[suggestion.taskName];
+    if (!taskState) continue;
+    if (taskState.status === "completed" || taskState.status === "running") continue;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    current = applyEvent(current, {
+      type: "task-started",
+      taskName: suggestion.taskName,
+      timestamp: now
+    });
+    current = applyEvent(current, {
+      type: "task-completed",
+      taskName: suggestion.taskName,
+      timestamp: now,
+      result: "llm-inferred"
+    });
+  }
+  return current;
+}
+async function inferAndApply(live, adapter, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const inference = await inferCompletions(live, adapter, options);
+  const updated = applyInferences(live, inference, threshold);
+  const applied = inference.suggestions.filter((s) => s.confidence >= threshold);
+  const skipped = inference.suggestions.filter((s) => s.confidence < threshold);
+  return {
+    live: updated,
+    inference,
+    applied,
+    skipped
+  };
+}
+function getAnalyzableCandidates(live, scope) {
+  const graphTasks = getAllTasks(live.config);
+  const { state } = live;
+  const candidates = [];
+  for (const [name, config] of Object.entries(graphTasks)) {
+    const taskState = state.tasks[name];
+    if (taskState?.status === "completed" || taskState?.status === "running") continue;
+    if (scope) {
+      if (scope.includes(name)) candidates.push(name);
+    } else {
+      if (config.inference?.autoDetectable) candidates.push(name);
+    }
+  }
+  return candidates;
+}
+function parseInferenceResponse(rawResponse, validNodes, _threshold) {
+  const validSet = new Set(validNodes);
+  try {
+    const jsonStr = extractJson(rawResponse);
+    if (!jsonStr) return [];
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) return [];
+    const suggestions = [];
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      if (typeof item.taskName !== "string") continue;
+      if (typeof item.confidence !== "number") continue;
+      if (!validSet.has(item.taskName)) continue;
+      const confidence = Math.max(0, Math.min(1, item.confidence));
+      suggestions.push({
+        taskName: item.taskName,
+        confidence,
+        reasoning: typeof item.reasoning === "string" ? item.reasoning : "",
+        detectionMethod: "llm-inferred"
+      });
+    }
+    return suggestions;
+  } catch {
+    return [];
+  }
+}
+function extractJson(text) {
+  if (!text || typeof text !== "string") return null;
+  const trimmed = text.trim();
+  const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (fenceMatch) return fenceMatch[1].trim();
+  const firstBracket = trimmed.indexOf("[");
+  const lastBracket = trimmed.lastIndexOf("]");
+  if (firstBracket !== -1 && lastBracket > firstBracket) {
+    return trimmed.slice(firstBracket, lastBracket + 1);
+  }
+  if (trimmed.startsWith("[")) return trimmed;
+  return null;
+}
+function createCliAdapter(opts) {
+  const timeout = opts.timeout ?? 6e4;
+  return {
+    analyze: (prompt) => {
+      return new Promise((resolve2, reject) => {
+        const args = opts.args(prompt);
+        const child = child_process.execFile(
+          opts.command,
+          opts.stdin ? opts.args("") : args,
+          {
+            timeout,
+            cwd: opts.cwd,
+            env: opts.env ? { ...process.env, ...opts.env } : void 0,
+            maxBuffer: 10 * 1024 * 1024
+            // 10MB
+          },
+          (error, stdout, stderr) => {
+            if (error) {
+              reject(new Error(
+                `CLI adapter failed: ${opts.command} exited with ${error.code ?? "error"}` + (stderr ? `
+stderr: ${stderr.slice(0, 500)}` : "") + `
+${error.message}`
+              ));
+            } else {
+              resolve2(stdout);
+            }
+          }
+        );
+        if (opts.stdin && child.stdin) {
+          child.stdin.write(prompt);
+          child.stdin.end();
+        }
+      });
+    }
+  };
+}
+function createHttpAdapter(opts) {
+  const timeout = opts.timeout ?? 6e4;
+  return {
+    analyze: async (prompt) => {
+      const body = opts.buildBody ? opts.buildBody(prompt) : { prompt };
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(opts.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...opts.headers ?? {}
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const text = await response.text().catch(() => "");
+          throw new Error(`HTTP ${response.status}: ${text.slice(0, 500)}`);
+        }
+        const json = await response.json();
+        if (opts.extractResponse) {
+          return opts.extractResponse(json);
+        }
+        if (typeof json.response === "string") return json.response;
+        if (typeof json.text === "string") return json.text;
+        if (typeof json.content === "string") return json.content;
+        return JSON.stringify(json);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
+// src/card-compute/index.ts
+function deepGet(obj, path) {
+  if (!path || !obj) return void 0;
+  const parts = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length; i++) {
+    if (cur == null) return void 0;
+    cur = cur[parts[i]];
+  }
+  return cur;
+}
+function deepSet(obj, path, value) {
+  const parts = path.split(".");
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null || typeof cur[parts[i]] !== "object") cur[parts[i]] = {};
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+var _fns = {};
+_fns.sum = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  return opts.field ? a.reduce((s, r) => s + (Number(r[opts.field]) || 0), 0) : a.reduce((s, v) => s + (Number(v) || 0), 0);
+};
+_fns.avg = (input, _e, opts) => {
+  const s = _fns.sum(input, _e, opts);
+  const n = Array.isArray(input) ? input.length : 1;
+  return n ? s / n : 0;
+};
+_fns.min = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
+  return vals.length ? Math.min(...vals) : 0;
+};
+_fns.max = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const vals = opts.field ? a.map((r) => Number(r[opts.field])) : a.map(Number);
+  return vals.length ? Math.max(...vals) : 0;
+};
+_fns.count = (input) => Array.isArray(input) ? input.length : input != null ? 1 : 0;
+_fns.first = (input) => Array.isArray(input) ? input[0] : input;
+_fns.last = (input) => Array.isArray(input) ? input[input.length - 1] : input;
+_fns.add = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.reduce((s, v) => s + Number(v), 0);
+};
+_fns.sub = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 ? Number(a[0]) - Number(a[1]) : 0;
+};
+_fns.mul = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.reduce((s, v) => s * Number(v), 1);
+};
+_fns.div = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[1]) !== 0 ? Number(a[0]) / Number(a[1]) : 0;
+};
+_fns.round = (input, _e, opts) => {
+  const decimals = opts.decimals != null ? opts.decimals : 0;
+  const factor = Math.pow(10, decimals);
+  return Math.round(Number(input) * factor) / factor;
+};
+_fns.abs = (input) => Math.abs(Number(input));
+_fns.mod = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 ? Number(a[0]) % Number(a[1]) : 0;
+};
+_fns.gt = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) > Number(a[1]);
+};
+_fns.gte = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) >= Number(a[1]);
+};
+_fns.lt = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) < Number(a[1]);
+};
+_fns.lte = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && Number(a[0]) <= Number(a[1]);
+};
+_fns.eq = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && a[0] === a[1];
+};
+_fns.neq = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 && a[0] !== a[1];
+};
+_fns.and = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.every(Boolean);
+};
+_fns.or = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.some(Boolean);
+};
+_fns.not = (input) => !input;
+_fns.concat = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.map((v) => v != null ? String(v) : "").join("");
+};
+_fns.upper = (input) => String(input || "").toUpperCase();
+_fns.lower = (input) => String(input || "").toLowerCase();
+_fns.template = (input, _e, opts) => {
+  let t = String(opts.format || "");
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    for (const k of Object.keys(input)) {
+      const v = input[k];
+      t = t.split("{{" + k + "}}").join(v != null ? String(v) : "");
+    }
+  }
+  return t;
+};
+_fns.join = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const sep = opts.separator != null ? String(opts.separator) : ", ";
+  return a.map((v) => v != null ? String(v) : "").join(sep);
+};
+_fns.split = (input, _e, opts) => {
+  const sep = opts.separator != null ? String(opts.separator) : ",";
+  return String(input || "").split(sep).map((s) => s.trim());
+};
+_fns.trim = (input) => String(input || "").trim();
+_fns.pluck = (input, _e, opts) => Array.isArray(input) ? input.map((r) => r[opts.field]) : [];
+_fns.filter = (input, _e, opts) => {
+  if (!Array.isArray(input)) return [];
+  if (opts.field) return input.filter((r) => !!r[opts.field]);
+  return input.filter(Boolean);
+};
+_fns.map = (input) => Array.isArray(input) ? input.slice() : [];
+_fns.sort = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input.slice() : [];
+  const f = opts.field;
+  const dir = opts.direction === "desc" ? -1 : 1;
+  if (f) return a.sort((x, y) => x[f] > y[f] ? dir : x[f] < y[f] ? -dir : 0);
+  return a.sort((x, y) => x > y ? dir : x < y ? -dir : 0);
+};
+_fns.slice = (input, _e, opts) => Array.isArray(input) ? input.slice(opts.start || 0, opts.end) : input;
+_fns.flat = (input, _e, opts) => {
+  const depth = opts.depth != null ? opts.depth : 1;
+  return Array.isArray(input) ? input.flat(depth) : [input];
+};
+_fns.unique = (input) => {
+  if (!Array.isArray(input)) return [input];
+  const seen = /* @__PURE__ */ new Set();
+  return input.filter((v) => {
+    const key = typeof v === "object" ? JSON.stringify(v) : v;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+_fns.group = (input, _e, opts) => {
+  const a = Array.isArray(input) ? input : [];
+  const g = {};
+  a.forEach((r) => {
+    const k = String(r[opts.field] || "");
+    if (!g[k]) g[k] = [];
+    g[k].push(r);
+  });
+  return g;
+};
+_fns.flatten_keys = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+  const result = [];
+  for (const k of Object.keys(input)) {
+    const vals = Array.isArray(input[k]) ? input[k] : [input[k]];
+    vals.forEach((v) => result.push({ key: k, value: v }));
+  }
+  return result;
+};
+_fns.entries = (input) => {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+  return Object.keys(input).map((k) => ({ key: k, value: input[k] }));
+};
+_fns.from_entries = (input) => {
+  if (!Array.isArray(input)) return {};
+  const obj = {};
+  input.forEach((item) => {
+    if (item.key != null) obj[item.key] = item.value;
+  });
+  return obj;
+};
+_fns.length = (input) => {
+  if (Array.isArray(input)) return input.length;
+  if (typeof input === "string") return input.length;
+  if (input && typeof input === "object") return Object.keys(input).length;
+  return 0;
+};
+_fns.get = (input, _e, opts) => deepGet(input, opts.field || opts.path || "");
+_fns.default = (input, _e, opts) => input != null ? input : opts.value;
+_fns.coalesce = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] != null) return a[i];
+  }
+  return null;
+};
+_fns.now = () => (/* @__PURE__ */ new Date()).toISOString();
+_fns.diff_days = (input) => {
+  const a = Array.isArray(input) ? input : [];
+  return a.length >= 2 ? Math.floor((new Date(a[0]).getTime() - new Date(a[1]).getTime()) / 864e5) : 0;
+};
+_fns.format_date = (input, _e, opts) => {
+  try {
+    const d = new Date(input);
+    if (opts.format === "iso") return d.toISOString();
+    if (opts.format === "date") return d.toLocaleDateString();
+    if (opts.format === "time") return d.toLocaleTimeString();
+    return d.toLocaleDateString();
+  } catch {
+    return String(input);
+  }
+};
+_fns.parse_date = (input) => {
+  try {
+    return new Date(input).toISOString();
+  } catch {
+    return null;
+  }
+};
+_fns.to_number = (input) => Number(input) || 0;
+_fns.to_string = (input) => input != null ? String(input) : "";
+_fns.to_bool = (input) => !!input;
+_fns.type_of = (input) => Array.isArray(input) ? "array" : typeof input;
+_fns.is_null = (input) => input == null;
+_fns.is_empty = (input) => {
+  if (input == null) return true;
+  if (Array.isArray(input)) return input.length === 0;
+  if (typeof input === "string") return input.length === 0;
+  if (typeof input === "object") return Object.keys(input).length === 0;
+  return false;
+};
+var _customFns = {};
+function evalExpr(expr, node) {
+  if (expr == null) return expr;
+  if (typeof expr !== "object" || Array.isArray(expr)) return expr;
+  const e = expr;
+  if (!e.fn) return expr;
+  let input = e.input;
+  if (typeof input === "string" && input.startsWith("state.")) {
+    input = deepGet(node, input);
+  } else if (Array.isArray(input)) {
+    input = input.map((v) => {
+      if (typeof v === "string" && v.startsWith("state.")) return deepGet(node, v);
+      if (v && typeof v === "object" && v.fn) return evalExpr(v, node);
+      return v;
+    });
+  } else if (input && typeof input === "object" && input.fn) {
+    input = evalExpr(input, node);
+  }
+  if (e.fn === "if") {
+    const cond = evalExpr(e.cond, node);
+    if (cond) {
+      return e.then && typeof e.then === "object" && e.then.fn ? evalExpr(e.then, node) : e.then;
+    } else {
+      return e.else && typeof e.else === "object" && e.else.fn ? evalExpr(e.else, node) : e.else;
+    }
+  }
+  if (e.fn === "filter" && Array.isArray(input) && e.where) {
+    return input.filter((item) => {
+      const tmp = { state: { ...node.state, $: item } };
+      return evalExpr(e.where, tmp);
+    });
+  }
+  if (e.fn === "map" && Array.isArray(input) && e.apply) {
+    return input.map((item) => {
+      const tmp = { state: { ...node.state, $: item } };
+      return evalExpr(e.apply, tmp);
+    });
+  }
+  const fn = _customFns[e.fn] || _fns[e.fn];
+  if (!fn) {
+    console.warn('CardCompute: unknown function "' + e.fn + '"');
+    return void 0;
+  }
+  return fn(input, evalExpr, e);
+}
+function run(node) {
+  if (!node || !node.compute) return node;
+  if (!node.state) node.state = {};
+  for (const key of Object.keys(node.compute)) {
+    try {
+      const val = evalExpr(node.compute[key], node);
+      deepSet(node.state, key, val);
+    } catch (err) {
+      console.error(`CardCompute.run error on "${node.id || "?"}.${key}":`, err);
+    }
+  }
+  return node;
+}
+function resolve(node, path) {
+  return deepGet(node, path);
+}
+function registerFunction(name, fn) {
+  _customFns[name] = fn;
+}
+var CardCompute = {
+  run,
+  eval: evalExpr,
+  resolve,
+  registerFunction,
+  get functions() {
+    const all = {};
+    for (const k of Object.keys(_fns)) all[k] = _fns[k];
+    for (const k of Object.keys(_customFns)) all[k] = _customFns[k];
+    return all;
+  }
+};
+
 exports.COMPLETION_STRATEGIES = COMPLETION_STRATEGIES;
 exports.CONFLICT_STRATEGIES = CONFLICT_STRATEGIES;
+exports.CardCompute = CardCompute;
 exports.DEFAULTS = DEFAULTS;
 exports.EXECUTION_MODES = EXECUTION_MODES;
 exports.EXECUTION_STATUS = EXECUTION_STATUS;
@@ -3047,13 +3616,17 @@ exports.addRequires = addRequires;
 exports.apply = apply;
 exports.applyAll = applyAll;
 exports.applyEvent = applyEvent;
+exports.applyInferences = applyInferences;
 exports.applyStepResult = applyStepResult;
 exports.batch = batch;
+exports.buildInferencePrompt = buildInferencePrompt;
 exports.checkCircuitBreaker = checkCircuitBreaker;
 exports.computeAvailableOutputs = computeAvailableOutputs;
 exports.computeStepInput = computeStepInput;
+exports.createCliAdapter = createCliAdapter;
 exports.createDefaultTaskState = createDefaultTaskState;
 exports.createEngine = createStepMachine;
+exports.createHttpAdapter = createHttpAdapter;
 exports.createInitialExecutionState = createInitialExecutionState;
 exports.createInitialState = createInitialState;
 exports.createLiveGraph = createLiveGraph;
@@ -3078,6 +3651,8 @@ exports.getUnreachableTokens = getUnreachableTokens;
 exports.getUpstream = getUpstream;
 exports.graphToMermaid = graphToMermaid;
 exports.hasTask = hasTask;
+exports.inferAndApply = inferAndApply;
+exports.inferCompletions = inferCompletions;
 exports.injectTokens = injectTokens;
 exports.inspect = inspect;
 exports.isExecutionComplete = isExecutionComplete;