@langchain/core 0.1.59 → 0.1.60

package/dist/chat_history.cjs

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseListChatMessageHistory = exports.BaseChatMessageHistory = void 0;
+exports.InMemoryChatMessageHistory = exports.BaseListChatMessageHistory = exports.BaseChatMessageHistory = void 0;
 const serializable_js_1 = require("./load/serializable.cjs");
 const index_js_1 = require("./messages/index.cjs");
+// TODO: Combine into one class for 0.2
 /**
  * Base class for all chat message histories. All chat message histories
  * should extend this class.
@@ -60,3 +61,50 @@ class BaseListChatMessageHistory extends serializable_js_1.Serializable {
     }
 }
 exports.BaseListChatMessageHistory = BaseListChatMessageHistory;
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+class InMemoryChatMessageHistory extends BaseListChatMessageHistory {
+    constructor(messages) {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "stores", "message", "in_memory"]
+        });
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.messages = messages ?? [];
+    }
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    async getMessages() {
+        return this.messages;
+    }
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    async addMessage(message) {
+        this.messages.push(message);
+    }
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    async clear() {
+        this.messages = [];
+    }
+}
+exports.InMemoryChatMessageHistory = InMemoryChatMessageHistory;

package/dist/chat_history.d.ts

@@ -54,3 +54,30 @@ export declare abstract class BaseListChatMessageHistory extends Serializable {
      */
     clear(): Promise<void>;
 }
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+export declare class InMemoryChatMessageHistory extends BaseListChatMessageHistory {
+    lc_namespace: string[];
+    private messages;
+    constructor(messages?: BaseMessage[]);
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    getMessages(): Promise<BaseMessage[]>;
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    addMessage(message: BaseMessage): Promise<void>;
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    clear(): Promise<void>;
+}

package/dist/chat_history.js

@@ -1,5 +1,6 @@
 import { Serializable } from "./load/serializable.js";
 import { HumanMessage, AIMessage } from "./messages/index.js";
+// TODO: Combine into one class for 0.2
 /**
  * Base class for all chat message histories. All chat message histories
  * should extend this class.
@@ -55,3 +56,49 @@ export class BaseListChatMessageHistory extends Serializable {
         throw new Error("Not implemented.");
     }
 }
+/**
+ * Class for storing chat message history in-memory. It extends the
+ * BaseListChatMessageHistory class and provides methods to get, add, and
+ * clear messages.
+ */
+export class InMemoryChatMessageHistory extends BaseListChatMessageHistory {
+    constructor(messages) {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "stores", "message", "in_memory"]
+        });
+        Object.defineProperty(this, "messages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.messages = messages ?? [];
+    }
+    /**
+     * Method to get all the messages stored in the ChatMessageHistory
+     * instance.
+     * @returns Array of stored BaseMessage instances.
+     */
+    async getMessages() {
+        return this.messages;
+    }
+    /**
+     * Method to add a new message to the ChatMessageHistory instance.
+     * @param message The BaseMessage instance to add.
+     * @returns A promise that resolves when the message has been added.
+     */
+    async addMessage(message) {
+        this.messages.push(message);
+    }
+    /**
+     * Method to clear all the messages from the ChatMessageHistory instance.
+     * @returns A promise that resolves when all messages have been cleared.
+     */
+    async clear() {
+        this.messages = [];
+    }
+}

package/dist/stores.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseStore = void 0;
+exports.InMemoryStore = exports.BaseStore = void 0;
 const serializable_js_1 = require("./load/serializable.cjs");
 /**
  * Abstract interface for a key-value store.
@@ -8,3 +8,83 @@ const serializable_js_1 = require("./load/serializable.cjs");
 class BaseStore extends serializable_js_1.Serializable {
 }
 exports.BaseStore = BaseStore;
+/**
+ * In-memory implementation of the BaseStore using a dictionary. Used for
+ * storing key-value pairs in memory.
+ * @example
+ * ```typescript
+ * const store = new InMemoryStore<BaseMessage>();
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     index % 2 === 0
+ *       ? new AIMessage("ai stuff...")
+ *       : new HumanMessage("human stuff..."),
+ *   ]),
+ * );
+ *
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * await store.mdelete(await store.yieldKeys("message:id:").toArray());
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class InMemoryStore extends BaseStore {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage"]
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    /**
+     * Retrieves the values associated with the given keys from the store.
+     * @param keys Keys to retrieve values for.
+     * @returns Array of values associated with the given keys.
+     */
+    async mget(keys) {
+        return keys.map((key) => this.store[key]);
+    }
+    /**
+     * Sets the values for the given keys in the store.
+     * @param keyValuePairs Array of key-value pairs to set in the store.
+     * @returns Promise that resolves when all key-value pairs have been set.
+     */
+    async mset(keyValuePairs) {
+        for (const [key, value] of keyValuePairs) {
+            this.store[key] = value;
+        }
+    }
+    /**
+     * Deletes the given keys and their associated values from the store.
+     * @param keys Keys to delete from the store.
+     * @returns Promise that resolves when all keys have been deleted.
+     */
+    async mdelete(keys) {
+        for (const key of keys) {
+            delete this.store[key];
+        }
+    }
+    /**
+     * Asynchronous generator that yields keys from the store. If a prefix is
+     * provided, it only yields keys that start with the prefix.
+     * @param prefix Optional prefix to filter keys.
+     * @returns AsyncGenerator that yields keys from the store.
+     */
+    async *yieldKeys(prefix) {
+        const keys = Object.keys(this.store);
+        for (const key of keys) {
+            if (prefix === undefined || key.startsWith(prefix)) {
+                yield key;
+            }
+        }
+    }
+}
+exports.InMemoryStore = InMemoryStore;

package/dist/stores.d.ts

@@ -55,3 +55,51 @@ export declare abstract class BaseStore<K, V> extends Serializable implements Ba
      */
     abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;
 }
+/**
+ * In-memory implementation of the BaseStore using a dictionary. Used for
+ * storing key-value pairs in memory.
+ * @example
+ * ```typescript
+ * const store = new InMemoryStore<BaseMessage>();
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     index % 2 === 0
+ *       ? new AIMessage("ai stuff...")
+ *       : new HumanMessage("human stuff..."),
+ *   ]),
+ * );
+ *
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * await store.mdelete(await store.yieldKeys("message:id:").toArray());
+ * ```
+ */
+export declare class InMemoryStore<T = any> extends BaseStore<string, T> {
+    lc_namespace: string[];
+    protected store: Record<string, T>;
+    /**
+     * Retrieves the values associated with the given keys from the store.
+     * @param keys Keys to retrieve values for.
+     * @returns Array of values associated with the given keys.
+     */
+    mget(keys: string[]): Promise<T[]>;
+    /**
+     * Sets the values for the given keys in the store.
+     * @param keyValuePairs Array of key-value pairs to set in the store.
+     * @returns Promise that resolves when all key-value pairs have been set.
+     */
+    mset(keyValuePairs: [string, T][]): Promise<void>;
+    /**
+     * Deletes the given keys and their associated values from the store.
+     * @param keys Keys to delete from the store.
+     * @returns Promise that resolves when all keys have been deleted.
+     */
+    mdelete(keys: string[]): Promise<void>;
+    /**
+     * Asynchronous generator that yields keys from the store. If a prefix is
+     * provided, it only yields keys that start with the prefix.
+     * @param prefix Optional prefix to filter keys.
+     * @returns AsyncGenerator that yields keys from the store.
+     */
+    yieldKeys(prefix?: string | undefined): AsyncGenerator<string>;
+}

package/dist/stores.js

@@ -4,3 +4,82 @@ import { Serializable } from "./load/serializable.js";
  */
 export class BaseStore extends Serializable {
 }
+/**
+ * In-memory implementation of the BaseStore using a dictionary. Used for
+ * storing key-value pairs in memory.
+ * @example
+ * ```typescript
+ * const store = new InMemoryStore<BaseMessage>();
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     index % 2 === 0
+ *       ? new AIMessage("ai stuff...")
+ *       : new HumanMessage("human stuff..."),
+ *   ]),
+ * );
+ *
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * await store.mdelete(await store.yieldKeys("message:id:").toArray());
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export class InMemoryStore extends BaseStore {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "storage"]
+        });
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+    }
+    /**
+     * Retrieves the values associated with the given keys from the store.
+     * @param keys Keys to retrieve values for.
+     * @returns Array of values associated with the given keys.
+     */
+    async mget(keys) {
+        return keys.map((key) => this.store[key]);
+    }
+    /**
+     * Sets the values for the given keys in the store.
+     * @param keyValuePairs Array of key-value pairs to set in the store.
+     * @returns Promise that resolves when all key-value pairs have been set.
+     */
+    async mset(keyValuePairs) {
+        for (const [key, value] of keyValuePairs) {
+            this.store[key] = value;
+        }
+    }
+    /**
+     * Deletes the given keys and their associated values from the store.
+     * @param keys Keys to delete from the store.
+     * @returns Promise that resolves when all keys have been deleted.
+     */
+    async mdelete(keys) {
+        for (const key of keys) {
+            delete this.store[key];
+        }
+    }
+    /**
+     * Asynchronous generator that yields keys from the store. If a prefix is
+     * provided, it only yields keys that start with the prefix.
+     * @param prefix Optional prefix to filter keys.
+     * @returns AsyncGenerator that yields keys from the store.
+     */
+    async *yieldKeys(prefix) {
+        const keys = Object.keys(this.store);
+        for (const key of keys) {
+            if (prefix === undefined || key.startsWith(prefix)) {
+                yield key;
+            }
+        }
+    }
+}

package/dist/structured_query/base.cjs

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicTranslator = exports.BaseTranslator = void 0;
+const ir_js_1 = require("./ir.cjs");
+const utils_js_1 = require("./utils.cjs");
+/**
+ * Abstract class that provides a blueprint for creating specific
+ * translator classes. Defines two abstract methods: formatFunction and
+ * mergeFilters.
+ */
+class BaseTranslator extends ir_js_1.Visitor {
+}
+exports.BaseTranslator = BaseTranslator;
+/**
+ * Class that extends the BaseTranslator class and provides concrete
+ * implementations for the abstract methods. Also declares three types:
+ * VisitOperationOutput, VisitComparisonOutput, and
+ * VisitStructuredQueryOutput, which are used as the return types for the
+ * visitOperation, visitComparison, and visitStructuredQuery methods
+ * respectively.
+ */
+class BasicTranslator extends BaseTranslator {
+    constructor(opts) {
+        super();
+        Object.defineProperty(this, "allowedOperators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "allowedComparators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.allowedOperators = opts?.allowedOperators ?? [
+            ir_js_1.Operators.and,
+            ir_js_1.Operators.or,
+        ];
+        this.allowedComparators = opts?.allowedComparators ?? [
+            ir_js_1.Comparators.eq,
+            ir_js_1.Comparators.ne,
+            ir_js_1.Comparators.gt,
+            ir_js_1.Comparators.gte,
+            ir_js_1.Comparators.lt,
+            ir_js_1.Comparators.lte,
+        ];
+    }
+    formatFunction(func) {
+        if (func in ir_js_1.Comparators) {
+            if (this.allowedComparators.length > 0 &&
+                this.allowedComparators.indexOf(func) === -1) {
+                throw new Error(`Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(", ")}`);
+            }
+        }
+        else if (func in ir_js_1.Operators) {
+            if (this.allowedOperators.length > 0 &&
+                this.allowedOperators.indexOf(func) === -1) {
+                throw new Error(`Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(", ")}`);
+            }
+        }
+        else {
+            throw new Error("Unknown comparator or operator");
+        }
+        return `$${func}`;
+    }
+    /**
+     * Visits an operation and returns a result.
+     * @param operation The operation to visit.
+     * @returns The result of visiting the operation.
+     */
+    visitOperation(operation) {
+        const args = operation.args?.map((arg) => arg.accept(this));
+        return {
+            [this.formatFunction(operation.operator)]: args,
+        };
+    }
+    /**
+     * Visits a comparison and returns a result.
+     * @param comparison The comparison to visit.
+     * @returns The result of visiting the comparison.
+     */
+    visitComparison(comparison) {
+        return {
+            [comparison.attribute]: {
+                [this.formatFunction(comparison.comparator)]: (0, utils_js_1.castValue)(comparison.value),
+            },
+        };
+    }
+    /**
+     * Visits a structured query and returns a result.
+     * @param query The structured query to visit.
+     * @returns The result of visiting the structured query.
+     */
+    visitStructuredQuery(query) {
+        let nextArg = {};
+        if (query.filter) {
+            nextArg = {
+                filter: query.filter.accept(this),
+            };
+        }
+        return nextArg;
+    }
+    mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
+        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) && (0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+            return undefined;
+        }
+        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) || mergeType === "replace") {
+            if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+                return undefined;
+            }
+            return generatedFilter;
+        }
+        if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+            if (forceDefaultFilter) {
+                return defaultFilter;
+            }
+            if (mergeType === "and") {
+                return undefined;
+            }
+            return defaultFilter;
+        }
+        if (mergeType === "and") {
+            return {
+                $and: [defaultFilter, generatedFilter],
+            };
+        }
+        else if (mergeType === "or") {
+            return {
+                $or: [defaultFilter, generatedFilter],
+            };
+        }
+        else {
+            throw new Error("Unknown merge type");
+        }
+    }
+}
+exports.BasicTranslator = BasicTranslator;

package/dist/structured_query/base.d.ts

@@ -0,0 +1,69 @@
+import { VectorStore } from "../vectorstores.js";
+import { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from "./ir.js";
+/**
+ * Options object for the BasicTranslator class. Specifies the allowed
+ * operators and comparators.
+ */
+export type TranslatorOpts = {
+    allowedOperators: Operator[];
+    allowedComparators: Comparator[];
+};
+/**
+ * Abstract class that provides a blueprint for creating specific
+ * translator classes. Defines two abstract methods: formatFunction and
+ * mergeFilters.
+ */
+export declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {
+    /**
+     * Formats a given function (either an operator or a comparator) into a
+     * string.
+     * @param func The function to format.
+     * @returns Formatted string representation of the function.
+     */
+    abstract formatFunction(func: Operator | Comparator): string;
+    /**
+     * Merges two filters into one, using a specified merge type.
+     * @param defaultFilter The default filter.
+     * @param generatedFilter The generated filter.
+     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.
+     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.
+     * @returns The merged filter, or undefined if both filters are empty.
+     */
+    abstract mergeFilters(defaultFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, generatedFilter: this["VisitStructuredQueryOutput"]["filter"] | undefined, mergeType?: "and" | "or" | "replace", forceDefaultFilter?: boolean): this["VisitStructuredQueryOutput"]["filter"] | undefined;
+}
+/**
+ * Class that extends the BaseTranslator class and provides concrete
+ * implementations for the abstract methods. Also declares three types:
+ * VisitOperationOutput, VisitComparisonOutput, and
+ * VisitStructuredQueryOutput, which are used as the return types for the
+ * visitOperation, visitComparison, and visitStructuredQuery methods
+ * respectively.
+ */
+export declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {
+    VisitOperationOutput: VisitorOperationResult;
+    VisitComparisonOutput: VisitorComparisonResult;
+    VisitStructuredQueryOutput: VisitorStructuredQueryResult;
+    allowedOperators: Operator[];
+    allowedComparators: Comparator[];
+    constructor(opts?: TranslatorOpts);
+    formatFunction(func: Operator | Comparator): string;
+    /**
+     * Visits an operation and returns a result.
+     * @param operation The operation to visit.
+     * @returns The result of visiting the operation.
+     */
+    visitOperation(operation: Operation): this["VisitOperationOutput"];
+    /**
+     * Visits a comparison and returns a result.
+     * @param comparison The comparison to visit.
+     * @returns The result of visiting the comparison.
+     */
+    visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+    /**
+     * Visits a structured query and returns a result.
+     * @param query The structured query to visit.
+     * @returns The result of visiting the structured query.
+     */
+    visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
+    mergeFilters(defaultFilter: VisitorStructuredQueryResult["filter"] | undefined, generatedFilter: VisitorStructuredQueryResult["filter"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult["filter"] | undefined;
+}