@langgraph-js/pure-graph 3.0.0 → 3.1.1

package/dist/{stream-umoA6h4q.js → stream-3xunCZso.js}

@@ -4,7 +4,7 @@ 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';
+import { BaseCheckpointSaver, TASKS, maxChannelVersion, getCheckpointId, copyCheckpoint, uuid6, WRITES_IDX_MAP } from '@langchain/langgraph-checkpoint';
 
 const getLangGraphCommand = (command) => {
   let goto = command.goto != null && !Array.isArray(command.goto) ? [command.goto] : command.goto;
@@ -820,6 +820,301 @@ class KyselyThreadsManager {
   }
 }
 
+function _parseShallowKey(key) {
+  const [threadId, checkpointNs] = key.split("::");
+  return { threadId, checkpointNs: checkpointNs ?? "" };
+}
+function _getWritesKey(threadId, checkpointNs, checkpointId) {
+  return `${threadId}::${checkpointNs}::${checkpointId}`;
+}
+function deterministicStringify(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return JSON.stringify(obj.map((item) => deterministicStringify(item)));
+  }
+  const sortedObj = {};
+  const sortedKeys = Object.keys(obj).sort();
+  for (const key of sortedKeys) {
+    sortedObj[key] = obj[key];
+  }
+  return JSON.stringify(sortedObj, (_, value) => {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const sorted = {};
+      const keys = Object.keys(value).sort();
+      for (const k of keys) {
+        sorted[k] = value[k];
+      }
+      return sorted;
+    }
+    return value;
+  });
+}
+class ShallowMemorySaver extends BaseCheckpointSaver {
+  // thread ID -> checkpoint namespace -> checkpoint data
+  // Each namespace only keeps ONE checkpoint
+  storage = {};
+  // writes storage: composite key -> writes data
+  // Key format: thread_id::checkpoint_ns::checkpoint_id
+  writes = {};
+  constructor(serde) {
+    super(serde);
+  }
+  /**
+   * Get just the checkpoint without metadata
+   * Convenience method matching ShallowRedisSaver API
+   */
+  async get(config) {
+    const tuple = await this.getTuple(config);
+    return tuple?.checkpoint;
+  }
+  /**
+   * Migrate pending sends for checkpoints with version < 4
+   * @internal
+   */
+  async _migratePendingSends(mutableCheckpoint, threadId, checkpointNs, parentCheckpointId) {
+    const deseriablizableCheckpoint = mutableCheckpoint;
+    const parentKey = _getWritesKey(threadId, checkpointNs, parentCheckpointId);
+    const pendingSends = await Promise.all(
+      Object.values(this.writes[parentKey] ?? {}).filter(([_taskId, channel]) => channel === TASKS).map(async ([_taskId, _channel, writes]) => await this.serde.loadsTyped("json", writes))
+    );
+    deseriablizableCheckpoint.channel_values ??= {};
+    deseriablizableCheckpoint.channel_values[TASKS] = pendingSends;
+    deseriablizableCheckpoint.channel_versions ??= {};
+    deseriablizableCheckpoint.channel_versions[TASKS] = Object.keys(deseriablizableCheckpoint.channel_versions).length > 0 ? maxChannelVersion(...Object.values(deseriablizableCheckpoint.channel_versions)) : this.getNextVersion(void 0);
+  }
+  /**
+   * Load pending writes for a specific checkpoint
+   */
+  async _loadPendingWrites(threadId, checkpointNs, checkpointId) {
+    const key = _getWritesKey(threadId, checkpointNs, checkpointId);
+    const writes = this.writes[key] ?? {};
+    if (Object.keys(writes).length === 0) {
+      return [];
+    }
+    return await Promise.all(
+      Object.values(writes).map(async ([taskId, channel, value]) => {
+        return [taskId, channel, await this.serde.loadsTyped("json", value)];
+      })
+    );
+  }
+  /**
+   * Clean up old writes for a checkpoint
+   */
+  _cleanupOldWrites(threadId, checkpointNs, checkpointId) {
+    const key = _getWritesKey(threadId, checkpointNs, checkpointId);
+    delete this.writes[key];
+  }
+  /**
+   * Check metadata filter matches (with deep comparison support)
+   * Matches ShallowRedisSaver behavior
+   */
+  _checkMetadataFilterMatch(metadata, filter) {
+    for (const [key, value] of Object.entries(filter)) {
+      const metadataValue = metadata?.[key];
+      if (value === null) {
+        if (!(key in (metadata || {})) || metadataValue !== null) {
+          return false;
+        }
+      } else if (typeof value === "object" && !Array.isArray(value)) {
+        if (typeof metadataValue !== "object" || metadataValue === null) {
+          return false;
+        }
+        if (deterministicStringify(value) !== deterministicStringify(metadataValue)) {
+          return false;
+        }
+      } else if (metadataValue !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async getTuple(config) {
+    const threadId = config.configurable?.thread_id;
+    const checkpointNs = config.configurable?.checkpoint_ns ?? "";
+    const requestedCheckpointId = getCheckpointId(config);
+    if (threadId === void 0) {
+      return void 0;
+    }
+    const namespaceData = this.storage[threadId]?.[checkpointNs];
+    if (namespaceData === void 0) {
+      return void 0;
+    }
+    const { checkpoint, metadata, checkpoint_id, parent_checkpoint_id } = namespaceData;
+    if (requestedCheckpointId && checkpoint_id !== requestedCheckpointId) {
+      return void 0;
+    }
+    const deserializedCheckpoint = await this.serde.loadsTyped("json", checkpoint);
+    if (deserializedCheckpoint.v < 4 && parent_checkpoint_id !== void 0) {
+      await this._migratePendingSends(deserializedCheckpoint, threadId, checkpointNs, parent_checkpoint_id);
+    }
+    const pendingWrites = await this._loadPendingWrites(threadId, checkpointNs, checkpoint_id);
+    const deserializedMetadata = await this.serde.loadsTyped("json", metadata);
+    const checkpointTuple = {
+      config: {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: checkpointNs,
+          checkpoint_id
+        }
+      },
+      checkpoint: deserializedCheckpoint,
+      metadata: deserializedMetadata,
+      pendingWrites
+    };
+    if (parent_checkpoint_id !== void 0) {
+      checkpointTuple.parentConfig = {
+        configurable: {
+          thread_id: threadId,
+          checkpoint_ns: checkpointNs,
+          checkpoint_id: parent_checkpoint_id
+        }
+      };
+    }
+    return checkpointTuple;
+  }
+  async *list(config, options) {
+    let { before, limit, filter } = options ?? {};
+    const threadIds = config.configurable?.thread_id ? [config.configurable.thread_id] : Object.keys(this.storage);
+    const configCheckpointNamespace = config.configurable?.checkpoint_ns;
+    const configCheckpointId = config.configurable?.checkpoint_id;
+    const matchingCheckpoints = [];
+    for (const threadId of threadIds) {
+      const namespaces = this.storage[threadId];
+      if (namespaces === void 0) continue;
+      for (const checkpointNs of Object.keys(namespaces)) {
+        if (configCheckpointNamespace !== void 0 && checkpointNs !== configCheckpointNamespace) {
+          continue;
+        }
+        const namespaceData = namespaces[checkpointNs];
+        if (namespaceData === void 0) continue;
+        const { checkpoint_id } = namespaceData;
+        if (configCheckpointId && checkpoint_id !== configCheckpointId) {
+          continue;
+        }
+        if (before?.configurable?.checkpoint_id && checkpoint_id >= before.configurable.checkpoint_id) {
+          continue;
+        }
+        const deserializedMetadata = await this.serde.loadsTyped(
+          "json",
+          namespaceData.metadata
+        );
+        if (filter && !this._checkMetadataFilterMatch(deserializedMetadata, filter)) {
+          continue;
+        }
+        matchingCheckpoints.push({ threadId, checkpointNs, namespaceData });
+      }
+    }
+    matchingCheckpoints.sort((a, b) => b.namespaceData.checkpoint_ts - a.namespaceData.checkpoint_ts);
+    let count = 0;
+    for (const { threadId, checkpointNs, namespaceData } of matchingCheckpoints) {
+      if (limit !== void 0 && count >= limit) {
+        return;
+      }
+      const { checkpoint, metadata, checkpoint_id, parent_checkpoint_id } = namespaceData;
+      const deserializedCheckpoint = await this.serde.loadsTyped("json", checkpoint);
+      if (deserializedCheckpoint.v < 4 && parent_checkpoint_id !== void 0) {
+        await this._migratePendingSends(deserializedCheckpoint, threadId, checkpointNs, parent_checkpoint_id);
+      }
+      const pendingWrites = await this._loadPendingWrites(threadId, checkpointNs, checkpoint_id);
+      const deserializedMetadata = await this.serde.loadsTyped("json", metadata);
+      const checkpointTuple = {
+        config: {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: checkpointNs,
+            checkpoint_id
+          }
+        },
+        checkpoint: deserializedCheckpoint,
+        metadata: deserializedMetadata,
+        pendingWrites
+      };
+      if (parent_checkpoint_id !== void 0) {
+        checkpointTuple.parentConfig = {
+          configurable: {
+            thread_id: threadId,
+            checkpoint_ns: checkpointNs,
+            checkpoint_id: parent_checkpoint_id
+          }
+        };
+      }
+      count++;
+      yield checkpointTuple;
+    }
+  }
+  async put(config, checkpoint, metadata, _newVersions) {
+    const preparedCheckpoint = copyCheckpoint(checkpoint);
+    const threadId = config.configurable?.thread_id;
+    const checkpointNamespace = config.configurable?.checkpoint_ns ?? "";
+    const parentCheckpointId = config.configurable?.checkpoint_id;
+    if (threadId === void 0) {
+      throw new Error("thread_id is required");
+    }
+    const checkpointId = checkpoint.id || uuid6(0);
+    if (!this.storage[threadId]) {
+      this.storage[threadId] = {};
+    }
+    const oldNamespaceData = this.storage[threadId][checkpointNamespace];
+    if (oldNamespaceData !== void 0 && oldNamespaceData.checkpoint_id !== checkpointId) {
+      this._cleanupOldWrites(threadId, checkpointNamespace, oldNamespaceData.checkpoint_id);
+    }
+    const [[, serializedCheckpoint], [, serializedMetadata]] = await Promise.all([
+      this.serde.dumpsTyped(preparedCheckpoint),
+      this.serde.dumpsTyped(metadata)
+    ]);
+    this.storage[threadId][checkpointNamespace] = {
+      checkpoint: serializedCheckpoint,
+      metadata: serializedMetadata,
+      checkpoint_id: checkpointId,
+      parent_checkpoint_id: parentCheckpointId,
+      checkpoint_ts: Date.now()
+      // Add timestamp for sorting
+    };
+    return {
+      configurable: {
+        thread_id: threadId,
+        checkpoint_ns: checkpointNamespace,
+        checkpoint_id: checkpointId
+      }
+    };
+  }
+  async putWrites(config, writes, taskId) {
+    const threadId = config.configurable?.thread_id;
+    const checkpointNamespace = config.configurable?.checkpoint_ns ?? "";
+    const checkpointId = config.configurable?.checkpoint_id;
+    if (!threadId || !checkpointId) {
+      throw new Error("thread_id and checkpoint_id are required");
+    }
+    const outerKey = _getWritesKey(threadId, checkpointNamespace, checkpointId);
+    const outerWrites_ = this.writes[outerKey];
+    if (this.writes[outerKey] === void 0) {
+      this.writes[outerKey] = {};
+    }
+    await Promise.all(
+      writes.map(async ([channel, value], idx) => {
+        const [, serializedValue] = await this.serde.dumpsTyped(value);
+        const innerKey = [taskId, WRITES_IDX_MAP[channel] || idx];
+        const innerKeyStr = `${innerKey[0]},${innerKey[1]}`;
+        if (innerKey[1] >= 0 && outerWrites_ && innerKeyStr in outerWrites_) {
+          return;
+        }
+        this.writes[outerKey][innerKeyStr] = [taskId, channel, serializedValue];
+      })
+    );
+  }
+  async deleteThread(threadId) {
+    delete this.storage[threadId];
+    for (const key of Object.keys(this.writes)) {
+      const { threadId: keyThreadId } = _parseShallowKey(key.split("::").slice(0, 2).join("::"));
+      if (keyThreadId === threadId) {
+        delete this.writes[key];
+      }
+    }
+  }
+}
+
 class EventMessage {
   event;
   data;
@@ -1340,13 +1635,13 @@ const createCheckPointer = async () => {
     "\x1B[33m%s\x1B[0m",
     "LG | set DATABASE_URL=postgresql://user:pass@localhost:5432/db to your .env file to use \x1B[1mPostgreSQL\x1B[0m for prod!"
   );
-  return new MemorySaver();
+  return new ShallowMemorySaver();
 };
 const createMessageQueue = async () => {
   let q;
   if (process.env.REDIS_URL) {
     console.debug("LG | Using redis as stream queue");
-    const { RedisStreamQueue } = await import('./queue-CtVch_az.js');
+    const { RedisStreamQueue } = await import('./queue-8-m4OzOj.js');
     q = RedisStreamQueue;
   } else {
     q = MemoryStreamQueue;
@@ -1386,7 +1681,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-5PeLHaxe.js');
+    const { SQLiteAdapter } = await import('./sqlite-adapter-Bbonr5S5.js');
     const database = config.checkpointer.db;
     const threadsManager = new KyselyThreadsManager(new SQLiteAdapter(database));
     await threadsManager.setup();
@@ -1584,4 +1879,4 @@ async function* streamState(threads, run, payload, options) {
 }
 
 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
+//# sourceMappingURL=stream-3xunCZso.js.map