@graphrefly/graphrefly 0.11.0 → 0.12.0

package/dist/index.js

@@ -64,7 +64,6 @@ import {
   fromSyslog,
   fromWebSocket,
   fromWebhook,
-  gate,
   interval,
   last,
   linear,
@@ -126,6 +125,7 @@ import {
   toWebSocket,
   tokenBucket,
   tokenTracker,
+  valve,
   verifiable,
   window,
   windowCount,
@@ -137,16 +137,16 @@ import {
   workerBridge,
   workerSelf,
   zip
-} from "./chunk-2VHNCFGG.js";
+} from "./chunk-BRPCN2HJ.js";
 import {
   cqrs_exports,
   nestjs_exports
-} from "./chunk-PZCDQD2U.js";
+} from "./chunk-NULSP7U4.js";
 import {
   DEFAULT_DOWN,
   bridge,
   core_exports
-} from "./chunk-FMVFRP7L.js";
+} from "./chunk-XWMTVV2D.js";
 import {
   JsonCodec,
   createDagCborCodec,
@@ -154,7 +154,7 @@ import {
   graph_exports,
   negotiateCodec,
   replayWAL
-} from "./chunk-U5HFZGAQ.js";
+} from "./chunk-IXTW3BIO.js";
 import {
   cached,
   createWatermarkController,
@@ -187,7 +187,7 @@ import {
   toArray,
   toMessages$,
   toObservable
-} from "./chunk-5WXTWOD7.js";
+} from "./chunk-X732W3QA.js";
 import {
   ResettableTimer
 } from "./chunk-WZ2Z2CRV.js";
@@ -195,17 +195,17 @@ import {
   analyzeAndMeasure,
   computeLineBreaks,
   reactive_layout_exports
-} from "./chunk-3WACHRHV.js";
+} from "./chunk-JYRHO63K.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
   reachable
-} from "./chunk-2OTXEZQO.js";
+} from "./chunk-VQWLA6XQ.js";
 import {
   describeNode,
   metaSnapshot,
   resolveDescribeFields
-} from "./chunk-OHUECHWY.js";
+} from "./chunk-6OLNYOGU.js";
 import {
   CLEANUP_RESULT,
   COMPLETE,
@@ -249,7 +249,7 @@ import {
   propagatesToMeta,
   state,
   wallClockNs
-} from "./chunk-UG2QZMRN.js";
+} from "./chunk-4F2ZFD5L.js";
 
 // src/compat/index.ts
 var compat_exports = {};
@@ -1075,6 +1075,7 @@ __export(ai_exports, {
   knobsAsTools: () => knobsAsTools,
   llmConsolidator: () => llmConsolidator,
   llmExtractor: () => llmExtractor,
+  promptNode: () => promptNode,
   suggestStrategy: () => suggestStrategy,
   systemPromptBuilder: () => systemPromptBuilder,
   toolRegistry: () => toolRegistry,
@@ -1590,6 +1591,75 @@ function fromLLMStream(adapter, messages, opts) {
     }
   };
 }
+function extractContent(resp) {
+  if (resp != null && typeof resp === "object" && "content" in resp) {
+    return String(resp.content);
+  }
+  if (typeof resp === "string") return resp;
+  return String(resp);
+}
+function promptNode(adapter, deps, prompt, opts) {
+  const format = opts?.format ?? "text";
+  const retries = opts?.retries ?? 0;
+  const useCache = opts?.cache ?? false;
+  const cache2 = useCache ? /* @__PURE__ */ new Map() : null;
+  const messagesNode = derived(
+    deps,
+    (values) => {
+      const text = typeof prompt === "string" ? prompt : prompt(...values);
+      const msgs = [];
+      if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
+      msgs.push({ role: "user", content: text });
+      return msgs;
+    },
+    {
+      name: opts?.name ? `${opts.name}::messages` : "prompt_node::messages",
+      meta: aiMeta("prompt_node")
+    }
+  );
+  const result = switchMap(messagesNode, (msgs) => {
+    if (!msgs || msgs.length === 0) {
+      return state(null);
+    }
+    const cacheKey = useCache ? JSON.stringify(msgs.map((m) => [m.role, m.content])) : "";
+    if (cache2?.has(cacheKey)) {
+      return state(cache2.get(cacheKey));
+    }
+    async function attempt(remaining) {
+      try {
+        const resp = await new Promise((resolve, reject) => {
+          const input = adapter.invoke(msgs, {
+            model: opts?.model,
+            temperature: opts?.temperature,
+            maxTokens: opts?.maxTokens,
+            systemPrompt: opts?.systemPrompt
+          });
+          if (input && typeof input.then === "function") {
+            input.then(resolve, reject);
+          } else if (input && typeof input.get === "function") {
+            resolve(input.get());
+          } else {
+            resolve(input);
+          }
+        });
+        const content = extractContent(resp);
+        let parsed;
+        if (format === "json") {
+          parsed = JSON.parse(stripFences(content));
+        } else {
+          parsed = content;
+        }
+        cache2?.set(cacheKey, parsed);
+        return parsed;
+      } catch (err) {
+        if (remaining > 0) return attempt(remaining - 1);
+        throw err;
+      }
+    }
+    return attempt(retries);
+  });
+  return result;
+}
 var ChatStreamGraph = class extends Graph {
   _log;
   _keepaliveSubs = [];
@@ -5229,7 +5299,7 @@ __export(orchestration_exports, {
   approval: () => approval,
   branch: () => branch,
   forEach: () => forEach2,
-  gate: () => gate2,
+  gate: () => gate,
   join: () => join,
   loop: () => loop,
   onFailure: () => onFailure,
@@ -5237,6 +5307,7 @@ __export(orchestration_exports, {
   sensor: () => sensor,
   subPipeline: () => subPipeline,
   task: () => task,
+  valve: () => valve2,
   wait: () => wait
 });
 function resolveDep(graph, dep) {
@@ -5336,7 +5407,7 @@ function branch(graph, name, source, predicate, opts) {
   registerStep(graph, name, step, src.path ? [src.path] : []);
   return step;
 }
-function gate2(graph, name, source, control, opts) {
+function valve2(graph, name, source, control, opts) {
   const src = resolveDep(graph, source);
   const ctrl = resolveDep(graph, control);
   const step = node(
@@ -5353,7 +5424,7 @@ function gate2(graph, name, source, control, opts) {
       ...opts,
       name,
       describeKind: "operator",
-      meta: baseMeta3("gate", opts?.meta)
+      meta: baseMeta3("valve", opts?.meta)
     }
   );
   registerStep(
@@ -5392,6 +5463,119 @@ function approval(graph, name, source, approver, opts) {
   );
   return step;
 }
+function gate(graph, name, source, opts) {
+  const maxPending = opts?.maxPending ?? Infinity;
+  if (maxPending < 1 && maxPending !== Infinity) {
+    throw new RangeError("gate: maxPending must be >= 1");
+  }
+  const startOpen = opts?.startOpen ?? false;
+  const src = resolveDep(graph, source);
+  const pendingNode = state([], { name: "pending", equals: () => false });
+  const isOpenNode = state(startOpen, { name: "isOpen" });
+  const countNode = node([pendingNode], ([arr]) => arr.length, {
+    name: "count",
+    describeKind: "derived"
+  });
+  let queue = [];
+  let torn = false;
+  function syncPending() {
+    pendingNode.down([[DATA, [...queue]]]);
+  }
+  function enqueue(value) {
+    queue.push(value);
+    if (queue.length > maxPending) queue.shift();
+    syncPending();
+  }
+  function dequeue(n) {
+    const items = queue.splice(0, n);
+    syncPending();
+    return items;
+  }
+  function guardTorn(method) {
+    if (torn) throw new Error(`gate: ${method}() called after gate was torn down`);
+  }
+  const output = node([src.node], () => void 0, {
+    name,
+    describeKind: "operator",
+    meta: baseMeta3("gate", opts?.meta),
+    onMessage(msg, _depIndex, actions) {
+      if (msg[0] === DATA) {
+        if (isOpenNode.get()) {
+          actions.emit(msg[1]);
+        } else {
+          enqueue(msg[1]);
+          actions.down([[RESOLVED]]);
+        }
+        return true;
+      }
+      if (msg[0] === TEARDOWN) {
+        torn = true;
+        queue = [];
+        syncPending();
+        actions.down([msg]);
+        return true;
+      }
+      if (msg[0] === COMPLETE || msg[0] === ERROR) {
+        torn = true;
+        queue = [];
+        syncPending();
+        actions.down([msg]);
+        return true;
+      }
+      actions.down([msg]);
+      return true;
+    }
+  });
+  const controller = {
+    node: output,
+    pending: pendingNode,
+    count: countNode,
+    isOpen: isOpenNode,
+    approve(count = 1) {
+      guardTorn("approve");
+      const items = dequeue(count);
+      for (const item of items) {
+        if (torn) break;
+        output.down([[DATA, item]]);
+      }
+    },
+    reject(count = 1) {
+      guardTorn("reject");
+      dequeue(count);
+    },
+    modify(fn, count = 1) {
+      guardTorn("modify");
+      const snapshot = [...queue];
+      const items = dequeue(count);
+      for (let i = 0; i < items.length; i++) {
+        if (torn) break;
+        output.down([[DATA, fn(items[i], i, snapshot)]]);
+      }
+    },
+    open() {
+      guardTorn("open");
+      isOpenNode.down([[DATA, true]]);
+      const items = dequeue(queue.length);
+      for (const item of items) {
+        if (torn) break;
+        output.down([[DATA, item]]);
+      }
+    },
+    close() {
+      guardTorn("close");
+      isOpenNode.down([[DATA, false]]);
+    }
+  };
+  countNode.subscribe(() => void 0);
+  registerStep(graph, name, output, src.path ? [src.path] : []);
+  const internal = new Graph(`${name}_state`);
+  internal.add("pending", pendingNode);
+  internal.add("isOpen", isOpenNode);
+  internal.add("count", countNode);
+  internal.connect("pending", "count");
+  graph.mount(`${name}_state`, internal);
+  return controller;
+}
 function forEach2(graph, name, source, run, opts) {
   const src = resolveDep(graph, source);
   let terminated = false;
@@ -5720,7 +5904,6 @@ export {
   fromTimer,
   fromWebSocket,
   fromWebhook,
-  gate,
   globToRegExp,
   graph_exports as graph,
   graphspec_exports as graphspec,
@@ -5836,6 +6019,7 @@ export {
   toWebSocket,
   tokenBucket,
   tokenTracker,
+  valve,
   verifiable,
   version,
   vue_exports as vue,