@langchain/core 0.1.58 → 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/output_parsers/structured.cjs

@@ -77,7 +77,13 @@ ${JSON.stringify((0, zod_to_json_schema_1.zodToJsonSchema)(this.schema))}
             const json = text.includes("```")
                 ? text.trim().split(/```(?:json)?/)[1]
                 : text.trim();
-            return await this.schema.parseAsync(JSON.parse(json));
+            const escapedJson = json
+                .replace(/"([^"\\]*(\\.[^"\\]*)*)"/g, (_match, capturedGroup) => {
+                const escapedInsideQuotes = capturedGroup.replace(/\n/g, "\\n");
+                return `"${escapedInsideQuotes}"`;
+            })
+                .replace(/\n/g, "");
+            return await this.schema.parseAsync(JSON.parse(escapedJson));
         }
         catch (e) {
             throw new base_js_1.OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);

package/dist/output_parsers/structured.js

@@ -74,7 +74,13 @@ ${JSON.stringify(zodToJsonSchema(this.schema))}
             const json = text.includes("```")
                 ? text.trim().split(/```(?:json)?/)[1]
                 : text.trim();
-            return await this.schema.parseAsync(JSON.parse(json));
+            const escapedJson = json
+                .replace(/"([^"\\]*(\\.[^"\\]*)*)"/g, (_match, capturedGroup) => {
+                const escapedInsideQuotes = capturedGroup.replace(/\n/g, "\\n");
+                return `"${escapedInsideQuotes}"`;
+            })
+                .replace(/\n/g, "");
+            return await this.schema.parseAsync(JSON.parse(escapedJson));
         }
         catch (e) {
             throw new OutputParserException(`Failed to parse. Text: "${text}". Error: ${e}`, text);

package/dist/runnables/base.cjs

@@ -927,7 +927,8 @@ class RunnableRetry extends RunnableBinding {
     }
     async _invoke(input, config, runManager) {
         return (0, p_retry_1.default)((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
-            onFailedAttempt: this.onFailedAttempt,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onFailedAttempt: (error) => this.onFailedAttempt(error, input),
             retries: Math.max(this.maxAttemptNumber - 1, 0),
             randomize: true,
         });
@@ -968,6 +969,8 @@ class RunnableRetry extends RunnableBinding {
                     if (result instanceof Error) {
                         if (firstException === undefined) {
                             firstException = result;
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            firstException.input = remainingInputs[i];
                         }
                     }
                     resultsMap[resultMapIndex.toString()] = result;
@@ -977,7 +980,8 @@ class RunnableRetry extends RunnableBinding {
                 }
                 return results;
             }, {
-                onFailedAttempt: this.onFailedAttempt,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                onFailedAttempt: (error) => this.onFailedAttempt(error, error.input),
                 retries: Math.max(this.maxAttemptNumber - 1, 0),
                 randomize: true,
             });

package/dist/runnables/base.d.ts

@@ -16,7 +16,7 @@ export type RunnableMapLike<RunInput, RunOutput> = {
     [K in keyof RunOutput]: RunnableLike<RunInput, RunOutput[K]>;
 };
 export type RunnableLike<RunInput = any, RunOutput = any> = RunnableInterface<RunInput, RunOutput> | RunnableFunc<RunInput, RunOutput> | RunnableMapLike<RunInput, RunOutput>;
-export type RunnableRetryFailedAttemptHandler = (error: any) => any;
+export type RunnableRetryFailedAttemptHandler = (error: any, input: any) => any;
 export declare function _coerceToDict(value: any, defaultKey: string): any;
 /**
  * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
@@ -332,7 +332,7 @@ export declare class RunnableRetry<RunInput = any, RunOutput = any, CallOptions
     static lc_name(): string;
     lc_namespace: string[];
     protected maxAttemptNumber: number;
-    onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    onFailedAttempt: RunnableRetryFailedAttemptHandler;
     constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions> & {
         maxAttemptNumber?: number;
         onFailedAttempt?: RunnableRetryFailedAttemptHandler;

package/dist/runnables/base.js

@@ -917,7 +917,8 @@ export class RunnableRetry extends RunnableBinding {
     }
     async _invoke(input, config, runManager) {
         return pRetry((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
-            onFailedAttempt: this.onFailedAttempt,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onFailedAttempt: (error) => this.onFailedAttempt(error, input),
             retries: Math.max(this.maxAttemptNumber - 1, 0),
             randomize: true,
         });
@@ -958,6 +959,8 @@ export class RunnableRetry extends RunnableBinding {
                     if (result instanceof Error) {
                         if (firstException === undefined) {
                             firstException = result;
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            firstException.input = remainingInputs[i];
                         }
                     }
                     resultsMap[resultMapIndex.toString()] = result;
@@ -967,7 +970,8 @@ export class RunnableRetry extends RunnableBinding {
                 }
                 return results;
             }, {
-                onFailedAttempt: this.onFailedAttempt,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                onFailedAttempt: (error) => this.onFailedAttempt(error, error.input),
                 retries: Math.max(this.maxAttemptNumber - 1, 0),
                 randomize: true,
             });

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;