@langchain/langgraph-cli 0.0.8 → 0.0.10

package/dist/storage/checkpoint.mjs

@@ -1,127 +0,0 @@
-import { MemorySaver, } from "@langchain/langgraph";
-import { FileSystemPersistence } from "./persist.mjs";
-const EXCLUDED_KEYS = ["checkpoint_ns", "checkpoint_id", "run_id", "thread_id"];
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
-const WriteKey = {
-    serialize: (key) => {
-        return JSON.stringify(key);
-    },
-    deserialize: (key) => {
-        const [threadId, checkpointNamespace, checkpointId] = JSON.parse(key);
-        return [threadId, checkpointNamespace, checkpointId];
-    },
-};
-const conn = new FileSystemPersistence(".langgraphjs_api.checkpointer.json", () => ({
-    storage: {},
-    writes: {},
-}));
-class InMemorySaver extends MemorySaver {
-    async initialize(cwd) {
-        await conn.initialize(cwd);
-        await conn.with(({ storage, writes }) => {
-            this.storage = storage;
-            this.writes = writes;
-        });
-        return conn;
-    }
-    clear() {
-        // { [threadId: string]: { [checkpointNs: string]: { [checkpointId]: [checkpoint, metadata, parentId] } }}
-        this.storage = {};
-        // { [WriteKey]: CheckpointPendingWrite[] }
-        this.writes = {};
-    }
-    // Patch every method that has access to this.storage or this.writes
-    // to also persist the changes to the filesystem in a non-blocking manner
-    async getTuple(...args) {
-        return await conn.with(() => super.getTuple(...args));
-    }
-    async *list(...args) {
-        yield* conn.withGenerator(super.list(...args));
-    }
-    async putWrites(...args) {
-        return await conn.with(() => super.putWrites(...args));
-    }
-    async put(config, checkpoint, metadata) {
-        return await conn.with(() => super.put(config, checkpoint, {
-            ...Object.fromEntries(Object.entries(config.configurable ?? {}).filter(([key]) => !key.startsWith("__") && !EXCLUDED_KEYS.includes(key))),
-            ...config.metadata,
-            ...metadata,
-        }));
-    }
-    async delete(threadId, runId) {
-        if (this.storage[threadId] == null)
-            return;
-        return await conn.with(() => {
-            if (runId != null) {
-                const writeKeysToDelete = [];
-                for (const ns of Object.keys(this.storage[threadId])) {
-                    for (const id of Object.keys(this.storage[threadId][ns])) {
-                        const [_checkpoint, metadata, _parentId] = this.storage[threadId][ns][id];
-                        const jsonMetadata = JSON.parse(textDecoder.decode(metadata));
-                        if (jsonMetadata.run_id === runId) {
-                            delete this.storage[threadId][ns][id];
-                            writeKeysToDelete.push(WriteKey.serialize([threadId, ns, id]));
-                            if (Object.keys(this.storage[threadId][ns]).length === 0) {
-                                delete this.storage[threadId][ns];
-                            }
-                        }
-                    }
-                }
-                for (const key of writeKeysToDelete) {
-                    delete this.writes[key];
-                }
-            }
-            else {
-                delete this.storage[threadId];
-                // delete all writes for this thread
-                const writeKeys = Object.keys(this.writes);
-                for (const key of writeKeys) {
-                    const [writeThreadId] = WriteKey.deserialize(key);
-                    if (writeThreadId === threadId)
-                        delete this.writes[key];
-                }
-            }
-        });
-    }
-    async copy(threadId, newThreadId) {
-        return await conn.with(() => {
-            // copy storage over
-            const newThreadCheckpoints = {};
-            for (const oldNs of Object.keys(this.storage[threadId] ?? {})) {
-                const newNs = oldNs.replace(threadId, newThreadId);
-                for (const oldId of Object.keys(this.storage[threadId][oldNs])) {
-                    const newId = oldId.replace(threadId, newThreadId);
-                    const [checkpoint, metadata, oldParentId] = this.storage[threadId][oldNs][oldId];
-                    const newParentId = oldParentId?.replace(threadId, newThreadId);
-                    const rawMetadata = textDecoder
-                        .decode(metadata)
-                        .replaceAll(threadId, newThreadId);
-                    newThreadCheckpoints[newNs] ??= {};
-                    newThreadCheckpoints[newNs][newId] = [
-                        checkpoint,
-                        textEncoder.encode(rawMetadata),
-                        newParentId,
-                    ];
-                }
-            }
-            this.storage[newThreadId] = newThreadCheckpoints;
-            // copy writes over (if any)
-            const outerKeys = [];
-            for (const keyJson of Object.keys(this.writes)) {
-                const key = WriteKey.deserialize(keyJson);
-                if (key[0] === threadId)
-                    outerKeys.push(keyJson);
-            }
-            for (const keyJson of outerKeys) {
-                const [_threadId, checkpointNamespace, checkpointId] = WriteKey.deserialize(keyJson);
-                this.writes[WriteKey.serialize([newThreadId, checkpointNamespace, checkpointId])] = structuredClone(this.writes[keyJson]);
-            }
-        });
-    }
-    toJSON() {
-        // Prevent serialization of internal state
-        return "[InMemorySaver]";
-    }
-}
-export const checkpointer = new InMemorySaver();