@langgraph-js/pure-graph 3.1.2 → 3.2.2

package/dist/{stream-CsqWsCjt.js → stream-jYlUzTZO.js}

@@ -5,6 +5,7 @@ import { EventEmitter } from 'eventemitter3';
 import { load } from '@langchain/core/load';
 import { v7 } from 'uuid';
 import { BaseCheckpointSaver, TASKS, maxChannelVersion, getCheckpointId, copyCheckpoint, uuid6, WRITES_IDX_MAP } from '@langchain/langgraph-checkpoint';
+import 'kysely';
 
 const getLangGraphCommand = (command) => {
   let goto = command.goto != null && !Array.isArray(command.goto) ? [command.goto] : command.goto;
@@ -320,11 +321,7 @@ class StreamQueueManager {
    * @param id 队列 ID / Queue ID
    */
   async cancelQueue(id) {
-    const queue = this.queues.get(id);
-    if (queue) {
-      await queue.cancel();
-      this.removeQueue(id);
-    }
+    await this.removeQueue(id);
   }
   /**
    * 向指定 id 的队列推送数据
@@ -369,10 +366,32 @@ class StreamQueueManager {
    * @param id 队列 ID / Queue ID
    * @returns 是否成功删除 / Whether successfully deleted
    */
-  removeQueue(id) {
-    setTimeout(() => {
-      return this.queues.delete(id);
-    }, 500);
+  async removeQueue(id) {
+    const queue = this.queues.get(id);
+    if (!queue) {
+      return false;
+    }
+    try {
+      await queue.cancel();
+    } catch (e) {
+      console.error("Error cancelling queue:", e);
+    }
+    try {
+      const clearResult = queue.clear();
+      if (clearResult instanceof Promise) {
+        await clearResult;
+      }
+    } catch (e) {
+      console.error("Error clearing queue:", e);
+    }
+    if (typeof queue.destroy === "function") {
+      try {
+        await queue.destroy();
+      } catch (e) {
+        console.error("Error destroying queue:", e);
+      }
+    }
+    return this.queues.delete(id);
   }
   /**
    * 获取所有队列的 ID
@@ -447,15 +466,29 @@ class KyselyThreadsManager {
   }
   async create(payload) {
     const threadId = payload?.threadId || v7();
+    const now = /* @__PURE__ */ new Date();
+    const metadata = payload?.metadata || {};
+    const interrupts = {};
     if (payload?.ifExists === "raise") {
       const existing = await this.db.selectFrom("threads").select("thread_id").where("thread_id", "=", threadId).executeTakeFirst();
       if (existing) {
         throw new Error(`Thread with ID ${threadId} already exists.`);
       }
     }
-    const now = /* @__PURE__ */ new Date();
-    const metadata = payload?.metadata || {};
-    const interrupts = {};
+    if (payload?.ifExists === "do_nothing" && payload?.threadId) {
+      const existing = await this.db.selectFrom("threads").selectAll().where("thread_id", "=", threadId).executeTakeFirst();
+      if (existing) {
+        return {
+          thread_id: existing.thread_id,
+          created_at: this.adapter.dbToDate(existing.created_at).toISOString(),
+          updated_at: this.adapter.dbToDate(existing.updated_at).toISOString(),
+          metadata: this.adapter.dbToJson(existing.metadata),
+          status: existing.status,
+          values: existing.values ? this.adapter.dbToJson(existing.values) : null,
+          interrupts: this.adapter.dbToJson(existing.interrupts)
+        };
+      }
+    }
     await this.db.insertInto("threads").values({
       thread_id: threadId,
       created_at: this.adapter.dateToDb(now),
@@ -595,10 +628,17 @@ class KyselyThreadsManager {
     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;
+    if (!graphId) {
+      await this.set(threadId, {
+        values: thread.values ?? null
+      });
+      return {
+        configurable: {
+          thread_id: threadId
+        }
+      };
+    }
     const config = {
       configurable: {
         thread_id: threadId,
@@ -1145,13 +1185,19 @@ class StreamErrorEventMessage extends EventMessage {
 
 class MemoryStreamQueue extends BaseStreamQueue {
   data = [];
+  activeGenerators = /* @__PURE__ */ new Set();
+  isDestroyed = false;
   async push(item) {
+    if (this.isDestroyed) return;
     const data = this.compressMessages ? await this.encodeData(item) : item;
     this.data.push(data);
     this.emit("dataChange", data);
   }
   onDataChange(listener) {
+    if (this.isDestroyed) return () => {
+    };
     this.on("dataChange", async (item) => {
+      if (this.isDestroyed) return;
       listener(this.compressMessages ? await this.decodeData(item) : item);
     });
     return () => this.off("dataChange", listener);
@@ -1160,16 +1206,27 @@ class MemoryStreamQueue extends BaseStreamQueue {
    * 异步生成器：支持 for await...of 方式消费队列数据
    */
   async *onDataReceive() {
-    let queue = [];
+    if (this.isDestroyed) {
+      return;
+    }
+    const localAbortController = new AbortController();
+    this.activeGenerators.add(localAbortController);
+    let localQueue = [];
     let pendingResolve = null;
     let isStreamEnded = false;
     let isCleanupDone = false;
+    let endTimeoutId = null;
     const handleData = async (item) => {
+      if (isCleanupDone || localAbortController.signal.aborted) return;
       try {
         const data = this.compressMessages ? await this.decodeData(item) : item;
-        queue.push(data);
+        localQueue.push(data);
         if (data.event === "__stream_end__" || data.event === "__stream_error__" || data.event === "__stream_cancel__") {
-          setTimeout(() => {
+          if (endTimeoutId) {
+            clearTimeout(endTimeoutId);
+            endTimeoutId = null;
+          }
+          endTimeoutId = setTimeout(() => {
             isStreamEnded = true;
             if (pendingResolve) {
               pendingResolve();
@@ -1177,7 +1234,7 @@ class MemoryStreamQueue extends BaseStreamQueue {
             }
           }, 300);
           if (data.event === "__stream_cancel__") {
-            await this.cancel();
+            localAbortController.abort("stream cancelled");
           }
         }
         if (pendingResolve) {
@@ -1200,35 +1257,39 @@ class MemoryStreamQueue extends BaseStreamQueue {
         pendingResolve = null;
       }
     };
-    this.cancelSignal.signal.addEventListener("abort", abortHandler);
+    localAbortController.signal.addEventListener("abort", abortHandler);
     const cleanup = () => {
       if (isCleanupDone) return;
       isCleanupDone = true;
+      if (endTimeoutId) {
+        clearTimeout(endTimeoutId);
+        endTimeoutId = null;
+      }
       try {
         this.off("dataChange", handleData);
       } catch (e) {
-        console.error("Error removing dataChange listener:", e);
       }
       try {
-        this.cancelSignal.signal.removeEventListener("abort", abortHandler);
+        localAbortController.signal.removeEventListener("abort", abortHandler);
       } catch (e) {
-        console.error("Error removing abort listener:", e);
       }
       if (pendingResolve) {
         pendingResolve();
         pendingResolve = null;
       }
+      localQueue.length = 0;
+      this.activeGenerators.delete(localAbortController);
     };
     try {
-      if (this.cancelSignal.signal.aborted) {
+      if (localAbortController.signal.aborted || this.isDestroyed) {
         return;
       }
-      while (!isStreamEnded && !this.cancelSignal.signal.aborted) {
-        if (queue.length > 0) {
-          for (const item of queue) {
+      while (!isStreamEnded && !localAbortController.signal.aborted && !this.isDestroyed) {
+        if (localQueue.length > 0) {
+          for (const item of localQueue) {
             yield item;
           }
-          queue = [];
+          localQueue.length = 0;
         } else {
           await new Promise((resolve) => {
             pendingResolve = resolve;
@@ -1240,17 +1301,29 @@ class MemoryStreamQueue extends BaseStreamQueue {
     }
   }
   async getAll() {
+    if (this.isDestroyed) return [];
     return this.compressMessages ? await Promise.all(
       this.data.map((i) => this.decodeData(i))
-    ) : this.data;
+    ) : [...this.data];
   }
   clear() {
-    this.data = [];
+    this.data.length = 0;
   }
   cancelSignal = new AbortController();
   async cancel() {
-    this.cancelSignal.abort("user cancel this run");
-    await this.push(new CancelEventMessage());
+    for (const controller of this.activeGenerators) {
+      try {
+        controller.abort("user cancel this run");
+      } catch (e) {
+      }
+    }
+    this.activeGenerators.clear();
+    if (!this.cancelSignal.signal.aborted) {
+      this.cancelSignal.abort("user cancel this run");
+    }
+    if (!this.isDestroyed) {
+      await this.push(new CancelEventMessage());
+    }
   }
   async copyToQueue(toId, ttl) {
     const data = this.data.slice();
@@ -1258,6 +1331,17 @@ class MemoryStreamQueue extends BaseStreamQueue {
     queue.data = data;
     return queue;
   }
+  /**
+   * 销毁队列，释放所有资源
+   */
+  async destroy() {
+    if (this.isDestroyed) return;
+    this.isDestroyed = true;
+    await this.cancel();
+    this.clear();
+    this.removeAllListeners();
+    this.activeGenerators.clear();
+  }
 }
 
 class MemoryThreadsManager {
@@ -1599,7 +1683,7 @@ class MemoryThreadsManager {
 }
 
 const createCheckPointer = async () => {
-  if (process.env.REDIS_URL && process.env.CHECKPOINT_TYPE === "redis" || process.env.CHECKPOINT_TYPE === "shallow/redis") {
+  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');
@@ -1621,9 +1705,15 @@ const createCheckPointer = async () => {
     return createPGCheckpoint();
   }
   if (process.env.SQLITE_DATABASE_URI) {
-    console.debug("LG | Using sqlite as checkpoint");
-    const { SqliteSaver } = await import('./checkpoint-1sAx_j1E.js');
-    const db = await SqliteSaver.fromConnStringAsync(process.env.SQLITE_DATABASE_URI);
+    if (process.env.CHECKPOINT_TYPE === "sqlite") {
+      console.debug("LG | Using sqlite (full) as checkpoint");
+      const { SqliteSaver } = await import('./checkpoint-CY59Lr2q.js');
+      const db2 = await SqliteSaver.fromConnStringAsync(process.env.SQLITE_DATABASE_URI);
+      return db2;
+    }
+    console.debug("LG | Using shallow sqlite as checkpoint (default)");
+    const { SqliteShallowSaver: SqliteShallowSaver2 } = await import('./shallow-checkpoint-ImbLxYNR.js');
+    const db = await SqliteShallowSaver2.fromConnStringAsync(process.env.SQLITE_DATABASE_URI);
     return db;
   }
   console.log("LG | You are using memory as checkpoint!");
@@ -1641,7 +1731,7 @@ const createMessageQueue = async () => {
   let q;
   if (process.env.REDIS_URL) {
     console.debug("LG | Using redis as stream queue");
-    const { RedisStreamQueue } = await import('./queue-Cu_nO_wt.js');
+    const { RedisStreamQueue } = await import('./queue-CUe5TDP1.js');
     q = RedisStreamQueue;
   } else {
     q = MemoryStreamQueue;
@@ -1681,7 +1771,7 @@ const createThreadManager = async (config) => {
   }
   if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
     console.debug("LG | Using SQLite ThreadsManager");
-    const { SQLiteAdapter } = await import('./sqlite-adapter-BKOLSdoL.js');
+    const { SQLiteAdapter } = await import('./sqlite-adapter-CJXgit1j.js');
     const database = config.checkpointer.db;
     const threadsManager = new KyselyThreadsManager(new SQLiteAdapter(database));
     await threadsManager.setup();
@@ -1727,7 +1817,7 @@ async function streamStateWithQueue(threads, run, queue, payload, options) {
   const graph = await options.getGraph(graphId, payload.config, {
     checkpointer: payload.temporary ? null : void 0
   });
-  const userStreamMode = payload.streamMode ?? [];
+  const userStreamMode = Array.isArray(payload.streamMode) ? payload.streamMode : payload.streamMode ? [payload.streamMode] : [];
   const libStreamMode = /* @__PURE__ */ new Set([
     "values",
     ...userStreamMode.filter((mode) => mode !== "events" && mode !== "messages-tuple")
@@ -1749,27 +1839,28 @@ async function streamStateWithQueue(threads, run, queue, payload, options) {
     ...payload.config?.metadata,
     run_attempt: options.attempt
   };
-  const events = graph.stream(
-    payload.command != null ? getLangGraphCommand(payload.command) : payload.input ?? null,
-    {
-      interruptAfter: payload.interruptAfter,
-      interruptBefore: payload.interruptBefore,
-      tags: payload.config?.tags,
-      configurable: payload.config?.configurable,
-      recursionLimit: payload.config?.recursionLimit,
-      subgraphs: payload.streamSubgraphs,
-      metadata,
-      runId: run.run_id,
-      streamMode: [...libStreamMode],
-      signal: queue.cancelSignal.signal
-    }
-  );
-  let sendedMetadataMessage;
-  let messageChunks;
+  let sendedMetadataMessage = null;
+  let messageChunks = null;
+  let eventsIterator = null;
   try {
     sendedMetadataMessage = /* @__PURE__ */ new Set();
     messageChunks = /* @__PURE__ */ new Map();
-    for await (const event of await events) {
+    eventsIterator = await graph.stream(
+      payload.command != null ? getLangGraphCommand(payload.command) : payload.input ?? null,
+      {
+        interruptAfter: payload.interruptAfter,
+        interruptBefore: payload.interruptBefore,
+        tags: payload.config?.tags,
+        configurable: payload.config?.configurable,
+        recursionLimit: payload.config?.recursionLimit,
+        subgraphs: payload.streamSubgraphs,
+        metadata,
+        runId: run.run_id,
+        streamMode: [...libStreamMode],
+        signal: queue.cancelSignal.signal
+      }
+    );
+    for await (const event of eventsIterator) {
       let ns = [];
       if (event.length === 3) {
         ns = event.splice(0, 1);
@@ -1821,14 +1912,29 @@ async function streamStateWithQueue(threads, run, queue, payload, options) {
         await queue.push(new EventMessage(getNameWithNs("updates"), updates));
       }
     }
+  } catch (error) {
+    if (!(error instanceof Error && error.message?.includes("cancel"))) {
+      console.error("streamStateWithQueue error:", error);
+      try {
+        await queue.push(new StreamErrorEventMessage(error));
+      } catch (e) {
+      }
+    }
+    throw error;
   } finally {
-    await queue.push(new StreamEndEventMessage());
+    try {
+      await queue.push(new StreamEndEventMessage());
+    } catch (e) {
+    }
     if (sendedMetadataMessage) {
       sendedMetadataMessage.clear();
+      sendedMetadataMessage = null;
     }
     if (messageChunks) {
       messageChunks.clear();
+      messageChunks = null;
     }
+    eventsIterator = null;
   }
 }
 const serialiseAsDict = (obj, indent = 0) => {
@@ -1849,12 +1955,17 @@ async function* streamState(threads, run, payload, options) {
   run = await run;
   const queueId = run.run_id;
   const threadId = run.thread_id;
+  let state = null;
+  let queue = null;
+  let backgroundTask = null;
+  let isCleaningUp = false;
   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) => {
+    queue = LangGraphGlobal.globalMessageQueue.createQueue(queueId);
+    state = queue.onDataReceive();
+    backgroundTask = streamStateWithQueue(threads, run, queue, payload, options).catch((error) => {
+      if (isCleaningUp) return;
       if (error.message !== "user cancel this run") console.error("Queue task error:", error);
       LangGraphGlobal.globalMessageQueue.pushToQueue(queueId, new StreamErrorEventMessage(error));
     });
@@ -1867,16 +1978,40 @@ async function* streamState(threads, run, payload, options) {
     await threads.updateRun(run.run_id, { status: "error" });
     await threads.set(threadId, { status: "error" });
   } finally {
+    isCleaningUp = true;
+    if (state) {
+      try {
+        await state.return(void 0);
+      } catch (e) {
+      }
+      state = null;
+    }
+    if (queue && !queue.cancelSignal.signal.aborted) {
+      try {
+        queue.cancelSignal.abort("Stream consumer disconnected");
+      } catch (e) {
+      }
+    }
+    if (backgroundTask) {
+      try {
+        await Promise.race([
+          backgroundTask,
+          new Promise((resolve) => setTimeout(resolve, 1e3))
+        ]);
+      } catch (e) {
+      }
+      backgroundTask = null;
+    }
     const nowState = await threads.get(threadId);
     if (nowState.status === "interrupted") {
       await LangGraphGlobal.globalMessageQueue.copyQueue(queueId, threadId, 3e4);
     } else {
       await threads.set(threadId, { status: "idle", interrupts: {} });
     }
-    await LangGraphGlobal.globalMessageQueue.clearQueue(queueId);
-    LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
+    await LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
+    queue = null;
   }
 }
 
 export { BaseStreamQueue as B, CancelEventMessage as C, GRAPHS as G, KyselyThreadsManager as K, LangGraphGlobal as L, streamState as a, getGraph as g, registerGraph as r, serialiseAsDict as s };
-//# sourceMappingURL=stream-CsqWsCjt.js.map
+//# sourceMappingURL=stream-jYlUzTZO.js.map