@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/chunk-5THCXDWY.js

@@ -0,0 +1,725 @@
+import {
+  aiMeta,
+  chatStream,
+  toolExecution,
+  toolRegistry
+} from "./chunk-OO5BM6CJ.js";
+import {
+  subscription,
+  topic
+} from "./chunk-Q3EYOCZB.js";
+import {
+  awaitSettled
+} from "./chunk-O3MT7DYI.js";
+
+// src/presets/ai/agent-loop.ts
+import {
+  batch,
+  DATA,
+  ERROR,
+  INVALIDATE,
+  node,
+  node as nodeFactory,
+  placeholderArgs,
+  RESOLVED
+} from "@graphrefly/pure-ts/core";
+import { fromAny, keepalive, switchMap } from "@graphrefly/pure-ts/extra";
+import { Graph } from "@graphrefly/pure-ts/graph";
+var AgentLoopGraph = class extends Graph {
+  chat;
+  tools;
+  /** Current agent status. `initial: "idle"` — always has a real value. */
+  status;
+  /** Turn count (completed LLM invocations this run). `initial: 0`. */
+  turn;
+  /** Aborted flag; flipped by `abort()` or external `AbortSignal`. `initial: false`. */
+  aborted;
+  /**
+   * Most recent LLM response. State-backed mirror driven by the response
+   * effect. **Stays SENTINEL** (`cache === undefined`, no DATA emitted)
+   * until the first real response — bridge subscribers see no spurious
+   * push-on-subscribe DATA. After a real response, holds the latest
+   * `LLMResponse`. Reset between `run()` calls via `[[INVALIDATE]]` (clears
+   * cache back to SENTINEL) so a second run with a pre-aborted signal
+   * cannot leak the prior run's response. Bridge with
+   * `awaitSettled(lastResponse)` for the first DATA as a Promise; consumers
+   * inside reactive fns gate on `ctx.prevData[i] === undefined`.
+   */
+  lastResponse;
+  /** Tool-call batch emitted by the most recent LLM response. SENTINEL. */
+  toolCalls;
+  /** Tool-result batch (one entry per call) after reactive execution. SENTINEL. */
+  toolResults;
+  _terminalResult;
+  _disposeRunWiring;
+  /** Guards against overlapping `run()` calls. */
+  _running = false;
+  /**
+   * Abort controller for the currently-running `adapter.invoke`. Minted per
+   * switchMap project; aborted when the reactive `aborted` node flips true
+   * OR when the caller's external `AbortSignal` fires. Threaded into
+   * `adapter.invoke({ signal })` AND `fromAny(promise, { signal })`, so the
+   * reactive layer sees ERROR when the wire call is cancelled.
+   */
+  _currentAbortController = null;
+  constructor(name, opts) {
+    super(name, opts.graph);
+    this.chat = chatStream(`${name}-chat`, { maxMessages: opts.maxMessages });
+    this.mount("chat", this.chat);
+    this.tools = toolRegistry(`${name}-tools`);
+    this.mount("tools", this.tools);
+    if (opts.tools) {
+      for (const tool of opts.tools) {
+        this.tools.register(tool);
+      }
+    }
+    this.status = node([], {
+      ...{
+        name: "status",
+        describeKind: "state",
+        meta: aiMeta("agent_status")
+      },
+      initial: "idle"
+    });
+    this.add(this.status, { name: "status" });
+    this.turn = node([], {
+      ...{
+        name: "turn",
+        describeKind: "state",
+        meta: aiMeta("agent_turn_count")
+      },
+      initial: 0
+    });
+    this.add(this.turn, { name: "turn" });
+    this.aborted = node([], {
+      ...{
+        name: "aborted",
+        describeKind: "state",
+        meta: aiMeta("agent_aborted")
+      },
+      initial: false
+    });
+    this.add(this.aborted, { name: "aborted" });
+    let latestTurn = 0;
+    const turnSub = this.turn.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === DATA) latestTurn = m[1];
+    });
+    let latestAborted = false;
+    const abortedSub = this.aborted.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === DATA) latestAborted = m[1];
+    });
+    const adapter = opts.adapter;
+    const systemPrompt = opts.systemPrompt;
+    const model = opts.model;
+    const temperature = opts.temperature;
+    const maxTokens = opts.maxTokens;
+    const maxTurns = opts.maxTurns ?? 10;
+    const stopWhen = opts.stopWhen;
+    const chat = this.chat;
+    const tools = this.tools;
+    const statusNode = this.status;
+    const turnNode = this.turn;
+    const abortedNode = this.aborted;
+    const promptInput = nodeFactory(
+      [statusNode],
+      (data, actions, ctx) => {
+        const stat = readLatest(data, ctx.prevData, 0, "idle");
+        if (stat !== "thinking" || latestAborted || latestTurn >= maxTurns) {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        const messages = this.chat.messages.cache ?? [];
+        if (messages.length === 0) {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        const schemas = this.tools.schemas.cache ?? [];
+        actions.emit({ messages, tools: schemas });
+      },
+      {
+        name: "promptInput",
+        describeKind: "derived",
+        meta: aiMeta("agent_prompt_input", {
+          // State this fn body samples beyond its declared `statusNode`
+          // dep. `aborted` / `turn` come from §28 closure mirrors
+          // (`latestAborted` / `latestTurn`); `chat.messages` /
+          // `tools.schemas` come from sole-owner `.cache` reads
+          // (Phase 12 D1 lock + F2 fix; see comment block above).
+          // Listed here so inspection tooling can surface fold-in
+          // state without grepping source.
+          closureReads: ["aborted", "turn", "chat.messages", "tools.schemas"]
+        })
+      }
+    );
+    const llmResponse = switchMap(
+      promptInput,
+      (input) => {
+        const controller = new AbortController();
+        this._currentAbortController = controller;
+        if (latestAborted) {
+          controller.abort(new Error("agentLoop: aborted"));
+        }
+        return fromAny(
+          adapter.invoke(input.messages, {
+            tools: input.tools.length > 0 ? input.tools : void 0,
+            systemPrompt,
+            model,
+            temperature,
+            maxTokens,
+            signal: controller.signal
+          }),
+          { signal: controller.signal }
+        );
+      },
+      { equals: () => false }
+    );
+    const lastResponseState = node([], {
+      name: "lastResponse",
+      describeKind: "state",
+      meta: aiMeta("agent_last_response")
+    });
+    this.lastResponse = lastResponseState;
+    const toolCallsRaw = nodeFactory(
+      [lastResponseState, statusNode],
+      (data, actions, ctx) => {
+        const resp = readLatest(data, ctx.prevData, 0, void 0);
+        const stat = readLatest(data, ctx.prevData, 1, "idle");
+        if (stat !== "acting") {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        const calls = resp?.toolCalls;
+        if (calls == null || calls.length === 0) {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        actions.emit(calls);
+      },
+      {
+        name: "toolCallsRaw",
+        describeKind: "derived",
+        meta: aiMeta("agent_tool_calls_raw")
+      }
+    );
+    const gatedToolCallsNode = opts.interceptToolCalls ? opts.interceptToolCalls(toolCallsRaw) : toolCallsRaw;
+    this.toolCalls = gatedToolCallsNode;
+    const toolResultsNode = toolExecution({
+      toolCalls: gatedToolCallsNode,
+      tools,
+      retryCount: 1
+    });
+    this.toolResults = toolResultsNode;
+    const effResponse = node(
+      [llmResponse],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        if (latestAborted) return;
+        const response = data[0];
+        const next = latestTurn + 1;
+        const hasToolCalls = response.toolCalls != null && response.toolCalls.length > 0;
+        const naturalStop = response.finishReason === "end_turn" && (!response.toolCalls || response.toolCalls.length === 0);
+        const customStop = stopWhen?.(response) === true;
+        const capReached = next >= maxTurns;
+        const nextStatus = customStop || naturalStop || !hasToolCalls || capReached ? "done" : "acting";
+        batch(() => {
+          lastResponseState.emit(response);
+          statusNode.emit(nextStatus);
+          turnNode.emit(next);
+          chat.append("assistant", response.content, {
+            toolCalls: response.toolCalls
+          });
+        });
+      },
+      { describeKind: "effect" }
+    );
+    const effResults = node(
+      [toolResultsNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        if (latestAborted) return;
+        const arr = data[0];
+        if (arr.length === 0) return;
+        const nextStatus = latestTurn >= maxTurns ? "done" : "thinking";
+        batch(() => {
+          statusNode.emit(nextStatus);
+          for (const r of arr) chat.appendToolResult(r.id, r.content);
+        });
+      },
+      { describeKind: "effect" }
+    );
+    let latestStatus = statusNode.cache ?? "idle";
+    const statusSub = statusNode.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === DATA) latestStatus = m[1];
+    });
+    const effAbort = node(
+      [abortedNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        if (data[0] === true) {
+          this._currentAbortController?.abort(new Error("agentLoop: aborted"));
+          if (latestStatus !== "done") statusNode.emit("done");
+        }
+      },
+      { describeKind: "effect" }
+    );
+    const kaResponse = keepalive(effResponse);
+    const kaResults = keepalive(effResults);
+    const kaAbort = keepalive(effAbort);
+    this._terminalResult = nodeFactory(
+      [statusNode, lastResponseState],
+      (data, actions, ctx) => {
+        const stat = readLatest(data, ctx.prevData, 0, "idle");
+        const resp = readLatest(data, ctx.prevData, 1, void 0);
+        if (stat === "done") {
+          if (resp !== void 0) {
+            actions.emit(resp);
+            return;
+          }
+          const err = new Error("agentLoop: aborted");
+          err.name = "AbortError";
+          actions.down([[ERROR, err]]);
+          return;
+        }
+        if (stat === "error") {
+          actions.down([[ERROR, new Error("agentLoop: errored")]]);
+          return;
+        }
+        actions.down([[RESOLVED]]);
+      },
+      {
+        name: "terminalResult",
+        describeKind: "derived",
+        meta: aiMeta("agent_terminal_result"),
+        // `lastResponseState` is SENTINEL until the first real response
+        // arrives — without `partial: true`, the spec §2.7 first-run
+        // gate would block this fn from ever firing on the abort-
+        // before-response path (`status → "done"` while `lastResponse`
+        // has never delivered DATA). The fn explicitly handles the
+        // SENTINEL case (`resp === undefined → ERROR(AbortError)`),
+        // so partial-fire is safe by design.
+        partial: true
+      }
+    );
+    this.add(promptInput, { name: "promptInput" });
+    this.add(llmResponse, { name: "llmResponse" });
+    this.add(this.lastResponse, { name: "lastResponse" });
+    if (this.toolCalls === toolCallsRaw) {
+      this.add(this.toolCalls, { name: "toolCalls" });
+    } else {
+      this.add(toolCallsRaw, { name: "toolCallsRaw" });
+      this.add(this.toolCalls, { name: "toolCalls" });
+    }
+    this.add(toolResultsNode, { name: "toolResults" });
+    this.add(this._terminalResult, { name: "terminalResult" });
+    this.addDisposer(turnSub);
+    this.addDisposer(abortedSub);
+    this.addDisposer(statusSub);
+    this.addDisposer(kaResponse);
+    this.addDisposer(kaResults);
+    this.addDisposer(kaAbort);
+    this._disposeRunWiring = () => {
+    };
+  }
+  /**
+   * Bridge to `Promise<LLMResponse>` over the reactive pipeline.
+   *
+   * - If `userMessage` is provided, appends it as a user message and
+   *   transitions status to `"thinking"` to kick the loop.
+   * - If `signal` is provided, binds it to the reactive `aborted` node
+   *   AND threads into `adapter.invoke({ signal })` so the wire call can
+   *   cancel mid-flight. The reactive `aborted` state + effect 3 guarantee
+   *   that even an adapter that ignores `signal` will stop emitting into
+   *   the agent graph.
+   * - Resolves when `status === "done"` with the final LLM response.
+   *   Rejects with `AbortError` when the abort signal fires pre-response.
+   *   Rejects with the stage error when `status === "error"`.
+   *
+   * **Concurrency:** `run()` refuses to overlap with a pending call on the
+   * same agent. Attempting to call `run()` while a previous `run()` is
+   * still in-flight throws a `RangeError` immediately. Stale-resolution
+   * safety is provided by `awaitSettled({skipCurrent: true})`, which
+   * ignores the cached initial DATA from any previous run and resolves
+   * only on a fresh post-subscribe emission of `_terminalResult`.
+   */
+  async run(userMessage, signal) {
+    if (this._running) {
+      throw new RangeError(
+        `agentLoop "${this.name}": run() called while a previous run() is still pending \u2014 await the previous run before starting another, or call abort() first`
+      );
+    }
+    this._running = true;
+    let offAbort;
+    try {
+      batch(() => {
+        this.lastResponse.down([[INVALIDATE]]);
+        this.turn.emit(0);
+        this.aborted.emit(false);
+        this.status.emit("idle");
+      });
+      if (userMessage != null) this.chat.append("user", userMessage);
+      const resultPromise = awaitSettled(this._terminalResult, { skipCurrent: true });
+      if (signal != null) {
+        if (signal.aborted) {
+          this.aborted.emit(true);
+        } else {
+          const listener = () => this.aborted.emit(true);
+          signal.addEventListener("abort", listener, { once: true });
+          offAbort = () => signal.removeEventListener("abort", listener);
+        }
+      }
+      if (signal?.aborted !== true) {
+        this.status.emit("thinking");
+      }
+      return await resultPromise;
+    } finally {
+      offAbort?.();
+      this._running = false;
+      this._currentAbortController = null;
+    }
+  }
+  /**
+   * Flip the reactive `aborted` state. Equivalent to setting an external
+   * `AbortSignal` — the pipeline observes and transitions to `"done"`.
+   */
+  abort() {
+    this.aborted.emit(true);
+  }
+  destroy() {
+    try {
+      this._disposeRunWiring();
+    } catch {
+    }
+    super.destroy();
+  }
+};
+function readLatest(batchData, prevData, index, fallback) {
+  const batch3 = batchData[index];
+  if (batch3 != null && batch3.length > 0) return batch3[batch3.length - 1];
+  const prev = prevData[index];
+  return prev !== void 0 ? prev : fallback;
+}
+function agentLoop(name, opts) {
+  const g = new AgentLoopGraph(name, opts);
+  g.tagFactory("agentLoop", placeholderArgs(opts));
+  return g;
+}
+
+// src/presets/ai/agent.ts
+import { batch as batch2, DATA as DATA2, INVALIDATE as INVALIDATE2, node as node2, RESOLVED as RESOLVED2 } from "@graphrefly/pure-ts/core";
+import { keepalive as keepalive2 } from "@graphrefly/pure-ts/extra";
+import { Graph as Graph2 } from "@graphrefly/pure-ts/graph";
+var EMPTY_INPUT = Object.freeze({ regular: 0 });
+var EMPTY_OUTPUT = Object.freeze({ regular: 0 });
+var EMPTY_USAGE = Object.freeze({ input: EMPTY_INPUT, output: EMPTY_OUTPUT });
+var ZERO_COST = Object.freeze({ usage: EMPTY_USAGE, turns: 0 });
+function addOptional(a, b) {
+  if (a == null && b == null) return void 0;
+  return (a ?? 0) + (b ?? 0);
+}
+function addExtensions(a, b) {
+  if (a == null && b == null) return void 0;
+  const out = { ...a ?? {} };
+  for (const [k, v] of Object.entries(b ?? {})) {
+    out[k] = (out[k] ?? 0) + v;
+  }
+  return out;
+}
+function addUsage(a, b) {
+  const out = {
+    input: {
+      regular: a.input.regular + b.input.regular,
+      ...addOptional(a.input.cacheRead, b.input.cacheRead) !== void 0 && {
+        cacheRead: addOptional(a.input.cacheRead, b.input.cacheRead)
+      },
+      ...addOptional(a.input.cacheWrite5m, b.input.cacheWrite5m) !== void 0 && {
+        cacheWrite5m: addOptional(a.input.cacheWrite5m, b.input.cacheWrite5m)
+      },
+      ...addOptional(a.input.cacheWrite1h, b.input.cacheWrite1h) !== void 0 && {
+        cacheWrite1h: addOptional(a.input.cacheWrite1h, b.input.cacheWrite1h)
+      },
+      ...addOptional(a.input.cacheWriteOther, b.input.cacheWriteOther) !== void 0 && {
+        cacheWriteOther: addOptional(a.input.cacheWriteOther, b.input.cacheWriteOther)
+      },
+      ...addOptional(a.input.audio, b.input.audio) !== void 0 && {
+        audio: addOptional(a.input.audio, b.input.audio)
+      },
+      ...addOptional(a.input.image, b.input.image) !== void 0 && {
+        image: addOptional(a.input.image, b.input.image)
+      },
+      ...addOptional(a.input.video, b.input.video) !== void 0 && {
+        video: addOptional(a.input.video, b.input.video)
+      },
+      ...addOptional(a.input.toolUse, b.input.toolUse) !== void 0 && {
+        toolUse: addOptional(a.input.toolUse, b.input.toolUse)
+      },
+      ...addExtensions(a.input.extensions, b.input.extensions) !== void 0 && {
+        extensions: addExtensions(a.input.extensions, b.input.extensions)
+      }
+    },
+    output: {
+      regular: a.output.regular + b.output.regular,
+      ...addOptional(a.output.reasoning, b.output.reasoning) !== void 0 && {
+        reasoning: addOptional(a.output.reasoning, b.output.reasoning)
+      },
+      ...addOptional(a.output.audio, b.output.audio) !== void 0 && {
+        audio: addOptional(a.output.audio, b.output.audio)
+      },
+      ...addOptional(a.output.predictionAccepted, b.output.predictionAccepted) !== void 0 && {
+        predictionAccepted: addOptional(
+          a.output.predictionAccepted,
+          b.output.predictionAccepted
+        )
+      },
+      ...addOptional(a.output.predictionRejected, b.output.predictionRejected) !== void 0 && {
+        predictionRejected: addOptional(
+          a.output.predictionRejected,
+          b.output.predictionRejected
+        )
+      },
+      ...addExtensions(a.output.extensions, b.output.extensions) !== void 0 && {
+        extensions: addExtensions(a.output.extensions, b.output.extensions)
+      }
+    },
+    ...addExtensions(a.auxiliary, b.auxiliary) !== void 0 && {
+      auxiliary: addExtensions(a.auxiliary, b.auxiliary)
+    }
+  };
+  return out;
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["done", "error"]);
+var AgentGraph = class extends Graph2 {
+  /** The agent's typed inbox. Writable; `in.emit(value)` kicks the loop. */
+  in;
+  /** The agent's typed outbox. SENTINEL until first response. */
+  out;
+  /** Lifecycle status (translated from the underlying loop's substates). */
+  status;
+  /** Cumulative cost for the current / most-recent input. */
+  cost;
+  /** The underlying agentLoop — exposed for inspection / advanced wiring. */
+  loop;
+  /** Optional shared memory subgraph (mounted at `memory/` if provided). */
+  memory;
+  constructor(spec, opts) {
+    super(spec.name, opts);
+    const initialTools = Array.isArray(spec.tools) ? spec.tools : void 0;
+    this.loop = agentLoop(`${spec.name}-loop`, {
+      adapter: spec.adapter,
+      ...spec.systemPrompt != null ? { systemPrompt: spec.systemPrompt } : {},
+      ...initialTools != null ? { tools: initialTools } : {},
+      ...spec.maxIterations != null ? { maxTurns: spec.maxIterations } : {}
+    });
+    this.mount("loop", this.loop);
+    if (spec.tools != null && !Array.isArray(spec.tools)) {
+      const toolsNode = spec.tools;
+      const registered = /* @__PURE__ */ new Set();
+      const unsubTools = toolsNode.subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] !== DATA2) continue;
+          const next = m[1];
+          const nextNames = new Set(next.map((t) => t.name));
+          for (const name of registered) {
+            if (!nextNames.has(name)) {
+              this.loop.tools.unregister(name);
+              registered.delete(name);
+            }
+          }
+          for (const tool of next) {
+            if (!registered.has(tool.name)) {
+              this.loop.tools.register(tool);
+              registered.add(tool.name);
+            }
+          }
+        }
+      });
+      this.addDisposer(unsubTools);
+    }
+    this.memory = spec.memory ?? null;
+    if (this.memory != null) {
+      this.mount("memory", this.memory);
+    }
+    this.in = node2([], {
+      name: "in",
+      describeKind: "state",
+      meta: aiMeta("agent_in"),
+      equals: () => false
+    });
+    this.add(this.in, { name: "in" });
+    const costNode = node2([], {
+      name: "cost",
+      describeKind: "state",
+      meta: aiMeta("agent_cost"),
+      initial: ZERO_COST
+    });
+    this.add(costNode, { name: "cost" });
+    this.cost = costNode;
+    const outMapper = spec.outMapper ?? defaultOutMapper();
+    const outNode = node2(
+      [this.loop.lastResponse],
+      (data, a, ctx) => {
+        const batch0 = data[0];
+        const resp = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+        if (resp === void 0) {
+          a.down([[RESOLVED2]]);
+          return;
+        }
+        a.emit(outMapper(resp));
+      },
+      {
+        name: "out",
+        describeKind: "derived",
+        meta: aiMeta("agent_out"),
+        // Each in.emit may produce a structurally-equal response (e.g.
+        // from a deterministic adapter) — disable framework dedup so
+        // repeat emits propagate and `awaitSettled({skipCurrent:true})`
+        // sees them. Callers can wrap with `distinctUntilChanged` if
+        // they want change-only semantics.
+        equals: () => false
+      }
+    );
+    this.add(outNode, { name: "out" });
+    this.out = outNode;
+    const statusNode = node2([], {
+      name: "status",
+      describeKind: "state",
+      meta: aiMeta("agent_status"),
+      initial: "idle"
+    });
+    this.add(statusNode, { name: "status" });
+    this.status = statusNode;
+    const statusMirrorEff = node2(
+      [this.loop.status],
+      (data, _a, ctx) => {
+        const batch0 = data[0];
+        const loopStatus = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0] ?? "idle";
+        const next = loopStatus === "idle" ? "idle" : loopStatus === "thinking" || loopStatus === "acting" ? "running" : loopStatus === "done" ? "done" : loopStatus === "error" ? "error" : "idle";
+        if (statusNode.cache !== next) statusNode.emit(next);
+      },
+      { describeKind: "effect", meta: aiMeta("agent_status_mirror") }
+    );
+    this.addDisposer(keepalive2(statusMirrorEff));
+    const costEff = node2(
+      [this.loop.lastResponse],
+      (data, _a, ctx) => {
+        const batch0 = data[0];
+        const resp = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+        if (resp === void 0) return;
+        const prev = costNode.cache ?? ZERO_COST;
+        const turns = this.loop.turn.cache ?? prev.turns;
+        const next = {
+          usage: resp.usage != null ? addUsage(prev.usage, resp.usage) : prev.usage,
+          turns
+        };
+        costNode.emit(next);
+      },
+      { describeKind: "effect", meta: aiMeta("agent_cost_rollup") }
+    );
+    this.addDisposer(keepalive2(costEff));
+    const inMapper = spec.inMapper ?? defaultInMapper();
+    const inputTopic = topic("input-topic");
+    this.mount("input-topic", inputTopic);
+    const inputSub = subscription("input-sub", inputTopic, {
+      from: "now"
+    });
+    this.mount("input-sub", inputSub);
+    const inputBridge = this.in.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] !== DATA2) continue;
+        const input = m[1];
+        inMapper(input);
+        inputTopic.publish(input);
+      }
+    });
+    this.addDisposer(inputBridge);
+    const drainEffect = node2(
+      [inputSub.available, this.loop.status],
+      (data, _a, ctx) => {
+        const availBatch = data[0];
+        const statusBatch = data[1];
+        const avail = (availBatch != null && availBatch.length > 0 ? availBatch.at(-1) : ctx.prevData[0] ?? []) ?? [];
+        const stat = (statusBatch != null && statusBatch.length > 0 ? statusBatch.at(-1) : ctx.prevData[1] ?? "idle") ?? "idle";
+        if (avail.length === 0) return;
+        if (stat === "thinking" || stat === "acting") return;
+        const result = inputSub.pullAndAck(1);
+        if (result.items.length === 0) return;
+        const input = result.items[0];
+        const userMsg = inMapper(input);
+        batch2(() => {
+          this.loop.lastResponse.down([[INVALIDATE2]]);
+          this.loop.turn.emit(0);
+          this.loop.aborted.emit(false);
+          costNode.emit(ZERO_COST);
+          this.loop.chat.append("user", userMsg);
+          this.loop.status.emit("thinking");
+        });
+      },
+      { describeKind: "effect", meta: aiMeta("agent_input_drain") }
+    );
+    this.addDisposer(keepalive2(drainEffect));
+    this.addDisposer(keepalive2(this.out));
+    void TERMINAL_STATUSES;
+  }
+};
+function defaultInMapper() {
+  return (input) => {
+    if (typeof input !== "string") {
+      throw new TypeError(
+        `agent: inMapper is required when TIn is not a string (got ${typeof input}). Pass spec.inMapper.`
+      );
+    }
+    return input;
+  };
+}
+function defaultOutMapper() {
+  return (response) => response;
+}
+
+// src/presets/ai/agents.ts
+import { reactiveMap } from "@graphrefly/pure-ts/extra";
+function agent(parent, spec) {
+  const graph = new AgentGraph(spec);
+  parent.mount(spec.name, graph);
+  return {
+    in: graph.in,
+    out: graph.out,
+    status: graph.status,
+    cost: graph.cost,
+    graph
+  };
+}
+function presetRegistry(initial) {
+  const registry = reactiveMap({ name: "presetRegistry" });
+  if (initial != null) {
+    for (const [id, preset] of initial) {
+      registry.set(id, preset);
+    }
+  }
+  return {
+    registry,
+    put(id, preset) {
+      registry.set(id, preset);
+    },
+    remove(id) {
+      if (!registry.has(id)) return false;
+      registry.delete(id);
+      return true;
+    }
+  };
+}
+
+export {
+  AgentLoopGraph,
+  agentLoop,
+  ZERO_COST,
+  addUsage,
+  AgentGraph,
+  agent,
+  presetRegistry
+};
+//# sourceMappingURL=chunk-5THCXDWY.js.map