@langgraph-js/pure-graph 1.4.1 → 1.4.2

package/dist/index-DcXE-SZb.js

@@ -0,0 +1,1264 @@
+import { isBaseMessage } from '@langchain/core/messages';
+import { Command, Send, StateGraph } from '@langchain/langgraph';
+import { EventEmitter } from 'eventemitter3';
+import { load } from '@langchain/core/load';
+import { MemorySaver } from '@langchain/langgraph-checkpoint';
+
+const getLangGraphCommand = (command) => {
+  let goto = command.goto != null && !Array.isArray(command.goto) ? [command.goto] : command.goto;
+  return new Command({
+    goto: goto?.map((item) => {
+      if (typeof item !== "string") return new Send(item.node, item.input);
+      return item;
+    }),
+    update: command.update ?? void 0,
+    resume: command.resume
+  });
+};
+
+var LIMIT_REPLACE_NODE = "[...]";
+var CIRCULAR_REPLACE_NODE = "[Circular]";
+var arr = [];
+var replacerStack = [];
+function defaultOptions() {
+  return {
+    depthLimit: Number.MAX_SAFE_INTEGER,
+    edgesLimit: Number.MAX_SAFE_INTEGER
+  };
+}
+function stringify(obj, replacer, spacer, options) {
+  if (typeof options === "undefined") {
+    options = defaultOptions();
+  }
+  decirc(obj, "", 0, [], void 0, 0, options);
+  var res;
+  try {
+    if (replacerStack.length === 0) {
+      res = JSON.stringify(obj, replacer, spacer);
+    } else {
+      res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+    }
+  } catch (_) {
+    return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+  } finally {
+    while (arr.length !== 0) {
+      var part = arr.pop();
+      if (part.length === 4) {
+        Object.defineProperty(part[0], part[1], part[3]);
+      } else {
+        part[0][part[1]] = part[2];
+      }
+    }
+  }
+  return res;
+}
+function setReplace(replace, val, k, parent) {
+  var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+  if (propertyDescriptor.get !== void 0) {
+    if (propertyDescriptor.configurable) {
+      Object.defineProperty(parent, k, { value: replace });
+      arr.push([parent, k, val, propertyDescriptor]);
+    } else {
+      replacerStack.push([val, k, replace]);
+    }
+  } else {
+    parent[k] = replace;
+    arr.push([parent, k, val]);
+  }
+}
+function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+  depth += 1;
+  var i;
+  if (typeof val === "object" && val !== null) {
+    for (i = 0; i < stack.length; i++) {
+      if (stack[i] === val) {
+        setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+        return;
+      }
+    }
+    if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+      return;
+    }
+    if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+      setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+      return;
+    }
+    stack.push(val);
+    if (Array.isArray(val)) {
+      for (i = 0; i < val.length; i++) {
+        decirc(val[i], i, i, stack, val, depth, options);
+      }
+    } else {
+      var keys = Object.keys(val);
+      for (i = 0; i < keys.length; i++) {
+        var key = keys[i];
+        decirc(val[key], key, i, stack, val, depth, options);
+      }
+    }
+    stack.pop();
+  }
+}
+function replaceGetterValues(replacer) {
+  replacer = typeof replacer !== "undefined" ? replacer : function(k, v) {
+    return v;
+  };
+  return function(key, val) {
+    if (replacerStack.length > 0) {
+      for (var i = 0; i < replacerStack.length; i++) {
+        var part = replacerStack[i];
+        if (part[1] === key && part[0] === val) {
+          val = part[2];
+          replacerStack.splice(i, 1);
+          break;
+        }
+      }
+    }
+    return replacer.call(this, key, val);
+  };
+}
+
+function isLangChainSerializedObject(value) {
+  return value !== null && value.lc === 1 && value.type === "constructor" && Array.isArray(value.id);
+}
+async function _reviver(value) {
+  if (value && typeof value === "object") {
+    if (Array.isArray(value)) {
+      const revivedArray = await Promise.all(value.map((item) => _reviver(item)));
+      return revivedArray;
+    } else {
+      const revivedObj = {};
+      for (const [k, v] of Object.entries(value)) {
+        revivedObj[k] = await _reviver(v);
+      }
+      if (revivedObj.lc === 2 && revivedObj.type === "undefined") {
+        return void 0;
+      } else if (revivedObj.lc === 2 && revivedObj.type === "constructor" && Array.isArray(revivedObj.id)) {
+        try {
+          const constructorName = revivedObj.id[revivedObj.id.length - 1];
+          let constructor;
+          switch (constructorName) {
+            case "Set":
+              constructor = Set;
+              break;
+            case "Map":
+              constructor = Map;
+              break;
+            case "RegExp":
+              constructor = RegExp;
+              break;
+            case "Error":
+              constructor = Error;
+              break;
+            default:
+              return revivedObj;
+          }
+          if (revivedObj.method) {
+            return constructor[revivedObj.method](...revivedObj.args || []);
+          } else {
+            return new constructor(...revivedObj.args || []);
+          }
+        } catch (error) {
+          return revivedObj;
+        }
+      } else if (isLangChainSerializedObject(revivedObj)) {
+        return load(JSON.stringify(revivedObj));
+      }
+      return revivedObj;
+    }
+  }
+  return value;
+}
+function _encodeConstructorArgs(constructor, method, args, kwargs) {
+  return {
+    lc: 2,
+    type: "constructor",
+    id: [constructor.name],
+    method: method ?? null,
+    args: args ?? [],
+    kwargs: kwargs ?? {}
+  };
+}
+function _default(obj) {
+  if (obj === void 0) {
+    return {
+      lc: 2,
+      type: "undefined"
+    };
+  } else if (obj instanceof Set || obj instanceof Map) {
+    return _encodeConstructorArgs(obj.constructor, void 0, [Array.from(obj)]);
+  } else if (obj instanceof RegExp) {
+    return _encodeConstructorArgs(RegExp, void 0, [obj.source, obj.flags]);
+  } else if (obj instanceof Error) {
+    return _encodeConstructorArgs(obj.constructor, void 0, [obj.message]);
+  } else if (obj?.lg_name === "Send") {
+    return {
+      node: obj.node,
+      args: obj.args
+    };
+  } else {
+    return obj;
+  }
+}
+class JsonPlusSerializer {
+  _dumps(obj) {
+    const encoder = new TextEncoder();
+    return encoder.encode(
+      stringify(obj, (_, value) => {
+        return _default(value);
+      })
+    );
+  }
+  async dumpsTyped(obj) {
+    if (obj instanceof Uint8Array) {
+      return ["bytes", obj];
+    } else {
+      return ["json", this._dumps(obj)];
+    }
+  }
+  async _loads(data) {
+    const parsed = JSON.parse(data);
+    return _reviver(parsed);
+  }
+  async loadsTyped(type, data) {
+    if (type === "bytes") {
+      return typeof data === "string" ? new TextEncoder().encode(data) : data;
+    } else if (type === "json") {
+      return this._loads(typeof data === "string" ? data : new TextDecoder().decode(data));
+    } else {
+      throw new Error(`Unknown serialization type: ${type}`);
+    }
+  }
+}
+
+class BaseStreamQueue extends EventEmitter {
+  /**
+   * 构造函数
+   * Constructor
+   * @param compressMessages 是否压缩消息 / Whether to compress messages
+   */
+  constructor(id, compressMessages = true) {
+    super();
+    this.id = id;
+    this.compressMessages = compressMessages;
+  }
+  /** 序列化器实例 / Serializer instance */
+  serializer = new JsonPlusSerializer();
+  /**
+   * 编码数据为 Uint8Array
+   * Encode data to Uint8Array
+   * @param message 要编码的消息 / Message to encode
+   * @returns 编码后的 Uint8Array / Encoded Uint8Array
+   */
+  async encodeData(message) {
+    const [_, serializedMessage] = await this.serializer.dumpsTyped(message);
+    return serializedMessage;
+  }
+  /**
+   * 解码数据为 EventMessage
+   * Decode data to EventMessage
+   * @param serializedMessage 要解码的消息 / Message to decode
+   * @returns 解码后的 EventMessage / Decoded EventMessage
+   */
+  async decodeData(serializedMessage) {
+    const message = await this.serializer.loadsTyped("json", serializedMessage);
+    return message;
+  }
+}
+class StreamQueueManager {
+  /** 存储队列实例的 Map / Map storing queue instances */
+  queues = /* @__PURE__ */ new Map();
+  /** 默认是否压缩消息 / Default compress messages setting */
+  defaultCompressMessages;
+  /** 队列构造函数 / Queue constructor */
+  queueConstructor;
+  /**
+   * 构造函数
+   * Constructor
+   * @param queueConstructor 队列构造函数 / Queue constructor
+   * @param options 配置选项 / Configuration options
+   */
+  constructor(queueConstructor, options = {}) {
+    this.defaultCompressMessages = options.defaultCompressMessages ?? true;
+    this.queueConstructor = queueConstructor;
+  }
+  /**
+   * 创建指定 id 的队列
+   * Create queue with specified id
+   * @param id 队列 ID / Queue ID
+   * @param compressMessages 是否压缩消息 / Whether to compress messages
+   * @returns 创建的队列实例 / Created queue instance
+   */
+  createQueue(id, compressMessages) {
+    compressMessages ?? this.defaultCompressMessages;
+    this.queues.set(id, new this.queueConstructor(id));
+    return this.queues.get(id);
+  }
+  /**
+   * 获取或创建指定 id 的队列
+   * Get or create queue with specified id
+   * @param id 队列 ID / Queue ID
+   * @param compressMessages 是否压缩消息，默认为构造函数中的默认值 / Whether to compress messages, defaults to constructor default
+   * @returns StreamQueue 实例 / StreamQueue instance
+   */
+  getQueue(id) {
+    const queue = this.queues.get(id);
+    if (!queue) {
+      throw new Error(`Queue with id '${id}' does not exist`);
+    }
+    return queue;
+  }
+  /**
+   * 取消指定 id 的队列
+   * Cancel queue with specified id
+   * @param id 队列 ID / Queue ID
+   */
+  cancelQueue(id) {
+    const queue = this.queues.get(id);
+    if (queue) {
+      queue.cancel();
+      this.removeQueue(id);
+    }
+  }
+  /**
+   * 向指定 id 的队列推送数据
+   * Push data to queue with specified id
+   * @param id 队列 ID / Queue ID
+   * @param item 要推送的数据项 / Item to push
+   * @param compressMessages 是否压缩消息，默认为构造函数中的默认值 / Whether to compress messages, defaults to constructor default
+   */
+  async pushToQueue(id, item, compressMessages) {
+    const queue = this.getQueue(id);
+    await queue.push(item);
+  }
+  /**
+   * 获取指定 id 队列中的所有数据
+   * Get all data from queue with specified id
+   * @param id 队列 ID / Queue ID
+   * @returns 队列中的所有数据 / All data in the queue
+   */
+  async getQueueData(id) {
+    const queue = this.queues.get(id);
+    if (!queue) {
+      throw new Error(`Queue with id '${id}' does not exist`);
+    }
+    return await queue.getAll();
+  }
+  /**
+   * 清空指定 id 的队列
+   * Clear queue with specified id
+   * @param id 队列 ID / Queue ID
+   */
+  clearQueue(id) {
+    const queue = this.queues.get(id);
+    if (queue) {
+      queue.clear();
+    }
+  }
+  /**
+   * 删除指定 id 的队列
+   * Remove queue with specified id
+   * @param id 队列 ID / Queue ID
+   * @returns 是否成功删除 / Whether successfully deleted
+   */
+  removeQueue(id) {
+    setTimeout(() => {
+      return this.queues.delete(id);
+    }, 500);
+  }
+  /**
+   * 获取所有队列的 ID
+   * Get all queue IDs
+   * @returns 所有队列 ID 的数组 / Array of all queue IDs
+   */
+  getAllQueueIds() {
+    return Array.from(this.queues.keys());
+  }
+  /**
+   * 获取所有队列及其数据的快照
+   * Get snapshot of all queues and their data
+   * @returns 包含所有队列数据的结果对象 / Result object containing all queue data
+   */
+  async getAllQueuesData() {
+    const result = {};
+    for (const [id, queue] of this.queues) {
+      result[id] = await queue.getAll();
+    }
+    return result;
+  }
+  /**
+   * 清空所有队列
+   * Clear all queues
+   */
+  clearAllQueues() {
+    for (const queue of this.queues.values()) {
+      queue.clear();
+    }
+  }
+}
+
+class EventMessage {
+  event;
+  data;
+  id;
+  constructor(event, data) {
+    this.event = event;
+    this.data = data;
+  }
+}
+class CancelEventMessage extends EventMessage {
+  constructor() {
+    super("__system_cancel__", "user cancel this run");
+  }
+}
+class StreamEndEventMessage extends EventMessage {
+  constructor() {
+    super("__stream_end__", "stream end");
+  }
+}
+class StreamErrorEventMessage extends EventMessage {
+  constructor(error) {
+    super("__stream_error__", {
+      error: error.name,
+      message: error.message
+    });
+  }
+}
+
+class MemoryStreamQueue extends BaseStreamQueue {
+  data = [];
+  async push(item) {
+    const data = this.compressMessages ? await this.encodeData(item) : item;
+    this.data.push(data);
+    this.emit("dataChange", data);
+  }
+  onDataChange(listener) {
+    this.on("dataChange", async (item) => {
+      listener(this.compressMessages ? await this.decodeData(item) : item);
+    });
+    return () => this.off("dataChange", listener);
+  }
+  /**
+   * 异步生成器：支持 for await...of 方式消费队列数据
+   */
+  async *onDataReceive() {
+    let queue = [];
+    let pendingResolve = null;
+    let isStreamEnded = false;
+    const handleData = async (item) => {
+      const data = this.compressMessages ? await this.decodeData(item) : item;
+      queue.push(data);
+      if (data.event === "__stream_end__" || data.event === "__stream_error__" || data.event === "__stream_cancel__") {
+        setTimeout(() => {
+          isStreamEnded = true;
+          if (pendingResolve) {
+            pendingResolve();
+            pendingResolve = null;
+          }
+        }, 300);
+        if (data.event === "__stream_cancel__") {
+          this.cancel();
+        }
+      }
+      if (pendingResolve) {
+        pendingResolve();
+        pendingResolve = null;
+      }
+    };
+    this.on("dataChange", handleData);
+    try {
+      while (!isStreamEnded) {
+        if (queue.length > 0) {
+          for (const item of queue) {
+            yield item;
+          }
+          queue = [];
+        } else {
+          await new Promise((resolve) => {
+            pendingResolve = resolve;
+          });
+        }
+      }
+    } finally {
+      this.off("dataChange", handleData);
+    }
+  }
+  async getAll() {
+    return this.compressMessages ? await Promise.all(
+      this.data.map((i) => this.decodeData(i))
+    ) : this.data;
+  }
+  clear() {
+    this.data = [];
+  }
+  cancelSignal = new AbortController();
+  cancel() {
+    this.push(new CancelEventMessage());
+    this.cancelSignal.abort("user cancel this run");
+  }
+}
+
+const GRAPHS = {};
+async function registerGraph(graphId, graph) {
+  GRAPHS[graphId] = graph;
+}
+async function getGraph(graphId, config, options) {
+  if (!GRAPHS[graphId]) throw new Error(`Graph "${graphId}" not found`);
+  const compiled = typeof GRAPHS[graphId] === "function" ? await GRAPHS[graphId](config ?? { configurable: {} }) : GRAPHS[graphId];
+  if (typeof options?.checkpointer !== "undefined") {
+    compiled.checkpointer = options?.checkpointer ?? LangGraphGlobal.globalCheckPointer;
+  } else {
+    compiled.checkpointer = LangGraphGlobal.globalCheckPointer;
+  }
+  compiled.store = options?.store ?? void 0;
+  return compiled;
+}
+
+class MemoryThreadsManager {
+  threads = [];
+  async setup() {
+    return;
+  }
+  async create(payload) {
+    const threadId = payload?.threadId || crypto.randomUUID();
+    if (payload?.ifExists === "raise" && this.threads.some((t) => t.thread_id === threadId)) {
+      throw new Error(`Thread with ID ${threadId} already exists.`);
+    }
+    const thread = {
+      thread_id: threadId,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: payload?.metadata || {},
+      status: "idle",
+      values: null,
+      interrupts: {}
+    };
+    this.threads.push(thread);
+    return thread;
+  }
+  async search(query) {
+    let filteredThreads = [...this.threads];
+    if (query?.status) {
+      filteredThreads = filteredThreads.filter((t) => t.status === query.status);
+    }
+    if (query?.metadata) {
+      for (const key in query.metadata) {
+        if (Object.prototype.hasOwnProperty.call(query.metadata, key)) {
+          filteredThreads = filteredThreads.filter(
+            (t) => t.metadata && t.metadata[key] === query.metadata?.[key]
+          );
+        }
+      }
+    }
+    if (query?.sortBy) {
+      filteredThreads.sort((a, b) => {
+        let aValue;
+        let bValue;
+        switch (query.sortBy) {
+          case "created_at":
+            aValue = new Date(a.created_at).getTime();
+            bValue = new Date(b.created_at).getTime();
+            break;
+          case "updated_at":
+            aValue = new Date(a.updated_at).getTime();
+            bValue = new Date(b.updated_at).getTime();
+            break;
+          default:
+            return 0;
+        }
+        if (query.sortOrder === "desc") {
+          return bValue - aValue;
+        } else {
+          return aValue - bValue;
+        }
+      });
+    }
+    const offset = query?.offset || 0;
+    const limit = query?.limit || filteredThreads.length;
+    return filteredThreads.slice(offset, offset + limit);
+  }
+  async get(threadId) {
+    const thread = this.threads.find((t) => t.thread_id === threadId);
+    if (!thread) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    return thread;
+  }
+  async set(threadId, thread) {
+    const index = this.threads.findIndex((t) => t.thread_id === threadId);
+    if (index === -1) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    this.threads[index] = { ...this.threads[index], ...thread };
+  }
+  async delete(threadId) {
+    const initialLength = this.threads.length;
+    this.threads = this.threads.filter((t) => t.thread_id !== threadId);
+    if (this.threads.length === initialLength) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+  }
+  async updateState(threadId, thread) {
+    const index = this.threads.findIndex((t) => t.thread_id === threadId);
+    if (index === -1) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    const targetThread = this.threads[index];
+    if (targetThread.status === "busy") {
+      throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+    }
+    this.threads[index] = { ...targetThread, values: thread.values };
+    if (!targetThread.metadata?.graph_id) {
+      throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+    }
+    const graphId = targetThread.metadata?.graph_id;
+    const config = {
+      configurable: {
+        thread_id: threadId,
+        graph_id: graphId
+      }
+    };
+    const graph = await getGraph(graphId, config);
+    const nextConfig = await graph.updateState(config, thread.values);
+    const graphState = await graph.getState(config);
+    await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
+    return nextConfig;
+  }
+  runs = [];
+  async createRun(threadId, assistantId, payload) {
+    const runId = crypto.randomUUID();
+    const run = {
+      run_id: runId,
+      thread_id: threadId,
+      assistant_id: assistantId,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending",
+      metadata: payload?.metadata ?? {},
+      multitask_strategy: "reject"
+    };
+    this.runs.push(run);
+    return run;
+  }
+  async listRuns(threadId, options) {
+    let filteredRuns = [...this.runs];
+    if (options?.status) {
+      filteredRuns = filteredRuns.filter((r) => r.status === options.status);
+    }
+    if (options?.limit) {
+      filteredRuns = filteredRuns.slice(options.offset || 0, (options.offset || 0) + options.limit);
+    }
+    return filteredRuns;
+  }
+  async updateRun(runId, run) {
+    const index = this.runs.findIndex((r) => r.run_id === runId);
+    if (index === -1) {
+      throw new Error(`Run with ID ${runId} not found.`);
+    }
+    this.runs[index] = { ...this.runs[index], ...run };
+  }
+}
+
+class SQLiteThreadsManager {
+  db;
+  isSetup = false;
+  constructor(checkpointer) {
+    this.db = checkpointer.db;
+  }
+  async setup() {
+    if (this.isSetup) {
+      return;
+    }
+    this.db.exec(`
+            CREATE TABLE IF NOT EXISTS threads (
+                thread_id TEXT PRIMARY KEY,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                metadata TEXT NOT NULL DEFAULT '{}',
+                status TEXT NOT NULL DEFAULT 'idle',
+                [values] TEXT,
+                interrupts TEXT NOT NULL DEFAULT '{}'
+            )
+        `);
+    this.db.exec(`
+            CREATE TABLE IF NOT EXISTS runs (
+                run_id TEXT PRIMARY KEY,
+                thread_id TEXT NOT NULL,
+                assistant_id TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'pending',
+                metadata TEXT NOT NULL DEFAULT '{}',
+                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
+                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
+            )
+        `);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`);
+    this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`);
+    this.isSetup = true;
+  }
+  async create(payload) {
+    const threadId = payload?.threadId || crypto.randomUUID();
+    if (payload?.ifExists === "raise") {
+      const existingThread = this.db.prepare("SELECT thread_id FROM threads WHERE thread_id = ?").get(threadId);
+      if (existingThread) {
+        throw new Error(`Thread with ID ${threadId} already exists.`);
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadata = JSON.stringify(payload?.metadata || {});
+    const interrupts = JSON.stringify({});
+    const thread = {
+      thread_id: threadId,
+      created_at: now,
+      updated_at: now,
+      metadata: payload?.metadata || {},
+      status: "idle",
+      values: null,
+      interrupts: {}
+    };
+    this.db.prepare(
+      `
+            INSERT INTO threads (thread_id, created_at, updated_at, metadata, status, [values], interrupts)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `
+    ).run(threadId, now, now, metadata, "idle", null, interrupts);
+    return thread;
+  }
+  async search(query) {
+    let sql = "SELECT * FROM threads";
+    const whereConditions = [];
+    const params = [];
+    if (query?.status) {
+      whereConditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query?.metadata) {
+      for (const [key, value] of Object.entries(query.metadata)) {
+        whereConditions.push(`json_extract(metadata, '$.${key}') = ?`);
+        params.push(JSON.stringify(value));
+      }
+    }
+    if (whereConditions.length > 0) {
+      sql += " WHERE " + whereConditions.join(" AND ");
+    }
+    if (query?.sortBy) {
+      sql += ` ORDER BY ${query.sortBy}`;
+      if (query.sortOrder === "desc") {
+        sql += " DESC";
+      } else {
+        sql += " ASC";
+      }
+    }
+    if (query?.limit) {
+      sql += ` LIMIT ${query.limit}`;
+      if (query?.offset) {
+        sql += ` OFFSET ${query.offset}`;
+      }
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      thread_id: row.thread_id,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      metadata: JSON.parse(row.metadata),
+      status: row.status,
+      values: row.values ? JSON.parse(row.values) : null,
+      interrupts: JSON.parse(row.interrupts)
+    }));
+  }
+  async get(threadId) {
+    const row = this.db.prepare("SELECT * FROM threads WHERE thread_id = ?").get(threadId);
+    if (!row) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    return {
+      thread_id: row.thread_id,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      metadata: JSON.parse(row.metadata),
+      status: row.status,
+      values: row.values ? JSON.parse(row.values) : null,
+      interrupts: JSON.parse(row.interrupts)
+    };
+  }
+  async set(threadId, thread) {
+    const existingThread = this.db.prepare("SELECT thread_id FROM threads WHERE thread_id = ?").get(threadId);
+    if (!existingThread) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    const updateFields = [];
+    const values = [];
+    if (thread.metadata !== void 0) {
+      updateFields.push("metadata = ?");
+      values.push(JSON.stringify(thread.metadata));
+    }
+    if (thread.status !== void 0) {
+      updateFields.push("status = ?");
+      values.push(thread.status);
+    }
+    if (thread.values !== void 0) {
+      updateFields.push("[values] = ?");
+      values.push(thread.values ? JSON.stringify(thread.values) : null);
+    }
+    if (thread.interrupts !== void 0) {
+      updateFields.push("interrupts = ?");
+      values.push(JSON.stringify(thread.interrupts));
+    }
+    updateFields.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    if (updateFields.length > 0) {
+      values.push(threadId);
+      this.db.prepare(
+        `
+                UPDATE threads 
+                SET ${updateFields.join(", ")} 
+                WHERE thread_id = ?
+            `
+      ).run(...values);
+    }
+  }
+  async updateState(threadId, thread) {
+    const row = this.db.prepare("SELECT * FROM threads WHERE thread_id = ?").get(threadId);
+    if (!row) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    const targetThread = {
+      thread_id: row.thread_id,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      metadata: JSON.parse(row.metadata),
+      status: row.status,
+      values: row.values ? JSON.parse(row.values) : null,
+      interrupts: JSON.parse(row.interrupts)
+    };
+    if (targetThread.status === "busy") {
+      throw new Error(`Thread with ID ${threadId} is busy, can't update state.`);
+    }
+    if (!targetThread.metadata?.graph_id) {
+      throw new Error(`Thread with ID ${threadId} has no graph_id.`);
+    }
+    const graphId = targetThread.metadata?.graph_id;
+    const config = {
+      configurable: {
+        thread_id: threadId,
+        graph_id: graphId
+      }
+    };
+    const graph = await getGraph(graphId, config);
+    const nextConfig = await graph.updateState(config, thread.values);
+    const graphState = await graph.getState(config);
+    await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
+    return nextConfig;
+  }
+  async delete(threadId) {
+    const result = this.db.prepare("DELETE FROM threads WHERE thread_id = ?").run(threadId);
+    if (result.changes === 0) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+  }
+  async createRun(threadId, assistantId, payload) {
+    const runId = crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const metadata = JSON.stringify(payload?.metadata ?? {});
+    const run = {
+      run_id: runId,
+      thread_id: threadId,
+      assistant_id: assistantId,
+      created_at: now,
+      updated_at: now,
+      status: "pending",
+      metadata: payload?.metadata ?? {},
+      multitask_strategy: "reject"
+    };
+    this.db.prepare(
+      `
+            INSERT INTO runs (run_id, thread_id, assistant_id, created_at, updated_at, status, metadata, multitask_strategy)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `
+    ).run(runId, threadId, assistantId, now, now, "pending", metadata, "reject");
+    return run;
+  }
+  async listRuns(threadId, options) {
+    let sql = "SELECT * FROM runs WHERE thread_id = ?";
+    const params = [threadId];
+    if (options?.status) {
+      sql += " AND status = ?";
+      params.push(options.status);
+    }
+    sql += " ORDER BY created_at DESC";
+    if (options?.limit) {
+      sql += ` LIMIT ${options.limit}`;
+      if (options?.offset) {
+        sql += ` OFFSET ${options.offset}`;
+      }
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      run_id: row.run_id,
+      thread_id: row.thread_id,
+      assistant_id: row.assistant_id,
+      created_at: row.created_at,
+      updated_at: row.updated_at,
+      status: row.status,
+      metadata: JSON.parse(row.metadata),
+      multitask_strategy: row.multitask_strategy
+    }));
+  }
+  async updateRun(runId, run) {
+    const existingRun = this.db.prepare("SELECT run_id FROM runs WHERE run_id = ?").get(runId);
+    if (!existingRun) {
+      throw new Error(`Run with ID ${runId} not found.`);
+    }
+    const updateFields = [];
+    const values = [];
+    if (run.status !== void 0) {
+      updateFields.push("status = ?");
+      values.push(run.status);
+    }
+    if (run.metadata !== void 0) {
+      updateFields.push("metadata = ?");
+      values.push(JSON.stringify(run.metadata));
+    }
+    if (run.multitask_strategy !== void 0) {
+      updateFields.push("multitask_strategy = ?");
+      values.push(run.multitask_strategy);
+    }
+    updateFields.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    if (updateFields.length > 0) {
+      values.push(runId);
+      this.db.prepare(
+        `
+                UPDATE runs 
+                SET ${updateFields.join(", ")} 
+                WHERE run_id = ?
+            `
+      ).run(...values);
+    }
+  }
+}
+
+const createCheckPointer = async () => {
+  if (process.env.REDIS_URL && process.env.CHECKPOINT_TYPE === "redis" || process.env.CHECKPOINT_TYPE === "shallow/redis") {
+    if (process.env.CHECKPOINT_TYPE === "redis") {
+      console.debug("LG | Using redis as checkpoint");
+      const { RedisSaver } = await import('@langchain/langgraph-checkpoint-redis');
+      return await RedisSaver.fromUrl(process.env.REDIS_URL, {
+        defaultTTL: 60,
+        // TTL in minutes
+        refreshOnRead: true
+      });
+    }
+    if (process.env.CHECKPOINT_TYPE === "shallow/redis") {
+      console.debug("LG | Using shallow redis as checkpoint");
+      const { ShallowRedisSaver } = await import('@langchain/langgraph-checkpoint-redis/shallow');
+      return await ShallowRedisSaver.fromUrl(process.env.REDIS_URL);
+    }
+  }
+  if (process.env.DATABASE_URL) {
+    console.debug("LG | Using postgres as checkpoint");
+    const { createPGCheckpoint } = await import('./checkpoint-DxiUsHMy.js');
+    return createPGCheckpoint();
+  }
+  if (process.env.SQLITE_DATABASE_URI) {
+    console.debug("LG | Using sqlite as checkpoint");
+    const { SqliteSaver } = await import('./checkpoint-BHKV54sL.js');
+    const db = SqliteSaver.fromConnString(process.env.SQLITE_DATABASE_URI);
+    return db;
+  }
+  return new MemorySaver();
+};
+const createMessageQueue = async () => {
+  let q;
+  if (process.env.REDIS_URL) {
+    console.debug("LG | Using redis as stream queue");
+    const { RedisStreamQueue } = await import('./queue-C6iEVbd2.js');
+    q = RedisStreamQueue;
+  } else {
+    q = MemoryStreamQueue;
+  }
+  return new StreamQueueManager(q);
+};
+const createThreadManager = async (config) => {
+  if (process.env.DATABASE_URL && config.checkpointer) {
+    const { PostgresThreadsManager } = await import('./threads-BUgBiCiK.js');
+    const threadsManager = new PostgresThreadsManager(config.checkpointer);
+    if (process.env.DATABASE_INIT === "true") {
+      await threadsManager.setup();
+    }
+    return threadsManager;
+  }
+  if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
+    const threadsManager = new SQLiteThreadsManager(config.checkpointer);
+    await threadsManager.setup();
+    return threadsManager;
+  }
+  return new MemoryThreadsManager();
+};
+
+const [globalMessageQueue, globalCheckPointer] = await Promise.all([createMessageQueue(), createCheckPointer()]);
+console.debug("LG | checkpointer created");
+const globalThreadsManager = await createThreadManager({
+  checkpointer: globalCheckPointer
+});
+console.debug("LG | threads manager created");
+console.debug("LG | global init done");
+class LangGraphGlobal {
+  static globalMessageQueue = globalMessageQueue;
+  static globalCheckPointer = globalCheckPointer;
+  static globalThreadsManager = globalThreadsManager;
+}
+
+async function streamStateWithQueue(threads, run, queue, payload, options) {
+  const kwargs = payload;
+  const graphId = kwargs.config?.configurable?.graph_id;
+  if (!graphId || typeof graphId !== "string") {
+    throw new Error("Invalid or missing graph_id");
+  }
+  const graph = await options.getGraph(graphId, payload.config, {
+    checkpointer: payload.temporary ? null : void 0
+  });
+  const userStreamMode = payload.stream_mode ?? [];
+  const libStreamMode = /* @__PURE__ */ new Set([
+    "values",
+    ...userStreamMode.filter((mode) => mode !== "events" && mode !== "messages-tuple")
+  ]);
+  if (userStreamMode.includes("messages-tuple")) {
+    libStreamMode.add("messages");
+  }
+  if (userStreamMode.includes("messages")) {
+    libStreamMode.add("values");
+  }
+  await queue.push(
+    new EventMessage("metadata", {
+      run_id: run.run_id,
+      attempt: options.attempt,
+      graph_id: graphId
+    })
+  );
+  const metadata = {
+    ...payload.config?.metadata,
+    run_attempt: options.attempt
+  };
+  const events = graph.streamEvents(
+    payload.command != null ? getLangGraphCommand(payload.command) : payload.input ?? null,
+    {
+      version: "v2",
+      interruptAfter: payload.interrupt_after,
+      interruptBefore: payload.interrupt_before,
+      tags: payload.config?.tags,
+      configurable: payload.config?.configurable,
+      recursionLimit: payload.config?.recursionLimit,
+      subgraphs: payload.stream_subgraphs,
+      metadata,
+      runId: run.run_id,
+      streamMode: [...libStreamMode],
+      signal: queue.cancelSignal.signal
+    }
+  );
+  const messages = {};
+  const completedIds = /* @__PURE__ */ new Set();
+  try {
+    for await (const event of events) {
+      if (event.tags?.includes("langsmith:hidden")) continue;
+      if (event.event === "on_chain_stream" && event.run_id === run.run_id) {
+        const [ns, mode, chunk] = payload.stream_subgraphs ? event.data.chunk : [null, ...event.data.chunk];
+        let data = chunk;
+        if (mode === "messages") {
+          if (userStreamMode.includes("messages-tuple")) {
+            await queue.push(new EventMessage("messages", data));
+          }
+        } else if (userStreamMode.includes(mode)) {
+          if (payload.stream_subgraphs && ns?.length) {
+            await queue.push(new EventMessage(`${mode}|${ns.join("|")}`, data));
+          } else {
+            await queue.push(new EventMessage(mode, data));
+          }
+        }
+        if (mode === "values") {
+          await threads.set(run.thread_id, {
+            values: data ? JSON.parse(serialiseAsDict(data)) : ""
+          });
+        }
+      } else if (userStreamMode.includes("events")) {
+        await queue.push(new EventMessage("events", event));
+      }
+      if (userStreamMode.includes("messages")) {
+        if (event.event === "on_chain_stream" && event.run_id === run.run_id) {
+          const newMessages = [];
+          const [_, chunk] = event.data.chunk;
+          let chunkMessages = [];
+          if (typeof chunk === "object" && chunk != null && "messages" in chunk && !isBaseMessage(chunk)) {
+            chunkMessages = chunk?.messages;
+          }
+          if (!Array.isArray(chunkMessages)) {
+            chunkMessages = [chunkMessages];
+          }
+          for (const message of chunkMessages) {
+            if (!message.id || completedIds.has(message.id)) continue;
+            completedIds.add(message.id);
+            newMessages.push(message);
+          }
+          if (newMessages.length > 0) {
+            await queue.push(new EventMessage("messages/complete", newMessages));
+          }
+        } else if (event.event === "on_chat_model_stream" && !event.tags?.includes("nostream")) {
+          const message = event.data.chunk;
+          if (!message.id) continue;
+          if (messages[message.id] == null) {
+            messages[message.id] = message;
+            await queue.push(
+              new EventMessage("messages/metadata", {
+                [message.id]: { metadata: event.metadata }
+              })
+            );
+          } else {
+            messages[message.id] = messages[message.id].concat(message);
+          }
+          await queue.push(new EventMessage("messages/partial", [messages[message.id]]));
+        }
+      }
+    }
+  } finally {
+    await queue.push(new StreamEndEventMessage());
+  }
+}
+const serialiseAsDict = (obj, indent = 2) => {
+  return JSON.stringify(
+    obj,
+    function(key, value) {
+      const rawValue = this[key];
+      if (rawValue != null && typeof rawValue === "object" && "toDict" in rawValue && typeof rawValue.toDict === "function") {
+        const { type, data } = rawValue.toDict();
+        return { ...data, type };
+      }
+      return value;
+    },
+    indent
+  );
+};
+async function* streamState(threads, run, payload, options) {
+  run = await run;
+  const queueId = run.run_id;
+  const threadId = run.thread_id;
+  try {
+    await threads.set(threadId, { status: "busy" });
+    await threads.updateRun(run.run_id, { status: "running" });
+    const queue = LangGraphGlobal.globalMessageQueue.createQueue(queueId);
+    const state = queue.onDataReceive();
+    streamStateWithQueue(threads, run, queue, payload, options).catch((error) => {
+      console.error("Queue task error:", error);
+      LangGraphGlobal.globalMessageQueue.pushToQueue(queueId, new StreamErrorEventMessage(error));
+    });
+    for await (const data of state) {
+      yield data;
+    }
+    await threads.updateRun(run.run_id, { status: "success" });
+  } catch (error) {
+    console.error("Stream error:", error);
+    await threads.updateRun(run.run_id, { status: "error" });
+    await threads.set(threadId, { status: "error" });
+  } finally {
+    await threads.set(threadId, { status: "idle" });
+    LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
+  }
+}
+
+const AssistantEndpoint = {
+  async search(query) {
+    if (query?.graphId) {
+      return [
+        {
+          assistant_id: query.graphId,
+          graph_id: query.graphId,
+          config: {},
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          metadata: {},
+          version: 1,
+          name: query.graphId,
+          description: ""
+        }
+      ];
+    }
+    return Object.entries(GRAPHS).map(
+      ([graphId, _]) => ({
+        assistant_id: graphId,
+        graph_id: graphId,
+        config: {},
+        metadata: {},
+        version: 1,
+        name: graphId,
+        description: "",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  },
+  async getGraph(assistantId, options) {
+    const config = {};
+    const graph = await getGraph(assistantId, config);
+    const drawable = await graph.getGraphAsync({
+      ...config,
+      xray: options?.xray ?? void 0
+    });
+    return drawable.toJSON();
+  }
+};
+const createEndpoint = () => {
+  const threads = LangGraphGlobal.globalThreadsManager;
+  return {
+    assistants: AssistantEndpoint,
+    threads,
+    runs: {
+      list(threadId, options) {
+        return threads.listRuns(threadId, options);
+      },
+      async cancel(threadId, runId, wait, action) {
+        return LangGraphGlobal.globalMessageQueue.cancelQueue(runId);
+      },
+      async *stream(threadId, assistantId, payload) {
+        if (!payload.config) {
+          payload.config = {
+            configurable: {
+              graph_id: assistantId,
+              thread_id: threadId
+            }
+          };
+        }
+        for await (const data of streamState(
+          threads,
+          threads.createRun(threadId, assistantId, payload),
+          payload,
+          {
+            attempt: 0,
+            getGraph
+          }
+        )) {
+          yield data;
+        }
+      },
+      joinStream(threadId, runId, options) {
+        throw new Error("Function not implemented.");
+      }
+    }
+  };
+};
+
+const createEntrypointGraph = ({
+  stateSchema,
+  config,
+  graph
+}) => {
+  const name = graph.getName();
+  return new StateGraph(stateSchema, config).addNode(name, (state, config2) => graph.invoke(state, config2)).addEdge("__start__", name).addEdge(name, "__end__").compile({
+    name
+  });
+};
+
+export { AssistantEndpoint as A, BaseStreamQueue as B, CancelEventMessage as C, LangGraphGlobal as L, createEntrypointGraph as a, createEndpoint as c, getGraph as g, registerGraph as r, serialiseAsDict as s };
+//# sourceMappingURL=index-DcXE-SZb.js.map