@graphrefly/graphrefly 0.11.0 → 0.12.0

package/dist/index.cjs

@@ -182,7 +182,6 @@ __export(index_exports, {
   fromTimer: () => fromTimer,
   fromWebSocket: () => fromWebSocket,
   fromWebhook: () => fromWebhook,
-  gate: () => gate,
   globToRegExp: () => globToRegExp,
   graph: () => graph_exports,
   graphspec: () => graphspec_exports,
@@ -298,6 +297,7 @@ __export(index_exports, {
   toWebSocket: () => toWebSocket,
   tokenBucket: () => tokenBucket,
   tokenTracker: () => tokenTracker,
+  valve: () => valve,
   verifiable: () => verifiable,
   version: () => version,
   vue: () => vue_exports,
@@ -6948,7 +6948,6 @@ __export(extra_exports, {
   fromTimer: () => fromTimer,
   fromWebSocket: () => fromWebSocket,
   fromWebhook: () => fromWebhook,
-  gate: () => gate,
   globToRegExp: () => globToRegExp,
   interval: () => interval,
   last: () => last,
@@ -7027,6 +7026,7 @@ __export(extra_exports, {
   toWebSocket: () => toWebSocket,
   tokenBucket: () => tokenBucket,
   tokenTracker: () => tokenTracker,
+  valve: () => valve,
   verifiable: () => verifiable,
   window: () => window,
   windowCount: () => windowCount,
@@ -11507,30 +11507,58 @@ function throttle(source, ms, opts) {
   );
 }
 function sample(source, notifier, opts) {
+  let lastSourceValue = NO_VALUE;
+  let terminated = false;
+  let sourceCompleted = false;
   return node([source, notifier], () => void 0, {
     ...operatorOpts3(opts),
     completeWhenDepsComplete: false,
+    onResubscribe: opts?.resubscribable === true ? () => {
+      lastSourceValue = NO_VALUE;
+      terminated = false;
+      sourceCompleted = false;
+    } : void 0,
     onMessage(msg, i, a) {
+      if (terminated) return true;
       const t = msg[0];
-      if (t === ERROR) {
+      const tier = messageTier(t);
+      if (tier >= 3) {
+        if (t === ERROR) {
+          terminated = true;
+          a.down([msg]);
+          return true;
+        }
+        if (t === COMPLETE) {
+          if (i === 0) {
+            sourceCompleted = true;
+            lastSourceValue = NO_VALUE;
+            return true;
+          }
+          terminated = true;
+          a.down([msg]);
+          return true;
+        }
         a.down([msg]);
         return true;
       }
-      if (t === COMPLETE) {
+      if (i === 0) {
+        if (t === DATA) {
+          lastSourceValue = msg[1];
+          return true;
+        }
+        if (t === DIRTY || t === RESOLVED) return true;
         a.down([msg]);
         return true;
       }
-      if (i === 1 && t === DATA) {
-        a.emit(source.get());
-        return true;
-      }
-      if (i === 1 && t === RESOLVED) {
-        return true;
-      }
-      if (i === 0) {
+      if (t === DATA) {
+        if (lastSourceValue !== NO_VALUE && !sourceCompleted) {
+          a.emit(lastSourceValue);
+        }
         return true;
       }
-      return false;
+      if (t === RESOLVED) return true;
+      a.down([msg]);
+      return true;
     }
   });
 }
@@ -11997,7 +12025,7 @@ function rescue(source, recover, opts) {
     }
   });
 }
-function gate(source, control, opts) {
+function valve(source, control, opts) {
   return node(
     [source, control],
     (_deps, a) => {
@@ -12963,6 +12991,7 @@ __export(ai_exports, {
   knobsAsTools: () => knobsAsTools,
   llmConsolidator: () => llmConsolidator,
   llmExtractor: () => llmExtractor,
+  promptNode: () => promptNode,
   suggestStrategy: () => suggestStrategy,
   systemPromptBuilder: () => systemPromptBuilder,
   toolRegistry: () => toolRegistry,
@@ -13478,6 +13507,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 = [];
@@ -17693,7 +17791,7 @@ __export(orchestration_exports, {
   approval: () => approval,
   branch: () => branch,
   forEach: () => forEach2,
-  gate: () => gate2,
+  gate: () => gate,
   join: () => join2,
   loop: () => loop,
   onFailure: () => onFailure,
@@ -17701,6 +17799,7 @@ __export(orchestration_exports, {
   sensor: () => sensor,
   subPipeline: () => subPipeline,
   task: () => task,
+  valve: () => valve2,
   wait: () => wait
 });
 function resolveDep(graph, dep) {
@@ -17800,7 +17899,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(
@@ -17817,7 +17916,7 @@ function gate2(graph, name, source, control, opts) {
       ...opts,
       name,
       describeKind: "operator",
-      meta: baseMeta3("gate", opts?.meta)
+      meta: baseMeta3("valve", opts?.meta)
     }
   );
   registerStep(
@@ -17856,6 +17955,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;
@@ -18675,7 +18887,6 @@ var version = "0.0.0";
   fromTimer,
   fromWebSocket,
   fromWebhook,
-  gate,
   globToRegExp,
   graph,
   graphspec,
@@ -18791,6 +19002,7 @@ var version = "0.0.0";
   toWebSocket,
   tokenBucket,
   tokenTracker,
+  valve,
   verifiable,
   version,
   vue,