@langchain/langgraph-checkpoint 0.0.5 → 0.0.7

package/dist/serde/jsonplus.cjs

@@ -4,101 +4,71 @@ exports.JsonPlusSerializer = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-instanceof/no-instanceof */
 const load_1 = require("@langchain/core/load");
-function isLangChainSerializable(value) {
-    return (typeof value.lc_serializable === "boolean" && Array.isArray(value.lc_id));
-}
+const index_js_1 = require("./utils/fast-safe-stringify/index.cjs");
 function isLangChainSerializedObject(value) {
     return (value !== null &&
         value.lc === 1 &&
         value.type === "constructor" &&
         Array.isArray(value.id));
 }
-const _serialize = (value, seen = new WeakSet()) => {
-    const defaultValue = _default("", value);
-    if (defaultValue === null) {
-        return "null";
-    }
-    else if (typeof defaultValue === "string") {
-        return JSON.stringify(defaultValue);
-    }
-    else if (typeof defaultValue === "number" ||
-        typeof defaultValue === "boolean") {
-        return defaultValue.toString();
-    }
-    else if (typeof defaultValue === "object") {
-        if (seen.has(defaultValue)) {
-            throw new TypeError("Circular reference detected");
-        }
-        seen.add(defaultValue);
-        if (Array.isArray(defaultValue)) {
-            const result = `[${defaultValue
-                .map((item) => _serialize(item, seen))
-                .join(",")}]`;
-            seen.delete(defaultValue);
-            return result;
-        }
-        else if (isLangChainSerializable(defaultValue)) {
-            return JSON.stringify(defaultValue);
-        }
-        else {
-            const entries = Object.entries(defaultValue).map(([k, v]) => `${JSON.stringify(k)}:${_serialize(v, seen)}`);
-            const result = `{${entries.join(",")}}`;
-            seen.delete(defaultValue);
-            return result;
-        }
-    }
-    // Only be reached for functions or symbols
-    return JSON.stringify(defaultValue);
-};
+/**
+ * The replacer in stringify does not allow delegation to built-in LangChain
+ * serialization methods, and instead immediately calls `.toJSON()` and
+ * continues to stringify subfields.
+ *
+ * We therefore must start from the most nested elements in the input and
+ * deserialize upwards rather than top-down.
+ */
 async function _reviver(value) {
     if (value && typeof value === "object") {
-        if (value.lc === 2 && value.type === "undefined") {
-            return undefined;
-        }
-        else if (value.lc === 2 &&
-            value.type === "constructor" &&
-            Array.isArray(value.id)) {
-            try {
-                const constructorName = value.id[value.id.length - 1];
-                let constructor;
-                switch (constructorName) {
-                    case "Set":
-                        constructor = Set;
-                        break;
-                    case "Map":
-                        constructor = Map;
-                        break;
-                    case "RegExp":
-                        constructor = RegExp;
-                        break;
-                    case "Error":
-                        constructor = Error;
-                        break;
-                    default:
-                        return value;
-                }
-                if (value.method) {
-                    return constructor[value.method](...(value.args || []));
-                }
-                else {
-                    return new constructor(...(value.args || []));
-                }
-            }
-            catch (error) {
-                return value;
-            }
-        }
-        else if (isLangChainSerializedObject(value)) {
-            return (0, load_1.load)(JSON.stringify(value));
-        }
-        else if (Array.isArray(value)) {
-            return Promise.all(value.map((item) => _reviver(item)));
+        if (Array.isArray(value)) {
+            const revivedArray = await Promise.all(value.map((item) => _reviver(item)));
+            return revivedArray;
         }
         else {
             const revivedObj = {};
             for (const [k, v] of Object.entries(value)) {
                 revivedObj[k] = await _reviver(v);
             }
+            if (revivedObj.lc === 2 && revivedObj.type === "undefined") {
+                return undefined;
+            }
+            else if (revivedObj.lc === 2 &&
+                revivedObj.type === "constructor" &&
+                Array.isArray(revivedObj.id)) {
+                try {
+                    const constructorName = revivedObj.id[revivedObj.id.length - 1];
+                    let constructor;
+                    switch (constructorName) {
+                        case "Set":
+                            constructor = Set;
+                            break;
+                        case "Map":
+                            constructor = Map;
+                            break;
+                        case "RegExp":
+                            constructor = RegExp;
+                            break;
+                        case "Error":
+                            constructor = Error;
+                            break;
+                        default:
+                            return revivedObj;
+                    }
+                    if (revivedObj.method) {
+                        return constructor[revivedObj.method](...(revivedObj.args || []));
+                    }
+                    else {
+                        return new constructor(...(revivedObj.args || []));
+                    }
+                }
+                catch (error) {
+                    return revivedObj;
+                }
+            }
+            else if (isLangChainSerializedObject(revivedObj)) {
+                return (0, load_1.load)(JSON.stringify(revivedObj));
+            }
             return revivedObj;
         }
     }
@@ -116,7 +86,7 @@ constructor, method, args, kwargs) {
         kwargs: kwargs ?? {},
     };
 }
-function _default(_key, obj) {
+function _default(obj) {
     if (obj === undefined) {
         return {
             lc: 2,
@@ -148,7 +118,9 @@ function _default(_key, obj) {
 class JsonPlusSerializer {
     _dumps(obj) {
         const encoder = new TextEncoder();
-        return encoder.encode(_serialize(obj));
+        return encoder.encode((0, index_js_1.stringify)(obj, (_, value) => {
+            return _default(value);
+        }));
     }
     dumpsTyped(obj) {
         if (obj instanceof Uint8Array) {

package/dist/serde/jsonplus.js

@@ -1,101 +1,71 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-instanceof/no-instanceof */
 import { load } from "@langchain/core/load";
-function isLangChainSerializable(value) {
-    return (typeof value.lc_serializable === "boolean" && Array.isArray(value.lc_id));
-}
+import { stringify } from "./utils/fast-safe-stringify/index.js";
 function isLangChainSerializedObject(value) {
     return (value !== null &&
         value.lc === 1 &&
         value.type === "constructor" &&
         Array.isArray(value.id));
 }
-const _serialize = (value, seen = new WeakSet()) => {
-    const defaultValue = _default("", value);
-    if (defaultValue === null) {
-        return "null";
-    }
-    else if (typeof defaultValue === "string") {
-        return JSON.stringify(defaultValue);
-    }
-    else if (typeof defaultValue === "number" ||
-        typeof defaultValue === "boolean") {
-        return defaultValue.toString();
-    }
-    else if (typeof defaultValue === "object") {
-        if (seen.has(defaultValue)) {
-            throw new TypeError("Circular reference detected");
-        }
-        seen.add(defaultValue);
-        if (Array.isArray(defaultValue)) {
-            const result = `[${defaultValue
-                .map((item) => _serialize(item, seen))
-                .join(",")}]`;
-            seen.delete(defaultValue);
-            return result;
-        }
-        else if (isLangChainSerializable(defaultValue)) {
-            return JSON.stringify(defaultValue);
-        }
-        else {
-            const entries = Object.entries(defaultValue).map(([k, v]) => `${JSON.stringify(k)}:${_serialize(v, seen)}`);
-            const result = `{${entries.join(",")}}`;
-            seen.delete(defaultValue);
-            return result;
-        }
-    }
-    // Only be reached for functions or symbols
-    return JSON.stringify(defaultValue);
-};
+/**
+ * The replacer in stringify does not allow delegation to built-in LangChain
+ * serialization methods, and instead immediately calls `.toJSON()` and
+ * continues to stringify subfields.
+ *
+ * We therefore must start from the most nested elements in the input and
+ * deserialize upwards rather than top-down.
+ */
 async function _reviver(value) {
     if (value && typeof value === "object") {
-        if (value.lc === 2 && value.type === "undefined") {
-            return undefined;
-        }
-        else if (value.lc === 2 &&
-            value.type === "constructor" &&
-            Array.isArray(value.id)) {
-            try {
-                const constructorName = value.id[value.id.length - 1];
-                let constructor;
-                switch (constructorName) {
-                    case "Set":
-                        constructor = Set;
-                        break;
-                    case "Map":
-                        constructor = Map;
-                        break;
-                    case "RegExp":
-                        constructor = RegExp;
-                        break;
-                    case "Error":
-                        constructor = Error;
-                        break;
-                    default:
-                        return value;
-                }
-                if (value.method) {
-                    return constructor[value.method](...(value.args || []));
-                }
-                else {
-                    return new constructor(...(value.args || []));
-                }
-            }
-            catch (error) {
-                return value;
-            }
-        }
-        else if (isLangChainSerializedObject(value)) {
-            return load(JSON.stringify(value));
-        }
-        else if (Array.isArray(value)) {
-            return Promise.all(value.map((item) => _reviver(item)));
+        if (Array.isArray(value)) {
+            const revivedArray = await Promise.all(value.map((item) => _reviver(item)));
+            return revivedArray;
         }
         else {
             const revivedObj = {};
             for (const [k, v] of Object.entries(value)) {
                 revivedObj[k] = await _reviver(v);
             }
+            if (revivedObj.lc === 2 && revivedObj.type === "undefined") {
+                return undefined;
+            }
+            else if (revivedObj.lc === 2 &&
+                revivedObj.type === "constructor" &&
+                Array.isArray(revivedObj.id)) {
+                try {
+                    const constructorName = revivedObj.id[revivedObj.id.length - 1];
+                    let constructor;
+                    switch (constructorName) {
+                        case "Set":
+                            constructor = Set;
+                            break;
+                        case "Map":
+                            constructor = Map;
+                            break;
+                        case "RegExp":
+                            constructor = RegExp;
+                            break;
+                        case "Error":
+                            constructor = Error;
+                            break;
+                        default:
+                            return revivedObj;
+                    }
+                    if (revivedObj.method) {
+                        return constructor[revivedObj.method](...(revivedObj.args || []));
+                    }
+                    else {
+                        return new constructor(...(revivedObj.args || []));
+                    }
+                }
+                catch (error) {
+                    return revivedObj;
+                }
+            }
+            else if (isLangChainSerializedObject(revivedObj)) {
+                return load(JSON.stringify(revivedObj));
+            }
             return revivedObj;
         }
     }
@@ -113,7 +83,7 @@ constructor, method, args, kwargs) {
         kwargs: kwargs ?? {},
     };
 }
-function _default(_key, obj) {
+function _default(obj) {
     if (obj === undefined) {
         return {
             lc: 2,
@@ -145,7 +115,9 @@ function _default(_key, obj) {
 export class JsonPlusSerializer {
     _dumps(obj) {
         const encoder = new TextEncoder();
-        return encoder.encode(_serialize(obj));
+        return encoder.encode(stringify(obj, (_, value) => {
+            return _default(value);
+        }));
     }
     dumpsTyped(obj) {
         if (obj instanceof Uint8Array) {

package/dist/serde/utils/fast-safe-stringify/index.cjs

@@ -0,0 +1,222 @@
+"use strict";
+/* eslint-disable */
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = void 0;
+// Stringify that can handle circular references.
+// Inlined due to ESM import issues
+// Source: https://www.npmjs.com/package/fast-safe-stringify
+var LIMIT_REPLACE_NODE = "[...]";
+var CIRCULAR_REPLACE_NODE = "[Circular]";
+var arr = [];
+var replacerStack = [];
+function defaultOptions() {
+    return {
+        depthLimit: Number.MAX_SAFE_INTEGER,
+        edgesLimit: Number.MAX_SAFE_INTEGER,
+    };
+}
+// Regular stringify
+function stringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    decirc(obj, "", 0, [], undefined, 0, options);
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(obj, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+exports.stringify = stringify;
+function setReplace(replace, val, k, parent) {
+    var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+    if (propertyDescriptor.get !== undefined) {
+        if (propertyDescriptor.configurable) {
+            Object.defineProperty(parent, k, { value: replace });
+            arr.push([parent, k, val, propertyDescriptor]);
+        }
+        else {
+            replacerStack.push([val, k, replace]);
+        }
+    }
+    else {
+        parent[k] = replace;
+        arr.push([parent, k, val]);
+    }
+}
+function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                decirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            var keys = Object.keys(val);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                decirc(val[key], key, i, stack, val, depth, options);
+            }
+        }
+        stack.pop();
+    }
+}
+// Stable-stringify
+function compareFunction(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function deterministicStringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    var tmp = deterministicDecirc(obj, "", 0, [], undefined, 0, options) || obj;
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(tmp, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        // Ensure that we restore the object as it was.
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        try {
+            if (typeof val.toJSON === "function") {
+                return;
+            }
+        }
+        catch (_) {
+            return;
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                deterministicDecirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            // Create a temporary object in the required way
+            var tmp = {};
+            var keys = Object.keys(val).sort(compareFunction);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                deterministicDecirc(val[key], key, i, stack, val, depth, options);
+                tmp[key] = val[key];
+            }
+            if (typeof parent !== "undefined") {
+                arr.push([parent, k, val]);
+                parent[k] = tmp;
+            }
+            else {
+                return tmp;
+            }
+        }
+        stack.pop();
+    }
+}
+// wraps replacer function to handle values we couldn't replace
+// and mark them as replaced value
+function replaceGetterValues(replacer) {
+    replacer =
+        typeof replacer !== "undefined"
+            ? replacer
+            : function (k, v) {
+                return v;
+            };
+    return function (key, val) {
+        if (replacerStack.length > 0) {
+            for (var i = 0; i < replacerStack.length; i++) {
+                var part = replacerStack[i];
+                if (part[1] === key && part[0] === val) {
+                    val = part[2];
+                    replacerStack.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        return replacer.call(this, key, val);
+    };
+}

package/dist/serde/utils/fast-safe-stringify/index.d.ts

@@ -0,0 +1 @@
+export declare function stringify(obj: any, replacer?: any, spacer?: any, options?: any): string;

package/dist/serde/utils/fast-safe-stringify/index.js

@@ -0,0 +1,218 @@
+/* eslint-disable */
+// @ts-nocheck
+// Stringify that can handle circular references.
+// Inlined due to ESM import issues
+// Source: https://www.npmjs.com/package/fast-safe-stringify
+var LIMIT_REPLACE_NODE = "[...]";
+var CIRCULAR_REPLACE_NODE = "[Circular]";
+var arr = [];
+var replacerStack = [];
+function defaultOptions() {
+    return {
+        depthLimit: Number.MAX_SAFE_INTEGER,
+        edgesLimit: Number.MAX_SAFE_INTEGER,
+    };
+}
+// Regular stringify
+export function stringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    decirc(obj, "", 0, [], undefined, 0, options);
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(obj, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+function setReplace(replace, val, k, parent) {
+    var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+    if (propertyDescriptor.get !== undefined) {
+        if (propertyDescriptor.configurable) {
+            Object.defineProperty(parent, k, { value: replace });
+            arr.push([parent, k, val, propertyDescriptor]);
+        }
+        else {
+            replacerStack.push([val, k, replace]);
+        }
+    }
+    else {
+        parent[k] = replace;
+        arr.push([parent, k, val]);
+    }
+}
+function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                decirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            var keys = Object.keys(val);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                decirc(val[key], key, i, stack, val, depth, options);
+            }
+        }
+        stack.pop();
+    }
+}
+// Stable-stringify
+function compareFunction(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function deterministicStringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+        options = defaultOptions();
+    }
+    var tmp = deterministicDecirc(obj, "", 0, [], undefined, 0, options) || obj;
+    var res;
+    try {
+        if (replacerStack.length === 0) {
+            res = JSON.stringify(tmp, replacer, spacer);
+        }
+        else {
+            res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+        }
+    }
+    catch (_) {
+        return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    }
+    finally {
+        // Ensure that we restore the object as it was.
+        while (arr.length !== 0) {
+            var part = arr.pop();
+            if (part.length === 4) {
+                Object.defineProperty(part[0], part[1], part[3]);
+            }
+            else {
+                part[0][part[1]] = part[2];
+            }
+        }
+    }
+    return res;
+}
+function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+    depth += 1;
+    var i;
+    if (typeof val === "object" && val !== null) {
+        for (i = 0; i < stack.length; i++) {
+            if (stack[i] === val) {
+                setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                return;
+            }
+        }
+        try {
+            if (typeof val.toJSON === "function") {
+                return;
+            }
+        }
+        catch (_) {
+            return;
+        }
+        if (typeof options.depthLimit !== "undefined" &&
+            depth > options.depthLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        if (typeof options.edgesLimit !== "undefined" &&
+            edgeIndex + 1 > options.edgesLimit) {
+            setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+            return;
+        }
+        stack.push(val);
+        // Optimize for Arrays. Big arrays could kill the performance otherwise!
+        if (Array.isArray(val)) {
+            for (i = 0; i < val.length; i++) {
+                deterministicDecirc(val[i], i, i, stack, val, depth, options);
+            }
+        }
+        else {
+            // Create a temporary object in the required way
+            var tmp = {};
+            var keys = Object.keys(val).sort(compareFunction);
+            for (i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                deterministicDecirc(val[key], key, i, stack, val, depth, options);
+                tmp[key] = val[key];
+            }
+            if (typeof parent !== "undefined") {
+                arr.push([parent, k, val]);
+                parent[k] = tmp;
+            }
+            else {
+                return tmp;
+            }
+        }
+        stack.pop();
+    }
+}
+// wraps replacer function to handle values we couldn't replace
+// and mark them as replaced value
+function replaceGetterValues(replacer) {
+    replacer =
+        typeof replacer !== "undefined"
+            ? replacer
+            : function (k, v) {
+                return v;
+            };
+    return function (key, val) {
+        if (replacerStack.length > 0) {
+            for (var i = 0; i < replacerStack.length; i++) {
+                var part = replacerStack[i];
+                if (part[1] === key && part[0] === val) {
+                    val = part[2];
+                    replacerStack.splice(i, 1);
+                    break;
+                }
+            }
+        }
+        return replacer.call(this, key, val);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-checkpoint",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Library with base interfaces for LangGraph checkpoint savers.",
   "type": "module",
   "engines": {
@@ -34,7 +34,7 @@
     "uuid": "^10.0.0"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.2.31 <0.3.0"
+    "@langchain/core": ">=0.2.31 <0.4.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",