langchain 0.0.201 → 0.0.203

package/dist/chat_models/baiduwenxin.d.ts

@@ -131,8 +131,8 @@ export declare class ChatBaiduWenxin extends BaseChatModel implements BaiduWenxi
      * Get the identifying parameters for the model
      */
     identifyingParams(): {
-        stream?: boolean | undefined;
         system?: string | undefined;
+        stream?: boolean | undefined;
         temperature?: number | undefined;
         top_p?: number | undefined;
         user_id?: string | undefined;

package/dist/document_loaders/fs/pdf.cjs

@@ -15,7 +15,7 @@ const document_js_2 = require("../../util/document.cjs");
  * ```
  */
 class PDFLoader extends buffer_js_1.BufferLoader {
-    constructor(filePathOrBlob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = " ", } = {}) {
+    constructor(filePathOrBlob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = "", } = {}) {
         super(filePathOrBlob);
         Object.defineProperty(this, "splitPages", {
             enumerable: true,

package/dist/document_loaders/fs/pdf.js

@@ -12,7 +12,7 @@ import { formatDocumentsAsString } from "../../util/document.js";
  * ```
  */
 export class PDFLoader extends BufferLoader {
-    constructor(filePathOrBlob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = " ", } = {}) {
+    constructor(filePathOrBlob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = "", } = {}) {
         super(filePathOrBlob);
         Object.defineProperty(this, "splitPages", {
             enumerable: true,

package/dist/document_loaders/web/pdf.cjs

@@ -14,7 +14,7 @@ const document_js_2 = require("../../util/document.cjs");
  * ```
  */
 class WebPDFLoader extends base_js_1.BaseDocumentLoader {
-    constructor(blob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = " ", } = {}) {
+    constructor(blob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = "", } = {}) {
         super();
         Object.defineProperty(this, "blob", {
             enumerable: true,

package/dist/document_loaders/web/pdf.js

@@ -11,7 +11,7 @@ import { formatDocumentsAsString } from "../../util/document.js";
  * ```
  */
 export class WebPDFLoader extends BaseDocumentLoader {
-    constructor(blob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = " ", } = {}) {
+    constructor(blob, { splitPages = true, pdfjs = PDFLoaderImports, parsedItemSeparator = "", } = {}) {
         super();
         Object.defineProperty(this, "blob", {
             enumerable: true,

package/dist/experimental/masking/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingTransformer = exports.RegexMaskingTransformer = exports.MaskingParser = void 0;
+var parser_js_1 = require("./parser.cjs");
+Object.defineProperty(exports, "MaskingParser", { enumerable: true, get: function () { return parser_js_1.MaskingParser; } });
+var regex_masking_transformer_js_1 = require("./regex_masking_transformer.cjs");
+Object.defineProperty(exports, "RegexMaskingTransformer", { enumerable: true, get: function () { return regex_masking_transformer_js_1.RegexMaskingTransformer; } });
+var transformer_js_1 = require("./transformer.cjs");
+Object.defineProperty(exports, "MaskingTransformer", { enumerable: true, get: function () { return transformer_js_1.MaskingTransformer; } });

package/dist/experimental/masking/index.d.ts

@@ -0,0 +1,4 @@
+export { MaskingParser } from "./parser.js";
+export { RegexMaskingTransformer } from "./regex_masking_transformer.js";
+export { MaskingTransformer } from "./transformer.js";
+export { type MaskingParserConfig, type HashFunction, type HookFunction, } from "./types.js";

package/dist/experimental/masking/index.js

@@ -0,0 +1,3 @@
+export { MaskingParser } from "./parser.js";
+export { RegexMaskingTransformer } from "./regex_masking_transformer.js";
+export { MaskingTransformer } from "./transformer.js";

package/dist/experimental/masking/parser.cjs

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingParser = void 0;
+/**
+ * MaskingParser class for handling the masking and rehydrating of messages.
+ */
+class MaskingParser {
+    constructor(config = {}) {
+        Object.defineProperty(this, "transformers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transformers = config.transformers ?? [];
+        this.state = new Map();
+        this.config = config;
+    }
+    /**
+     * Adds a transformer to the parser.
+     * @param transformer - An instance of a class extending MaskingTransformer.
+     */
+    addTransformer(transformer) {
+        this.transformers.push(transformer);
+    }
+    /**
+     * Getter method for retrieving the current state.
+     * @returns The current state map.
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Masks the provided message using the added transformers.
+     * This method sequentially applies each transformer's masking logic to the message.
+     * It utilizes a state map to track original values corresponding to their masked versions.
+     *
+     * @param message - The message to be masked.
+     * @returns A masked version of the message.
+     * @throws {TypeError} If the message is not a string.
+     * @throws {Error} If no transformers are added.
+     */
+    async mask(message) {
+        // If onMaskingStart is a function, handle it accordingly
+        if (this.config.onMaskingStart) {
+            await this.config.onMaskingStart(message);
+        }
+        // Check if there are any transformers added to the parser. If not, throw an error
+        // as masking requires at least one transformer to apply its logic.
+        if (this.transformers.length === 0) {
+            throw new Error("MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.");
+        }
+        if (typeof message !== "string") {
+            throw new TypeError("MaskingParser.mask Error: The 'message' argument must be a string.");
+        }
+        // Initialize the variable to hold the progressively masked message.
+        // It starts as the original message and gets transformed by each transformer.
+        let processedMessage = message;
+        // Iterate through each transformer and apply their transform method.
+        for (const transformer of this.transformers) {
+            // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.
+            const [transformedMessage, transformerState] = await transformer.transform(processedMessage, new Map(this.state));
+            // Update the processed message for subsequent transformers.
+            processedMessage = transformedMessage;
+            // Merge state changes from the transformer into the parser's state.
+            // This accumulates all transformations' effects on the state.
+            transformerState.forEach((value, key) => this.state.set(key, value));
+        }
+        // Handle onMaskingEnd callback
+        if (this.config.onMaskingEnd) {
+            await this.config.onMaskingEnd(processedMessage);
+        }
+        // Return the fully masked message after all transformers have been applied.
+        return processedMessage;
+    }
+    /**
+     * Rehydrates a masked message back to its original form.
+     * This method sequentially applies the rehydration logic of each added transformer in reverse order.
+     * It relies on the state map to correctly map the masked values back to their original values.
+     *
+     * The rehydration process is essential for restoring the original content of a message
+     * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+     *
+     * @param message - The masked message to be rehydrated.
+     * @returns The original (rehydrated) version of the message.
+     */
+    async rehydrate(message, state) {
+        // Handle onRehydratingStart callback
+        if (this.config.onRehydratingStart) {
+            await this.config.onRehydratingStart(message);
+        }
+        if (typeof message !== "string") {
+            throw new TypeError("MaskingParser.rehydrate Error: The 'message' argument must be a string.");
+        }
+        // Check if any transformers have been added to the parser.
+        // If no transformers are present, throw an error as rehydration requires at least one transformer.
+        if (this.transformers.length === 0) {
+            throw new Error("MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (state && !(state instanceof Map)) {
+            throw new TypeError("MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.");
+        }
+        const rehydrationState = state || this.state; // Use provided state or fallback to internal state
+        // Initialize the rehydratedMessage with the input masked message.
+        // This variable will undergo rehydration by each transformer in reverse order.
+        let rehydratedMessage = message;
+        // Use a reverse for...of loop to accommodate asynchronous rehydrate methods
+        const reversedTransformers = this.transformers.slice().reverse();
+        for (const transformer of reversedTransformers) {
+            // Check if the result is a Promise and use await, otherwise use it directly
+            rehydratedMessage = await transformer.rehydrate(rehydratedMessage, rehydrationState);
+        }
+        // Handle onRehydratingEnd callback
+        if (this.config.onRehydratingEnd) {
+            await this.config.onRehydratingEnd(rehydratedMessage);
+        }
+        // Return the fully rehydrated message after all transformers have been applied.
+        return rehydratedMessage;
+    }
+}
+exports.MaskingParser = MaskingParser;

package/dist/experimental/masking/parser.d.ts

@@ -0,0 +1,44 @@
+import { MaskingTransformer } from "./transformer.js";
+import type { MaskingParserConfig } from "./types.js";
+/**
+ * MaskingParser class for handling the masking and rehydrating of messages.
+ */
+export declare class MaskingParser {
+    private transformers;
+    private state;
+    private config;
+    constructor(config?: MaskingParserConfig);
+    /**
+     * Adds a transformer to the parser.
+     * @param transformer - An instance of a class extending MaskingTransformer.
+     */
+    addTransformer(transformer: MaskingTransformer): void;
+    /**
+     * Getter method for retrieving the current state.
+     * @returns The current state map.
+     */
+    getState(): Map<string, string>;
+    /**
+     * Masks the provided message using the added transformers.
+     * This method sequentially applies each transformer's masking logic to the message.
+     * It utilizes a state map to track original values corresponding to their masked versions.
+     *
+     * @param message - The message to be masked.
+     * @returns A masked version of the message.
+     * @throws {TypeError} If the message is not a string.
+     * @throws {Error} If no transformers are added.
+     */
+    mask(message: string): Promise<string>;
+    /**
+     * Rehydrates a masked message back to its original form.
+     * This method sequentially applies the rehydration logic of each added transformer in reverse order.
+     * It relies on the state map to correctly map the masked values back to their original values.
+     *
+     * The rehydration process is essential for restoring the original content of a message
+     * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+     *
+     * @param message - The masked message to be rehydrated.
+     * @returns The original (rehydrated) version of the message.
+     */
+    rehydrate(message: string, state?: Map<string, string>): Promise<string>;
+}

package/dist/experimental/masking/parser.js

@@ -0,0 +1,130 @@
+/**
+ * MaskingParser class for handling the masking and rehydrating of messages.
+ */
+export class MaskingParser {
+    constructor(config = {}) {
+        Object.defineProperty(this, "transformers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.transformers = config.transformers ?? [];
+        this.state = new Map();
+        this.config = config;
+    }
+    /**
+     * Adds a transformer to the parser.
+     * @param transformer - An instance of a class extending MaskingTransformer.
+     */
+    addTransformer(transformer) {
+        this.transformers.push(transformer);
+    }
+    /**
+     * Getter method for retrieving the current state.
+     * @returns The current state map.
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Masks the provided message using the added transformers.
+     * This method sequentially applies each transformer's masking logic to the message.
+     * It utilizes a state map to track original values corresponding to their masked versions.
+     *
+     * @param message - The message to be masked.
+     * @returns A masked version of the message.
+     * @throws {TypeError} If the message is not a string.
+     * @throws {Error} If no transformers are added.
+     */
+    async mask(message) {
+        // If onMaskingStart is a function, handle it accordingly
+        if (this.config.onMaskingStart) {
+            await this.config.onMaskingStart(message);
+        }
+        // Check if there are any transformers added to the parser. If not, throw an error
+        // as masking requires at least one transformer to apply its logic.
+        if (this.transformers.length === 0) {
+            throw new Error("MaskingParser.mask Error: No transformers have been added. Please add at least one transformer before parsing.");
+        }
+        if (typeof message !== "string") {
+            throw new TypeError("MaskingParser.mask Error: The 'message' argument must be a string.");
+        }
+        // Initialize the variable to hold the progressively masked message.
+        // It starts as the original message and gets transformed by each transformer.
+        let processedMessage = message;
+        // Iterate through each transformer and apply their transform method.
+        for (const transformer of this.transformers) {
+            // Transform the message and get the transformer's state changes, ensuring no direct mutation of the shared state.
+            const [transformedMessage, transformerState] = await transformer.transform(processedMessage, new Map(this.state));
+            // Update the processed message for subsequent transformers.
+            processedMessage = transformedMessage;
+            // Merge state changes from the transformer into the parser's state.
+            // This accumulates all transformations' effects on the state.
+            transformerState.forEach((value, key) => this.state.set(key, value));
+        }
+        // Handle onMaskingEnd callback
+        if (this.config.onMaskingEnd) {
+            await this.config.onMaskingEnd(processedMessage);
+        }
+        // Return the fully masked message after all transformers have been applied.
+        return processedMessage;
+    }
+    /**
+     * Rehydrates a masked message back to its original form.
+     * This method sequentially applies the rehydration logic of each added transformer in reverse order.
+     * It relies on the state map to correctly map the masked values back to their original values.
+     *
+     * The rehydration process is essential for restoring the original content of a message
+     * that has been transformed (masked) by the transformers. This process is the inverse of the masking process.
+     *
+     * @param message - The masked message to be rehydrated.
+     * @returns The original (rehydrated) version of the message.
+     */
+    async rehydrate(message, state) {
+        // Handle onRehydratingStart callback
+        if (this.config.onRehydratingStart) {
+            await this.config.onRehydratingStart(message);
+        }
+        if (typeof message !== "string") {
+            throw new TypeError("MaskingParser.rehydrate Error: The 'message' argument must be a string.");
+        }
+        // Check if any transformers have been added to the parser.
+        // If no transformers are present, throw an error as rehydration requires at least one transformer.
+        if (this.transformers.length === 0) {
+            throw new Error("MaskingParser.rehydrate Error: No transformers have been added. Please add at least one transformer before rehydrating.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (state && !(state instanceof Map)) {
+            throw new TypeError("MaskingParser.rehydrate Error: The 'state' argument, if provided, must be an instance of Map.");
+        }
+        const rehydrationState = state || this.state; // Use provided state or fallback to internal state
+        // Initialize the rehydratedMessage with the input masked message.
+        // This variable will undergo rehydration by each transformer in reverse order.
+        let rehydratedMessage = message;
+        // Use a reverse for...of loop to accommodate asynchronous rehydrate methods
+        const reversedTransformers = this.transformers.slice().reverse();
+        for (const transformer of reversedTransformers) {
+            // Check if the result is a Promise and use await, otherwise use it directly
+            rehydratedMessage = await transformer.rehydrate(rehydratedMessage, rehydrationState);
+        }
+        // Handle onRehydratingEnd callback
+        if (this.config.onRehydratingEnd) {
+            await this.config.onRehydratingEnd(rehydratedMessage);
+        }
+        // Return the fully rehydrated message after all transformers have been applied.
+        return rehydratedMessage;
+    }
+}

package/dist/experimental/masking/regex_masking_transformer.cjs

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegexMaskingTransformer = void 0;
+const transformer_js_1 = require("./transformer.cjs");
+/**
+ * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+ */
+class RegexMaskingTransformer extends transformer_js_1.MaskingTransformer {
+    /**
+     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+     * Validates the provided patterns to ensure they conform to the expected structure.
+     *
+     * @param patterns - An object containing masking patterns. Each pattern should include
+     *                   a regular expression (`regex`) and optionally a `replacement` string
+     *                   or a `mask` function.
+     * @param hashFunction - An optional custom hash function to be used for masking.
+     */
+    constructor(patterns, hashFunction) {
+        super();
+        Object.defineProperty(this, "patterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hashFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Validates the provided masking patterns before initializing the transformer.
+        // This ensures that each pattern has a valid regular expression.
+        this.validatePatterns(patterns);
+        // Assigns the validated patterns and the hash function to the transformer.
+        // If no custom hash function is provided, the default hash function is used.
+        this.patterns = patterns;
+        this.hashFunction = hashFunction || this.defaultHashFunction;
+    }
+    /**
+     * Validates the given masking patterns to ensure each pattern has a valid regular expression.
+     * Throws an error if any pattern is found to be invalid.
+     *
+     * @param patterns - The patterns object to validate.
+     */
+    validatePatterns(patterns) {
+        for (const key of Object.keys(patterns)) {
+            const pattern = patterns[key];
+            // Checks that each pattern is an object and has a regex property that is an instance of RegExp.
+            // Throws an error if these conditions are not met, indicating an invalid pattern configuration.
+            if (!pattern ||
+                typeof pattern !== "object" ||
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(pattern.regex instanceof RegExp)) {
+                throw new Error("Invalid pattern configuration.");
+            }
+        }
+    }
+    /**
+     * Masks content in a message based on the defined patterns.
+     * @param message - The message to be masked.
+     * @param state - The current state containing original values.
+     * @returns A tuple of the masked message and the updated state.
+     */
+    async transform(message, state) {
+        if (typeof message !== "string") {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'message' argument must be a string.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.");
+        }
+        // Holds the progressively masked message
+        let processedMessage = message;
+        // Initialize original values map with the current state or a new map
+        const originalValues = state || new Map();
+        // Iterate over each pattern defined in the transformer
+        for (const key of Object.keys(this.patterns)) {
+            const pattern = this.patterns[key];
+            // Apply the current pattern's regex to the message
+            processedMessage = processedMessage.replace(pattern.regex, (match) => {
+                // Determine the masked value: use the mask function if provided, else use the replacement string,
+                // else use the hash function.
+                const maskedValue = pattern.mask
+                    ? pattern.mask(match)
+                    : pattern.replacement ?? this.hashFunction(match);
+                // Store the mapping of the masked value to the original value (match)
+                originalValues.set(maskedValue, match);
+                // Return the masked value to replace the original value in the message
+                return maskedValue;
+            });
+        }
+        // Return the fully masked message and the state map with all original values
+        // Wrap the synchronous return values in Promise.resolve() to maintain compatibility
+        // with the MaskingParser's expectation of a Promise return type.
+        return [processedMessage, originalValues];
+    }
+    /**
+     * Rehydrates a masked message back to its original form using the provided state.
+     * @param message - The masked message to be rehydrated.
+     * @param state - The state map containing mappings of masked values to their original values.
+     * @returns The rehydrated (original) message.
+     */
+    async rehydrate(message, state) {
+        if (typeof message !== "string") {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.");
+        }
+        // Convert the state map to an array and use reduce to sequentially replace masked values with original values.
+        const rehydratedMessage = Array.from(state).reduce((msg, [masked, original]) => {
+            // Escape special characters in the masked string to ensure it can be used in a regular expression safely.
+            // This is necessary because masked values might contain characters that have special meanings in regex.
+            const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            // Replace all instances of the escaped masked value in the message with the original value.
+            // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.
+            return msg.replace(new RegExp(escapedMasked, "g"), original);
+        }, message);
+        return rehydratedMessage;
+    }
+    /**
+     * Default hash function for creating unique hash values.
+     * @param input - The input string to hash.
+     * @returns The resulting hash as a string.
+     */
+    defaultHashFunction(input) {
+        let hash = 0;
+        // Iterate over each character in the input string
+        for (let i = 0; i < input.length; i += 1) {
+            // Get ASCII value of the character
+            const char = input.charCodeAt(i);
+            // Combine the current hash with the new character and ensure it remains a 32-bit integer
+            hash = (hash << 5) - hash + char;
+            // Bitwise OR operation to convert to a 32-bit integer.
+            // This is a common technique to ensure the final hash value stays within the 32-bit limit,
+            // effectively wrapping the value when it becomes too large.
+            hash |= 0;
+        }
+        // Convert the numerical hash value to a string and return
+        return hash.toString();
+    }
+}
+exports.RegexMaskingTransformer = RegexMaskingTransformer;

package/dist/experimental/masking/regex_masking_transformer.d.ts

@@ -0,0 +1,48 @@
+import { MaskingTransformer } from "./transformer.js";
+import type { HashFunction, MaskingPattern } from "./types.js";
+/**
+ * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+ */
+export declare class RegexMaskingTransformer extends MaskingTransformer {
+    private patterns;
+    private hashFunction;
+    /**
+     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+     * Validates the provided patterns to ensure they conform to the expected structure.
+     *
+     * @param patterns - An object containing masking patterns. Each pattern should include
+     *                   a regular expression (`regex`) and optionally a `replacement` string
+     *                   or a `mask` function.
+     * @param hashFunction - An optional custom hash function to be used for masking.
+     */
+    constructor(patterns: {
+        [key: string]: MaskingPattern;
+    }, hashFunction?: HashFunction);
+    /**
+     * Validates the given masking patterns to ensure each pattern has a valid regular expression.
+     * Throws an error if any pattern is found to be invalid.
+     *
+     * @param patterns - The patterns object to validate.
+     */
+    private validatePatterns;
+    /**
+     * Masks content in a message based on the defined patterns.
+     * @param message - The message to be masked.
+     * @param state - The current state containing original values.
+     * @returns A tuple of the masked message and the updated state.
+     */
+    transform(message: string, state: Map<string, string>): Promise<[string, Map<string, string>]>;
+    /**
+     * Rehydrates a masked message back to its original form using the provided state.
+     * @param message - The masked message to be rehydrated.
+     * @param state - The state map containing mappings of masked values to their original values.
+     * @returns The rehydrated (original) message.
+     */
+    rehydrate(message: string, state: Map<string, string>): Promise<string>;
+    /**
+     * Default hash function for creating unique hash values.
+     * @param input - The input string to hash.
+     * @returns The resulting hash as a string.
+     */
+    private defaultHashFunction;
+}

package/dist/experimental/masking/regex_masking_transformer.js

@@ -0,0 +1,141 @@
+import { MaskingTransformer } from "./transformer.js";
+/**
+ * RegexMaskingTransformer class for masking and rehydrating messages with Regex.
+ */
+export class RegexMaskingTransformer extends MaskingTransformer {
+    /**
+     * Constructs a RegexMaskingTransformer with given patterns and an optional hash function.
+     * Validates the provided patterns to ensure they conform to the expected structure.
+     *
+     * @param patterns - An object containing masking patterns. Each pattern should include
+     *                   a regular expression (`regex`) and optionally a `replacement` string
+     *                   or a `mask` function.
+     * @param hashFunction - An optional custom hash function to be used for masking.
+     */
+    constructor(patterns, hashFunction) {
+        super();
+        Object.defineProperty(this, "patterns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hashFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Validates the provided masking patterns before initializing the transformer.
+        // This ensures that each pattern has a valid regular expression.
+        this.validatePatterns(patterns);
+        // Assigns the validated patterns and the hash function to the transformer.
+        // If no custom hash function is provided, the default hash function is used.
+        this.patterns = patterns;
+        this.hashFunction = hashFunction || this.defaultHashFunction;
+    }
+    /**
+     * Validates the given masking patterns to ensure each pattern has a valid regular expression.
+     * Throws an error if any pattern is found to be invalid.
+     *
+     * @param patterns - The patterns object to validate.
+     */
+    validatePatterns(patterns) {
+        for (const key of Object.keys(patterns)) {
+            const pattern = patterns[key];
+            // Checks that each pattern is an object and has a regex property that is an instance of RegExp.
+            // Throws an error if these conditions are not met, indicating an invalid pattern configuration.
+            if (!pattern ||
+                typeof pattern !== "object" ||
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                !(pattern.regex instanceof RegExp)) {
+                throw new Error("Invalid pattern configuration.");
+            }
+        }
+    }
+    /**
+     * Masks content in a message based on the defined patterns.
+     * @param message - The message to be masked.
+     * @param state - The current state containing original values.
+     * @returns A tuple of the masked message and the updated state.
+     */
+    async transform(message, state) {
+        if (typeof message !== "string") {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'message' argument must be a string.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.transform Error: The 'state' argument must be an instance of Map.");
+        }
+        // Holds the progressively masked message
+        let processedMessage = message;
+        // Initialize original values map with the current state or a new map
+        const originalValues = state || new Map();
+        // Iterate over each pattern defined in the transformer
+        for (const key of Object.keys(this.patterns)) {
+            const pattern = this.patterns[key];
+            // Apply the current pattern's regex to the message
+            processedMessage = processedMessage.replace(pattern.regex, (match) => {
+                // Determine the masked value: use the mask function if provided, else use the replacement string,
+                // else use the hash function.
+                const maskedValue = pattern.mask
+                    ? pattern.mask(match)
+                    : pattern.replacement ?? this.hashFunction(match);
+                // Store the mapping of the masked value to the original value (match)
+                originalValues.set(maskedValue, match);
+                // Return the masked value to replace the original value in the message
+                return maskedValue;
+            });
+        }
+        // Return the fully masked message and the state map with all original values
+        // Wrap the synchronous return values in Promise.resolve() to maintain compatibility
+        // with the MaskingParser's expectation of a Promise return type.
+        return [processedMessage, originalValues];
+    }
+    /**
+     * Rehydrates a masked message back to its original form using the provided state.
+     * @param message - The masked message to be rehydrated.
+     * @param state - The state map containing mappings of masked values to their original values.
+     * @returns The rehydrated (original) message.
+     */
+    async rehydrate(message, state) {
+        if (typeof message !== "string") {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'message' argument must be a string.");
+        }
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (!(state instanceof Map)) {
+            throw new TypeError("RegexMaskingTransformer.rehydrate Error: The 'state' argument must be an instance of Map.");
+        }
+        // Convert the state map to an array and use reduce to sequentially replace masked values with original values.
+        const rehydratedMessage = Array.from(state).reduce((msg, [masked, original]) => {
+            // Escape special characters in the masked string to ensure it can be used in a regular expression safely.
+            // This is necessary because masked values might contain characters that have special meanings in regex.
+            const escapedMasked = masked.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            // Replace all instances of the escaped masked value in the message with the original value.
+            // The 'g' flag in the RegExp ensures that all occurrences of the masked value are replaced.
+            return msg.replace(new RegExp(escapedMasked, "g"), original);
+        }, message);
+        return rehydratedMessage;
+    }
+    /**
+     * Default hash function for creating unique hash values.
+     * @param input - The input string to hash.
+     * @returns The resulting hash as a string.
+     */
+    defaultHashFunction(input) {
+        let hash = 0;
+        // Iterate over each character in the input string
+        for (let i = 0; i < input.length; i += 1) {
+            // Get ASCII value of the character
+            const char = input.charCodeAt(i);
+            // Combine the current hash with the new character and ensure it remains a 32-bit integer
+            hash = (hash << 5) - hash + char;
+            // Bitwise OR operation to convert to a 32-bit integer.
+            // This is a common technique to ensure the final hash value stays within the 32-bit limit,
+            // effectively wrapping the value when it becomes too large.
+            hash |= 0;
+        }
+        // Convert the numerical hash value to a string and return
+        return hash.toString();
+    }
+}

package/dist/experimental/masking/transformer.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaskingTransformer = void 0;
+/**
+ * Abstract class representing a transformer used for masking and rehydrating messages.
+ */
+class MaskingTransformer {
+}
+exports.MaskingTransformer = MaskingTransformer;

package/dist/experimental/masking/transformer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Abstract class representing a transformer used for masking and rehydrating messages.
+ */
+export declare abstract class MaskingTransformer {
+    abstract transform(message: string, state?: Map<string, string>): Promise<[string, Map<string, string>]>;
+    abstract rehydrate(message: string, state: Map<string, string>): Promise<string>;
+}

package/dist/experimental/masking/transformer.js

@@ -0,0 +1,5 @@
+/**
+ * Abstract class representing a transformer used for masking and rehydrating messages.
+ */
+export class MaskingTransformer {
+}

package/dist/experimental/masking/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/experimental/masking/types.d.ts

@@ -0,0 +1,25 @@
+import { MaskingTransformer } from "./transformer.js";
+/**
+ * Configuration type for MaskingParser.
+ */
+export type MaskingParserConfig = {
+    transformers?: MaskingTransformer[];
+    defaultHashFunction?: HashFunction;
+    onMaskingStart?: HookFunction;
+    onMaskingEnd?: HookFunction;
+    onRehydratingStart?: HookFunction;
+    onRehydratingEnd?: HookFunction;
+};
+/**
+ *  Regex Masking Pattern used for masking in PIIMaskingTransformer.
+ */
+export type MaskingPattern = {
+    regex: RegExp;
+    replacement?: string;
+    mask?: (match: string) => string;
+};
+export type HookFunction = ((message: string) => Promise<void>) | ((message: string) => void);
+/**
+ * Represents a function that can hash a string input.
+ */
+export type HashFunction = (input: string) => string;

package/dist/experimental/masking/types.js

@@ -0,0 +1 @@
+export {};

package/dist/load/import_map.cjs

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.document_transformers__openai_functions = exports.document_loaders__web__sort_xyz_blockchain = exports.document_loaders__web__serpapi = exports.document_loaders__web__searchapi = exports.document_loaders__base = exports.document = exports.memory = exports.text_splitter = exports.vectorstores__xata = exports.vectorstores__vectara = exports.vectorstores__prisma = exports.vectorstores__memory = exports.vectorstores__base = exports.prompts = exports.llms__fake = exports.llms__yandex = exports.llms__fireworks = exports.llms__ollama = exports.llms__cloudflare_workersai = exports.llms__aleph_alpha = exports.llms__ai21 = exports.llms__openai = exports.llms__base = exports.embeddings__voyage = exports.embeddings__minimax = exports.embeddings__openai = exports.embeddings__ollama = exports.embeddings__fake = exports.embeddings__cache_backed = exports.embeddings__base = exports.chains__openai_functions = exports.chains__combine_documents__reduce = exports.chains = exports.tools__google_places = exports.tools__render = exports.tools__connery = exports.tools = exports.base_language = exports.agents__openai__output_parser = exports.agents__xml__output_parser = exports.agents__react__output_parser = exports.agents__format_scratchpad__log_to_message = exports.agents__format_scratchpad__xml = exports.agents__format_scratchpad__log = exports.agents__format_scratchpad__openai_tools = exports.agents__format_scratchpad = exports.agents__toolkits__connery = exports.agents__toolkits = exports.agents = exports.load__serializable = void 0;
 exports.experimental__plan_and_execute = exports.experimental__generative_agents = exports.experimental__babyagi = exports.experimental__openai_files = exports.experimental__openai_assistant = exports.experimental__autogpt = exports.util__time = exports.util__math = exports.util__document = exports.storage__in_memory = exports.storage__encoder_backed = exports.stores__message__in_memory = exports.stores__file__in_memory = exports.stores__doc__in_memory = exports.cache = exports.retrievers__vespa = exports.retrievers__score_threshold = exports.retrievers__hyde = exports.retrievers__document_compressors__embeddings_filter = exports.retrievers__document_compressors__chain_extract = exports.retrievers__time_weighted = exports.retrievers__tavily_search_api = exports.retrievers__parent_document = exports.retrievers__multi_vector = exports.retrievers__multi_query = exports.retrievers__document_compressors = exports.retrievers__contextual_compression = exports.retrievers__databerry = exports.retrievers__chaindesk = exports.retrievers__remote = exports.output_parsers = exports.callbacks = exports.schema__storage = exports.schema__runnable = exports.schema__retriever = exports.schema__query_constructor = exports.schema__prompt_template = exports.schema__output_parser = exports.schema__document = exports.schema = exports.chat_models__fake = exports.chat_models__yandex = exports.chat_models__minimax = exports.chat_models__ollama = exports.chat_models__baiduwenxin = exports.chat_models__fireworks = exports.chat_models__cloudflare_workersai = exports.chat_models__anthropic = exports.chat_models__openai = exports.chat_models__base = void 0;
-exports.runnables__remote = exports.runnables = exports.evaluation = exports.experimental__chains__violation_of_expectations = exports.experimental__chat_models__ollama_functions = exports.experimental__chat_models__bittensor = void 0;
+exports.runnables__remote = exports.runnables = exports.evaluation = exports.experimental__masking = exports.experimental__chains__violation_of_expectations = exports.experimental__chat_models__ollama_functions = exports.experimental__chat_models__bittensor = void 0;
 exports.load__serializable = __importStar(require("../load/serializable.cjs"));
 exports.agents = __importStar(require("../agents/index.cjs"));
 exports.agents__toolkits = __importStar(require("../agents/toolkits/index.cjs"));
@@ -130,6 +130,7 @@ exports.experimental__plan_and_execute = __importStar(require("../experimental/p
 exports.experimental__chat_models__bittensor = __importStar(require("../experimental/chat_models/bittensor.cjs"));
 exports.experimental__chat_models__ollama_functions = __importStar(require("../experimental/chat_models/ollama_functions.cjs"));
 exports.experimental__chains__violation_of_expectations = __importStar(require("../experimental/chains/violation_of_expectations/index.cjs"));
+exports.experimental__masking = __importStar(require("../experimental/masking/index.cjs"));
 exports.evaluation = __importStar(require("../evaluation/index.cjs"));
 exports.runnables = __importStar(require("../runnables/index.cjs"));
 exports.runnables__remote = __importStar(require("../runnables/remote.cjs"));

package/dist/load/import_map.d.ts

@@ -101,6 +101,7 @@ export * as experimental__plan_and_execute from "../experimental/plan_and_execut
 export * as experimental__chat_models__bittensor from "../experimental/chat_models/bittensor.js";
 export * as experimental__chat_models__ollama_functions from "../experimental/chat_models/ollama_functions.js";
 export * as experimental__chains__violation_of_expectations from "../experimental/chains/violation_of_expectations/index.js";
+export * as experimental__masking from "../experimental/masking/index.js";
 export * as evaluation from "../evaluation/index.js";
 export * as runnables from "../runnables/index.js";
 export * as runnables__remote from "../runnables/remote.js";

package/dist/load/import_map.js

@@ -102,6 +102,7 @@ export * as experimental__plan_and_execute from "../experimental/plan_and_execut
 export * as experimental__chat_models__bittensor from "../experimental/chat_models/bittensor.js";
 export * as experimental__chat_models__ollama_functions from "../experimental/chat_models/ollama_functions.js";
 export * as experimental__chains__violation_of_expectations from "../experimental/chains/violation_of_expectations/index.js";
+export * as experimental__masking from "../experimental/masking/index.js";
 export * as evaluation from "../evaluation/index.js";
 export * as runnables from "../runnables/index.js";
 export * as runnables__remote from "../runnables/remote.js";

package/dist/util/stream.cjs

@@ -1,87 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IterableReadableStream = void 0;
-/*
- * Support async iterator syntax for ReadableStreams in all environments.
- * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-class IterableReadableStream extends ReadableStream {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "reader", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    ensureReader() {
-        if (!this.reader) {
-            this.reader = this.getReader();
-        }
-    }
-    async next() {
-        this.ensureReader();
-        try {
-            const result = await this.reader.read();
-            if (result.done)
-                this.reader.releaseLock(); // release lock when stream becomes closed
-            return {
-                done: result.done,
-                value: result.value, // Cloudflare Workers typing fix
-            };
-        }
-        catch (e) {
-            this.reader.releaseLock(); // release lock when stream becomes errored
-            throw e;
-        }
-    }
-    async return() {
-        this.ensureReader();
-        const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
-        this.reader.releaseLock(); // release lock first
-        await cancelPromise; // now await it
-        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    static fromReadableStream(stream) {
-        // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
-        const reader = stream.getReader();
-        return new IterableReadableStream({
-            start(controller) {
-                return pump();
-                function pump() {
-                    return reader.read().then(({ done, value }) => {
-                        // When no more data needs to be consumed, close the stream
-                        if (done) {
-                            controller.close();
-                            return;
-                        }
-                        // Enqueue the next data chunk into our target stream
-                        controller.enqueue(value);
-                        return pump();
-                    });
-                }
-            },
-            cancel() {
-                reader.releaseLock();
-            },
-        });
-    }
-    static fromAsyncGenerator(generator) {
-        return new IterableReadableStream({
-            async pull(controller) {
-                const { value, done } = await generator.next();
-                // When no more data needs to be consumed, close the stream
-                if (done) {
-                    controller.close();
-                }
-                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
-                controller.enqueue(value);
-            },
-        });
-    }
-}
-exports.IterableReadableStream = IterableReadableStream;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("@langchain/core/utils/stream"), exports);

package/dist/util/stream.d.ts

@@ -1,15 +1 @@
-export declare class IterableReadableStream<T> extends ReadableStream<T> {
-    reader: ReadableStreamDefaultReader<T>;
-    ensureReader(): void;
-    next(): Promise<{
-        done: boolean;
-        value: T;
-    }>;
-    return(): Promise<{
-        done: boolean;
-        value: T;
-    }>;
-    [Symbol.asyncIterator](): this;
-    static fromReadableStream<T>(stream: ReadableStream<T>): IterableReadableStream<T>;
-    static fromAsyncGenerator<T>(generator: AsyncGenerator<T>): IterableReadableStream<T>;
-}
+export * from "@langchain/core/utils/stream";

package/dist/util/stream.js

@@ -1,83 +1 @@
-/*
- * Support async iterator syntax for ReadableStreams in all environments.
- * Source: https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-export class IterableReadableStream extends ReadableStream {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "reader", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-    }
-    ensureReader() {
-        if (!this.reader) {
-            this.reader = this.getReader();
-        }
-    }
-    async next() {
-        this.ensureReader();
-        try {
-            const result = await this.reader.read();
-            if (result.done)
-                this.reader.releaseLock(); // release lock when stream becomes closed
-            return {
-                done: result.done,
-                value: result.value, // Cloudflare Workers typing fix
-            };
-        }
-        catch (e) {
-            this.reader.releaseLock(); // release lock when stream becomes errored
-            throw e;
-        }
-    }
-    async return() {
-        this.ensureReader();
-        const cancelPromise = this.reader.cancel(); // cancel first, but don't await yet
-        this.reader.releaseLock(); // release lock first
-        await cancelPromise; // now await it
-        return { done: true, value: undefined }; // This cast fixes TS typing, and convention is to ignore final chunk value anyway
-    }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    static fromReadableStream(stream) {
-        // From https://developer.mozilla.org/en-US/docs/Web/API/Streams_API/Using_readable_streams#reading_the_stream
-        const reader = stream.getReader();
-        return new IterableReadableStream({
-            start(controller) {
-                return pump();
-                function pump() {
-                    return reader.read().then(({ done, value }) => {
-                        // When no more data needs to be consumed, close the stream
-                        if (done) {
-                            controller.close();
-                            return;
-                        }
-                        // Enqueue the next data chunk into our target stream
-                        controller.enqueue(value);
-                        return pump();
-                    });
-                }
-            },
-            cancel() {
-                reader.releaseLock();
-            },
-        });
-    }
-    static fromAsyncGenerator(generator) {
-        return new IterableReadableStream({
-            async pull(controller) {
-                const { value, done } = await generator.next();
-                // When no more data needs to be consumed, close the stream
-                if (done) {
-                    controller.close();
-                }
-                // Fix: `else if (value)` will hang the streaming when nullish value (e.g. empty string) is pulled
-                controller.enqueue(value);
-            },
-        });
-    }
-}
+export * from "@langchain/core/utils/stream";

package/dist/vectorstores/prisma.cjs

@@ -292,6 +292,7 @@ class PrismaVectorStore extends base_js_1.VectorStore {
         return instance;
     }
 }
+exports.PrismaVectorStore = PrismaVectorStore;
 Object.defineProperty(PrismaVectorStore, "IdColumn", {
     enumerable: true,
     configurable: true,
@@ -304,4 +305,3 @@ Object.defineProperty(PrismaVectorStore, "ContentColumn", {
     writable: true,
     value: ContentColumnSymbol
 });
-exports.PrismaVectorStore = PrismaVectorStore;

package/dist/vectorstores/prisma.js

@@ -19,7 +19,7 @@ const OpMap = {
  * work with Prisma. It provides methods for adding models, documents, and
  * vectors, as well as for performing similarity searches.
  */
-class PrismaVectorStore extends VectorStore {
+export class PrismaVectorStore extends VectorStore {
     _vectorstoreType() {
         return "prisma";
     }
@@ -301,4 +301,3 @@ Object.defineProperty(PrismaVectorStore, "ContentColumn", {
     writable: true,
     value: ContentColumnSymbol
 });
-export { PrismaVectorStore };

package/dist/vectorstores/xata.cjs

@@ -89,7 +89,7 @@ class XataVectorSearch extends base_js_1.VectorStore {
      * @returns Promise resolving to an array of tuples, each containing a Document and its score.
      */
     async similaritySearchVectorWithScore(query, k, filter) {
-        const records = await this.client.db[this.table].vectorSearch("embedding", query, {
+        const { records } = await this.client.db[this.table].vectorSearch("embedding", query, {
             size: k,
             filter,
         });

package/dist/vectorstores/xata.js

@@ -86,7 +86,7 @@ export class XataVectorSearch extends VectorStore {
      * @returns Promise resolving to an array of tuples, each containing a Document and its score.
      */
     async similaritySearchVectorWithScore(query, k, filter) {
-        const records = await this.client.db[this.table].vectorSearch("embedding", query, {
+        const { records } = await this.client.db[this.table].vectorSearch("embedding", query, {
             size: k,
             filter,
         });

package/experimental/masking.cjs

@@ -0,0 +1 @@
+module.exports = require('../dist/experimental/masking/index.cjs');

package/experimental/masking.d.ts

@@ -0,0 +1 @@
+export * from '../dist/experimental/masking/index.js'

package/experimental/masking.js

@@ -0,0 +1 @@
+export * from '../dist/experimental/masking/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.0.201",
+  "version": "0.0.203",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {
@@ -835,6 +835,9 @@
     "experimental/chains/violation_of_expectations.cjs",
     "experimental/chains/violation_of_expectations.js",
     "experimental/chains/violation_of_expectations.d.ts",
+    "experimental/masking.cjs",
+    "experimental/masking.js",
+    "experimental/masking.d.ts",
     "experimental/tools/pyinterpreter.cjs",
     "experimental/tools/pyinterpreter.js",
     "experimental/tools/pyinterpreter.d.ts",
@@ -944,7 +947,7 @@
     "@vercel/kv": "^0.2.3",
     "@vercel/postgres": "^0.5.0",
     "@writerai/writer-sdk": "^0.40.2",
-    "@xata.io/client": "^0.25.1",
+    "@xata.io/client": "^0.28.0",
     "@xenova/transformers": "^2.5.4",
     "@zilliz/milvus2-sdk-node": ">=2.2.11",
     "apify-client": "^2.7.1",
@@ -1012,7 +1015,7 @@
     "srt-parser-2": "^1.2.2",
     "ts-jest": "^29.1.0",
     "typeorm": "^0.3.12",
-    "typescript": "^5.0.0",
+    "typescript": "~5.1.6",
     "typesense": "^1.5.3",
     "usearch": "^1.1.1",
     "vectordb": "^0.1.4",
@@ -1066,7 +1069,7 @@
     "@vercel/kv": "^0.2.3",
     "@vercel/postgres": "^0.5.0",
     "@writerai/writer-sdk": "^0.40.2",
-    "@xata.io/client": "^0.25.1",
+    "@xata.io/client": "^0.28.0",
     "@xenova/transformers": "^2.5.4",
     "@zilliz/milvus2-sdk-node": ">=2.2.7",
     "apify-client": "^2.7.1",
@@ -1432,7 +1435,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.9.1",
-    "@langchain/core": "~0.0.8",
+    "@langchain/core": "~0.0.10",
     "binary-extensions": "^2.2.0",
     "expr-eval": "^2.0.2",
     "flat": "^5.0.2",
@@ -2843,6 +2846,11 @@
       "import": "./experimental/chains/violation_of_expectations.js",
       "require": "./experimental/chains/violation_of_expectations.cjs"
     },
+    "./experimental/masking": {
+      "types": "./experimental/masking.d.ts",
+      "import": "./experimental/masking.js",
+      "require": "./experimental/masking.cjs"
+    },
     "./experimental/tools/pyinterpreter": {
       "types": "./experimental/tools/pyinterpreter.d.ts",
       "import": "./experimental/tools/pyinterpreter.js",