@kortyx/runtime 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,26 +1,1312 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./checkpointer"), exports);
-__exportStar(require("./framework/adapter"), exports);
-__exportStar(require("./framework/pending-requests"), exports);
-__exportStar(require("./graph/create-langgraph"), exports);
-__exportStar(require("./interrupt/tokens"), exports);
-__exportStar(require("./node-registry"), exports);
-__exportStar(require("./registry/file-registry"), exports);
-__exportStar(require("./registry/in-memory-registry"), exports);
-__exportStar(require("./registry/interface"), exports);
-__exportStar(require("./state/build-initial-state"), exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildInitialGraphState: () => buildInitialGraphState,
+  clearRegisteredNodes: () => clearRegisteredNodes,
+  createFileWorkflowRegistry: () => createFileWorkflowRegistry,
+  createFrameworkAdapterFromEnv: () => createFrameworkAdapterFromEnv,
+  createInMemoryFrameworkAdapter: () => createInMemoryFrameworkAdapter,
+  createInMemoryPendingRequestStore: () => createInMemoryPendingRequestStore,
+  createInMemoryWorkflowRegistry: () => createInMemoryWorkflowRegistry,
+  createLangGraph: () => createLangGraph,
+  createRedisFrameworkAdapter: () => createRedisFrameworkAdapter,
+  getCheckpointer: () => getCheckpointer,
+  getRegisteredNode: () => getRegisteredNode,
+  listRegisteredNodes: () => listRegisteredNodes,
+  makeRequestId: () => makeRequestId,
+  makeResumeToken: () => makeResumeToken,
+  registerNode: () => registerNode,
+  resolveNode: () => resolveNode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/framework/in-memory-checkpointer.ts
+var import_langgraph_checkpoint = require("@langchain/langgraph-checkpoint");
+var utf8Bytes = (s) => new Uint8Array(Buffer.from(s, "utf8"));
+var utf8String = (u8) => typeof u8 === "string" ? u8 : Buffer.from(u8).toString("utf8");
+var jsonSerde = {
+  async dumpsTyped(data) {
+    return ["json", utf8Bytes(JSON.stringify(data))];
+  },
+  async loadsTyped(_type, data) {
+    return JSON.parse(utf8String(data));
+  }
+};
+function createInMemoryCheckpointSaver(options) {
+  const maxWritesPerCheckpoint = options?.maxWritesPerCheckpoint ?? 2e3;
+  const latest = /* @__PURE__ */ new Map();
+  const checkpoints = /* @__PURE__ */ new Map();
+  const nsKey = (threadId, checkpointNs) => `${threadId}
${checkpointNs}`;
+  const chkKey = (threadId, checkpointNs, checkpointId) => `${threadId}
${checkpointNs}
${checkpointId}`;
+  const saver = {
+    serde: jsonSerde,
+    async get(config) {
+      const value = await saver.getTuple(config);
+      return value ? value.checkpoint : void 0;
+    },
+    getNextVersion(current) {
+      if (typeof current === "string") {
+        throw new Error("Please override this method to use string versions.");
+      }
+      return current !== void 0 && typeof current === "number" ? current + 1 : 1;
+    },
+    async getTuple(config) {
+      const threadId = config.configurable?.thread_id;
+      const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+      if (!threadId) return void 0;
+      const requested = (0, import_langgraph_checkpoint.getCheckpointId)(config);
+      const id = requested || latest.get(nsKey(threadId, checkpointNs));
+      if (!id) return void 0;
+      const stored = checkpoints.get(chkKey(threadId, checkpointNs, id));
+      if (!stored) return void 0;
+      const pendingWrites = Array.from(stored.writes.values());
+      const tuple = {
+        config: {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: checkpointNs,
+            checkpoint_id: id
+          }
+        },
+        checkpoint: stored.checkpoint,
+        metadata: stored.metadata,
+        pendingWrites
+      };
+      if (stored.parentCheckpointId) {
+        tuple.parentConfig = {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: checkpointNs,
+            checkpoint_id: stored.parentCheckpointId
+          }
+        };
+      }
+      return tuple;
+    },
+    async *list(_config, _options) {
+    },
+    async put(config, checkpoint, metadata, _newVersions) {
+      const threadId = config.configurable?.thread_id;
+      const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+      if (!threadId) {
+        throw new Error(
+          'Failed to put checkpoint: missing "thread_id" in config.configurable.'
+        );
+      }
+      const ns = nsKey(threadId, checkpointNs);
+      const prevId = latest.get(ns);
+      const prepared = (0, import_langgraph_checkpoint.copyCheckpoint)(checkpoint);
+      const entry = {
+        checkpoint: prepared,
+        metadata,
+        parentCheckpointId: config.configurable?.checkpoint_id,
+        writes: /* @__PURE__ */ new Map()
+      };
+      const id = checkpoint.id;
+      checkpoints.set(chkKey(threadId, checkpointNs, id), entry);
+      latest.set(ns, id);
+      if (prevId && prevId !== id) {
+        checkpoints.delete(chkKey(threadId, checkpointNs, prevId));
+      }
+      return {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: checkpointNs,
+          checkpoint_id: id
+        }
+      };
+    },
+    async putWrites(config, writes, taskId) {
+      const threadId = config.configurable?.thread_id;
+      const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+      const checkpointId = config.configurable?.checkpoint_id;
+      if (!threadId || !checkpointId) return;
+      const stored = checkpoints.get(
+        chkKey(threadId, checkpointNs, checkpointId)
+      );
+      if (!stored) return;
+      for (let idx = 0; idx < writes.length; idx++) {
+        const [channel, value] = writes[idx];
+        const mappedIdx = import_langgraph_checkpoint.WRITES_IDX_MAP[channel] ?? idx;
+        const key = `${taskId},${mappedIdx}`;
+        if (mappedIdx >= 0 && stored.writes.has(key)) continue;
+        if (stored.writes.size >= maxWritesPerCheckpoint) break;
+        stored.writes.set(key, [taskId, channel, value]);
+      }
+    },
+    async deleteThread(threadId) {
+      for (const k of Array.from(latest.keys())) {
+        if (k.startsWith(`${threadId}
`)) latest.delete(k);
+      }
+      for (const k of Array.from(checkpoints.keys())) {
+        if (k.startsWith(`${threadId}
`)) checkpoints.delete(k);
+      }
+    }
+  };
+  return saver;
+}
+
+// src/checkpointer.ts
+var MAX_CHECKPOINTERS = 200;
+var map = /* @__PURE__ */ new Map();
+function getCheckpointer(key) {
+  const k = key || "__default__";
+  const existing = map.get(k);
+  if (existing) return existing;
+  const saver = createInMemoryCheckpointSaver();
+  map.set(k, saver);
+  if (map.size > MAX_CHECKPOINTERS) {
+    const first = map.keys().next().value;
+    if (first) map.delete(first);
+  }
+  return saver;
+}
+
+// src/framework/pending-requests.ts
+function createInMemoryPendingRequestStore() {
+  const store = /* @__PURE__ */ new Map();
+  const prune = () => {
+    const t = Date.now();
+    for (const [k, v] of store.entries()) {
+      if (t - v.createdAt > v.ttlMs) store.delete(k);
+    }
+  };
+  return {
+    async save(rec) {
+      prune();
+      store.set(rec.token, rec);
+    },
+    async get(token) {
+      prune();
+      return store.get(token) ?? null;
+    },
+    async delete(token) {
+      store.delete(token);
+    },
+    async update(token, patch) {
+      const prev = store.get(token);
+      if (!prev) return;
+      store.set(token, { ...prev, ...patch });
+    }
+  };
+}
+
+// src/framework/redis/pending-request-store.ts
+function createRedisPendingRequestStore(options) {
+  const prefix = options.prefix ?? "kortyx:pending:";
+  const key = (token) => `${prefix}${token}`;
+  return {
+    async save(rec) {
+      await options.store.set(key(rec.token), JSON.stringify(rec), rec.ttlMs);
+    },
+    async get(token) {
+      const raw = await options.store.get(key(token));
+      if (!raw) return null;
+      return JSON.parse(raw);
+    },
+    async delete(token) {
+      await options.store.del(key(token));
+    },
+    async update(token, patch) {
+      const prevRaw = await options.store.get(key(token));
+      if (!prevRaw) return;
+      const prev = JSON.parse(prevRaw);
+      const next = { ...prev, ...patch };
+      const ttlLeft = Math.max(1, next.ttlMs - (Date.now() - next.createdAt));
+      await options.store.set(key(token), JSON.stringify(next), ttlLeft);
+    }
+  };
+}
+
+// src/framework/redis/redis-checkpointer.ts
+var import_langgraph_checkpoint2 = require("@langchain/langgraph-checkpoint");
+var utf8Bytes2 = (s) => new Uint8Array(Buffer.from(s, "utf8"));
+var utf8String2 = (u8) => typeof u8 === "string" ? u8 : Buffer.from(u8).toString("utf8");
+var jsonSerde2 = {
+  async dumpsTyped(data) {
+    return ["json", utf8Bytes2(JSON.stringify(data))];
+  },
+  async loadsTyped(_type, data) {
+    return JSON.parse(utf8String2(data));
+  }
+};
+var b64FromBytes = (u8) => Buffer.from(u8).toString("base64");
+var bytesFromB64 = (s) => new Uint8Array(Buffer.from(s, "base64"));
+function createRedisCheckpointSaver(options) {
+  const store = options.store;
+  const ttlMs = options.ttlMs;
+  const prefix = options.prefix ?? "kortyx:cp:";
+  const latestKey = (threadId, checkpointNs) => `${prefix}latest:${threadId}:${checkpointNs}`;
+  const checkpointKey = (threadId, checkpointNs, checkpointId) => `${prefix}chk:${threadId}:${checkpointNs}:${checkpointId}`;
+  const writesKey = (threadId, checkpointNs, checkpointId) => `${prefix}wr:${threadId}:${checkpointNs}:${checkpointId}`;
+  const serde = jsonSerde2;
+  const saver = {
+    serde,
+    async get(config) {
+      const value = await saver.getTuple(config);
+      return value ? value.checkpoint : void 0;
+    },
+    getNextVersion(current) {
+      if (typeof current === "string") {
+        throw new Error("Please override this method to use string versions.");
+      }
+      return current !== void 0 && typeof current === "number" ? current + 1 : 1;
+    },
+    async getTuple(config) {
+      const threadId = config.configurable?.thread_id;
+      const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+      if (!threadId) return void 0;
+      const requested = (0, import_langgraph_checkpoint2.getCheckpointId)(config);
+      const checkpointId = requested || await store.get(latestKey(threadId, checkpointNs)) || "";
+      if (!checkpointId) return void 0;
+      const raw = await store.get(
+        checkpointKey(threadId, checkpointNs, checkpointId)
+      );
+      if (!raw) return void 0;
+      const parsed = JSON.parse(raw);
+      const checkpoint = await serde.loadsTyped(
+        "json",
+        bytesFromB64(parsed.checkpoint)
+      );
+      const metadata = await serde.loadsTyped(
+        "json",
+        bytesFromB64(parsed.metadata)
+      );
+      const writes = await store.hgetall(
+        writesKey(threadId, checkpointNs, checkpointId)
+      );
+      const pendingWrites = await Promise.all(
+        Object.values(writes).map(async (v) => {
+          const w = JSON.parse(v);
+          return [
+            w.taskId,
+            w.channel,
+            await serde.loadsTyped("json", bytesFromB64(w.value))
+          ];
+        })
+      );
+      const tuple = {
+        config: {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: checkpointNs,
+            checkpoint_id: checkpointId
+          }
+        },
+        checkpoint,
+        metadata,
+        pendingWrites
+      };
+      if (parsed.parentCheckpointId) {
+        tuple.parentConfig = {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: checkpointNs,
+            checkpoint_id: parsed.parentCheckpointId
+          }
+        };
+      }
+      return tuple;
+    },
+    async *list(_config, _options) {
+    },
+    async put(config, checkpoint, metadata, _newVersions) {
+      const threadId = config.configurable?.thread_id;
+      const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+      if (!threadId) {
+        throw new Error(
+          'Failed to put checkpoint: missing "thread_id" in config.configurable.'
+        );
+      }
+      const prevId = await store.get(latestKey(threadId, checkpointNs));
+      const prepared = (0, import_langgraph_checkpoint2.copyCheckpoint)(checkpoint);
+      const [[, chkBytes], [, metaBytes]] = await Promise.all([
+        serde.dumpsTyped(prepared),
+        serde.dumpsTyped(metadata)
+      ]);
+      const checkpointId = checkpoint.id;
+      const key = checkpointKey(threadId, checkpointNs, checkpointId);
+      const stored = {
+        checkpoint: b64FromBytes(chkBytes),
+        metadata: b64FromBytes(metaBytes),
+        parentCheckpointId: config.configurable?.checkpoint_id
+      };
+      await store.set(key, JSON.stringify(stored), ttlMs);
+      await store.set(latestKey(threadId, checkpointNs), checkpointId, ttlMs);
+      if (prevId && prevId !== checkpointId) {
+        await store.del(checkpointKey(threadId, checkpointNs, prevId));
+        await store.del(writesKey(threadId, checkpointNs, prevId));
+      }
+      return {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: checkpointNs,
+          checkpoint_id: checkpointId
+        }
+      };
+    },
+    async putWrites(config, writes, taskId) {
+      const threadId = config.configurable?.thread_id;
+      const checkpointNs = config.configurable?.checkpoint_ns;
+      const checkpointId = config.configurable?.checkpoint_id;
+      if (!threadId) {
+        throw new Error(
+          'Failed to put writes: missing "thread_id" in config.configurable.'
+        );
+      }
+      if (!checkpointId) {
+        throw new Error(
+          'Failed to put writes: missing "checkpoint_id" in config.configurable.'
+        );
+      }
+      const outer = writesKey(threadId, checkpointNs ?? "", checkpointId);
+      await store.expire(outer, ttlMs);
+      await Promise.all(
+        writes.map(async ([channel, value], idx) => {
+          const [, vBytes] = await serde.dumpsTyped(value);
+          const mappedIdx = import_langgraph_checkpoint2.WRITES_IDX_MAP[channel] ?? idx;
+          const innerKeyStr = `${taskId},${mappedIdx}`;
+          const payload = {
+            taskId,
+            channel,
+            value: b64FromBytes(vBytes)
+          };
+          const serialized = JSON.stringify(payload);
+          if (mappedIdx >= 0) {
+            await store.hsetnx(outer, innerKeyStr, serialized);
+          } else {
+            await store.hset(outer, innerKeyStr, serialized);
+          }
+        })
+      );
+    },
+    async deleteThread(threadId) {
+      const chkKeys = await store.scanKeys(`${prefix}chk:${threadId}:`);
+      const wrKeys = await store.scanKeys(`${prefix}wr:${threadId}:`);
+      const latestKeys = await store.scanKeys(`${prefix}latest:${threadId}:`);
+      await store.delRaw([...chkKeys, ...wrKeys, ...latestKeys]);
+    }
+  };
+  return saver;
+}
+
+// src/framework/redis/redis-client.ts
+var import_node_net = require("net");
+var import_node_tls = require("tls");
+var encodeBulk = (s) => {
+  const b = Buffer.from(s, "utf8");
+  return Buffer.concat([
+    Buffer.from(`$${b.length}\r
+`),
+    b,
+    Buffer.from("\r\n")
+  ]);
+};
+var encodeCommand = (cmd, args) => {
+  const parts = [cmd, ...args];
+  const bufs = [Buffer.from(`*${parts.length}\r
+`)];
+  for (const p of parts) bufs.push(encodeBulk(p));
+  return Buffer.concat(bufs);
+};
+function readLine(buf, start) {
+  const idx = buf.indexOf("\r\n", start);
+  if (idx === -1) return null;
+  return { line: buf.slice(start, idx).toString("utf8"), next: idx + 2 };
+}
+function parseReply(buf, start) {
+  if (start >= buf.length) return null;
+  const byte = buf[start];
+  if (byte === void 0) return null;
+  const prefix = String.fromCharCode(byte);
+  if (prefix === "+" || prefix === "-" || prefix === ":") {
+    const line = readLine(buf, start + 1);
+    if (!line) return null;
+    if (prefix === "+") return { value: line.line, next: line.next };
+    if (prefix === ":")
+      return { value: Number.parseInt(line.line, 10), next: line.next };
+    return { value: { type: "error", message: line.line }, next: line.next };
+  }
+  if (prefix === "$") {
+    const line = readLine(buf, start + 1);
+    if (!line) return null;
+    const len = Number.parseInt(line.line, 10);
+    if (len === -1) return { value: null, next: line.next };
+    const end = line.next + len;
+    if (end + 2 > buf.length) return null;
+    const data = buf.slice(line.next, end).toString("utf8");
+    return { value: data, next: end + 2 };
+  }
+  if (prefix === "*") {
+    const line = readLine(buf, start + 1);
+    if (!line) return null;
+    const count = Number.parseInt(line.line, 10);
+    if (count === -1) return { value: null, next: line.next };
+    const items = [];
+    let cursor = line.next;
+    for (let i = 0; i < count; i++) {
+      const parsed = parseReply(buf, cursor);
+      if (!parsed) return null;
+      items.push(parsed.value);
+      cursor = parsed.next;
+    }
+    return { value: items, next: cursor };
+  }
+  return {
+    value: { type: "error", message: `Unknown RESP prefix: ${prefix}` },
+    next: buf.length
+  };
+}
+function createRedisClient(options) {
+  const resolvedOptions = {
+    connectTimeoutMs: options.connectTimeoutMs ?? 5e3,
+    url: options.url
+  };
+  let socket = null;
+  let buffer = Buffer.alloc(0);
+  const inflight = [];
+  let connecting = null;
+  let ready = false;
+  const drainReplies = () => {
+    while (inflight.length) {
+      const parsed = parseReply(buffer, 0);
+      if (!parsed) return;
+      const waiter = inflight.shift();
+      buffer = buffer.slice(parsed.next);
+      waiter.resolve(parsed.value);
+    }
+  };
+  const send = (cmd, args = []) => {
+    if (!socket) return Promise.reject(new Error("Redis socket not available"));
+    const payload = encodeCommand(cmd, args);
+    return new Promise((resolve2, reject) => {
+      inflight.push({ resolve: resolve2, reject });
+      socket.write(payload);
+    });
+  };
+  const ensureConnected = async () => {
+    if (ready) return;
+    if (connecting) return connecting;
+    connecting = (async () => {
+      const u = new URL(resolvedOptions.url);
+      const isTls = u.protocol === "rediss:";
+      const host = u.hostname || "127.0.0.1";
+      const port = u.port ? Number(u.port) : isTls ? 6380 : 6379;
+      const password = u.password ? decodeURIComponent(u.password) : "";
+      const db = u.pathname && u.pathname !== "/" ? Number(u.pathname.slice(1)) : 0;
+      const s = isTls ? (0, import_node_tls.connect)({ host, port, servername: host }) : (0, import_node_net.connect)({ host, port });
+      socket = s;
+      s.setNoDelay(true);
+      s.setKeepAlive(true);
+      s.on("data", (chunk) => {
+        buffer = Buffer.concat([buffer, chunk]);
+        drainReplies();
+      });
+      s.on("error", (err) => {
+        ready = false;
+        while (inflight.length) inflight.shift().reject(err);
+      });
+      s.on("close", () => {
+        ready = false;
+        while (inflight.length)
+          inflight.shift().reject(new Error("Redis socket closed"));
+      });
+      await new Promise((resolve2, reject) => {
+        const timer = setTimeout(
+          () => reject(new Error("Redis connect timeout")),
+          resolvedOptions.connectTimeoutMs
+        );
+        const onConnect = () => {
+          clearTimeout(timer);
+          resolve2();
+        };
+        s.once("connect", onConnect);
+        s.once?.("secureConnect", onConnect);
+        s.once("error", (e) => {
+          clearTimeout(timer);
+          reject(e);
+        });
+      });
+      if (password) {
+        const r = await send("AUTH", [password]);
+        if (typeof r === "object" && r && r.type === "error") {
+          throw new Error(`Redis AUTH failed: ${r.message}`);
+        }
+      }
+      if (db && Number.isFinite(db) && db > 0) {
+        const r = await send("SELECT", [String(db)]);
+        if (typeof r === "object" && r && r.type === "error") {
+          throw new Error(`Redis SELECT failed: ${r.message}`);
+        }
+      }
+      ready = true;
+    })();
+    try {
+      await connecting;
+    } finally {
+      connecting = null;
+    }
+  };
+  return {
+    async command(cmd, args = []) {
+      await ensureConnected();
+      return send(cmd, args);
+    }
+  };
+}
+
+// src/framework/redis/redis-store.ts
+var isRedisError = (r) => Boolean(r) && typeof r === "object" && r.type === "error";
+function createRedisFrameworkStore(options) {
+  const client = createRedisClient({ url: options.url });
+  const prefix = options.prefix ?? "kortyx:fw:";
+  const k = (key) => `${prefix}${key}`;
+  return {
+    async get(key) {
+      const r = await client.command("GET", [k(key)]);
+      if (r === null) return null;
+      if (typeof r === "string") return r;
+      if (isRedisError(r)) {
+        throw new Error(`Redis GET error: ${r.message}`);
+      }
+      return null;
+    },
+    async set(key, value, ttlMs) {
+      const args = [k(key), value, "PX", String(Math.max(1, ttlMs))];
+      const r = await client.command("SET", args);
+      if (isRedisError(r)) {
+        throw new Error(`Redis SET error: ${r.message}`);
+      }
+    },
+    async del(key) {
+      const r = await client.command("DEL", [k(key)]);
+      if (isRedisError(r)) {
+        throw new Error(`Redis DEL error: ${r.message}`);
+      }
+    },
+    async hset(key, field, value) {
+      const r = await client.command("HSET", [k(key), field, value]);
+      if (isRedisError(r)) {
+        throw new Error(`Redis HSET error: ${r.message}`);
+      }
+    },
+    async hsetnx(key, field, value) {
+      const r = await client.command("HSETNX", [k(key), field, value]);
+      if (isRedisError(r)) {
+        throw new Error(`Redis HSETNX error: ${r.message}`);
+      }
+      return typeof r === "number" ? r : 0;
+    },
+    async hgetall(key) {
+      const r = await client.command("HGETALL", [k(key)]);
+      if (isRedisError(r)) {
+        throw new Error(`Redis HGETALL error: ${r.message}`);
+      }
+      if (!Array.isArray(r)) return {};
+      const out = {};
+      for (let i = 0; i < r.length; i += 2) {
+        const kk = r[i];
+        const v = r[i + 1];
+        if (typeof kk === "string" && typeof v === "string") out[kk] = v;
+      }
+      return out;
+    },
+    async expire(key, ttlMs) {
+      const r = await client.command("PEXPIRE", [
+        k(key),
+        String(Math.max(1, ttlMs))
+      ]);
+      if (isRedisError(r)) {
+        throw new Error(`Redis PEXPIRE error: ${r.message}`);
+      }
+    },
+    async scanKeys(prefixKey) {
+      const fullPrefix = k(prefixKey);
+      let cursor = "0";
+      const keys = [];
+      do {
+        const r = await client.command("SCAN", [
+          cursor,
+          "MATCH",
+          `${fullPrefix}*`,
+          "COUNT",
+          "200"
+        ]);
+        if (!Array.isArray(r) || r.length < 2) break;
+        cursor = typeof r[0] === "string" ? r[0] : "0";
+        const batch = r[1];
+        if (Array.isArray(batch)) {
+          for (const key of batch) {
+            if (typeof key === "string") keys.push(key);
+          }
+        }
+      } while (cursor !== "0");
+      return keys;
+    },
+    async delRaw(keys) {
+      if (keys.length === 0) return;
+      const r = await client.command("DEL", keys);
+      if (isRedisError(r)) {
+        throw new Error(`Redis DEL error: ${r.message}`);
+      }
+    }
+  };
+}
+
+// src/framework/adapter.ts
+function createInMemoryFrameworkAdapter(options) {
+  const ttlMs = options?.ttlMs ?? 15 * 60 * 1e3;
+  const checkpointer = createInMemoryCheckpointSaver();
+  return {
+    kind: "memory",
+    ttlMs,
+    pendingRequests: createInMemoryPendingRequestStore(),
+    checkpointer,
+    cleanupRun: async (runId) => {
+      try {
+        await checkpointer.deleteThread(runId);
+      } catch {
+      }
+    }
+  };
+}
+function createRedisFrameworkAdapter(options) {
+  const ttlMs = options.ttlMs ?? 15 * 60 * 1e3;
+  const store = createRedisFrameworkStore({
+    url: options.url,
+    prefix: options.prefix ?? "kortyx:fw:"
+  });
+  const cpPrefix = "kortyx:cp:";
+  return {
+    kind: "redis",
+    ttlMs,
+    pendingRequests: createRedisPendingRequestStore({
+      store,
+      prefix: "kortyx:pending:"
+    }),
+    checkpointer: createRedisCheckpointSaver({
+      store,
+      ttlMs,
+      prefix: cpPrefix
+    }),
+    cleanupRun: async (runId, namespaces) => {
+      const nsList = namespaces.length > 0 ? namespaces : [""];
+      await Promise.all(
+        nsList.map(async (checkpointNs) => {
+          const ns = String(checkpointNs ?? "");
+          const latestKey = `${cpPrefix}latest:${runId}:${ns}`;
+          const checkpointId = await store.get(latestKey) ?? "";
+          if (!checkpointId) return;
+          await Promise.all([
+            store.del(`${cpPrefix}chk:${runId}:${ns}:${checkpointId}`),
+            store.del(`${cpPrefix}wr:${runId}:${ns}:${checkpointId}`),
+            store.del(latestKey)
+          ]);
+        })
+      );
+    }
+  };
+}
+function createFrameworkAdapterFromEnv(env = process.env) {
+  const url = env.KORTYX_REDIS_URL || env.REDIS_URL || env.KORTYX_FRAMEWORK_REDIS_URL || "";
+  const ttlMsRaw = env.KORTYX_FRAMEWORK_TTL_MS || env.KORTYX_TTL_MS || "";
+  const ttlMs = ttlMsRaw ? Number(ttlMsRaw) : void 0;
+  if (url)
+    return createRedisFrameworkAdapter({ url, ...ttlMs ? { ttlMs } : {} });
+  return createInMemoryFrameworkAdapter({ ...ttlMs ? { ttlMs } : {} });
+}
+
+// src/graph/create-langgraph.ts
+var import_hooks = require("@kortyx/hooks");
+var import_internal = require("@kortyx/hooks/internal");
+var import_utils = require("@kortyx/utils");
+var import_langgraph = require("@langchain/langgraph");
+
+// src/node-loader.ts
+var import_node_path = require("path");
+var import_node_url = require("url");
+
+// src/node-registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerNode(id, fn) {
+  registry.set(id, fn);
+}
+function getRegisteredNode(id) {
+  return registry.get(id) ?? null;
+}
+function listRegisteredNodes() {
+  return [...registry.keys()].sort();
+}
+function clearRegisteredNodes() {
+  registry.clear();
+}
+function resolveNode(id) {
+  const fn = registry.get(id);
+  if (!fn) {
+    throw new Error(
+      `Node '${id}' is not registered. Call registerNode('${id}', fn) before running workflows that reference it.`
+    );
+  }
+  return fn;
+}
+
+// src/node-loader.ts
+var dynamicImport = new Function(
+  "specifier",
+  // Avoid bundler static analysis of `import(...)` (e.g. Next.js/Turbopack).
+  // This is only used on the server.
+  "return import(specifier)"
+);
+function looksLikePath(specifier) {
+  if (specifier.startsWith("file:")) return true;
+  if (specifier.startsWith("./") || specifier.startsWith("../")) return true;
+  if (specifier.startsWith("/")) return true;
+  return specifier.includes("/");
+}
+function getWorkflowBaseDir(workflow, cwd) {
+  const meta = workflow?.metadata;
+  const filePath = meta?.__filePath;
+  if (typeof filePath === "string" && filePath.length > 0) {
+    return (0, import_node_path.dirname)(filePath);
+  }
+  return cwd;
+}
+function pickNodeExport(mod, exportName) {
+  if (exportName) {
+    const candidate = mod[exportName];
+    if (typeof candidate === "function") return candidate;
+    throw new Error(`Node export "${exportName}" not found or not a function.`);
+  }
+  const defaultExport = mod.default;
+  if (typeof defaultExport === "function") return defaultExport;
+  const fnExports = Object.entries(mod).filter(
+    ([, v]) => typeof v === "function"
+  );
+  if (fnExports.length === 1) return fnExports[0][1];
+  const names = fnExports.map(([k]) => k).sort();
+  throw new Error(
+    `Node module must export a default function or exactly one named function (found: ${names.join(", ") || "none"}).`
+  );
+}
+async function resolveNodeHandler(args) {
+  const { run, workflow } = args;
+  const cwd = args.cwd ?? process.cwd();
+  if (typeof run === "function") return run;
+  if (looksLikePath(run)) {
+    const [moduleRef, exportName] = run.split("#", 2);
+    const baseDir = getWorkflowBaseDir(workflow, cwd);
+    const specifier = moduleRef.startsWith("file:") ? moduleRef : (0, import_node_path.isAbsolute)(moduleRef) ? (0, import_node_url.pathToFileURL)(moduleRef).href : (0, import_node_url.pathToFileURL)((0, import_node_path.resolve)(baseDir, moduleRef)).href;
+    const mod = await dynamicImport(specifier);
+    return pickNodeExport(mod, exportName);
+  }
+  return resolveNode(run);
+}
+
+// src/graph/create-langgraph.ts
+async function createLangGraph(workflow, config) {
+  const StateAnnotation = import_langgraph.Annotation.Root({
+    input: import_langgraph.Annotation,
+    output: import_langgraph.Annotation,
+    lastNode: import_langgraph.Annotation,
+    lastCondition: import_langgraph.Annotation,
+    lastIntent: import_langgraph.Annotation,
+    memory: (0, import_langgraph.Annotation)({
+      reducer: (l, r) => (0, import_utils.deepMergeWithArrayOverwrite)(l ?? {}, r ?? {}),
+      default: () => ({})
+    }),
+    config: import_langgraph.Annotation,
+    transitionTo: import_langgraph.Annotation,
+    data: (0, import_langgraph.Annotation)({
+      reducer: (l, r) => (0, import_utils.deepMergeWithArrayOverwrite)(l ?? {}, r ?? {}),
+      default: () => ({})
+    }),
+    conversationHistory: (0, import_langgraph.Annotation)({
+      reducer: (l, r) => [...l ?? [], ...r ?? []],
+      default: () => []
+    }),
+    awaitingHumanInput: import_langgraph.Annotation
+  });
+  const builder = new import_langgraph.StateGraph(StateAnnotation);
+  const edgeApi = builder;
+  const workflowName = workflow.id;
+  const runtimeConfig = config;
+  if (!runtimeConfig.emit) {
+    runtimeConfig.emit = () => {
+    };
+  }
+  const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  const toRecordInput = (value) => {
+    if (isRecord(value)) return value;
+    if (value === void 0) return {};
+    return { rawInput: value };
+  };
+  const buildNodeConfig = (params, nodeBehavior) => {
+    const model = isRecord(params?.model) ? params.model : void 0;
+    const tool = isRecord(params?.tool) ? params.tool : void 0;
+    const behaviorFromParams = isRecord(params?.behavior) ? params.behavior : void 0;
+    const behavior = {
+      ...behaviorFromParams ?? {},
+      ...nodeBehavior ?? {}
+    };
+    const options = params ?? void 0;
+    return {
+      ...model ? { model } : {},
+      ...tool ? { tool } : {},
+      ...Object.keys(behavior).length > 0 ? { behavior } : {},
+      ...options ? { options } : {}
+    };
+  };
+  for (const [nodeId, nodeDef] of Object.entries(workflow.nodes ?? {})) {
+    const resolvedRun = await resolveNodeHandler({
+      run: nodeDef.run,
+      workflow
+    });
+    const nodeParams = nodeDef.params ?? void 0;
+    const nodeConfig = buildNodeConfig(
+      nodeParams,
+      nodeDef.behavior ?? void 0
+    );
+    const behavior = nodeConfig.behavior ?? {};
+    builder.addNode(nodeId, async (state) => {
+      const ctx = {
+        graph: { name: workflowName, node: nodeId },
+        config: nodeConfig,
+        emit: (event, payload) => {
+          runtimeConfig.emit(event, payload);
+        },
+        error: (message) => {
+          runtimeConfig.emit("error", {
+            node: nodeId,
+            message
+          });
+        },
+        awaitInterrupt: (interruptConfig) => {
+          const { kind, question } = interruptConfig;
+          const isMulti = kind === "multi-choice" || interruptConfig.kind !== "text" && interruptConfig.multiple === true;
+          const payload = {
+            kind,
+            multiple: isMulti,
+            question,
+            ...interruptConfig.kind !== "text" ? { options: interruptConfig.options } : {},
+            ...typeof interruptConfig.id === "string" && interruptConfig.id.length > 0 ? { id: interruptConfig.id } : {},
+            ...typeof interruptConfig.schemaId === "string" && interruptConfig.schemaId.length > 0 ? { schemaId: interruptConfig.schemaId } : {},
+            ...typeof interruptConfig.schemaVersion === "string" && interruptConfig.schemaVersion.length > 0 ? { schemaVersion: interruptConfig.schemaVersion } : {},
+            ...interruptConfig.meta && typeof interruptConfig.meta === "object" && !Array.isArray(interruptConfig.meta) ? { meta: interruptConfig.meta } : {}
+          };
+          runtimeConfig.emit("interrupt", {
+            node: nodeId,
+            workflow: workflowName,
+            input: payload
+          });
+          const resumed = (0, import_langgraph.interrupt)(payload);
+          if (isMulti) {
+            if (Array.isArray(resumed)) {
+              return resumed.map(
+                (v) => typeof v === "string" ? v : v && typeof v.id === "string" ? v.id : ""
+              ).filter(Boolean);
+            }
+            if (typeof resumed === "string") return [resumed];
+            return [];
+          }
+          if (typeof resumed === "string") return resumed;
+          if (resumed && typeof resumed.id === "string")
+            return String(resumed.id);
+          return "";
+        },
+        speak: async (args) => {
+          const providerId = args.model?.provider ?? nodeConfig.model?.provider ?? "google";
+          const modelName = args.model?.name ?? nodeConfig.model?.name ?? "gemini-2.5-flash";
+          const temperature = args.model?.temperature ?? nodeConfig.model?.temperature ?? 0.3;
+          const getProvider = runtimeConfig.getProvider;
+          if (!getProvider) {
+            throw new Error(
+              "Runtime config is missing getProvider; wire a provider factory into @kortyx/runtime."
+            );
+          }
+          const result = await (0, import_internal.runReasonEngine)({
+            getProvider,
+            model: {
+              providerId,
+              modelId: modelName
+            },
+            input: args.user ?? "",
+            system: args.system,
+            temperature,
+            stream: true,
+            emit: true,
+            nodeId,
+            emitEvent: ctx.emit
+          });
+          return result.text;
+        }
+      };
+      if (behavior.checkpoint && config?.onCheckpoint) {
+        config.onCheckpoint({ nodeId, state });
+      }
+      const maxAttempts = behavior.retry?.maxAttempts ?? 1;
+      let attempt = 0;
+      let nodeResult;
+      let hookMemoryUpdates = null;
+      let retryHookMemory = null;
+      while (attempt < maxAttempts) {
+        try {
+          attempt++;
+          const attemptState = retryHookMemory && typeof retryHookMemory === "object" ? {
+            ...state,
+            memory: (0, import_utils.deepMergeWithArrayOverwrite)(
+              state.memory ?? {},
+              retryHookMemory
+            )
+          } : state;
+          const hookContext = {
+            node: ctx,
+            state: attemptState,
+            ...runtimeConfig.getProvider ? { getProvider: runtimeConfig.getProvider } : {},
+            ...runtimeConfig.memoryAdapter ? { memoryAdapter: runtimeConfig.memoryAdapter } : {}
+          };
+          const hookRun = await (0, import_hooks.runWithHookContext)(
+            hookContext,
+            async () => resolvedRun({
+              input: state.input,
+              params: nodeParams ?? {}
+            })
+          );
+          nodeResult = hookRun.result;
+          hookMemoryUpdates = hookRun.memoryUpdates;
+          break;
+        } catch (err) {
+          const patch = err?.__kortyxMemoryUpdates;
+          if (patch && typeof patch === "object") {
+            state.memory = (0, import_utils.deepMergeWithArrayOverwrite)(
+              state.memory ?? {},
+              patch
+            );
+            retryHookMemory = (0, import_utils.deepMergeWithArrayOverwrite)(
+              retryHookMemory ?? {},
+              patch
+            );
+          }
+          const hasMore = attempt < maxAttempts;
+          const delayMs = behavior.retry?.delayMs ?? 0;
+          if (hasMore && delayMs > 0) {
+            await new Promise((r) => setTimeout(r, delayMs));
+            continue;
+          }
+          if (!hasMore) throw err;
+        }
+      }
+      const res = nodeResult ?? {};
+      if (hookMemoryUpdates) {
+        res.infra = {
+          ...res.infra ?? {},
+          memory: (0, import_utils.deepMergeWithArrayOverwrite)(
+            (res.infra?.memory ?? {}) || {},
+            hookMemoryUpdates
+          )
+        };
+      }
+      const uiMessage = res.ui?.message;
+      const shouldRespond = typeof uiMessage === "string" && uiMessage.trim().length > 0;
+      if (shouldRespond) {
+        ctx.emit("message", { node: nodeId, content: uiMessage });
+      }
+      if (res.transitionTo) {
+        ctx.emit("transition", {
+          transitionTo: res.transitionTo,
+          payload: res.data ?? {}
+        });
+      }
+      const updates = {};
+      if (typeof res.condition === "string")
+        updates.lastCondition = res.condition;
+      if (typeof res.intent === "string") updates.lastIntent = res.intent;
+      if (res.data && typeof res.data === "object") {
+        updates.input = (0, import_utils.deepMergeWithArrayOverwrite)(
+          toRecordInput(state.input),
+          res.data
+        );
+        updates.data = (0, import_utils.deepMergeWithArrayOverwrite)(
+          state.data ?? {},
+          res.data
+        );
+      }
+      if (res.infra?.memory && typeof res.infra.memory === "object") {
+        updates.memory = (0, import_utils.deepMergeWithArrayOverwrite)(
+          state.memory ?? {},
+          res.infra.memory
+        );
+      }
+      if (res.ui) {
+        updates.ui = {
+          message: typeof res.ui.message === "string" ? res.ui.message : state.ui?.message ?? "",
+          structured: (0, import_utils.deepMergeWithArrayOverwrite)(
+            state.ui?.structured ?? {},
+            res.ui.structured ?? {}
+          )
+        };
+      }
+      if (shouldRespond && uiMessage) {
+        updates.conversationHistory = [
+          ...state.conversationHistory ?? [],
+          {
+            node: nodeId,
+            message: uiMessage,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ];
+      }
+      if (res.ui?.structured) {
+        const payload = res.ui.structured;
+        const inferredType = payload && typeof payload === "object" && "jobs" in payload ? "jobs" : typeof payload.summary === "string" || payload.topJobs ? "summary" : "generic";
+        ctx.emit("structured_data", {
+          node: nodeId,
+          dataType: inferredType,
+          data: payload
+        });
+      }
+      return updates;
+    });
+  }
+  const condGroups = {};
+  const plainEdges = [];
+  for (const edge of workflow.edges) {
+    const [from, to, condition] = edge;
+    if (condition && typeof condition.when === "string" && condition.when) {
+      if (!condGroups[from]) condGroups[from] = [];
+      condGroups[from].push({ when: condition.when, to });
+    } else {
+      plainEdges.push([from, to]);
+    }
+  }
+  for (const [from, to] of plainEdges) {
+    edgeApi.addEdge(from, to);
+  }
+  for (const [from, rules] of Object.entries(condGroups)) {
+    const mapping = Object.fromEntries(
+      rules.map((r) => [r.when, r.to])
+    );
+    const fallbackKey = `__default__:${from}`;
+    mapping[fallbackKey] = "__end__";
+    edgeApi.addConditionalEdges(
+      from,
+      (s) => {
+        const trigger = s.lastCondition ?? s.lastIntent;
+        if (trigger && Object.hasOwn(mapping, trigger)) {
+          return trigger;
+        }
+        return fallbackKey;
+      },
+      mapping
+    );
+  }
+  const sessionId = config?.session?.id ?? "__default__";
+  const checkpointer = config.checkpointer ?? getCheckpointer(sessionId);
+  const graph = builder.compile({ checkpointer });
+  const runtimeGraph = graph;
+  runtimeGraph.name = workflow.id;
+  runtimeGraph.config = config;
+  runtimeGraph.resume = async (state, input) => {
+    const resumed = { ...state, input, awaitingHumanInput: false };
+    return graph.invoke(resumed);
+  };
+  runtimeGraph.timeTravelTo = async (state, checkpointId) => {
+    const checkpoints = state.memory?.checkpoints;
+    const snapshot = checkpoints?.[checkpointId];
+    if (!snapshot) throw new Error(`Checkpoint '${checkpointId}' not found`);
+    return graph.invoke(
+      snapshot.snapshot
+    );
+  };
+  return runtimeGraph;
+}
+
+// src/interrupt/tokens.ts
+var import_uuid = require("uuid");
+function makeResumeToken() {
+  return (0, import_uuid.v7)();
+}
+function makeRequestId(prefix = "req") {
+  return `${prefix}-${(0, import_uuid.v7)()}`;
+}
+
+// src/registry/file-registry.ts
+var import_core = require("@kortyx/core");
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var DEFAULT_EXTENSIONS = [
+  ".workflow.ts",
+  ".workflow.mts",
+  ".workflow.js",
+  ".workflow.mjs",
+  ".workflow.json",
+  ".workflow.yml",
+  ".workflow.yaml"
+];
+function isWorkflowFile(name, extensions) {
+  return extensions.some((ext) => name.endsWith(ext));
+}
+function isDeclarativeWorkflowFile(name) {
+  return name.endsWith(".workflow.json") || name.endsWith(".workflow.yml") || name.endsWith(".workflow.yaml");
+}
+function createFileWorkflowRegistry(options) {
+  const workflowsDir = options.workflowsDir;
+  const fallbackId = options.fallbackId ?? "general-chat";
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const shouldCache = options.cache ?? true;
+  let workflowCache = null;
+  async function loadWorkflows() {
+    if (shouldCache && workflowCache) return workflowCache;
+    const files = await (0, import_promises.readdir)(workflowsDir, { withFileTypes: true });
+    const workflowFiles = files.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((file) => isWorkflowFile(file, extensions));
+    const workflows = {};
+    for (const file of workflowFiles) {
+      try {
+        const modulePath = (0, import_path.join)(workflowsDir, file);
+        if (isDeclarativeWorkflowFile(file)) {
+          const raw = await (0, import_promises.readFile)(modulePath, "utf8");
+          const workflow = (0, import_core.loadWorkflow)(raw);
+          workflow.metadata = {
+            ...workflow.metadata ?? {},
+            __filePath: modulePath
+          };
+          workflows[workflow.id] = workflow;
+          continue;
+        }
+        const module2 = await import(modulePath);
+        const workflowExport = Object.values(module2).find(
+          (exp) => {
+            const obj = exp;
+            return exp !== null && typeof exp === "object" && typeof obj.id === "string" && typeof obj.nodes === "object" && obj.nodes !== null && Array.isArray(obj.edges);
+          }
+        );
+        if (workflowExport) {
+          workflowExport.metadata = {
+            ...workflowExport.metadata ?? {},
+            __filePath: modulePath
+          };
+          workflows[workflowExport.id] = workflowExport;
+        }
+      } catch (error) {
+        console.warn(`Failed to load workflow from ${file}:`, error);
+      }
+    }
+    if (shouldCache) workflowCache = workflows;
+    return workflows;
+  }
+  async function list() {
+    const workflows = await loadWorkflows();
+    return Object.values(workflows);
+  }
+  async function get(id) {
+    const workflows = await loadWorkflows();
+    return workflows[id] ?? null;
+  }
+  async function select(id, selectOptions) {
+    const workflows = await loadWorkflows();
+    const fallback = selectOptions?.fallbackId ?? fallbackId;
+    const selected = workflows[id] ?? (fallback ? workflows[fallback] : null);
+    if (!selected) {
+      throw new Error(
+        `No workflow found for id "${id}" and no fallback "${fallback}" workflow available`
+      );
+    }
+    return selected;
+  }
+  async function refresh() {
+    workflowCache = null;
+    await loadWorkflows();
+  }
+  return {
+    list,
+    get,
+    select,
+    refresh
+  };
+}
+
+// src/registry/in-memory-registry.ts
+function createInMemoryWorkflowRegistry(workflows, options) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const wf of workflows) byId.set(wf.id, wf);
+  const fallbackId = options?.fallbackId ?? "general-chat";
+  return {
+    async list() {
+      return Array.from(byId.values());
+    },
+    async get(id) {
+      return byId.get(id) ?? null;
+    },
+    async select(id, selectOptions) {
+      const fallback = selectOptions?.fallbackId ?? fallbackId;
+      const wf = byId.get(id) ?? (fallback ? byId.get(fallback) : void 0);
+      if (!wf) {
+        throw new Error(
+          `Workflow "${id}" not found${fallback ? ` (fallback "${fallback}" missing too)` : ""}.`
+        );
+      }
+      return wf;
+    }
+  };
+}
+
+// src/state/build-initial-state.ts
+async function buildInitialGraphState({
+  input,
+  memory,
+  config,
+  defaultWorkflowId
+}) {
+  const currentWorkflow = memory.currentWorkflow || defaultWorkflowId;
+  if (!currentWorkflow) {
+    throw new Error(
+      "No workflow selected. Provide defaultWorkflowId (or set memory.currentWorkflow) before starting the graph."
+    );
+  }
+  return {
+    input,
+    lastNode: "__start__",
+    memory,
+    config,
+    conversationHistory: [],
+    currentWorkflow,
+    awaitingHumanInput: false
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildInitialGraphState,
+  clearRegisteredNodes,
+  createFileWorkflowRegistry,
+  createFrameworkAdapterFromEnv,
+  createInMemoryFrameworkAdapter,
+  createInMemoryPendingRequestStore,
+  createInMemoryWorkflowRegistry,
+  createLangGraph,
+  createRedisFrameworkAdapter,
+  getCheckpointer,
+  getRegisteredNode,
+  listRegisteredNodes,
+  makeRequestId,
+  makeResumeToken,
+  registerNode,
+  resolveNode
+});
+//# sourceMappingURL=index.js.map