@langchain/langgraph 0.0.12 → 0.0.13

package/dist/checkpoint/id.js

@@ -0,0 +1,35 @@
+import { v1 } from "uuid";
+/**
+ * Returns an unsigned `x`-bit random integer.
+ * @param x - An unsigned integer ranging from 0 to 53, inclusive.
+ * @returns An unsigned `x`-bit random integer (`0 <= f(x) < 2^x`).
+ */
+function getRandomInt(x) {
+    if (x < 0 || x > 53) {
+        return NaN;
+    }
+    const n = 0 | (Math.random() * 0x40000000); // 1 << 30
+    return x > 30
+        ? n + (0 | (Math.random() * (1 << (x - 30)))) * 0x40000000
+        : n >>> (30 - x);
+}
+export function uuid6(clockseq) {
+    const node = typeof crypto !== "undefined"
+        ? crypto.getRandomValues(new Uint8Array(6))
+        : [
+            getRandomInt(8),
+            getRandomInt(8),
+            getRandomInt(8),
+            getRandomInt(8),
+            getRandomInt(8),
+            getRandomInt(8),
+        ];
+    const uuid1 = v1({ node, clockseq });
+    return convert1to6(uuid1);
+}
+export function convert1to6(uuid1) {
+    // https://github.com/oittaa/uuid6-python/blob/main/src/uuid6/__init__.py#L81
+    const hex = uuid1.replace(/-/g, "");
+    const v6 = `${hex.slice(13, 16)}${hex.slice(8, 12)}${hex.slice(0, 1)}-${hex.slice(1, 5)}-6${hex.slice(5, 8)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    return v6;
+}

package/dist/checkpoint/index.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.MemorySaverAssertImmutable = exports.MemorySaver = void 0;
+exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = void 0;
 var memory_js_1 = require("./memory.cjs");
 Object.defineProperty(exports, "MemorySaver", { enumerable: true, get: function () { return memory_js_1.MemorySaver; } });
-Object.defineProperty(exports, "MemorySaverAssertImmutable", { enumerable: true, get: function () { return memory_js_1.MemorySaverAssertImmutable; } });
 var base_js_1 = require("./base.cjs");
+Object.defineProperty(exports, "copyCheckpoint", { enumerable: true, get: function () { return base_js_1.copyCheckpoint; } });
 Object.defineProperty(exports, "emptyCheckpoint", { enumerable: true, get: function () { return base_js_1.emptyCheckpoint; } });
 Object.defineProperty(exports, "BaseCheckpointSaver", { enumerable: true, get: function () { return base_js_1.BaseCheckpointSaver; } });

package/dist/checkpoint/index.d.ts

@@ -1,2 +1,2 @@
-export { MemorySaver, MemorySaverAssertImmutable } from "./memory.js";
-export { type ConfigurableFieldSpec, type Checkpoint, type CheckpointAt, emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";
+export { MemorySaver } from "./memory.js";
+export { type Checkpoint, type CheckpointMetadata, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";

package/dist/checkpoint/index.js

@@ -1,2 +1,2 @@
-export { MemorySaver, MemorySaverAssertImmutable } from "./memory.js";
-export { emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";
+export { MemorySaver } from "./memory.js";
+export { copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "./base.js";

package/dist/checkpoint/memory.cjs

@@ -1,65 +1,79 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemorySaverAssertImmutable = exports.MemorySaver = void 0;
+exports.MemorySaver = void 0;
 const base_js_1 = require("./base.cjs");
 class MemorySaver extends base_js_1.BaseCheckpointSaver {
-    constructor() {
-        super(...arguments);
+    constructor(serde) {
+        super(serde);
         Object.defineProperty(this, "storage", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: {}
+            value: void 0
         });
+        this.storage = {};
     }
-    get configSpecs() {
-        return [
-            {
-                id: "threadId",
-                name: "Thread ID",
-                annotation: null,
-                description: null,
-                default: null,
-                isShared: true,
-                dependencies: null,
-            },
-        ];
-    }
-    get(config) {
-        return this.storage[config.configurable?.threadId];
-    }
-    put(config, checkpoint) {
-        this.storage[config.configurable?.threadId] = checkpoint;
+    async getTuple(config) {
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_id = config.configurable?.checkpoint_id;
+        const checkpoints = this.storage[thread_id];
+        if (checkpoint_id) {
+            const checkpoint = checkpoints[checkpoint_id];
+            if (checkpoint) {
+                return {
+                    config,
+                    checkpoint: this.serde.parse(checkpoint[0]),
+                    metadata: this.serde.parse(checkpoint[1]),
+                };
+            }
+        }
+        else {
+            if (checkpoints) {
+                const maxThreadTs = Object.keys(checkpoints).sort((a, b) => b.localeCompare(a))[0];
+                const checkpoint = checkpoints[maxThreadTs];
+                return {
+                    config: { configurable: { thread_id, checkpoint_id: maxThreadTs } },
+                    checkpoint: this.serde.parse(checkpoint[0]),
+                    metadata: this.serde.parse(checkpoint[1]),
+                };
+            }
+        }
+        return undefined;
     }
-}
-exports.MemorySaver = MemorySaver;
-class MemorySaverAssertImmutable extends MemorySaver {
-    constructor() {
-        super();
-        Object.defineProperty(this, "storageForCopies", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        this.storageForCopies = {};
-        this.at = "end_of_step" /* CheckpointAt.END_OF_STEP */;
+    async *list(config) {
+        const thread_id = config.configurable?.thread_id;
+        const checkpoints = this.storage[thread_id] ?? {};
+        // sort in desc order
+        for (const [checkpoint_id, checkpoint] of Object.entries(checkpoints).sort((a, b) => b[0].localeCompare(a[0]))) {
+            yield {
+                config: { configurable: { thread_id, checkpoint_id } },
+                checkpoint: this.serde.parse(checkpoint[0]),
+                metadata: this.serde.parse(checkpoint[1]),
+            };
+        }
     }
-    put(config, checkpoint) {
-        const threadId = config.configurable?.threadId;
-        if (!this.storageForCopies[threadId]) {
-            this.storageForCopies[threadId] = {};
+    async put(config, checkpoint, metadata) {
+        const thread_id = config.configurable?.thread_id;
+        if (this.storage[thread_id]) {
+            this.storage[thread_id][checkpoint.id] = [
+                this.serde.stringify(checkpoint),
+                this.serde.stringify(metadata),
+            ];
         }
-        // assert checkpoint hasn't been modified since last written
-        const saved = super.get(config);
-        if (saved) {
-            const savedTs = saved.ts;
-            if (this.storageForCopies[threadId][savedTs]) {
-                console.assert(this.storageForCopies[threadId][savedTs] === saved, "Checkpoint has been modified");
-            }
+        else {
+            this.storage[thread_id] = {
+                [checkpoint.id]: [
+                    this.serde.stringify(checkpoint),
+                    this.serde.stringify(metadata),
+                ],
+            };
         }
-        this.storageForCopies[threadId][checkpoint.ts] = (0, base_js_1.copyCheckpoint)(checkpoint);
-        return super.put(config, checkpoint);
+        return {
+            configurable: {
+                thread_id,
+                checkpoint_id: checkpoint.id,
+            },
+        };
     }
 }
-exports.MemorySaverAssertImmutable = MemorySaverAssertImmutable;
+exports.MemorySaver = MemorySaver;

package/dist/checkpoint/memory.d.ts

@@ -1,13 +1,10 @@
 import { RunnableConfig } from "@langchain/core/runnables";
-import { BaseCheckpointSaver, Checkpoint, ConfigurableFieldSpec } from "./base.js";
+import { BaseCheckpointSaver, Checkpoint, CheckpointMetadata, CheckpointTuple } from "./base.js";
+import { SerializerProtocol } from "../serde/base.js";
 export declare class MemorySaver extends BaseCheckpointSaver {
-    storage: Record<string, Checkpoint>;
-    get configSpecs(): ConfigurableFieldSpec[];
-    get(config: RunnableConfig): Checkpoint | undefined;
-    put(config: RunnableConfig, checkpoint: Checkpoint): void;
-}
-export declare class MemorySaverAssertImmutable extends MemorySaver {
-    storageForCopies: Record<string, Record<string, Checkpoint>>;
-    constructor();
-    put(config: RunnableConfig, checkpoint: Checkpoint): void;
+    storage: Record<string, Record<string, [string, string]>>;
+    constructor(serde?: SerializerProtocol<unknown>);
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    list(config: RunnableConfig): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
 }

package/dist/checkpoint/memory.js

@@ -1,60 +1,75 @@
-import { BaseCheckpointSaver, copyCheckpoint, } from "./base.js";
+import { BaseCheckpointSaver, } from "./base.js";
 export class MemorySaver extends BaseCheckpointSaver {
-    constructor() {
-        super(...arguments);
+    constructor(serde) {
+        super(serde);
         Object.defineProperty(this, "storage", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: {}
+            value: void 0
         });
+        this.storage = {};
     }
-    get configSpecs() {
-        return [
-            {
-                id: "threadId",
-                name: "Thread ID",
-                annotation: null,
-                description: null,
-                default: null,
-                isShared: true,
-                dependencies: null,
-            },
-        ];
-    }
-    get(config) {
-        return this.storage[config.configurable?.threadId];
-    }
-    put(config, checkpoint) {
-        this.storage[config.configurable?.threadId] = checkpoint;
+    async getTuple(config) {
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_id = config.configurable?.checkpoint_id;
+        const checkpoints = this.storage[thread_id];
+        if (checkpoint_id) {
+            const checkpoint = checkpoints[checkpoint_id];
+            if (checkpoint) {
+                return {
+                    config,
+                    checkpoint: this.serde.parse(checkpoint[0]),
+                    metadata: this.serde.parse(checkpoint[1]),
+                };
+            }
+        }
+        else {
+            if (checkpoints) {
+                const maxThreadTs = Object.keys(checkpoints).sort((a, b) => b.localeCompare(a))[0];
+                const checkpoint = checkpoints[maxThreadTs];
+                return {
+                    config: { configurable: { thread_id, checkpoint_id: maxThreadTs } },
+                    checkpoint: this.serde.parse(checkpoint[0]),
+                    metadata: this.serde.parse(checkpoint[1]),
+                };
+            }
+        }
+        return undefined;
     }
-}
-export class MemorySaverAssertImmutable extends MemorySaver {
-    constructor() {
-        super();
-        Object.defineProperty(this, "storageForCopies", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: {}
-        });
-        this.storageForCopies = {};
-        this.at = "end_of_step" /* CheckpointAt.END_OF_STEP */;
+    async *list(config) {
+        const thread_id = config.configurable?.thread_id;
+        const checkpoints = this.storage[thread_id] ?? {};
+        // sort in desc order
+        for (const [checkpoint_id, checkpoint] of Object.entries(checkpoints).sort((a, b) => b[0].localeCompare(a[0]))) {
+            yield {
+                config: { configurable: { thread_id, checkpoint_id } },
+                checkpoint: this.serde.parse(checkpoint[0]),
+                metadata: this.serde.parse(checkpoint[1]),
+            };
+        }
     }
-    put(config, checkpoint) {
-        const threadId = config.configurable?.threadId;
-        if (!this.storageForCopies[threadId]) {
-            this.storageForCopies[threadId] = {};
+    async put(config, checkpoint, metadata) {
+        const thread_id = config.configurable?.thread_id;
+        if (this.storage[thread_id]) {
+            this.storage[thread_id][checkpoint.id] = [
+                this.serde.stringify(checkpoint),
+                this.serde.stringify(metadata),
+            ];
         }
-        // assert checkpoint hasn't been modified since last written
-        const saved = super.get(config);
-        if (saved) {
-            const savedTs = saved.ts;
-            if (this.storageForCopies[threadId][savedTs]) {
-                console.assert(this.storageForCopies[threadId][savedTs] === saved, "Checkpoint has been modified");
-            }
+        else {
+            this.storage[thread_id] = {
+                [checkpoint.id]: [
+                    this.serde.stringify(checkpoint),
+                    this.serde.stringify(metadata),
+                ],
+            };
         }
-        this.storageForCopies[threadId][checkpoint.ts] = copyCheckpoint(checkpoint);
-        return super.put(config, checkpoint);
+        return {
+            configurable: {
+                thread_id,
+                checkpoint_id: checkpoint.id,
+            },
+        };
     }
 }

package/dist/checkpoint/sqlite.cjs

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteSaver = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const base_js_1 = require("./base.cjs");
+class SqliteSaver extends base_js_1.BaseCheckpointSaver {
+    constructor(db, serde) {
+        super(serde);
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isSetup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.db = db;
+        this.isSetup = false;
+    }
+    static fromConnString(connStringOrLocalPath) {
+        return new SqliteSaver(new better_sqlite3_1.default(connStringOrLocalPath));
+    }
+    setup() {
+        if (this.isSetup) {
+            return;
+        }
+        try {
+            this.db.pragma("journal_mode=WAL");
+            this.db.exec(`
+CREATE TABLE IF NOT EXISTS checkpoints (
+  thread_id TEXT NOT NULL,
+  checkpoint_id TEXT NOT NULL,
+  parent_id TEXT,
+  checkpoint BLOB,
+  metadata BLOB,
+  PRIMARY KEY (thread_id, checkpoint_id)
+);`);
+        }
+        catch (error) {
+            console.log("Error creating checkpoints table", error);
+            throw error;
+        }
+        this.isSetup = true;
+    }
+    async getTuple(config) {
+        this.setup();
+        const thread_id = config.configurable?.thread_id;
+        const checkpoint_id = config.configurable?.checkpoint_id;
+        if (checkpoint_id) {
+            try {
+                const row = this.db
+                    .prepare(`SELECT checkpoint, parent_id, metadata FROM checkpoints WHERE thread_id = ? AND checkpoint_id = ?`)
+                    .get(thread_id, checkpoint_id);
+                if (row) {
+                    return {
+                        config,
+                        checkpoint: this.serde.parse(row.checkpoint),
+                        metadata: this.serde.parse(row.metadata),
+                        parentConfig: row.parent_id
+                            ? {
+                                configurable: {
+                                    thread_id,
+                                    checkpoint_id: row.parent_id,
+                                },
+                            }
+                            : undefined,
+                    };
+                }
+            }
+            catch (error) {
+                console.log("Error retrieving checkpoint", error);
+                throw error;
+            }
+        }
+        else {
+            const row = this.db
+                .prepare(`SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = ? ORDER BY checkpoint_id DESC LIMIT 1`)
+                .get(thread_id);
+            if (row) {
+                return {
+                    config: {
+                        configurable: {
+                            thread_id: row.thread_id,
+                            checkpoint_id: row.checkpoint_id,
+                        },
+                    },
+                    checkpoint: this.serde.parse(row.checkpoint),
+                    metadata: this.serde.parse(row.metadata),
+                    parentConfig: row.parent_id
+                        ? {
+                            configurable: {
+                                thread_id: row.thread_id,
+                                checkpoint_id: row.parent_id,
+                            },
+                        }
+                        : undefined,
+                };
+            }
+        }
+        return undefined;
+    }
+    async *list(config) {
+        this.setup();
+        const thread_id = config.configurable?.thread_id;
+        try {
+            const rows = this.db
+                .prepare(`SELECT thread_id, checkpoint_id, parent_id, checkpoint, metadata FROM checkpoints WHERE thread_id = ? ORDER BY checkpoint_id DESC`)
+                .all(thread_id);
+            if (rows) {
+                for (const row of rows) {
+                    yield {
+                        config: {
+                            configurable: {
+                                thread_id: row.thread_id,
+                                checkpoint_id: row.checkpoint_id,
+                            },
+                        },
+                        checkpoint: this.serde.parse(row.checkpoint),
+                        metadata: this.serde.parse(row.metadata),
+                        parentConfig: row.parent_id
+                            ? {
+                                configurable: {
+                                    thread_id: row.thread_id,
+                                    checkpoint_id: row.parent_id,
+                                },
+                            }
+                            : undefined,
+                    };
+                }
+            }
+        }
+        catch (error) {
+            console.log("Error listing checkpoints", error);
+            throw error;
+        }
+    }
+    async put(config, checkpoint, metadata) {
+        this.setup();
+        try {
+            const row = [
+                config.configurable?.thread_id,
+                checkpoint.id,
+                config.configurable?.checkpoint_id,
+                this.serde.stringify(checkpoint),
+                this.serde.stringify(metadata),
+            ];
+            this.db
+                .prepare(`INSERT OR REPLACE INTO checkpoints (thread_id, checkpoint_id, parent_id, checkpoint, metadata) VALUES (?, ?, ?, ?, ?)`)
+                .run(...row);
+        }
+        catch (error) {
+            console.log("Error saving checkpoint", error);
+            throw error;
+        }
+        return {
+            configurable: {
+                thread_id: config.configurable?.thread_id,
+                checkpoint_id: checkpoint.id,
+            },
+        };
+    }
+}
+exports.SqliteSaver = SqliteSaver;

package/dist/checkpoint/sqlite.d.ts

@@ -0,0 +1,14 @@
+import { Database as DatabaseType } from "better-sqlite3";
+import { RunnableConfig } from "@langchain/core/runnables";
+import { BaseCheckpointSaver, Checkpoint, CheckpointMetadata, CheckpointTuple } from "./base.js";
+import { SerializerProtocol } from "../serde/base.js";
+export declare class SqliteSaver extends BaseCheckpointSaver {
+    db: DatabaseType;
+    protected isSetup: boolean;
+    constructor(db: DatabaseType, serde?: SerializerProtocol<Checkpoint>);
+    static fromConnString(connStringOrLocalPath: string): SqliteSaver;
+    private setup;
+    getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
+    list(config: RunnableConfig): AsyncGenerator<CheckpointTuple>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
+}