@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/chunk-HULCUY35.js

@@ -0,0 +1,2508 @@
+import {
+  compileSpec
+} from "./chunk-2OB3CEJS.js";
+import {
+  pipelineGraph
+} from "./chunk-CGHORL6G.js";
+import {
+  cascadingLlmAdapter
+} from "./chunk-4GYMCUDZ.js";
+import {
+  CircuitOpenError,
+  adaptiveRateLimiter,
+  circuitBreaker
+} from "./chunk-RJOG4IJU.js";
+import {
+  adaptInvokeResult,
+  adapterWrapper,
+  buildCallStats,
+  dryRunAdapter,
+  emptyUsageStub,
+  withLayer,
+  withReplayCache
+} from "./chunk-CXANAIZU.js";
+import {
+  aiMeta,
+  resolveToolHandlerResult,
+  stripFences
+} from "./chunk-OO5BM6CJ.js";
+import {
+  topic
+} from "./chunk-Q3EYOCZB.js";
+import {
+  firstValueFrom
+} from "./chunk-O3MT7DYI.js";
+
+// src/utils/ai/adapters/core/capabilities.ts
+import { node } from "@graphrefly/pure-ts/core";
+import { reactiveMap } from "@graphrefly/pure-ts/extra";
+function capKey(provider, model) {
+  return `${provider}::${model}`;
+}
+function createCapabilitiesRegistry(initial) {
+  const bundle = reactiveMap({
+    name: "capabilitiesRegistry"
+  });
+  const register = (cap) => {
+    bundle.set(capKey(cap.provider, cap.id), cap);
+  };
+  if (initial) for (const cap of initial) register(cap);
+  const lookupSync = (provider, model) => {
+    const exact = bundle.get(capKey(provider, model));
+    if (exact) return exact;
+    const snapshot = bundle.entries.cache;
+    if (!snapshot) return void 0;
+    let best;
+    for (const [, cap] of snapshot) {
+      if (cap.provider !== provider) continue;
+      const candidate = cap.id;
+      if (model.startsWith(candidate)) {
+        if (!best || candidate.length > best.id.length) {
+          best = cap;
+        }
+      }
+    }
+    return best;
+  };
+  const LOOKUP_CACHE_MAX = 128;
+  const lookupCache = /* @__PURE__ */ new Map();
+  const byProviderCache = /* @__PURE__ */ new Map();
+  const lruTouch = (cache, key, value, max) => {
+    if (cache.has(key)) cache.delete(key);
+    cache.set(key, value);
+    while (cache.size > max) {
+      const oldest = cache.keys().next().value;
+      if (oldest === void 0) break;
+      cache.delete(oldest);
+    }
+  };
+  const entriesNode = node(
+    [bundle.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit(
+        snapshot instanceof Map ? Array.from(snapshot.values()) : []
+      );
+    },
+    {
+      describeKind: "derived",
+      name: "capabilitiesRegistry/entries",
+      initial: []
+    }
+  );
+  return {
+    register,
+    lookup: lookupSync,
+    remove(provider, model) {
+      const existed = bundle.has(capKey(provider, model));
+      if (existed) bundle.delete(capKey(provider, model));
+      return existed;
+    },
+    entries() {
+      const snapshot = bundle.entries.cache;
+      return (function* () {
+        if (!snapshot) return;
+        for (const cap of snapshot.values()) yield cap;
+      })();
+    },
+    lookupNode(provider, model) {
+      const cacheKey = capKey(provider, model);
+      const cached = lookupCache.get(cacheKey);
+      if (cached) {
+        lookupCache.delete(cacheKey);
+        lookupCache.set(cacheKey, cached);
+        return cached;
+      }
+      const lookupNode = node(
+        [bundle.entries],
+        (_batchData, actions) => {
+          actions.emit(lookupSync(provider, model));
+        },
+        {
+          describeKind: "derived",
+          name: `capabilitiesRegistry/lookup/${provider}::${model}`,
+          initial: void 0
+        }
+      );
+      lruTouch(lookupCache, cacheKey, lookupNode, LOOKUP_CACHE_MAX);
+      return lookupNode;
+    },
+    entriesNode,
+    byProvider(provider) {
+      const cached = byProviderCache.get(provider);
+      if (cached) {
+        byProviderCache.delete(provider);
+        byProviderCache.set(provider, cached);
+        return cached;
+      }
+      const providerNode = node(
+        [entriesNode],
+        (batchData, actions, ctx) => {
+          const data = batchData.map(
+            (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+          );
+          const entries = data[0];
+          actions.emit(entries.filter((c) => c.provider === provider));
+        },
+        {
+          describeKind: "derived",
+          name: `capabilitiesRegistry/byProvider/${provider}`,
+          initial: []
+        }
+      );
+      lruTouch(byProviderCache, provider, providerNode, LOOKUP_CACHE_MAX);
+      return providerNode;
+    }
+  };
+}
+
+// src/utils/ai/adapters/core/observable.ts
+import { monotonicNs, node as node2, wallClockNs } from "@graphrefly/pure-ts/core";
+import { keepalive, reactiveLog } from "@graphrefly/pure-ts/extra";
+
+// src/utils/ai/adapters/core/types.ts
+function sumInputTokens(u) {
+  const i = u.input;
+  const base = i.regular + (i.cacheRead ?? 0) + (i.cacheWrite5m ?? 0) + (i.cacheWrite1h ?? 0) + (i.cacheWriteOther ?? 0) + (i.audio ?? 0) + (i.image ?? 0) + (i.video ?? 0) + (i.toolUse ?? 0);
+  if (!i.extensions) return base;
+  let ext = 0;
+  for (const v of Object.values(i.extensions)) ext += v;
+  return base + ext;
+}
+function sumOutputTokens(u) {
+  const o = u.output;
+  const base = o.regular + (o.reasoning ?? 0) + (o.audio ?? 0) + (o.predictionAccepted ?? 0) + (o.predictionRejected ?? 0);
+  if (!o.extensions) return base;
+  let ext = 0;
+  for (const v of Object.values(o.extensions)) ext += v;
+  return base + ext;
+}
+function emptyUsage() {
+  return { input: { regular: 0 }, output: { regular: 0 } };
+}
+
+// src/utils/ai/adapters/core/observable.ts
+function observableAdapter(inner, opts) {
+  const logMax = opts?.logMax ?? 1e3;
+  const allCalls = reactiveLog(void 0, {
+    name: opts?.name ? `${opts.name}/stats` : "adapterStats",
+    maxSize: logMax
+  });
+  const lastCall = node2([], {
+    name: "adapterStats/lastCall",
+    initial: null
+  });
+  const totalCalls = node2(
+    [allCalls.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const entries = data[0];
+      actions.emit(entries.length);
+    },
+    { describeKind: "derived", name: "adapterStats/totalCalls", initial: 0 }
+  );
+  const totalInputTokens = node2(
+    [allCalls.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const entries = data[0];
+      actions.emit(entries.reduce((acc, ev) => acc + sumInputTokens(ev.usage), 0));
+    },
+    { describeKind: "derived", name: "adapterStats/totalInputTokens", initial: 0 }
+  );
+  const totalOutputTokens = node2(
+    [allCalls.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const entries = data[0];
+      actions.emit(entries.reduce((acc, ev) => acc + sumOutputTokens(ev.usage), 0));
+    },
+    { describeKind: "derived", name: "adapterStats/totalOutputTokens", initial: 0 }
+  );
+  const unsubKeepalives = [
+    keepalive(totalCalls),
+    keepalive(totalInputTokens),
+    keepalive(totalOutputTokens)
+  ];
+  const record = (ev) => {
+    allCalls.append(ev);
+    lastCall.emit(ev);
+  };
+  const reset = () => {
+    allCalls.clear();
+    lastCall.emit(null);
+  };
+  const wrap = adapterWrapper(inner, {
+    invoke(messages, invokeOpts) {
+      const startNs = monotonicNs();
+      const startWallClockNs = wallClockNs();
+      const model = inner.model ?? invokeOpts?.model ?? "";
+      const recordResp = (resp) => {
+        record(
+          buildCallStats({
+            provider: inner.provider,
+            model: inner.model ?? invokeOpts?.model ?? resp.model ?? "",
+            tier: invokeOpts?.tier ?? resp.tier,
+            usage: resp.usage ?? emptyUsageStub(),
+            startNs,
+            startWallClockNs,
+            method: "invoke"
+          })
+        );
+        return resp;
+      };
+      const recordErr = (err) => {
+        const e = err;
+        record(
+          buildCallStats({
+            provider: inner.provider,
+            model,
+            tier: invokeOpts?.tier,
+            usage: emptyUsageStub(),
+            startNs,
+            startWallClockNs,
+            method: "invoke",
+            error: {
+              type: e?.name ?? "Error",
+              message: e?.message ?? String(err)
+            }
+          })
+        );
+      };
+      return adaptInvokeResult(inner.invoke(messages, invokeOpts), {
+        onResp: recordResp,
+        onError: recordErr,
+        name: "adapterStats/invokeTap"
+      });
+    },
+    async *stream(messages, invokeOpts) {
+      const startNs = monotonicNs();
+      const startWallClockNs = wallClockNs();
+      const model = inner.model ?? invokeOpts?.model ?? "";
+      let finalUsage;
+      try {
+        for await (const delta of inner.stream(messages, invokeOpts)) {
+          if (delta.type === "usage") finalUsage = delta.usage;
+          yield delta;
+        }
+        record(
+          buildCallStats({
+            provider: inner.provider,
+            model,
+            tier: invokeOpts?.tier,
+            usage: finalUsage ?? emptyUsageStub(),
+            startNs,
+            startWallClockNs,
+            method: "stream"
+          })
+        );
+      } catch (err) {
+        const e = err;
+        record(
+          buildCallStats({
+            provider: inner.provider,
+            model,
+            tier: invokeOpts?.tier,
+            usage: finalUsage ?? emptyUsageStub(),
+            startNs,
+            startWallClockNs,
+            method: "stream",
+            error: {
+              type: e?.name ?? "Error",
+              message: e?.message ?? String(err)
+            }
+          })
+        );
+        throw err;
+      }
+    }
+  });
+  withLayer(wrap, "observableAdapter", inner);
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    for (const fn of unsubKeepalives) fn();
+    unsubKeepalives.length = 0;
+  };
+  const stats = {
+    lastCall,
+    allCalls,
+    totalCalls,
+    totalInputTokens,
+    totalOutputTokens,
+    reset,
+    dispose
+  };
+  return { adapter: wrap, stats };
+}
+
+// src/utils/ai/adapters/core/pricing.ts
+function rateAt(rate, totalInput) {
+  if (rate == null) return 0;
+  if (typeof rate === "number") return rate;
+  if (rate.thresholdTokens != null && rate.pricePerMillionAbove != null && totalInput > rate.thresholdTokens) {
+    return rate.pricePerMillionAbove;
+  }
+  return rate.pricePerMillion;
+}
+function zeroPrice(currency = "USD") {
+  return { total: 0, currency };
+}
+function computePrice(usage, pricing, opts) {
+  const totalInput = sumInputTokens(usage);
+  const currency = pricing.currency ?? "USD";
+  const withBreakdown = opts?.withBreakdown === true;
+  const breakdown = withBreakdown ? {} : null;
+  let total = 0;
+  const addLine = (key, tokens, rate) => {
+    if (!tokens || rate == null) return;
+    const rateUsd = rateAt(rate, totalInput);
+    const line = tokens * rateUsd / 1e6;
+    total += line;
+    if (withBreakdown) breakdown[key] = (breakdown[key] ?? 0) + line;
+  };
+  const i = usage.input;
+  const pi = pricing.input;
+  if (pi) {
+    addLine("input.regular", i.regular, pi.regular);
+    addLine("input.cacheRead", i.cacheRead ?? 0, pi.cacheRead);
+    addLine("input.cacheWrite5m", i.cacheWrite5m ?? 0, pi.cacheWrite5m);
+    addLine("input.cacheWrite1h", i.cacheWrite1h ?? 0, pi.cacheWrite1h);
+    addLine("input.cacheWriteOther", i.cacheWriteOther ?? 0, pi.cacheWriteOther);
+    addLine("input.audio", i.audio ?? 0, pi.audio);
+    addLine("input.image", i.image ?? 0, pi.image);
+    addLine("input.video", i.video ?? 0, pi.video);
+    addLine("input.toolUse", i.toolUse ?? 0, pi.toolUse);
+    if (i.extensions && pi.extensions) {
+      for (const [k, v] of Object.entries(i.extensions)) {
+        addLine(`input.ext.${k}`, v, pi.extensions[k]);
+      }
+    }
+  }
+  const o = usage.output;
+  const po = pricing.output;
+  if (po) {
+    addLine("output.regular", o.regular, po.regular);
+    addLine("output.reasoning", o.reasoning ?? 0, po.reasoning);
+    addLine("output.audio", o.audio ?? 0, po.audio);
+    addLine("output.predictionAccepted", o.predictionAccepted ?? 0, po.predictionAccepted);
+    addLine("output.predictionRejected", o.predictionRejected ?? 0, po.predictionRejected);
+    if (o.extensions && po.extensions) {
+      for (const [k, v] of Object.entries(o.extensions)) {
+        addLine(`output.ext.${k}`, v, po.extensions[k]);
+      }
+    }
+  }
+  const tier = opts?.tier;
+  if (tier && pricing.tierMultipliers) {
+    const mult = pricing.tierMultipliers[tier];
+    if (mult != null) {
+      total *= mult;
+      if (withBreakdown) {
+        for (const k of Object.keys(breakdown)) breakdown[k] *= mult;
+      }
+    }
+  }
+  const aux = usage.auxiliary;
+  const paux = pricing.auxiliary;
+  if (aux && paux) {
+    for (const [k, units] of Object.entries(aux)) {
+      const rate = paux[k];
+      if (rate == null || !units) continue;
+      const line = units * rate;
+      total += line;
+      if (withBreakdown) breakdown[`auxiliary.${k}`] = line;
+    }
+  }
+  return withBreakdown ? { total, currency, breakdown } : { total, currency };
+}
+function registryKey(provider, model) {
+  return `${provider}::${model}`;
+}
+function createPricingRegistry(initial) {
+  const map = /* @__PURE__ */ new Map();
+  const indexByProvider = /* @__PURE__ */ new Map();
+  const register = (provider, model, pricing) => {
+    map.set(registryKey(provider, model), { provider, model, pricing });
+    let models = indexByProvider.get(provider);
+    if (!models) {
+      models = /* @__PURE__ */ new Set();
+      indexByProvider.set(provider, models);
+    }
+    models.add(model);
+  };
+  if (initial) {
+    for (const [p, m, pricing] of initial) register(p, m, pricing);
+  }
+  return {
+    register,
+    lookup(provider, model) {
+      const exact = map.get(registryKey(provider, model));
+      if (exact) return exact.pricing;
+      const models = indexByProvider.get(provider);
+      if (!models) return void 0;
+      let best;
+      for (const candidate of models) {
+        if (model.startsWith(candidate)) {
+          if (!best || candidate.length > best.key.length) {
+            const entry = map.get(registryKey(provider, candidate));
+            if (entry) best = { key: candidate, pricing: entry.pricing };
+          }
+        }
+      }
+      return best?.pricing;
+    },
+    remove(provider, model) {
+      const existed = map.delete(registryKey(provider, model));
+      if (existed) {
+        const models = indexByProvider.get(provider);
+        models?.delete(model);
+        if (models && models.size === 0) indexByProvider.delete(provider);
+      }
+      return existed;
+    },
+    entries() {
+      const iter = map.values();
+      return (function* () {
+        for (const { provider, model, pricing } of iter) {
+          yield [provider, model, pricing];
+        }
+      })();
+    }
+  };
+}
+function registryPricing(registry, defaultCurrency = "USD") {
+  return (usage, ctx) => {
+    const pricing = registry.lookup(ctx.provider, ctx.model);
+    if (!pricing) return zeroPrice(defaultCurrency);
+    return computePrice(usage, pricing, { tier: ctx.tier, withBreakdown: ctx.withBreakdown });
+  };
+}
+function composePricing(...fns) {
+  return (usage, ctx) => {
+    for (const fn of fns) {
+      const p = fn(usage, ctx);
+      if (p.total !== 0) return p;
+    }
+    return fns.length > 0 ? fns[0](usage, ctx) : zeroPrice();
+  };
+}
+function pricingFor(capabilities, usage, opts) {
+  if (!capabilities?.pricing) return zeroPrice();
+  return computePrice(usage, capabilities.pricing, opts);
+}
+
+// src/utils/ai/adapters/middleware/breaker.ts
+import { fromAny } from "@graphrefly/pure-ts/extra";
+function withLLMBreaker(inner, opts = {}) {
+  const breaker = opts.breaker ?? circuitBreaker(opts);
+  const adapter = adapterWrapper(inner, {
+    async invoke(messages, invokeOpts) {
+      if (!breaker.canExecute()) throw new CircuitOpenError();
+      try {
+        const resp = await firstValueFrom(fromAny(inner.invoke(messages, invokeOpts)));
+        breaker.recordSuccess();
+        return resp;
+      } catch (err) {
+        breaker.recordFailure(err);
+        throw err;
+      }
+    },
+    async *stream(messages, invokeOpts) {
+      if (!breaker.canExecute()) throw new CircuitOpenError();
+      try {
+        for await (const d of inner.stream(messages, invokeOpts)) yield d;
+        breaker.recordSuccess();
+      } catch (err) {
+        breaker.recordFailure(err);
+        throw err;
+      }
+    }
+  });
+  withLayer(adapter, "withLLMBreaker", inner);
+  return { adapter, breaker };
+}
+
+// src/utils/ai/adapters/middleware/budget-gate.ts
+import { DATA, monotonicNs as monotonicNs2, node as node3 } from "@graphrefly/pure-ts/core";
+import { keepalive as keepalive2, reactiveLog as reactiveLog2 } from "@graphrefly/pure-ts/extra";
+var BudgetExhaustedError = class extends Error {
+  constructor(which, limit, observed) {
+    super(`Budget exhausted: ${which} (limit=${limit}, observed=${observed})`);
+    this.which = which;
+    this.limit = limit;
+    this.observed = observed;
+  }
+  name = "BudgetExhaustedError";
+};
+var EMPTY_TOTALS = Object.freeze({
+  calls: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  usd: 0
+});
+var makeEmptyTotals = () => ({
+  calls: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  usd: 0
+});
+function withBudgetGate(inner, opts) {
+  const log = reactiveLog2(void 0, {
+    name: opts.name ? `${opts.name}/log` : "budgetGate/log",
+    maxSize: opts.logMax ?? 1e3
+  });
+  const totals = node3([], {
+    name: opts.name ? `${opts.name}/totals` : "budgetGate/totals",
+    initial: makeEmptyTotals()
+  });
+  const isOpen = node3(
+    [totals],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const tt = data[0];
+      if (opts.caps.calls != null && tt.calls >= opts.caps.calls) {
+        actions.emit(false);
+        return;
+      }
+      if (opts.caps.inputTokens != null && tt.inputTokens >= opts.caps.inputTokens) {
+        actions.emit(false);
+        return;
+      }
+      if (opts.caps.outputTokens != null && tt.outputTokens >= opts.caps.outputTokens) {
+        actions.emit(false);
+        return;
+      }
+      if (opts.caps.usd != null && tt.usd >= opts.caps.usd) {
+        actions.emit(false);
+        return;
+      }
+      actions.emit(true);
+    },
+    {
+      describeKind: "derived",
+      name: opts.name ? `${opts.name}/isOpen` : "budgetGate/isOpen",
+      initial: true
+    }
+  );
+  const disposers = [];
+  let disposed = false;
+  disposers.push(keepalive2(isOpen));
+  if (opts.onExhausted != null) {
+    const handler = opts.onExhausted;
+    let seeded = false;
+    let wasOpen = true;
+    const unsub = isOpen.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA) {
+          const v = m[1];
+          if (seeded && wasOpen && v === false) {
+            const which = pickExhaustedKey(totals.cache ?? EMPTY_TOTALS, opts.caps);
+            if (which) handler(which);
+          }
+          wasOpen = v;
+          seeded = true;
+        }
+      }
+    });
+    disposers.push(unsub);
+  }
+  const buildClosedError = () => {
+    if (isOpen.cache === false) {
+      const t = totals.cache ?? EMPTY_TOTALS;
+      const which = pickExhaustedKey(t, opts.caps);
+      return new BudgetExhaustedError(
+        which ?? "budget",
+        opts.caps[which ?? "calls"] ?? 0,
+        whichValue(t, which ?? "calls")
+      );
+    }
+    return void 0;
+  };
+  const record = (usage, meta) => {
+    const provider = inner.provider;
+    const event = buildCallStats({
+      provider,
+      model: meta.model,
+      tier: meta.tier,
+      usage,
+      startNs: meta.startNs,
+      method: meta.method,
+      ...meta.error ? { error: meta.error } : {}
+    });
+    log.append(event);
+    const prev = totals.cache ?? EMPTY_TOTALS;
+    const usd = opts.pricingFn ? prev.usd + opts.pricingFn(usage, { model: meta.model, provider, tier: meta.tier }).total : prev.usd;
+    totals.emit({
+      calls: prev.calls + 1,
+      inputTokens: prev.inputTokens + sumInputTokens(usage),
+      outputTokens: prev.outputTokens + sumOutputTokens(usage),
+      usd
+    });
+  };
+  const reset = () => {
+    log.clear();
+    totals.emit(makeEmptyTotals());
+  };
+  const inflight = /* @__PURE__ */ new Set();
+  let isOpenSeeded = false;
+  let isOpenWasOpen = true;
+  const isOpenAbortUnsub = isOpen.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] !== DATA) continue;
+      const v = m[1];
+      if (isOpenSeeded && isOpenWasOpen && v === false && inflight.size > 0) {
+        const reason = buildClosedError() ?? new Error("budget exhausted");
+        for (const ctrl of inflight) {
+          try {
+            ctrl.abort(reason);
+          } catch {
+          }
+        }
+      }
+      isOpenWasOpen = v;
+      isOpenSeeded = true;
+    }
+  });
+  disposers.push(isOpenAbortUnsub);
+  function combineSignals(callerSignal) {
+    const ctrl = new AbortController();
+    if (isOpen.cache === false) {
+      ctrl.abort(buildClosedError() ?? new Error("budget exhausted"));
+    }
+    const onCallerAbort = () => {
+      if (!ctrl.signal.aborted) ctrl.abort(callerSignal.reason);
+    };
+    if (callerSignal != null) {
+      if (callerSignal.aborted) {
+        ctrl.abort(callerSignal.reason);
+      } else {
+        callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+    }
+    inflight.add(ctrl);
+    const cleanup = () => {
+      inflight.delete(ctrl);
+      if (callerSignal != null) callerSignal.removeEventListener("abort", onCallerAbort);
+    };
+    return { ctrl, cleanup };
+  }
+  const wrap = adapterWrapper(inner, {
+    invoke(messages, invokeOpts) {
+      const closedErr = buildClosedError();
+      if (closedErr) return Promise.reject(closedErr);
+      const startNs = monotonicNs2();
+      const model = inner.model ?? invokeOpts?.model ?? "";
+      const { ctrl, cleanup } = combineSignals(invokeOpts?.signal);
+      const recordResp = (resp) => {
+        cleanup();
+        record(resp.usage ?? emptyUsageStub(), {
+          model: inner.model ?? invokeOpts?.model ?? resp.model ?? "",
+          tier: invokeOpts?.tier ?? resp.tier,
+          startNs,
+          method: "invoke"
+        });
+        return resp;
+      };
+      const recordErr = (err) => {
+        cleanup();
+        const e = err;
+        record(emptyUsageStub(), {
+          model,
+          tier: invokeOpts?.tier,
+          startNs,
+          method: "invoke",
+          error: { type: e?.name ?? "Error", message: e?.message ?? String(err) }
+        });
+      };
+      const innerOpts = { ...invokeOpts ?? {}, signal: ctrl.signal };
+      return adaptInvokeResult(inner.invoke(messages, innerOpts), {
+        onResp: recordResp,
+        onError: recordErr,
+        name: "budgetGate/invokeTap"
+      });
+    },
+    async *stream(messages, invokeOpts) {
+      const closedErr = buildClosedError();
+      if (closedErr) throw closedErr;
+      const startNs = monotonicNs2();
+      let finalUsage;
+      const { ctrl, cleanup } = combineSignals(invokeOpts?.signal);
+      const innerOpts = { ...invokeOpts ?? {}, signal: ctrl.signal };
+      try {
+        for await (const delta of inner.stream(messages, innerOpts)) {
+          if (delta.type === "usage") finalUsage = delta.usage;
+          yield delta;
+        }
+        cleanup();
+        record(finalUsage ?? emptyUsageStub(), {
+          model: inner.model ?? invokeOpts?.model ?? "",
+          tier: invokeOpts?.tier,
+          startNs,
+          method: "stream"
+        });
+      } catch (err) {
+        cleanup();
+        const error = err;
+        record(finalUsage ?? emptyUsageStub(), {
+          model: inner.model ?? invokeOpts?.model ?? "",
+          tier: invokeOpts?.tier,
+          startNs,
+          method: "stream",
+          error: { type: error?.name ?? "Error", message: error?.message ?? String(err) }
+        });
+        throw err;
+      }
+    }
+  });
+  withLayer(wrap, "withBudgetGate", inner);
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    const reason = new Error("withBudgetGate disposed");
+    for (const ctrl of inflight) {
+      try {
+        ctrl.abort(reason);
+      } catch {
+      }
+    }
+    inflight.clear();
+    for (const d of disposers) {
+      try {
+        d();
+      } catch {
+      }
+    }
+    disposers.length = 0;
+  };
+  return { adapter: wrap, budget: { totals, isOpen, log, reset, dispose } };
+}
+function pickExhaustedKey(t, caps) {
+  if (caps.calls != null && t.calls >= caps.calls) return "calls";
+  if (caps.inputTokens != null && t.inputTokens >= caps.inputTokens) return "inputTokens";
+  if (caps.outputTokens != null && t.outputTokens >= caps.outputTokens) return "outputTokens";
+  if (caps.usd != null && t.usd >= caps.usd) return "usd";
+  return void 0;
+}
+function whichValue(t, which) {
+  switch (which) {
+    case "calls":
+      return t.calls;
+    case "inputTokens":
+      return t.inputTokens;
+    case "outputTokens":
+      return t.outputTokens;
+    case "usd":
+      return t.usd;
+  }
+}
+
+// src/utils/ai/adapters/middleware/dry-run.ts
+import { fromAny as fromAny2, keepalive as keepalive3 } from "@graphrefly/pure-ts/extra";
+function withDryRun(inner, opts) {
+  const mock = opts.mock ?? dryRunAdapter({ provider: inner.provider, model: inner.model });
+  const enabledLiteral = typeof opts.enabled === "boolean" ? opts.enabled : void 0;
+  const enabledNode = enabledLiteral === void 0 ? fromAny2(opts.enabled) : void 0;
+  let unsubKeepalive;
+  if (enabledNode) unsubKeepalive = keepalive3(enabledNode);
+  const isEnabled = () => {
+    if (enabledLiteral !== void 0) return enabledLiteral;
+    return Boolean(enabledNode?.cache);
+  };
+  const adapter = adapterWrapper(inner, {
+    invoke(messages, invokeOpts) {
+      return isEnabled() ? mock.invoke(messages, invokeOpts) : inner.invoke(messages, invokeOpts);
+    },
+    stream(messages, invokeOpts) {
+      return isEnabled() ? mock.stream(messages, invokeOpts) : inner.stream(messages, invokeOpts);
+    }
+  });
+  withLayer(adapter, "withDryRun", inner);
+  const dispose = () => {
+    if (unsubKeepalive) {
+      unsubKeepalive();
+      unsubKeepalive = void 0;
+    }
+  };
+  return { adapter, dispose };
+}
+
+// src/utils/ai/adapters/middleware/http429-parser.ts
+function parseRateLimitFromError(err) {
+  if (err == null || typeof err !== "object") return void 0;
+  const like = err;
+  const status = like.status;
+  const headerLookup = toHeaderGetter(like.headers);
+  if (status !== 429 && status !== 503 && !looksLikeRateLimitMessage(like.message)) {
+    return void 0;
+  }
+  const sig = {};
+  const retryAfter = headerLookup("retry-after");
+  const retryAfterMs = parseRetryAfter(retryAfter);
+  if (retryAfterMs != null) sig.retryAfterMs = retryAfterMs;
+  const anthReqReset = headerLookup("anthropic-ratelimit-requests-reset");
+  if (anthReqReset) {
+    const ms = parseIsoResetHeaderToDelayMs(anthReqReset);
+    if (ms != null) sig.retryAfterMs = Math.max(sig.retryAfterMs ?? 0, ms);
+  }
+  const anthTokReset = headerLookup("anthropic-ratelimit-tokens-reset");
+  if (anthTokReset) {
+    const ms = parseIsoResetHeaderToDelayMs(anthTokReset);
+    if (ms != null) sig.retryAfterMs = Math.max(sig.retryAfterMs ?? 0, ms);
+  }
+  const limitRequests = numHeader(headerLookup, "x-ratelimit-limit-requests");
+  if (limitRequests != null) sig.rpmCap = limitRequests;
+  const limitTokens = numHeader(headerLookup, "x-ratelimit-limit-tokens");
+  if (limitTokens != null) sig.tpmCap = limitTokens;
+  const remainingReq = numHeader(headerLookup, "x-ratelimit-remaining-requests");
+  const remainingTok = numHeader(headerLookup, "x-ratelimit-remaining-tokens");
+  if (remainingReq != null && limitRequests != null && limitRequests > 0) {
+    sig.usageHint ??= {};
+    sig.usageHint.rpm = 1 - remainingReq / limitRequests;
+  }
+  if (remainingTok != null && limitTokens != null && limitTokens > 0) {
+    sig.usageHint ??= {};
+    sig.usageHint.tpm = 1 - remainingTok / limitTokens;
+  }
+  if (sig.retryAfterMs == null && like.message) {
+    const msgMs = parseRetryAfterFromMessage(like.message);
+    if (msgMs != null) sig.retryAfterMs = msgMs;
+  }
+  if (like.headers) sig.metadata = { headers: serializeHeaders(like.headers) };
+  if (sig.retryAfterMs == null && sig.rpmCap == null && sig.tpmCap == null && sig.usageHint == null) {
+    return sig.metadata ? sig : void 0;
+  }
+  return sig;
+}
+function toHeaderGetter(h) {
+  if (!h) return () => void 0;
+  if (typeof h.get === "function") {
+    const hh = h;
+    return (name) => hh.get(name) ?? hh.get(name.toLowerCase()) ?? void 0;
+  }
+  const record = h;
+  const lc = {};
+  for (const [k, v] of Object.entries(record)) {
+    const sv = Array.isArray(v) ? v.join(", ") : v;
+    if (sv != null) lc[k.toLowerCase()] = sv;
+  }
+  return (name) => lc[name.toLowerCase()];
+}
+function serializeHeaders(h) {
+  const out = {};
+  if (typeof h.forEach === "function") {
+    h.forEach((v, k) => {
+      out[k] = v;
+    });
+    return out;
+  }
+  for (const [k, v] of Object.entries(h)) {
+    if (v != null) out[k] = Array.isArray(v) ? v.join(", ") : v;
+  }
+  return out;
+}
+function numHeader(getter, name) {
+  const raw = getter(name);
+  if (raw == null) return void 0;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : void 0;
+}
+function parseRetryAfter(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  const asNum = Number(trimmed);
+  if (Number.isFinite(asNum) && asNum >= 0) return asNum * 1e3;
+  const ts = Date.parse(trimmed);
+  if (Number.isFinite(ts)) {
+    const delta = ts - Date.now();
+    if (delta > 0) return delta;
+  }
+  return void 0;
+}
+function parseIsoResetHeaderToDelayMs(raw) {
+  if (!raw) return void 0;
+  const ts = Date.parse(raw);
+  if (Number.isFinite(ts)) return Math.max(0, ts - Date.now());
+  return void 0;
+}
+var RETRY_MSG_RE = /retry\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*(ms|s|sec|seconds?|m|min|minutes?)/i;
+function parseRetryAfterFromMessage(msg) {
+  const m = RETRY_MSG_RE.exec(msg);
+  if (!m) return void 0;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n)) return void 0;
+  const unit = (m[2] ?? "s").toLowerCase();
+  if (unit === "ms") return n;
+  if (unit.startsWith("s")) return n * 1e3;
+  if (unit.startsWith("m")) return n * 6e4;
+  return void 0;
+}
+var RATE_LIMIT_MSG_RE = /rate\s*limit|too\s*many\s*requests|quota|429/i;
+function looksLikeRateLimitMessage(msg) {
+  return !!msg && RATE_LIMIT_MSG_RE.test(msg);
+}
+
+// src/utils/ai/adapters/middleware/rate-limiter.ts
+import { fromAny as fromAny3 } from "@graphrefly/pure-ts/extra";
+function withRateLimiter(inner, opts = {}) {
+  const limiter = opts.limiter ?? adaptiveRateLimiter({
+    name: opts.name ?? "rateLimiter",
+    rpm: opts.rpm,
+    tpm: opts.tpm,
+    adaptation: opts.adaptation,
+    burstMultiplier: opts.burstMultiplier
+  });
+  const estimateCost = (messages, invokeOpts) => {
+    if (opts.costFn) return opts.costFn(messages, invokeOpts);
+    return 0;
+  };
+  const handleError = (err) => {
+    const sig = parseRateLimitFromError(err);
+    if (sig) limiter.recordSignal(sig);
+  };
+  const wrap = adapterWrapper(inner, {
+    async invoke(messages, invokeOpts) {
+      const tokenCost = estimateCost(messages, invokeOpts);
+      await limiter.acquire({ requestCost: 1, tokenCost, signal: invokeOpts?.signal });
+      try {
+        const resp = await firstValueFrom(fromAny3(inner.invoke(messages, invokeOpts)));
+        const usage = resp.usage ?? emptyUsage();
+        const actual = sumInputTokens(usage) + sumOutputTokens(usage);
+        const delta = actual - tokenCost;
+        if (delta > 0) limiter.recordUsage(delta);
+        return resp;
+      } catch (err) {
+        handleError(err);
+        throw err;
+      }
+    },
+    async *stream(messages, invokeOpts) {
+      const tokenCost = estimateCost(messages, invokeOpts);
+      await limiter.acquire({ requestCost: 1, tokenCost, signal: invokeOpts?.signal });
+      try {
+        let finalTokens = 0;
+        for await (const delta of inner.stream(messages, invokeOpts)) {
+          if (delta.type === "usage") {
+            finalTokens = sumInputTokens(delta.usage) + sumOutputTokens(delta.usage);
+          }
+          yield delta;
+        }
+        const d = finalTokens - tokenCost;
+        if (d > 0) limiter.recordUsage(d);
+      } catch (err) {
+        handleError(err);
+        throw err;
+      }
+    }
+  });
+  withLayer(wrap, "withRateLimiter", inner);
+  return { adapter: wrap, limiter };
+}
+
+// src/utils/ai/adapters/middleware/retry.ts
+import { ResettableTimer } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny4 } from "@graphrefly/pure-ts/extra";
+function makeAbortError(reason = "aborted") {
+  const err = new Error(reason);
+  err.name = "AbortError";
+  return err;
+}
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(makeAbortError());
+  return new Promise((resolve, reject) => {
+    const timer = new ResettableTimer();
+    let onAbort;
+    const cleanup = () => {
+      timer.cancel();
+      if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+    };
+    timer.start(ms, () => {
+      cleanup();
+      resolve();
+    });
+    if (signal) {
+      onAbort = () => {
+        cleanup();
+        reject(makeAbortError());
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function withRetry(inner, opts = {}) {
+  const attempts = opts.attempts ?? 3;
+  const baseDelayMs = opts.baseDelayMs ?? 500;
+  const maxDelayMs = opts.maxDelayMs ?? 1e4;
+  const strategy = opts.strategy ?? "decorrelated";
+  const jitter = opts.jitter ?? true;
+  const shouldRetry = opts.shouldRetry ?? defaultShouldRetry;
+  const retryStreaming = opts.retryStreaming ?? true;
+  const delay = (attempt, prevDelay) => {
+    if (strategy === "decorrelated") {
+      const upper = Math.min(maxDelayMs, Math.max(baseDelayMs, prevDelay * 3));
+      return baseDelayMs + Math.random() * (upper - baseDelayMs);
+    }
+    const nominal = strategy === "exp" ? baseDelayMs * 2 ** (attempt - 1) : baseDelayMs * attempt;
+    const bounded = Math.min(maxDelayMs, nominal);
+    if (!jitter) return bounded;
+    const jittered = bounded * (0.5 + Math.random());
+    return Math.min(maxDelayMs, jittered);
+  };
+  const wrap = adapterWrapper(inner, {
+    async invoke(messages, invokeOpts) {
+      if (invokeOpts?.signal?.aborted) throw makeAbortError();
+      let lastErr;
+      let prevDelay = baseDelayMs;
+      for (let attempt = 1; attempt <= attempts; attempt++) {
+        try {
+          return await firstValueFrom(fromAny4(inner.invoke(messages, invokeOpts)));
+        } catch (err) {
+          lastErr = err;
+          if (attempt >= attempts || !shouldRetry(err, attempt)) throw err;
+          const waitMs = delay(attempt, prevDelay);
+          prevDelay = waitMs;
+          await sleep(waitMs, invokeOpts?.signal);
+        }
+      }
+      throw lastErr;
+    },
+    async *stream(messages, invokeOpts) {
+      if (invokeOpts?.signal?.aborted) throw makeAbortError();
+      if (!retryStreaming) {
+        for await (const d of inner.stream(messages, invokeOpts)) yield d;
+        return;
+      }
+      let lastErr;
+      let prevDelay = baseDelayMs;
+      for (let attempt = 1; attempt <= attempts; attempt++) {
+        let yieldedAny = false;
+        try {
+          for await (const d of inner.stream(messages, invokeOpts)) {
+            yieldedAny = true;
+            yield d;
+          }
+          return;
+        } catch (err) {
+          lastErr = err;
+          if (yieldedAny) throw err;
+          if (attempt >= attempts || !shouldRetry(err, attempt)) throw err;
+          const waitMs = delay(attempt, prevDelay);
+          prevDelay = waitMs;
+          await sleep(waitMs, invokeOpts?.signal);
+        }
+      }
+      throw lastErr;
+    }
+  });
+  withLayer(wrap, "withRetry", inner);
+  return wrap;
+}
+function defaultShouldRetry(err, _attempt) {
+  if (err == null) return false;
+  const e = err;
+  if (e.name === "LLMTimeoutError") return true;
+  if (e.name === "AbortError") return false;
+  if (e.message === "aborted") return false;
+  if (e.name === "DOMException" && e.code != null && Number(e.code) === 20) {
+    return false;
+  }
+  if (e.name === "BudgetExhaustedError") return false;
+  if (e.name === "CircuitOpenError") return false;
+  if (e.status != null) {
+    if (e.status === 429) return true;
+    if (e.status >= 500 && e.status < 600) return true;
+    return false;
+  }
+  if (e.code && typeof e.code === "string") {
+    if (/^E[A-Z]+$/.test(e.code)) return true;
+  }
+  if (e.message) {
+    return /network|timeout|socket|fetch|econn|eai_/i.test(e.message);
+  }
+  return false;
+}
+
+// src/utils/ai/adapters/middleware/timeout.ts
+import { ResettableTimer as ResettableTimer2 } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny5 } from "@graphrefly/pure-ts/extra";
+var LLMTimeoutError = class extends Error {
+  constructor(ms) {
+    super(`LLM call timed out after ${ms}ms`);
+    this.ms = ms;
+  }
+  name = "LLMTimeoutError";
+};
+function withLLMTimeout(inner, ms) {
+  if (ms <= 0) throw new RangeError("withLLMTimeout: ms must be > 0");
+  const linkedSignal = (parent) => {
+    const ac = new AbortController();
+    let timerFired = false;
+    let onParentAbort;
+    const timer = new ResettableTimer2();
+    if (parent) {
+      if (parent.aborted) ac.abort(parent.reason);
+      else {
+        onParentAbort = () => {
+          timer.cancel();
+          ac.abort(parent.reason);
+        };
+        parent.addEventListener("abort", onParentAbort, { once: true });
+      }
+    }
+    timer.start(ms, () => {
+      timerFired = true;
+      ac.abort(new LLMTimeoutError(ms));
+    });
+    return {
+      signal: ac.signal,
+      cancel: () => {
+        timer.cancel();
+        if (parent && onParentAbort) parent.removeEventListener("abort", onParentAbort);
+      },
+      timedOut: () => timerFired
+    };
+  };
+  const convertAbortToTimeout = (err, timedOut) => {
+    if (!timedOut) throw err;
+    if (err instanceof LLMTimeoutError) throw err;
+    const e = err;
+    const isAbort = e?.name === "AbortError" || e?.name === "DOMException" && Number(e.code) === 20 || err?.message === "aborted";
+    if (isAbort) {
+      const timeout = new LLMTimeoutError(ms);
+      timeout.cause = err;
+      throw timeout;
+    }
+    throw err;
+  };
+  const wrap = adapterWrapper(inner, {
+    async invoke(messages, invokeOpts) {
+      const { signal, cancel, timedOut } = linkedSignal(invokeOpts?.signal);
+      try {
+        return await firstValueFrom(fromAny5(inner.invoke(messages, { ...invokeOpts, signal })));
+      } catch (err) {
+        return convertAbortToTimeout(err, timedOut());
+      } finally {
+        cancel();
+      }
+    },
+    async *stream(messages, invokeOpts) {
+      const { signal, cancel, timedOut } = linkedSignal(invokeOpts?.signal);
+      try {
+        for await (const d of inner.stream(messages, { ...invokeOpts, signal })) yield d;
+      } catch (err) {
+        convertAbortToTimeout(err, timedOut());
+      } finally {
+        cancel();
+      }
+    }
+  });
+  withLayer(wrap, "withLLMTimeout", inner);
+  return wrap;
+}
+
+// src/utils/ai/adapters/middleware/resilient-adapter.ts
+function resilientAdapter(inner, opts = {}) {
+  const bundle = { adapter: inner };
+  let current = inner;
+  if (opts.rateLimit) {
+    const wrapped = withRateLimiter(current, opts.rateLimit);
+    current = wrapped.adapter;
+    bundle.rateLimiter = wrapped.limiter;
+  }
+  if (opts.budget) {
+    const wrapped = withBudgetGate(current, opts.budget);
+    current = wrapped.adapter;
+    bundle.budget = wrapped.budget;
+  }
+  if (opts.breaker) {
+    const wrapped = withLLMBreaker(current, opts.breaker);
+    current = wrapped.adapter;
+    bundle.breaker = wrapped.breaker;
+  }
+  if (opts.timeoutMs != null) {
+    current = withLLMTimeout(current, opts.timeoutMs);
+  }
+  if (opts.retry) {
+    current = withRetry(current, opts.retry);
+  }
+  if (opts.fallback) {
+    if (opts.name === "fallback") {
+      throw new RangeError(
+        'resilientAdapter: `name` cannot be "fallback" \u2014 collides with the secondary tier label.'
+      );
+    }
+    const cascadeOpts = {};
+    if (opts.onFallback) cascadeOpts.onFallback = opts.onFallback;
+    if (opts.onExhausted) cascadeOpts.onExhausted = opts.onExhausted;
+    current = cascadingLlmAdapter(
+      [
+        { name: opts.name ?? "primary", adapter: current },
+        { name: "fallback", adapter: opts.fallback }
+      ],
+      cascadeOpts
+    );
+  }
+  if (opts.cache) {
+    current = withReplayCache(current, opts.cache);
+  }
+  bundle.adapter = current;
+  return bundle;
+}
+
+// src/utils/ai/prompts/frozen-context.ts
+import { factoryTag, node as nodeFactory } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny6 } from "@graphrefly/pure-ts/extra";
+function frozenContext(source, opts) {
+  const src = fromAny6(source);
+  const trigger = opts?.refreshTrigger != null ? fromAny6(opts.refreshTrigger) : null;
+  const frozenArgs = opts?.name !== void 0 ? { name: opts.name } : void 0;
+  const frozenTag = factoryTag("frozenContext", frozenArgs);
+  if (trigger == null) {
+    return nodeFactory(
+      [src],
+      (data, actions, ctx) => {
+        const alreadyEmitted = ctx.store.emitted === true;
+        if (alreadyEmitted) return;
+        const srcBatch = data[0];
+        const srcValue = srcBatch != null && srcBatch.length > 0 ? srcBatch.at(-1) : ctx.prevData[0];
+        if (srcValue === void 0) return;
+        ctx.store.emitted = true;
+        actions.emit(srcValue);
+        const store = ctx.store;
+        return {
+          onInvalidate: () => {
+            store.emitted = false;
+          },
+          onDeactivation: () => {
+            delete store.emitted;
+          },
+          onResubscribableReset: () => {
+            delete store.emitted;
+          }
+        };
+      },
+      {
+        name: opts?.name ?? "frozenContext",
+        describeKind: "derived",
+        initial: null,
+        meta: aiMeta("frozen_context", { ...frozenTag })
+      }
+    );
+  }
+  return nodeFactory(
+    [src, trigger],
+    (data, actions, ctx) => {
+      const triggerBatch = data[1];
+      const triggered = triggerBatch != null && triggerBatch.length > 0;
+      if (!triggered) return;
+      const srcBatch = data[0];
+      const srcValue = srcBatch != null && srcBatch.length > 0 ? srcBatch.at(-1) : ctx.prevData[0];
+      actions.emit(srcValue);
+    },
+    {
+      name: opts?.name ?? "frozenContext",
+      describeKind: "derived",
+      initial: null,
+      meta: aiMeta("frozen_context", { ...frozenTag })
+    }
+  );
+}
+
+// src/utils/ai/prompts/streaming.ts
+import { batch, factoryTag as factoryTag2, node as node4, wallClockNs as wallClockNs2 } from "@graphrefly/pure-ts/core";
+import { filter, fromAny as fromAny7, keepalive as keepalive4, switchMap } from "@graphrefly/pure-ts/extra";
+async function streamingInvoke(adapter, msgs, invokeOpts, deltaTopic) {
+  let accumulated = "";
+  let seq = 0;
+  for await (const delta of adapter.stream(msgs, invokeOpts)) {
+    deltaTopic.publish({ ...delta, seq: seq++, ts: wallClockNs2() });
+    if (delta.type === "token") accumulated += delta.delta;
+  }
+  return accumulated;
+}
+function parseAccumulated(accumulated, format) {
+  if (format === "json") {
+    try {
+      return JSON.parse(stripFences(accumulated));
+    } catch (err) {
+      const preview = accumulated.slice(0, 160);
+      throw new Error(
+        `streamingPromptNode: format:"json" \u2014 failed to parse accumulated text as JSON: ${err.message}; content preview: ${preview}`
+      );
+    }
+  }
+  return accumulated;
+}
+function makeAccumulatedText(deltaTopic, name) {
+  let cleanup;
+  return node4(
+    [deltaTopic.latest],
+    (batchData, actions, ctx) => {
+      if (cleanup === void 0) {
+        const store2 = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store2.acc;
+          }
+        };
+      }
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const d = data[0];
+      const store = ctx.store;
+      if (d === void 0) {
+        actions.emit(store.acc ?? "");
+        return cleanup;
+      }
+      const delta = d;
+      if (delta.seq === 0) store.acc = "";
+      if (delta.type === "token") {
+        store.acc = (store.acc ?? "") + delta.delta;
+      }
+      actions.emit(store.acc ?? "");
+      return cleanup;
+    },
+    {
+      name,
+      describeKind: "derived",
+      meta: aiMeta("accumulated_text"),
+      initial: ""
+    }
+  );
+}
+function streamingPromptNode(adapter, deps, prompt, opts) {
+  const sourceName = opts?.name ?? "llm";
+  const format = opts?.format ?? "text";
+  const deltaTopic = topic(`${sourceName}/stream`, {
+    ...opts?.retainedLimit != null ? { retainedLimit: opts.retainedLimit } : {}
+  });
+  const messagesNode = node4(
+    deps,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      if (data.some((v) => v == null)) {
+        actions.emit([]);
+        return;
+      }
+      const text = typeof prompt === "string" ? prompt : prompt(...data);
+      if (!text) {
+        actions.emit([]);
+        return;
+      }
+      actions.emit([{ role: "user", content: text }]);
+    },
+    {
+      name: `${sourceName}::messages`,
+      meta: aiMeta("prompt_node::messages"),
+      initial: []
+    }
+  );
+  const output = switchMap(
+    messagesNode,
+    (msgs) => {
+      const chatMsgs = msgs;
+      if (!chatMsgs || chatMsgs.length === 0) {
+        return node4([], { initial: null });
+      }
+      const ac = new AbortController();
+      async function* pumpAndCollect() {
+        try {
+          const accumulated = await streamingInvoke(
+            adapter,
+            chatMsgs,
+            {
+              model: opts?.model,
+              temperature: opts?.temperature,
+              maxTokens: opts?.maxTokens,
+              systemPrompt: opts?.systemPrompt,
+              signal: ac.signal
+            },
+            deltaTopic
+          );
+          yield parseAccumulated(accumulated, format);
+        } finally {
+          ac.abort();
+        }
+      }
+      return fromAny7(pumpAndCollect());
+    },
+    { meta: factoryTag2("streamingPromptNode") }
+  );
+  const accumulatedText = makeAccumulatedText(deltaTopic, `${sourceName}::accumulatedText`);
+  const unsubOutput = keepalive4(output);
+  return {
+    output,
+    deltaTopic,
+    accumulatedText,
+    dispose: () => {
+      unsubOutput();
+      deltaTopic.destroy();
+    }
+  };
+}
+function gatedStream(graph, name, adapter, deps, prompt, opts) {
+  const cancelSignal = node4([], { name: `${name}/cancel`, initial: 0 });
+  let cancelCounter = 0;
+  const allDeps = [...deps, cancelSignal];
+  const sourceName = opts?.name ?? name;
+  const format = opts?.format ?? "text";
+  const deltaTopic = topic(`${sourceName}/stream`, {
+    ...opts?.retainedLimit != null ? { retainedLimit: opts.retainedLimit } : {}
+  });
+  const messagesNode = node4(
+    allDeps,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const depValues = data.slice(0, -1);
+      if (depValues.some((v) => v == null)) {
+        actions.emit([]);
+        return;
+      }
+      const text = typeof prompt === "string" ? prompt : prompt(...depValues);
+      if (!text) {
+        actions.emit([]);
+        return;
+      }
+      actions.emit([{ role: "user", content: text }]);
+    },
+    {
+      name: `${sourceName}::messages`,
+      meta: aiMeta("prompt_node::messages"),
+      initial: []
+    }
+  );
+  const output = switchMap(
+    messagesNode,
+    (msgs) => {
+      const chatMsgs = msgs;
+      if (!chatMsgs || chatMsgs.length === 0) {
+        return node4([], { initial: null });
+      }
+      const ac = new AbortController();
+      async function* pumpAndCollect() {
+        try {
+          const accumulated = await streamingInvoke(
+            adapter,
+            chatMsgs,
+            {
+              model: opts?.model,
+              temperature: opts?.temperature,
+              maxTokens: opts?.maxTokens,
+              systemPrompt: opts?.systemPrompt,
+              signal: ac.signal
+            },
+            deltaTopic
+          );
+          yield parseAccumulated(accumulated, format);
+        } finally {
+          ac.abort();
+        }
+      }
+      return fromAny7(pumpAndCollect());
+    },
+    { meta: factoryTag2("gatedStream") }
+  );
+  const accumulatedText = makeAccumulatedText(deltaTopic, `${sourceName}::accumulatedText`);
+  const nonNullOutput = filter(output, (v) => v != null);
+  graph.add(nonNullOutput, { name: `${name}/raw` });
+  const gateSubgraph = pipelineGraph(`${name}/gate-graph`);
+  graph.mount(`${name}/gate-graph`, gateSubgraph);
+  const gateCtrl = gateSubgraph.approvalGate(
+    `${name}/gate`,
+    nonNullOutput,
+    opts?.gate
+  );
+  const unsubOutput = keepalive4(output);
+  const unsubGate = keepalive4(gateCtrl.output);
+  const unsubAccumulated = keepalive4(accumulatedText);
+  graph.addDisposer(unsubOutput);
+  graph.addDisposer(unsubGate);
+  graph.addDisposer(unsubAccumulated);
+  const originalReject = gateCtrl.reject.bind(gateCtrl);
+  const gateWithAbort = {
+    ...gateCtrl,
+    reject(count = 1) {
+      batch(() => {
+        originalReject(count);
+        cancelSignal.emit(++cancelCounter);
+      });
+    }
+  };
+  return {
+    output: gateCtrl.output,
+    deltaTopic,
+    accumulatedText,
+    gate: gateWithAbort,
+    dispose: () => {
+      unsubOutput();
+      unsubGate();
+      unsubAccumulated();
+      deltaTopic.destroy();
+    }
+  };
+}
+
+// src/utils/ai/prompts/system-prompt.ts
+import { node as node5 } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny8, keepalive as keepalive5 } from "@graphrefly/pure-ts/extra";
+function systemPromptBuilder(sections, opts) {
+  const separator = opts?.separator ?? "\n\n";
+  const sectionNodes = sections.map(
+    (s) => typeof s === "string" ? node5([], { initial: s }) : fromAny8(s)
+  );
+  const prompt = node5(
+    sectionNodes,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(data.filter((v) => v != null && v !== "").join(separator));
+    },
+    {
+      name: opts?.name ?? "systemPrompt",
+      describeKind: "derived",
+      meta: aiMeta("system_prompt"),
+      initial: ""
+    }
+  );
+  const unsub = keepalive5(prompt);
+  return Object.assign(prompt, { dispose: unsub });
+}
+
+// src/utils/ai/extractors/cost-meter.ts
+import { node as node6 } from "@graphrefly/pure-ts/core";
+var costMeterEqual = (a, b) => {
+  if (a === b) return true;
+  return a.chunkCount === b.chunkCount && a.charCount === b.charCount && a.estimatedTokens === b.estimatedTokens && a.estimated === b.estimated;
+};
+function costMeterExtractor(deltaTopic, opts) {
+  const charsPerToken = opts?.charsPerToken ?? 4;
+  const ZERO = {
+    chunkCount: 0,
+    charCount: 0,
+    estimatedTokens: 0,
+    estimated: true
+  };
+  let cleanup;
+  return node6(
+    [deltaTopic.latest],
+    (batchData, actions, ctx) => {
+      if (cleanup === void 0) {
+        const store2 = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store2.chunkCount;
+            delete store2.charCount;
+            delete store2.usageTokens;
+            delete store2.sawUsage;
+          }
+        };
+      }
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const d = data[0];
+      if (d === void 0) {
+        actions.emit(ZERO);
+        return cleanup;
+      }
+      const delta = d;
+      if (!("chunkCount" in ctx.store)) {
+        ctx.store.chunkCount = 0;
+        ctx.store.charCount = 0;
+        ctx.store.usageTokens = 0;
+        ctx.store.sawUsage = false;
+      }
+      const store = ctx.store;
+      if (delta.type === "token") {
+        store.chunkCount += 1;
+        store.charCount += delta.delta.length;
+      } else if (delta.type === "usage") {
+        store.sawUsage = true;
+        store.usageTokens = sumInputTokens(delta.usage) + sumOutputTokens(delta.usage);
+      }
+      const estimatedTokens = store.sawUsage ? store.usageTokens : Math.ceil(store.charCount / charsPerToken);
+      actions.emit({
+        chunkCount: store.chunkCount,
+        charCount: store.charCount,
+        estimatedTokens,
+        estimated: !store.sawUsage
+      });
+      return cleanup;
+    },
+    {
+      name: opts?.name ?? "cost-meter",
+      describeKind: "derived",
+      initial: ZERO,
+      meta: aiMeta("cost_meter_extractor"),
+      equals: costMeterEqual
+    }
+  );
+}
+
+// src/utils/ai/extractors/keyword-flag.ts
+import { node as node7 } from "@graphrefly/pure-ts/core";
+var keywordFlagsEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.label !== y.label || x.pattern !== y.pattern || x.match !== y.match || x.position !== y.position) {
+      return false;
+    }
+  }
+  return true;
+};
+function keywordFlagExtractor(accumulatedText, opts) {
+  const maxPatternLength = opts.maxPatternLength ?? 128;
+  for (const p of opts.patterns) {
+    if (p.pattern.source.length > maxPatternLength) {
+      throw new Error(
+        `keywordFlagExtractor: pattern "${p.label}" literal exceeds maxPatternLength (${p.pattern.source.length} > ${maxPatternLength}); raise the option or shorten the pattern.`
+      );
+    }
+  }
+  const compiled = opts.patterns.map((p) => ({
+    label: p.label,
+    pattern: p.pattern,
+    compiled: new RegExp(p.pattern.source, `${p.pattern.flags.replace("g", "")}g`)
+  }));
+  let cleanup;
+  return node7(
+    [accumulatedText],
+    (batchData, actions, ctx) => {
+      if (cleanup === void 0) {
+        const store = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store.flags;
+            delete store.scannedTo;
+          }
+        };
+      }
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const text = data[0];
+      if (text == null) {
+        actions.emit([]);
+        return cleanup;
+      }
+      const accumulated = text;
+      if (!("flags" in ctx.store)) {
+        ctx.store.flags = [];
+        ctx.store.scannedTo = 0;
+      }
+      const flags = ctx.store.flags;
+      const scannedTo = ctx.store.scannedTo;
+      const startOffset = Math.max(0, scannedTo - maxPatternLength);
+      const region = accumulated.slice(startOffset);
+      let added = false;
+      for (const { pattern, label, compiled: re } of compiled) {
+        re.lastIndex = 0;
+        for (const m of region.matchAll(re)) {
+          const pos = startOffset + (m.index ?? 0);
+          if (pos + m[0].length <= scannedTo) continue;
+          flags.push({ label, pattern, match: m[0], position: pos });
+          added = true;
+        }
+      }
+      ctx.store.scannedTo = accumulated.length;
+      actions.emit(added ? [...flags] : flags.slice());
+      return cleanup;
+    },
+    {
+      name: opts.name ?? "keyword-flag-extractor",
+      describeKind: "derived",
+      initial: [],
+      meta: aiMeta("keyword_flag_extractor"),
+      equals: keywordFlagsEqual
+    }
+  );
+}
+
+// src/utils/ai/extractors/stream-extractor.ts
+import { node as node8 } from "@graphrefly/pure-ts/core";
+function streamExtractor(accumulatedText, extractFn, opts) {
+  return node8(
+    [accumulatedText],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const text = data[0];
+      actions.emit(text == null ? null : extractFn(text));
+    },
+    {
+      name: opts?.name ?? "extractor",
+      describeKind: "derived",
+      initial: null,
+      meta: aiMeta("stream_extractor"),
+      ...opts?.equals ? { equals: opts.equals } : {}
+    }
+  );
+}
+
+// src/utils/ai/extractors/tool-call.ts
+import { node as node9 } from "@graphrefly/pure-ts/core";
+var toolCallsEqual = (a, b) => {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.startIndex !== y.startIndex || x.name !== y.name || x.raw !== y.raw) {
+      return false;
+    }
+  }
+  return true;
+};
+function toolCallExtractor(accumulatedText, opts) {
+  let cleanup;
+  return node9(
+    [accumulatedText],
+    (batchData, actions, ctx) => {
+      if (cleanup === void 0) {
+        const store = ctx.store;
+        cleanup = {
+          onDeactivation: () => {
+            delete store.calls;
+            delete store.scanFrom;
+          }
+        };
+      }
+      const data = batchData.map(
+        (batch2, i2) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i2]
+      );
+      const text = data[0];
+      if (text == null) {
+        actions.emit([]);
+        return cleanup;
+      }
+      const accumulated = text;
+      if (!("calls" in ctx.store)) {
+        ctx.store.calls = [];
+        ctx.store.scanFrom = 0;
+      }
+      const calls = ctx.store.calls;
+      let i = ctx.store.scanFrom;
+      let added = false;
+      while (i < accumulated.length) {
+        const start = accumulated.indexOf("{", i);
+        if (start === -1) {
+          ctx.store.scanFrom = accumulated.length;
+          break;
+        }
+        let depth = 0;
+        let end = -1;
+        let inString = false;
+        for (let j = start; j < accumulated.length; j++) {
+          const ch = accumulated[j];
+          if (inString) {
+            if (ch === "\\" && j + 1 < accumulated.length) {
+              j++;
+            } else if (ch === '"') {
+              inString = false;
+            }
+          } else if (ch === '"') {
+            inString = true;
+          } else if (ch === "{") {
+            depth++;
+          } else if (ch === "}") {
+            depth--;
+            if (depth === 0) {
+              end = j;
+              break;
+            }
+          }
+        }
+        if (end === -1) {
+          ctx.store.scanFrom = start;
+          break;
+        }
+        const raw = accumulated.slice(start, end + 1);
+        try {
+          const parsed = JSON.parse(raw);
+          if (typeof parsed.name === "string" && parsed.arguments != null && typeof parsed.arguments === "object") {
+            calls.push({
+              name: parsed.name,
+              arguments: parsed.arguments,
+              raw,
+              startIndex: start
+            });
+            added = true;
+          }
+        } catch {
+        }
+        i = end + 1;
+        ctx.store.scanFrom = i;
+      }
+      actions.emit(added ? [...calls] : calls.slice());
+      return cleanup;
+    },
+    {
+      name: opts?.name ?? "tool-call-extractor",
+      describeKind: "derived",
+      initial: [],
+      meta: aiMeta("tool_call_extractor"),
+      equals: toolCallsEqual
+    }
+  );
+}
+
+// src/utils/ai/safety/content-gate.ts
+import { node as node10 } from "@graphrefly/pure-ts/core";
+function contentGate(accumulatedText, classifier, threshold, opts) {
+  const hardThreshold = threshold * (opts?.hardMultiplier ?? 1.5);
+  const isNodeClassifier = typeof classifier !== "function";
+  const deps = [accumulatedText];
+  if (isNodeClassifier) deps.push(classifier);
+  return node10(
+    deps,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const text = data[0] ?? "";
+      if (text.length === 0) {
+        actions.emit("allow");
+        return;
+      }
+      const score = isNodeClassifier ? data[1] ?? 0 : classifier(text);
+      if (score >= hardThreshold) {
+        actions.emit("block");
+        return;
+      }
+      if (score >= threshold) {
+        actions.emit("review");
+        return;
+      }
+      actions.emit("allow");
+    },
+    { describeKind: "derived", name: opts?.name ?? "content-gate", initial: "allow" }
+  );
+}
+
+// src/utils/ai/safety/redactor.ts
+import { node as node11 } from "@graphrefly/pure-ts/core";
+function redactor(accumulatedText, patterns, replaceFn, opts) {
+  const replace = replaceFn ?? (() => "[REDACTED]");
+  function sanitize(text) {
+    let result = text;
+    for (const pat of patterns) {
+      const global = pat.global ? pat : new RegExp(pat.source, `${pat.flags}g`);
+      result = result.replace(global, (m) => replace(m, pat));
+    }
+    return result;
+  }
+  return node11(
+    [accumulatedText],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit(sanitize(data[0] ?? ""));
+    },
+    { describeKind: "derived", name: opts?.name ?? "redactor", initial: "" }
+  );
+}
+
+// src/utils/ai/agents/handoff.ts
+import { factoryTag as factoryTag3, node as node12 } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny9, switchMap as switchMap2 } from "@graphrefly/pure-ts/extra";
+function handoff(from, toFactory, opts) {
+  const src = fromAny9(from);
+  const cond = opts?.condition != null ? fromAny9(opts.condition) : null;
+  const nullState = node12([], {
+    initial: null,
+    name: opts?.name ? `${opts.name}::null` : "handoff::null"
+  });
+  if (cond == null) {
+    return switchMap2(
+      src,
+      (v) => {
+        if (v == null) return nullState;
+        const input = node12([], { initial: v });
+        return toFactory(input);
+      },
+      { meta: factoryTag3("handoff") }
+    );
+  }
+  const router = node12(
+    [src, cond],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      actions.emit({ v: data[0], open: data[1] === true });
+    },
+    { name: opts?.name ? `${opts.name}::router` : "handoff::router", describeKind: "derived" }
+  );
+  return switchMap2(
+    router,
+    ({ v, open }) => {
+      if (v == null) return nullState;
+      if (!open) return node12([], { initial: v });
+      const input = node12([], { initial: v });
+      return toFactory(input);
+    },
+    { meta: factoryTag3("handoff") }
+  );
+}
+
+// src/utils/ai/agents/tool-selector.ts
+import { factoryTag as factoryTag4, node as node13 } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny10 } from "@graphrefly/pure-ts/extra";
+function toolSelector(allTools, constraints, opts) {
+  const allToolsNode = fromAny10(allTools);
+  const constraintNodes = constraints.map((c) => fromAny10(c));
+  const deps = [allToolsNode, ...constraintNodes];
+  return node13(
+    deps,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch2, i) => batch2 != null && batch2.length > 0 ? batch2.at(-1) : ctx.prevData[i]
+      );
+      const tools = data[0] ?? [];
+      const preds = data.slice(1);
+      actions.emit(
+        tools.filter((tool) => {
+          for (const pred of preds) {
+            if (pred == null) continue;
+            if (!pred(tool)) return false;
+          }
+          return true;
+        })
+      );
+    },
+    {
+      name: opts?.name ?? "tool-selector",
+      describeKind: "derived",
+      meta: { ...aiMeta("tool_selector"), ...factoryTag4("toolSelector") },
+      equals: (a, b) => {
+        const la = a;
+        const lb = b;
+        if (la.length !== lb.length) return false;
+        for (let i = 0; i < la.length; i++) {
+          if (la[i] !== lb[i]) return false;
+        }
+        return true;
+      }
+    }
+  );
+}
+
+// src/utils/ai/memory/admission.ts
+function admissionScored(opts) {
+  const thresholds = opts.thresholds ?? {};
+  return (raw) => {
+    const scores = opts.scoreFn(raw);
+    for (const dim of Object.keys(thresholds)) {
+      const min = thresholds[dim];
+      if (min === void 0) continue;
+      const s = scores[dim];
+      const safe = Number.isFinite(s) ? s : Number.NEGATIVE_INFINITY;
+      if (safe < min) return false;
+    }
+    return true;
+  };
+}
+function admissionFilter3D(opts) {
+  const thresholds = {
+    persistence: opts.persistenceThreshold ?? 0.3,
+    personalValue: opts.personalValueThreshold ?? 0.3
+  };
+  const base = admissionScored({
+    scoreFn: opts.scoreFn,
+    thresholds
+  });
+  if (!opts.requireStructured) return base;
+  return (raw) => {
+    if (!base(raw)) return false;
+    const s = opts.scoreFn(raw).structure;
+    return Number.isFinite(s) && s > 0;
+  };
+}
+
+// src/utils/ai/graph-integration/gauges-as-context.ts
+function gaugesAsContext(graph, actor, options) {
+  const described = graph.describe({ actor, detail: "full" });
+  const groupByTags = options?.groupByTags ?? true;
+  const separator = options?.separator ?? "\n";
+  const entries = [];
+  const sinceVersion = options?.sinceVersion;
+  for (const [path, node16] of Object.entries(described.nodes)) {
+    const meta = node16.meta ?? {};
+    const desc = meta.description;
+    const format = meta.format;
+    if (!desc && !format) continue;
+    if (sinceVersion != null && node16.v != null) {
+      const lastSeen = sinceVersion.get(path);
+      if (lastSeen != null && lastSeen.id === node16.v.id && node16.v.version <= lastSeen.version)
+        continue;
+    }
+    const label = desc ?? path;
+    const value = node16.value;
+    const unit = meta.unit;
+    let formatted;
+    if (format === "currency" && typeof value === "number") {
+      formatted = `$${value.toFixed(2)}`;
+    } else if (format === "percentage" && typeof value === "number") {
+      formatted = `${(value * 100).toFixed(1)}%`;
+    } else if (value === void 0 || value === null) {
+      formatted = "(no value)";
+    } else {
+      formatted = String(value);
+    }
+    if (unit && format !== "currency" && format !== "percentage") {
+      formatted = `${formatted} ${unit}`;
+    }
+    entries.push({ path, description: label, formatted });
+  }
+  if (entries.length === 0) return "";
+  if (groupByTags) {
+    const tagGroups = /* @__PURE__ */ new Map();
+    const ungrouped = [];
+    for (const entry of entries) {
+      const node16 = described.nodes[entry.path];
+      const tags = node16.meta?.tags;
+      if (tags && tags.length > 0) {
+        const tag = tags[0];
+        let group = tagGroups.get(tag);
+        if (!group) {
+          group = [];
+          tagGroups.set(tag, group);
+        }
+        group.push(entry);
+      } else {
+        ungrouped.push(entry);
+      }
+    }
+    if (tagGroups.size === 0) {
+      return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
+    }
+    const sections = [];
+    for (const [tag, group] of [...tagGroups.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+      sections.push(
+        `[${tag}]${separator}${group.map((e) => `- ${e.description}: ${e.formatted}`).join(separator)}`
+      );
+    }
+    if (ungrouped.length > 0) {
+      sections.push(ungrouped.map((e) => `- ${e.description}: ${e.formatted}`).join(separator));
+    }
+    return sections.join(separator + separator);
+  }
+  return entries.map((e) => `- ${e.description}: ${e.formatted}`).join(separator);
+}
+
+// src/utils/ai/graph-integration/graph-from-spec.ts
+import { COMPLETE, ERROR, node as node14 } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny11, switchMap as switchMap3 } from "@graphrefly/pure-ts/extra";
+var GRAPH_FROM_SPEC_SYSTEM_PROMPT = `You are a graph architect for GraphReFly, a reactive graph protocol.
+
+Given a natural-language description, produce a JSON graph specification with this structure:
+
+{
+  "name": "<graph_name>",
+  "nodes": {
+    "<node_name>": {
+      "type": "state" | "derived" | "producer" | "effect" | "operator",
+      "initial": <initial_value_for_state_nodes>,
+      "deps": ["<dep_node_name>", ...],
+      "meta": {
+        "description": "<human-readable purpose>",
+        "type": "string" | "number" | "boolean" | "integer" | "enum",
+        "range": [min, max],
+        "values": ["a", "b"],
+        "format": "currency" | "percentage" | "status",
+        "access": "human" | "llm" | "both" | "system",
+        "unit": "<unit>",
+        "tags": ["<tag>"]
+      }
+    }
+  }
+}
+
+Rules:
+- "state" nodes have no deps and hold user/LLM-writable values (knobs). Use "initial" for the starting value.
+- "derived" nodes have deps and compute from them (pure, no side effects).
+- "effect" nodes have deps but produce side effects (no return value).
+- "producer" nodes have no deps but generate values asynchronously.
+- "operator" nodes are parameterized transformations with deps.
+- Use "deps" inside each node to declare dependencies \u2014 no separate "edges" array.
+- meta.description is required for every node.
+- Return ONLY valid JSON, no markdown fences or commentary.`;
+async function graphFromSpec(naturalLanguage, adapter, opts) {
+  const systemPrompt = opts?.systemPromptExtra ? `${GRAPH_FROM_SPEC_SYSTEM_PROMPT}
+
+${opts.systemPromptExtra}` : GRAPH_FROM_SPEC_SYSTEM_PROMPT;
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: naturalLanguage }
+  ];
+  const rawResult = adapter.invoke(messages, {
+    model: opts?.model,
+    temperature: opts?.temperature ?? 0,
+    maxTokens: opts?.maxTokens,
+    signal: opts?.signal
+  });
+  const response = await resolveToolHandlerResult(rawResult);
+  let content = response.content.trim();
+  if (content.startsWith("```")) {
+    content = stripFences(content);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`graphFromSpec: LLM response is not valid JSON: ${content.slice(0, 200)}`);
+  }
+  return compileSpec(parsed, { catalog: opts?.catalog });
+}
+function graphFromSpecReactive(input, adapter, opts) {
+  const inputNode = fromAny11(input);
+  return switchMap3(inputNode, (nl) => {
+    if (!nl || typeof nl !== "string" || nl.trim().length === 0) {
+      return node14([], { initial: null });
+    }
+    return node14(
+      (_data, actions) => {
+        const controller = new AbortController();
+        let cancelled = false;
+        graphFromSpec(nl, adapter, { ...opts, signal: controller.signal }).then((g) => {
+          if (cancelled) {
+            g.destroy();
+            return;
+          }
+          actions.emit(g);
+          actions.down([[COMPLETE]]);
+        }).catch((err) => {
+          if (cancelled) return;
+          actions.down([[ERROR, err]]);
+        });
+        return () => {
+          cancelled = true;
+          controller.abort();
+        };
+      },
+      { describeKind: "producer", ...{ name: "graphFromSpec::call" } }
+    );
+  });
+}
+
+// src/utils/ai/graph-integration/knobs-as-tools.ts
+function metaToJsonSchema(meta) {
+  const schema = {};
+  const metaType = meta.type;
+  if (metaType === "enum" && Array.isArray(meta.values)) {
+    schema.type = "string";
+    schema.enum = meta.values;
+  } else if (metaType === "integer") {
+    schema.type = "integer";
+  } else if (metaType === "number") {
+    schema.type = "number";
+  } else if (metaType === "boolean") {
+    schema.type = "boolean";
+  } else if (metaType === "string") {
+    schema.type = "string";
+  } else {
+    schema.type = ["string", "number", "boolean"];
+  }
+  if (Array.isArray(meta.range) && meta.range.length === 2) {
+    schema.minimum = meta.range[0];
+    schema.maximum = meta.range[1];
+  }
+  if (typeof meta.format === "string") {
+    schema.description = `Format: ${meta.format}`;
+  }
+  if (typeof meta.unit === "string") {
+    if (schema.description) {
+      schema.description += ` (${meta.unit})`;
+    } else {
+      schema.description = `Unit: ${meta.unit}`;
+    }
+  }
+  return schema;
+}
+function knobsAsTools(graph, actor) {
+  const described = graph.describe({ actor, detail: "full" });
+  const openai = [];
+  const mcp = [];
+  const definitions = [];
+  for (const [path, node16] of Object.entries(described.nodes)) {
+    if (node16.type !== "state") continue;
+    if (path.includes("::__meta__::")) continue;
+    if (node16.status === "completed" || node16.status === "errored") continue;
+    const meta = node16.meta ?? {};
+    const access = meta.access;
+    if (access === "human" || access === "system") continue;
+    const description = meta.description ?? `Set the value of ${path}`;
+    const valueSchema = metaToJsonSchema(meta);
+    const parameterSchema = {
+      type: "object",
+      required: ["value"],
+      properties: {
+        value: valueSchema
+      },
+      additionalProperties: false
+    };
+    const sanitizedName = path.replace(/::/g, "__");
+    openai.push({
+      type: "function",
+      function: {
+        name: sanitizedName,
+        description,
+        parameters: parameterSchema
+      }
+    });
+    mcp.push({
+      name: path,
+      description,
+      inputSchema: parameterSchema
+    });
+    const graphRef = graph;
+    const actorRef = actor;
+    const nv = node16.v;
+    definitions.push({
+      name: path,
+      description,
+      parameters: parameterSchema,
+      handler(args) {
+        graphRef.set(path, args.value, actorRef ? { actor: actorRef } : void 0);
+        return args.value;
+      },
+      ...nv != null ? { version: { id: nv.id, version: nv.version } } : {}
+    });
+  }
+  return { openai, mcp, definitions };
+}
+
+// src/utils/ai/graph-integration/suggest-strategy.ts
+import { COMPLETE as COMPLETE2, ERROR as ERROR2, node as node15 } from "@graphrefly/pure-ts/core";
+import { fromAny as fromAny12, switchMap as switchMap4, withLatestFrom } from "@graphrefly/pure-ts/extra";
+var SUGGEST_STRATEGY_SYSTEM_PROMPT = `You are a reactive graph optimizer for GraphReFly.
+
+Given a graph's current structure (from describe()) and a problem statement, suggest topology and parameter changes to solve the problem.
+
+Return ONLY valid JSON with this structure:
+{
+  "summary": "<one-line summary of the strategy>",
+  "reasoning": "<explanation of why these changes help>",
+  "operations": [
+    { "type": "add_node", "name": "<name>", "nodeType": "state|derived|effect|producer|operator", "meta": {...}, "initial": <value> },
+    { "type": "remove_node", "name": "<name>" },
+    { "type": "connect", "from": "<source>", "to": "<target>" },
+    { "type": "disconnect", "from": "<source>", "to": "<target>" },
+    { "type": "set_value", "name": "<name>", "value": <new_value> },
+    { "type": "update_meta", "name": "<name>", "key": "<meta_key>", "value": <new_value> }
+  ]
+}
+
+Rules:
+- Only suggest operations that reference existing nodes (for remove/disconnect/set_value/update_meta) or new nodes you define (for add_node).
+- Keep changes minimal \u2014 prefer the smallest set of operations that solves the problem.
+- Return ONLY valid JSON, no markdown fences or commentary.`;
+async function suggestStrategy(graph, problem, adapter, opts) {
+  const { expand: _, ...described } = graph.describe({ actor: opts?.actor, detail: "standard" });
+  const messages = [
+    { role: "system", content: SUGGEST_STRATEGY_SYSTEM_PROMPT },
+    {
+      role: "user",
+      content: JSON.stringify({
+        graph: described,
+        problem
+      })
+    }
+  ];
+  const rawResult = adapter.invoke(messages, {
+    model: opts?.model,
+    temperature: opts?.temperature ?? 0,
+    maxTokens: opts?.maxTokens,
+    signal: opts?.signal
+  });
+  const response = await resolveToolHandlerResult(rawResult);
+  let content = response.content.trim();
+  if (content.startsWith("```")) {
+    content = content.replace(/^```(?:json)?\s*/, "").replace(/\s*```$/, "");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    throw new Error(`suggestStrategy: LLM response is not valid JSON: ${content.slice(0, 200)}`);
+  }
+  const plan = parsed;
+  if (typeof plan.summary !== "string") {
+    throw new Error("suggestStrategy: missing 'summary' in response");
+  }
+  if (typeof plan.reasoning !== "string") {
+    throw new Error("suggestStrategy: missing 'reasoning' in response");
+  }
+  if (!Array.isArray(plan.operations)) {
+    throw new Error("suggestStrategy: missing 'operations' array in response");
+  }
+  return {
+    summary: plan.summary,
+    reasoning: plan.reasoning,
+    operations: plan.operations
+  };
+}
+function suggestStrategyReactive(graph, problem, adapter, opts) {
+  const problemNode = fromAny12(problem);
+  const paired = withLatestFrom(problemNode, graph);
+  return switchMap4(paired, (pair) => {
+    if (pair == null) return node15([], { initial: null });
+    const [pText, g] = pair;
+    if (!g || !pText || typeof pText !== "string" || pText.trim().length === 0) {
+      return node15([], { initial: null });
+    }
+    if (g.destroyed) return node15([], { initial: null });
+    return node15(
+      (_data, actions) => {
+        const controller = new AbortController();
+        let cancelled = false;
+        suggestStrategy(g, pText, adapter, { ...opts, signal: controller.signal }).then((plan) => {
+          if (cancelled) return;
+          actions.emit(plan);
+          actions.down([[COMPLETE2]]);
+        }).catch((err) => {
+          if (cancelled) return;
+          actions.down([[ERROR2, err]]);
+        });
+        return () => {
+          cancelled = true;
+          controller.abort();
+        };
+      },
+      { describeKind: "producer", ...{ name: "suggestStrategy::call" } }
+    );
+  });
+}
+
+// src/utils/ai/graph-integration/validate-graph-def.ts
+var VALID_NODE_TYPES = /* @__PURE__ */ new Set(["state", "derived", "producer", "operator", "effect"]);
+function validateGraphDef(def) {
+  const errors = [];
+  if (def == null || typeof def !== "object") {
+    return { valid: false, errors: ["Definition must be a non-null object"] };
+  }
+  const d = def;
+  if (typeof d.name !== "string" || d.name.length === 0) {
+    errors.push("Missing or empty 'name' field");
+  }
+  if (d.nodes == null || typeof d.nodes !== "object" || Array.isArray(d.nodes)) {
+    errors.push("Missing or invalid 'nodes' field (must be an object)");
+    return { valid: false, errors };
+  }
+  const nodeNames = new Set(Object.keys(d.nodes));
+  for (const [name, raw] of Object.entries(d.nodes)) {
+    if (raw == null || typeof raw !== "object") {
+      errors.push(`Node "${name}": must be an object`);
+      continue;
+    }
+    const node16 = raw;
+    if (typeof node16.type !== "string" || !VALID_NODE_TYPES.has(node16.type)) {
+      errors.push(
+        `Node "${name}": invalid type "${String(node16.type)}" (expected: ${[...VALID_NODE_TYPES].join(", ")})`
+      );
+    }
+    if (Array.isArray(node16.deps)) {
+      for (const dep of node16.deps) {
+        if (typeof dep === "string" && !nodeNames.has(dep)) {
+          errors.push(`Node "${name}": dep "${dep}" does not reference an existing node`);
+        }
+      }
+    }
+  }
+  if (!Array.isArray(d.edges)) {
+    if (d.edges !== void 0) {
+      errors.push("'edges' must be an array");
+    }
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < d.edges.length; i++) {
+      const edge = d.edges[i];
+      if (edge == null || typeof edge !== "object") {
+        errors.push(`Edge [${i}]: must be an object`);
+        continue;
+      }
+      const e = edge;
+      if (typeof e.from !== "string" || !nodeNames.has(e.from)) {
+        errors.push(`Edge [${i}]: 'from' "${String(e.from)}" does not reference an existing node`);
+      }
+      if (typeof e.to !== "string" || !nodeNames.has(e.to)) {
+        errors.push(`Edge [${i}]: 'to' "${String(e.to)}" does not reference an existing node`);
+      }
+      const key = `${e.from}->${e.to}`;
+      if (seen.has(key)) {
+        errors.push(`Edge [${i}]: duplicate edge ${key}`);
+      }
+      seen.add(key);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+export {
+  createCapabilitiesRegistry,
+  observableAdapter,
+  zeroPrice,
+  computePrice,
+  createPricingRegistry,
+  registryPricing,
+  composePricing,
+  pricingFor,
+  withLLMBreaker,
+  BudgetExhaustedError,
+  withBudgetGate,
+  withDryRun,
+  parseRateLimitFromError,
+  withRateLimiter,
+  withRetry,
+  LLMTimeoutError,
+  withLLMTimeout,
+  resilientAdapter,
+  frozenContext,
+  streamingPromptNode,
+  gatedStream,
+  systemPromptBuilder,
+  costMeterExtractor,
+  keywordFlagExtractor,
+  streamExtractor,
+  toolCallExtractor,
+  contentGate,
+  redactor,
+  handoff,
+  toolSelector,
+  admissionScored,
+  admissionFilter3D,
+  gaugesAsContext,
+  graphFromSpec,
+  graphFromSpecReactive,
+  knobsAsTools,
+  suggestStrategy,
+  suggestStrategyReactive,
+  validateGraphDef
+};
+//# sourceMappingURL=chunk-HULCUY35.js.map