@langchain/langgraph-checkpoint 0.0.6 → 0.0.8-rc.0

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/dist/store/base.cjs

@@ -0,0 +1,98 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStore = void 0;
+/**
+ * Abstract base class for key-value stores.
+ */
+class BaseStore {
+    // convenience methods
+    /**
+     * Retrieve a single item.
+     * @param namespace Hierarchical path for the item.
+     * @param id Unique identifier within the namespace.
+     * @returns A promise that resolves to the retrieved item or null if not found.
+     */
+    async get(namespace, id) {
+        const batchResult = await this.batch([{ namespace, id }]);
+        return batchResult[0];
+    }
+    /**
+     * Search for items within a namespace prefix.
+     * @param namespacePrefix Hierarchical path prefix to search within.
+     * @param options Search options.
+     * @param options.filter Key-value pairs to filter results.
+     * @param options.limit Maximum number of items to return (default: 10).
+     * @param options.offset Number of items to skip before returning results (default: 0).
+     * @returns A promise that resolves to a list of items matching the search criteria.
+     */
+    async search(namespacePrefix, options) {
+        const optionsWithDefaults = {
+            limit: 10,
+            offset: 0,
+            ...(options || {}),
+        };
+        const batchResults = await this.batch([
+            { namespacePrefix, ...optionsWithDefaults },
+        ]);
+        return batchResults[0];
+    }
+    /**
+     * Store or update an item.
+     * @param namespace Hierarchical path for the item.
+     * @param id Unique identifier within the namespace.
+     * @param value Object containing the item's data.
+     */
+    async put(namespace, id, value) {
+        await this.batch([{ namespace, id, value }]);
+    }
+    /**
+     * Delete an item.
+     * @param namespace Hierarchical path for the item.
+     * @param id Unique identifier within the namespace.
+     */
+    async delete(namespace, id) {
+        await this.batch([{ namespace, id, value: null }]);
+    }
+    /**
+     * List and filter namespaces in the store.
+     * @param options Options for listing namespaces.
+     * @param options.prefix Filter namespaces that start with this path.
+     * @param options.suffix Filter namespaces that end with this path.
+     * @param options.maxDepth Return namespaces up to this depth in the hierarchy.
+     * @param options.limit Maximum number of namespaces to return (default 100).
+     * @param options.offset Number of namespaces to skip for pagination (default 0).
+     * @returns A promise that resolves to a list of namespace arrays that match the criteria.
+     */
+    async listNamespaces(options) {
+        const { prefix, suffix, maxDepth, limit = 100, offset = 0 } = options;
+        const matchConditions = [];
+        if (prefix) {
+            matchConditions.push({ matchType: "prefix", path: prefix });
+        }
+        if (suffix) {
+            matchConditions.push({ matchType: "suffix", path: suffix });
+        }
+        const op = {
+            matchConditions: matchConditions.length > 0 ? matchConditions : undefined,
+            maxDepth,
+            limit,
+            offset,
+        };
+        const batchResults = await this.batch([op]);
+        return batchResults[0];
+    }
+    /**
+     * Stop the store. No-op if not implemented.
+     */
+    stop() {
+        // no-op if not implemented.
+    }
+    /**
+     * Start the store. No-op if not implemented.
+     */
+    start() {
+        // no-op if not implemented.
+    }
+}
+exports.BaseStore = BaseStore;