@langgraph-js/pure-graph 2.10.0 → 3.0.0

package/dist/{stream-D0YD2Pjq.js → stream-umoA6h4q.js}

@@ -3,6 +3,7 @@ import { Command, Send } from '@langchain/langgraph';
 import { concat } from '@langchain/core/utils/stream';
 import { EventEmitter } from 'eventemitter3';
 import { load } from '@langchain/core/load';
+import { v7 } from 'uuid';
 import { MemorySaver } from '@langchain/langgraph-checkpoint';
 
 const getLangGraphCommand = (command) => {
@@ -353,10 +354,13 @@ class StreamQueueManager {
    * Clear queue with specified id
    * @param id 队列 ID / Queue ID
    */
-  clearQueue(id) {
+  async clearQueue(id) {
     const queue = this.queues.get(id);
     if (queue) {
-      queue.clear();
+      const result = queue.clear();
+      if (result instanceof Promise) {
+        await result;
+      }
     }
   }
   /**
@@ -442,7 +446,7 @@ class KyselyThreadsManager {
     await this.adapter.createIndexes(this.db);
   }
   async create(payload) {
-    const threadId = payload?.threadId || crypto.randomUUID();
+    const threadId = payload?.threadId || v7();
     if (payload?.ifExists === "raise") {
       const existing = await this.db.selectFrom("threads").select("thread_id").where("thread_id", "=", threadId).executeTakeFirst();
       if (existing) {
@@ -472,9 +476,38 @@ class KyselyThreadsManager {
     };
   }
   async search(query) {
-    let queryBuilder = this.db.selectFrom("threads").selectAll();
-    if (query?.withoutDetails) {
-      queryBuilder = this.db.selectFrom("threads").select(["thread_id", "created_at", "updated_at", "metadata", "status"]);
+    let queryBuilder = this.db.selectFrom("threads");
+    let selectedFields;
+    if (query?.select) {
+      selectedFields = new Set(query.select);
+    } else if (query?.withoutDetails) {
+      selectedFields = /* @__PURE__ */ new Set(["thread_id", "created_at", "updated_at", "metadata", "status"]);
+    } else {
+      selectedFields = /* @__PURE__ */ new Set([
+        "thread_id",
+        "created_at",
+        "updated_at",
+        "metadata",
+        "status",
+        "values",
+        "interrupts"
+      ]);
+    }
+    const selections = [];
+    if (selectedFields.has("thread_id")) selections.push("thread_id");
+    if (selectedFields.has("created_at")) selections.push("created_at");
+    if (selectedFields.has("updated_at")) selections.push("updated_at");
+    if (selectedFields.has("metadata")) selections.push("metadata");
+    if (selectedFields.has("status")) selections.push("status");
+    if (selectedFields.has("values")) selections.push("values");
+    if (selectedFields.has("interrupts")) selections.push("interrupts");
+    if (selections.length > 0) {
+      queryBuilder = queryBuilder.select(selections);
+    } else {
+      queryBuilder = queryBuilder.selectAll();
+    }
+    if (query?.ids && query.ids.length > 0) {
+      queryBuilder = queryBuilder.where("thread_id", "in", query.ids);
     }
     if (query?.status) {
       queryBuilder = queryBuilder.where("status", "=", query.status);
@@ -484,6 +517,11 @@ class KyselyThreadsManager {
         queryBuilder = queryBuilder.where(this.adapter.buildJsonQuery(this.db, "metadata", key, value));
       }
     }
+    if (query?.values) {
+      queryBuilder = queryBuilder.where((eb) => {
+        return eb("values", "=", this.adapter.jsonToDb(query.values));
+      });
+    }
     if (query?.sortBy) {
       const order = query.sortOrder === "desc" ? "desc" : "asc";
       queryBuilder = queryBuilder.orderBy(query.sortBy, order);
@@ -495,15 +533,19 @@ class KyselyThreadsManager {
       }
     }
     const rows = await queryBuilder.execute();
-    return rows.map((row) => ({
-      thread_id: row.thread_id,
-      created_at: this.adapter.dbToDate(row.created_at).toISOString(),
-      updated_at: this.adapter.dbToDate(row.updated_at).toISOString(),
-      metadata: this.adapter.dbToJson(row.metadata),
-      status: row.status,
-      values: row.values ? this.adapter.dbToJson(row.values) : null,
-      interrupts: this.adapter.dbToJson(row.interrupts)
-    }));
+    return rows.map((row) => {
+      const result = { thread_id: row.thread_id };
+      if (selectedFields.has("created_at"))
+        result.created_at = this.adapter.dbToDate(row.created_at).toISOString();
+      if (selectedFields.has("updated_at"))
+        result.updated_at = this.adapter.dbToDate(row.updated_at).toISOString();
+      if (selectedFields.has("metadata")) result.metadata = this.adapter.dbToJson(row.metadata);
+      if (selectedFields.has("status")) result.status = row.status;
+      if (selectedFields.has("values"))
+        result.values = row.values ? this.adapter.dbToJson(row.values) : null;
+      if (selectedFields.has("interrupts")) result.interrupts = this.adapter.dbToJson(row.interrupts);
+      return result;
+    });
   }
   async get(threadId) {
     const row = await this.db.selectFrom("threads").selectAll().where("thread_id", "=", threadId).executeTakeFirst();
@@ -542,6 +584,12 @@ class KyselyThreadsManager {
     }
     await this.db.updateTable("threads").set(updates).where("thread_id", "=", threadId).execute();
   }
+  async delete(threadId) {
+    const result = await this.db.deleteFrom("threads").where("thread_id", "=", threadId).executeTakeFirst();
+    if (result.numDeletedRows === 0n) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+  }
   async updateState(threadId, thread) {
     const targetThread = await this.get(threadId);
     if (targetThread.status === "busy") {
@@ -563,14 +611,8 @@ class KyselyThreadsManager {
     await this.set(threadId, { values: JSON.parse(serialiseAsDict(graphState.values)) });
     return nextConfig;
   }
-  async delete(threadId) {
-    const result = await this.db.deleteFrom("threads").where("thread_id", "=", threadId).executeTakeFirst();
-    if (result.numDeletedRows === 0n) {
-      throw new Error(`Thread with ID ${threadId} not found.`);
-    }
-  }
   async createRun(threadId, assistantId, payload) {
-    const runId = crypto.randomUUID();
+    const runId = v7();
     const now = /* @__PURE__ */ new Date();
     const metadata = payload?.metadata ?? {};
     await this.db.insertInto("runs").values({
@@ -636,6 +678,146 @@ class KyselyThreadsManager {
     }
     await this.db.updateTable("runs").set(updates).where("run_id", "=", runId).execute();
   }
+  // New methods for Threads API
+  async count(query) {
+    const threads = await this.search(query);
+    return threads.length;
+  }
+  async patch(threadId, updates) {
+    const existing = await this.db.selectFrom("threads").selectAll().where("thread_id", "=", threadId).executeTakeFirst();
+    if (!existing) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    const patchUpdates = {
+      updated_at: this.adapter.dateToDb(/* @__PURE__ */ new Date())
+    };
+    if (updates.metadata !== void 0) {
+      const existingMetadata = this.adapter.dbToJson(existing.metadata) || {};
+      patchUpdates.metadata = this.adapter.jsonToDb({ ...existingMetadata, ...updates.metadata });
+    }
+    if (updates.status !== void 0) {
+      patchUpdates.status = updates.status;
+    }
+    if (updates.values !== void 0) {
+      patchUpdates.values = updates.values ? this.adapter.jsonToDb(updates.values) : null;
+    }
+    if (updates.interrupts !== void 0) {
+      patchUpdates.interrupts = this.adapter.jsonToDb(updates.interrupts);
+    }
+    await this.db.updateTable("threads").set(patchUpdates).where("thread_id", "=", threadId).execute();
+    return await this.get(threadId);
+  }
+  async getState(threadId, options) {
+    const thread = await this.get(threadId);
+    if (options?.checkpointId) {
+      const checkpoint = await this.db.selectFrom("checkpoints").selectAll().where("checkpoint_id", "=", options.checkpointId).where("thread_id", "=", threadId).executeTakeFirst();
+      if (!checkpoint) {
+        throw new Error(`Checkpoint with ID ${options.checkpointId} not found for thread ${threadId}`);
+      }
+      return {
+        values: this.adapter.dbToJson(checkpoint.values),
+        next: this.adapter.dbToJson(checkpoint.next),
+        metadata: this.adapter.dbToJson(checkpoint.metadata),
+        checkpoint: {
+          /** @ts-ignore */
+          id: checkpoint.checkpoint_id,
+          thread_id: threadId,
+          parent_checkpoint_id: null,
+          checkpoint_ns: "",
+          metadata: this.adapter.dbToJson(checkpoint.metadata),
+          created_at: this.adapter.dbToDate(checkpoint.created_at).toISOString()
+        },
+        created_at: this.adapter.dbToDate(checkpoint.created_at).toISOString(),
+        parent_checkpoint: null,
+        tasks: []
+      };
+    }
+    const state = {
+      values: thread.values || {},
+      next: [],
+      metadata: thread.metadata,
+      /**@ts-ignore 没有查询 checkpointer */
+      checkpoint: null,
+      created_at: thread.created_at,
+      parent_checkpoint: null,
+      tasks: []
+    };
+    return state;
+  }
+  async getStateHistory(threadId, options) {
+    let queryBuilder = this.db.selectFrom("checkpoints").selectAll().where("thread_id", "=", threadId).orderBy("created_at", "asc");
+    const checkpoints = await queryBuilder.execute();
+    let history = checkpoints.map(
+      (cp) => ({
+        values: this.adapter.dbToJson(cp.values),
+        next: this.adapter.dbToJson(cp.next),
+        metadata: this.adapter.dbToJson(cp.metadata),
+        checkpoint: {
+          thread_id: threadId,
+          checkpoint_ns: "",
+          checkpoint_id: cp.checkpoint_id,
+          checkpoint_map: null
+        },
+        created_at: this.adapter.dbToDate(cp.created_at).toISOString(),
+        parent_checkpoint: null,
+        tasks: []
+      })
+    );
+    if (options?.before) {
+      const beforeIndex = checkpoints.findIndex((c) => c.checkpoint_id === options.before);
+      if (beforeIndex !== -1) {
+        history = history.slice(beforeIndex + 1);
+      }
+    }
+    if (options?.limit) {
+      history = history.slice(0, options.limit);
+    }
+    return history;
+  }
+  async copy(threadId) {
+    const originalThread = await this.get(threadId);
+    const newThreadId = v7();
+    const now = /* @__PURE__ */ new Date();
+    await this.db.insertInto("threads").values({
+      thread_id: newThreadId,
+      created_at: this.adapter.dateToDb(now),
+      updated_at: this.adapter.dateToDb(now),
+      metadata: this.adapter.jsonToDb(originalThread.metadata),
+      status: originalThread.status,
+      values: originalThread.values ? this.adapter.jsonToDb(originalThread.values) : null,
+      interrupts: this.adapter.jsonToDb(originalThread.interrupts)
+    }).execute();
+    const checkpoints = await this.db.selectFrom("checkpoints").selectAll().where("thread_id", "=", threadId).orderBy("created_at", "asc").execute();
+    for (const cp of checkpoints) {
+      await this.db.insertInto("checkpoints").values({
+        checkpoint_id: v7(),
+        thread_id: newThreadId,
+        values: cp.values,
+        next: cp.next,
+        config: cp.config,
+        created_at: cp.created_at,
+        metadata: cp.metadata
+      }).execute();
+    }
+    return {
+      ...originalThread,
+      thread_id: newThreadId,
+      created_at: now.toISOString(),
+      updated_at: now.toISOString()
+    };
+  }
+  // Helper method to save checkpoint (used internally)
+  async saveCheckpoint(threadId, values, next, config, metadata) {
+    await this.db.insertInto("checkpoints").values({
+      checkpoint_id: v7(),
+      thread_id: threadId,
+      values: this.adapter.jsonToDb(values),
+      next: this.adapter.jsonToDb(next),
+      config: this.adapter.jsonToDb(config),
+      created_at: this.adapter.dateToDb(/* @__PURE__ */ new Date()),
+      metadata: this.adapter.jsonToDb(metadata || {})
+    }).execute();
+  }
 }
 
 class EventMessage {
@@ -686,27 +868,33 @@ class MemoryStreamQueue extends BaseStreamQueue {
     let queue = [];
     let pendingResolve = null;
     let isStreamEnded = false;
-    if (this.cancelSignal.signal.aborted) {
-      return;
-    }
+    let isCleanupDone = 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;
+      try {
+        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__") {
+            await this.cancel();
           }
-        }, 300);
-        if (data.event === "__stream_cancel__") {
-          await this.cancel();
         }
-      }
-      if (pendingResolve) {
-        pendingResolve();
-        pendingResolve = null;
+        if (pendingResolve) {
+          pendingResolve();
+          pendingResolve = null;
+        }
+      } catch (error) {
+        console.error("Error in handleData:", error);
+        if (pendingResolve) {
+          pendingResolve();
+          pendingResolve = null;
+        }
       }
     };
     this.on("dataChange", handleData);
@@ -718,7 +906,28 @@ class MemoryStreamQueue extends BaseStreamQueue {
       }
     };
     this.cancelSignal.signal.addEventListener("abort", abortHandler);
+    const cleanup = () => {
+      if (isCleanupDone) return;
+      isCleanupDone = true;
+      try {
+        this.off("dataChange", handleData);
+      } catch (e) {
+        console.error("Error removing dataChange listener:", e);
+      }
+      try {
+        this.cancelSignal.signal.removeEventListener("abort", abortHandler);
+      } catch (e) {
+        console.error("Error removing abort listener:", e);
+      }
+      if (pendingResolve) {
+        pendingResolve();
+        pendingResolve = null;
+      }
+    };
     try {
+      if (this.cancelSignal.signal.aborted) {
+        return;
+      }
       while (!isStreamEnded && !this.cancelSignal.signal.aborted) {
         if (queue.length > 0) {
           for (const item of queue) {
@@ -732,8 +941,7 @@ class MemoryStreamQueue extends BaseStreamQueue {
         }
       }
     } finally {
-      this.off("dataChange", handleData);
-      this.cancelSignal.signal.removeEventListener("abort", abortHandler);
+      cleanup();
     }
   }
   async getAll() {
@@ -750,7 +958,7 @@ class MemoryStreamQueue extends BaseStreamQueue {
     await this.push(new CancelEventMessage());
   }
   async copyToQueue(toId, ttl) {
-    const data = this.data;
+    const data = this.data.slice();
     const queue = new MemoryStreamQueue(toId, this.compressMessages, ttl ?? this.ttl);
     queue.data = data;
     return queue;
@@ -759,11 +967,12 @@ class MemoryStreamQueue extends BaseStreamQueue {
 
 class MemoryThreadsManager {
   threads = [];
+  checkpoints = /* @__PURE__ */ new Map();
   async setup() {
     return;
   }
   async create(payload) {
-    const threadId = payload?.threadId || crypto.randomUUID();
+    const threadId = payload?.threadId || v7();
     if (payload?.ifExists === "raise" && this.threads.some((t) => t.thread_id === threadId)) {
       throw new Error(`Thread with ID ${threadId} already exists.`);
     }
@@ -776,11 +985,15 @@ class MemoryThreadsManager {
       values: null,
       interrupts: {}
     };
+    this.checkpoints.set(threadId, []);
     this.threads.push(thread);
     return thread;
   }
   async search(query) {
     let filteredThreads = [...this.threads];
+    if (query?.ids && query.ids.length > 0) {
+      filteredThreads = filteredThreads.filter((t) => query.ids.includes(t.thread_id));
+    }
     if (query?.status) {
       filteredThreads = filteredThreads.filter((t) => t.status === query.status);
     }
@@ -793,11 +1006,21 @@ class MemoryThreadsManager {
         }
       }
     }
+    if (query?.values) {
+      filteredThreads = filteredThreads.filter((t) => {
+        if (!t.values) return false;
+        return this.deepEqual(t.values, query.values);
+      });
+    }
     if (query?.sortBy) {
       filteredThreads.sort((a, b) => {
         let aValue;
         let bValue;
         switch (query.sortBy) {
+          case "thread_id":
+            aValue = a.thread_id;
+            bValue = b.thread_id;
+            break;
           case "created_at":
             aValue = new Date(a.created_at).getTime();
             bValue = new Date(b.created_at).getTime();
@@ -806,26 +1029,64 @@ class MemoryThreadsManager {
             aValue = new Date(a.updated_at).getTime();
             bValue = new Date(b.updated_at).getTime();
             break;
+          case "status":
+            aValue = a.status;
+            bValue = b.status;
+            break;
           default:
             return 0;
         }
         if (query.sortOrder === "desc") {
-          return bValue - aValue;
+          return bValue > aValue ? 1 : bValue < aValue ? -1 : 0;
         } else {
-          return aValue - bValue;
+          return aValue > bValue ? 1 : aValue < bValue ? -1 : 0;
         }
       });
     }
     const offset = query?.offset || 0;
     const limit = query?.limit || filteredThreads.length;
-    return filteredThreads.slice(offset, offset + limit).map((i) => {
-      if (query?.withoutDetails) {
-        i.values = null;
-        i.interrupts = null;
+    const paginatedThreads = filteredThreads.slice(offset, offset + limit);
+    return paginatedThreads.map((i) => {
+      const result = { thread_id: i.thread_id };
+      let includeFields;
+      if (query?.select) {
+        includeFields = new Set(query.select);
+      } else if (query?.withoutDetails) {
+        includeFields = /* @__PURE__ */ new Set(["thread_id", "created_at", "updated_at", "metadata", "status"]);
+      } else {
+        includeFields = /* @__PURE__ */ new Set([
+          "thread_id",
+          "created_at",
+          "updated_at",
+          "metadata",
+          "status",
+          "values",
+          "interrupts"
+        ]);
       }
-      return i;
+      if (includeFields.has("thread_id")) result.thread_id = i.thread_id;
+      if (includeFields.has("created_at")) result.created_at = i.created_at;
+      if (includeFields.has("updated_at")) result.updated_at = i.updated_at;
+      if (includeFields.has("metadata")) result.metadata = i.metadata;
+      if (includeFields.has("status")) result.status = i.status;
+      if (includeFields.has("values")) result.values = i.values;
+      if (includeFields.has("interrupts")) result.interrupts = i.interrupts;
+      return result;
     });
   }
+  deepEqual(a, b) {
+    if (a === b) return true;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object" || a === null || b === null) return false;
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!keysB.includes(key)) return false;
+      if (!this.deepEqual(a[key], b[key])) return false;
+    }
+    return true;
+  }
   async get(threadId) {
     const thread = this.threads.find((t) => t.thread_id === threadId);
     if (!thread) {
@@ -843,6 +1104,7 @@ class MemoryThreadsManager {
   async delete(threadId) {
     const initialLength = this.threads.length;
     this.threads = this.threads.filter((t) => t.thread_id !== threadId);
+    this.checkpoints.delete(threadId);
     if (this.threads.length === initialLength) {
       throw new Error(`Thread with ID ${threadId} not found.`);
     }
@@ -856,26 +1118,38 @@ class MemoryThreadsManager {
     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.`);
+    this.threads[index] = {
+      ...targetThread,
+      values: thread.values,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (targetThread.metadata?.graph_id) {
+      const graphId = targetThread.metadata?.graph_id;
+      const config = {
+        configurable: {
+          thread_id: threadId,
+          graph_id: graphId
+        }
+      };
+      try {
+        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;
+      } catch (error) {
+        console.warn("Failed to update graph state:", error);
+      }
     }
-    const graphId = targetThread.metadata?.graph_id;
-    const config = {
+    return {
       configurable: {
-        thread_id: threadId,
-        graph_id: graphId
+        thread_id: threadId
       }
     };
-    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 runId = v7();
     const run = {
       run_id: runId,
       thread_id: threadId,
@@ -906,6 +1180,127 @@ class MemoryThreadsManager {
     }
     this.runs[index] = { ...this.runs[index], ...run };
   }
+  // New methods for Threads API
+  async count(query) {
+    const threads = await this.search(query);
+    return threads.length;
+  }
+  async patch(threadId, updates) {
+    const index = this.threads.findIndex((t) => t.thread_id === threadId);
+    if (index === -1) {
+      throw new Error(`Thread with ID ${threadId} not found.`);
+    }
+    const updatedThread = {
+      ...this.threads[index],
+      ...updates,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: updates.metadata ? { ...this.threads[index].metadata, ...updates.metadata } : this.threads[index].metadata
+    };
+    this.threads[index] = updatedThread;
+    return updatedThread;
+  }
+  async getState(threadId, options) {
+    const thread = await this.get(threadId);
+    if (options?.checkpointId) {
+      const checkpoints = this.checkpoints.get(threadId) || [];
+      const checkpoint = checkpoints.find((c) => c.checkpoint_id === options.checkpointId);
+      if (!checkpoint) {
+        throw new Error(`Checkpoint with ID ${options.checkpointId} not found for thread ${threadId}`);
+      }
+      return {
+        values: checkpoint.values,
+        next: checkpoint.next,
+        metadata: checkpoint.metadata,
+        checkpoint: {
+          /** @ts-ignore 附加属性 */
+          id: checkpoint.checkpoint_id,
+          thread_id: threadId,
+          parent_checkpoint_id: null,
+          checkpoint_ns: "",
+          metadata: checkpoint.metadata,
+          created_at: checkpoint.created_at
+        },
+        created_at: checkpoint.created_at,
+        parent_checkpoint: null,
+        tasks: []
+      };
+    }
+    const state = {
+      values: thread.values || {},
+      next: [],
+      metadata: thread.metadata,
+      /** @ts-ignore 没有查询过 */
+      checkpoint: null,
+      created_at: thread.created_at,
+      parent_checkpoint: null,
+      tasks: []
+    };
+    return state;
+  }
+  async getStateHistory(threadId, options) {
+    const checkpoints = this.checkpoints.get(threadId) || [];
+    let history = checkpoints.map(
+      (cp) => ({
+        values: cp.values,
+        next: cp.next,
+        metadata: cp.metadata,
+        checkpoint: {
+          checkpoint_id: cp.checkpoint_id,
+          thread_id: threadId,
+          checkpoint_ns: "",
+          checkpoint_map: void 0
+        },
+        created_at: cp.created_at,
+        parent_checkpoint: null,
+        tasks: []
+      })
+    );
+    if (options?.before) {
+      const beforeIndex = checkpoints.findIndex((c) => c.checkpoint_id === options.before);
+      if (beforeIndex !== -1) {
+        history = history.slice(beforeIndex + 1);
+      }
+    }
+    if (options?.limit) {
+      history = history.slice(0, options.limit);
+    }
+    return history;
+  }
+  async copy(threadId) {
+    const originalThread = await this.get(threadId);
+    const newThreadId = v7();
+    const newThread = {
+      ...originalThread,
+      thread_id: newThreadId,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.threads.push(newThread);
+    const originalCheckpoints = this.checkpoints.get(threadId) || [];
+    const newCheckpoints = originalCheckpoints.map((cp) => ({
+      ...cp,
+      checkpoint_id: v7(),
+      // Generate new checkpoint IDs
+      thread_id: newThreadId
+    }));
+    this.checkpoints.set(newThreadId, newCheckpoints);
+    return newThread;
+  }
+  // Helper method to save checkpoint (used internally)
+  async saveCheckpoint(threadId, values, next, config, metadata) {
+    const checkpoints = this.checkpoints.get(threadId) || [];
+    const checkpoint = {
+      checkpoint_id: v7(),
+      thread_id: threadId,
+      values,
+      next,
+      config,
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    checkpoints.push(checkpoint);
+    this.checkpoints.set(threadId, checkpoints);
+  }
 }
 
 const createCheckPointer = async () => {
@@ -925,7 +1320,7 @@ const createCheckPointer = async () => {
       return await ShallowRedisSaver.fromUrl(process.env.REDIS_URL);
     }
   }
-  if (process.env.DATABASE_URL) {
+  if (process.env.DATABASE_URL && getDatabaseType(process.env.DATABASE_URL) === "postgres") {
     console.debug("LG | Using postgres as checkpoint");
     const { createPGCheckpoint } = await import('./checkpoint-DxiUsHMy.js');
     return createPGCheckpoint();
@@ -951,23 +1346,43 @@ const createMessageQueue = async () => {
   let q;
   if (process.env.REDIS_URL) {
     console.debug("LG | Using redis as stream queue");
-    const { RedisStreamQueue } = await import('./queue-D6tEGCGs.js');
+    const { RedisStreamQueue } = await import('./queue-CtVch_az.js');
     q = RedisStreamQueue;
   } else {
     q = MemoryStreamQueue;
   }
   return new StreamQueueManager(q);
 };
+function getDatabaseType(databaseUrl) {
+  const url = databaseUrl.toLowerCase();
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return "remote";
+  }
+  return "postgres";
+}
 const createThreadManager = async (config) => {
-  if (process.env.DATABASE_URL && config.checkpointer) {
-    console.debug("LG | Using PostgreSQL ThreadsManager");
-    const { PostgresAdapter } = await import('./pg-adapter-BFtir1GE.js');
-    const pool = config.checkpointer.pool;
-    const threadsManager = new KyselyThreadsManager(new PostgresAdapter(pool));
-    if (process.env.DATABASE_INIT === "true") {
-      await threadsManager.setup();
+  if (process.env.DATABASE_URL) {
+    const dbType = getDatabaseType(process.env.DATABASE_URL);
+    if (dbType === "remote") {
+      console.debug("LG | Using Remote PostgreSQL ThreadsManager");
+      const { RemoteKyselyThreadsManager } = await import('./remote-threads-CrG03ZS7.js');
+      const threadsManager = new RemoteKyselyThreadsManager(process.env.DATABASE_URL);
+      if (process.env.DATABASE_INIT === "true") {
+        await threadsManager.setup();
+      }
+      return threadsManager;
+    } else {
+      if (config.checkpointer) {
+        console.debug("LG | Using PostgreSQL ThreadsManager");
+        const { PostgresAdapter } = await import('./pg-adapter-BFtir1GE.js');
+        const pool = config.checkpointer.pool;
+        const threadsManager = new KyselyThreadsManager(new PostgresAdapter(pool));
+        if (process.env.DATABASE_INIT === "true") {
+          await threadsManager.setup();
+        }
+        return threadsManager;
+      }
     }
-    return threadsManager;
   }
   if (process.env.SQLITE_DATABASE_URI && config.checkpointer) {
     console.debug("LG | Using SQLite ThreadsManager");
@@ -1054,9 +1469,11 @@ async function streamStateWithQueue(threads, run, queue, payload, options) {
       signal: queue.cancelSignal.signal
     }
   );
+  let sendedMetadataMessage;
+  let messageChunks;
   try {
-    const sendedMetadataMessage = /* @__PURE__ */ new Set();
-    const messageChunks = /* @__PURE__ */ new Map();
+    sendedMetadataMessage = /* @__PURE__ */ new Set();
+    messageChunks = /* @__PURE__ */ new Map();
     for await (const event of await events) {
       let ns = [];
       if (event.length === 3) {
@@ -1111,6 +1528,12 @@ async function streamStateWithQueue(threads, run, queue, payload, options) {
     }
   } finally {
     await queue.push(new StreamEndEventMessage());
+    if (sendedMetadataMessage) {
+      sendedMetadataMessage.clear();
+    }
+    if (messageChunks) {
+      messageChunks.clear();
+    }
   }
 }
 const serialiseAsDict = (obj, indent = 0) => {
@@ -1155,9 +1578,10 @@ async function* streamState(threads, run, payload, options) {
     } else {
       await threads.set(threadId, { status: "idle", interrupts: {} });
     }
+    await LangGraphGlobal.globalMessageQueue.clearQueue(queueId);
     LangGraphGlobal.globalMessageQueue.removeQueue(queueId);
   }
 }
 
-export { BaseStreamQueue as B, CancelEventMessage as C, GRAPHS as G, LangGraphGlobal as L, streamState as a, getGraph as g, registerGraph as r, serialiseAsDict as s };
-//# sourceMappingURL=stream-D0YD2Pjq.js.map
+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-umoA6h4q.js.map