langchain 0.3.31 → 1.0.0-alpha.1

package/dist/memory/buffer_window_memory.js

@@ -1,94 +1,76 @@
-import { getBufferString } from "@langchain/core/messages";
 import { BaseChatMemory } from "./chat_memory.js";
+import { getBufferString } from "@langchain/core/messages";
+
+//#region src/memory/buffer_window_memory.ts
 /**
- * Class for managing and storing previous chat messages. It extends the
- * BaseChatMemory class and implements the BufferWindowMemoryInput
- * interface. This class is stateful and stores messages in a buffer. When
- * called in a chain, it returns all of the messages it has stored.
- * @example
- * ```typescript
- * const prompt =
- *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
- * Current conversation:
- * {chat_history}
- * Human: {input}
- * AI:`);
- *
- * const chain = new LLMChain({
- *   llm: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.9 }),
- *   prompt,
- *   memory: new BufferWindowMemory({ memoryKey: "chat_history", k: 1 }),
- * });
- *
- * // Example of initiating a conversation with the AI
- * const res1 = await chain.call({ input: "Hi! I'm Jim." });
- * console.log({ res1 });
- *
- * // Example of following up with another question
- * const res2 = await chain.call({ input: "What's my name?" });
- * console.log({ res2 });
- * ```
- */
-export class BufferWindowMemory extends BaseChatMemory {
-    constructor(fields) {
-        super({
-            returnMessages: fields?.returnMessages ?? false,
-            chatHistory: fields?.chatHistory,
-            inputKey: fields?.inputKey,
-            outputKey: fields?.outputKey,
-        });
-        Object.defineProperty(this, "humanPrefix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "Human"
-        });
-        Object.defineProperty(this, "aiPrefix", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "AI"
-        });
-        Object.defineProperty(this, "memoryKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "history"
-        });
-        Object.defineProperty(this, "k", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 5
-        });
-        this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;
-        this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;
-        this.memoryKey = fields?.memoryKey ?? this.memoryKey;
-        this.k = fields?.k ?? this.k;
-    }
-    get memoryKeys() {
-        return [this.memoryKey];
-    }
-    /**
-     * Method to load the memory variables. Retrieves the chat messages from
-     * the history, slices the last 'k' messages, and stores them in the
-     * memory under the memoryKey. If the returnMessages property is set to
-     * true, the method returns the messages as they are. Otherwise, it
-     * returns a string representation of the messages.
-     * @param _values InputValues object.
-     * @returns Promise that resolves to a MemoryVariables object.
-     */
-    async loadMemoryVariables(_values) {
-        const messages = await this.chatHistory.getMessages();
-        if (this.returnMessages) {
-            const result = {
-                [this.memoryKey]: messages.slice(-this.k * 2),
-            };
-            return result;
-        }
-        const result = {
-            [this.memoryKey]: getBufferString(messages.slice(-this.k * 2), this.humanPrefix, this.aiPrefix),
-        };
-        return result;
-    }
-}
+* Class for managing and storing previous chat messages. It extends the
+* BaseChatMemory class and implements the BufferWindowMemoryInput
+* interface. This class is stateful and stores messages in a buffer. When
+* called in a chain, it returns all of the messages it has stored.
+* @example
+* ```typescript
+* const prompt =
+*   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+* Current conversation:
+* {chat_history}
+* Human: {input}
+* AI:`);
+*
+* const chain = new LLMChain({
+*   llm: new ChatOpenAI({ model: "gpt-4o-mini", temperature: 0.9 }),
+*   prompt,
+*   memory: new BufferWindowMemory({ memoryKey: "chat_history", k: 1 }),
+* });
+*
+* // Example of initiating a conversation with the AI
+* const res1 = await chain.call({ input: "Hi! I'm Jim." });
+* console.log({ res1 });
+*
+* // Example of following up with another question
+* const res2 = await chain.call({ input: "What's my name?" });
+* console.log({ res2 });
+* ```
+*/
+var BufferWindowMemory = class extends BaseChatMemory {
+	humanPrefix = "Human";
+	aiPrefix = "AI";
+	memoryKey = "history";
+	k = 5;
+	constructor(fields) {
+		super({
+			returnMessages: fields?.returnMessages ?? false,
+			chatHistory: fields?.chatHistory,
+			inputKey: fields?.inputKey,
+			outputKey: fields?.outputKey
+		});
+		this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;
+		this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;
+		this.memoryKey = fields?.memoryKey ?? this.memoryKey;
+		this.k = fields?.k ?? this.k;
+	}
+	get memoryKeys() {
+		return [this.memoryKey];
+	}
+	/**
+	* Method to load the memory variables. Retrieves the chat messages from
+	* the history, slices the last 'k' messages, and stores them in the
+	* memory under the memoryKey. If the returnMessages property is set to
+	* true, the method returns the messages as they are. Otherwise, it
+	* returns a string representation of the messages.
+	* @param _values InputValues object.
+	* @returns Promise that resolves to a MemoryVariables object.
+	*/
+	async loadMemoryVariables(_values) {
+		const messages = await this.chatHistory.getMessages();
+		if (this.returnMessages) {
+			const result$1 = { [this.memoryKey]: messages.slice(-this.k * 2) };
+			return result$1;
+		}
+		const result = { [this.memoryKey]: getBufferString(messages.slice(-this.k * 2), this.humanPrefix, this.aiPrefix) };
+		return result;
+	}
+};
+
+//#endregion
+export { BufferWindowMemory };
+//# sourceMappingURL=buffer_window_memory.js.map

package/dist/memory/buffer_window_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_window_memory.js","names":["fields?: BufferWindowMemoryInput","_values: InputValues","result"],"sources":["../../src/memory/buffer_window_memory.ts"],"sourcesContent":["import { InputValues, MemoryVariables } from \"@langchain/core/memory\";\nimport { getBufferString } from \"@langchain/core/messages\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters of the BufferWindowMemory class.\n */\nexport interface BufferWindowMemoryInput extends BaseChatMemoryInput {\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n  k?: number;\n}\n\n/**\n * Class for managing and storing previous chat messages. It extends the\n * BaseChatMemory class and implements the BufferWindowMemoryInput\n * interface. This class is stateful and stores messages in a buffer. When\n * called in a chain, it returns all of the messages it has stored.\n * @example\n * ```typescript\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n *\n * const chain = new LLMChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 }),\n *   prompt,\n *   memory: new BufferWindowMemory({ memoryKey: \"chat_history\", k: 1 }),\n * });\n *\n * // Example of initiating a conversation with the AI\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1 });\n *\n * // Example of following up with another question\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2 });\n * ```\n */\nexport class BufferWindowMemory\n  extends BaseChatMemory\n  implements BufferWindowMemoryInput\n{\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  k = 5;\n\n  constructor(fields?: BufferWindowMemoryInput) {\n    super({\n      returnMessages: fields?.returnMessages ?? false,\n      chatHistory: fields?.chatHistory,\n      inputKey: fields?.inputKey,\n      outputKey: fields?.outputKey,\n    });\n    this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.k = fields?.k ?? this.k;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method to load the memory variables. Retrieves the chat messages from\n   * the history, slices the last 'k' messages, and stores them in the\n   * memory under the memoryKey. If the returnMessages property is set to\n   * true, the method returns the messages as they are. Otherwise, it\n   * returns a string representation of the messages.\n   * @param _values InputValues object.\n   * @returns Promise that resolves to a MemoryVariables object.\n   */\n  async loadMemoryVariables(_values: InputValues): Promise<MemoryVariables> {\n    const messages = await this.chatHistory.getMessages();\n    if (this.returnMessages) {\n      const result = {\n        [this.memoryKey]: messages.slice(-this.k * 2),\n      };\n      return result;\n    }\n    const result = {\n      [this.memoryKey]: getBufferString(\n        messages.slice(-this.k * 2),\n        this.humanPrefix,\n        this.aiPrefix\n      ),\n    };\n    return result;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,qBAAb,cACU,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,IAAI;CAEJ,YAAYA,QAAkC;EAC5C,MAAM;GACJ,gBAAgB,QAAQ,kBAAkB;GAC1C,aAAa,QAAQ;GACrB,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACpB,EAAC;EACF,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,IAAI,QAAQ,KAAK,KAAK;CAC5B;CAED,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,SAAU;CACxB;;;;;;;;;;CAWD,MAAM,oBAAoBC,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,gBAAgB;GACvB,MAAMC,WAAS,GACZ,KAAK,YAAY,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,CAC9C;AACD,UAAOA;EACR;EACD,MAAM,SAAS,GACZ,KAAK,YAAY,gBAChB,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAC3B,KAAK,aACL,KAAK,SACN,CACF;AACD,SAAO;CACR;AACF"}

package/dist/memory/chat_memory.cjs

@@ -1,63 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseChatMemory = void 0;
-const memory_1 = require("@langchain/core/memory");
-const in_memory_js_1 = require("../stores/message/in_memory.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const __langchain_core_chat_history = require_rolldown_runtime.__toESM(require("@langchain/core/chat_history"));
+const __langchain_core_memory = require_rolldown_runtime.__toESM(require("@langchain/core/memory"));
+
+//#region src/memory/chat_memory.ts
+var chat_memory_exports = {};
+require_rolldown_runtime.__export(chat_memory_exports, { BaseChatMemory: () => BaseChatMemory });
 /**
- * Abstract class that provides a base for implementing different types of
- * memory systems. It is designed to maintain the state of an application,
- * specifically the history of a conversation. This class is typically
- * extended by other classes to create specific types of memory systems.
- */
-class BaseChatMemory extends memory_1.BaseMemory {
-    constructor(fields) {
-        super();
-        Object.defineProperty(this, "chatHistory", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "returnMessages", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "inputKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "outputKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.chatHistory = fields?.chatHistory ?? new in_memory_js_1.ChatMessageHistory();
-        this.returnMessages = fields?.returnMessages ?? this.returnMessages;
-        this.inputKey = fields?.inputKey ?? this.inputKey;
-        this.outputKey = fields?.outputKey ?? this.outputKey;
-    }
-    /**
-     * Method to add user and AI messages to the chat history in sequence.
-     * @param inputValues The input values from the user.
-     * @param outputValues The output values from the AI.
-     * @returns Promise that resolves when the context has been saved.
-     */
-    async saveContext(inputValues, outputValues) {
-        // this is purposefully done in sequence so they're saved in order
-        await this.chatHistory.addUserMessage((0, memory_1.getInputValue)(inputValues, this.inputKey));
-        await this.chatHistory.addAIChatMessage((0, memory_1.getOutputValue)(outputValues, this.outputKey));
-    }
-    /**
-     * Method to clear the chat history.
-     * @returns Promise that resolves when the chat history has been cleared.
-     */
-    async clear() {
-        await this.chatHistory.clear();
-    }
-}
+* Abstract class that provides a base for implementing different types of
+* memory systems. It is designed to maintain the state of an application,
+* specifically the history of a conversation. This class is typically
+* extended by other classes to create specific types of memory systems.
+*/
+var BaseChatMemory = class extends __langchain_core_memory.BaseMemory {
+	chatHistory;
+	returnMessages = false;
+	inputKey;
+	outputKey;
+	constructor(fields) {
+		super();
+		this.chatHistory = fields?.chatHistory ?? new __langchain_core_chat_history.InMemoryChatMessageHistory();
+		this.returnMessages = fields?.returnMessages ?? this.returnMessages;
+		this.inputKey = fields?.inputKey ?? this.inputKey;
+		this.outputKey = fields?.outputKey ?? this.outputKey;
+	}
+	/**
+	* Method to add user and AI messages to the chat history in sequence.
+	* @param inputValues The input values from the user.
+	* @param outputValues The output values from the AI.
+	* @returns Promise that resolves when the context has been saved.
+	*/
+	async saveContext(inputValues, outputValues) {
+		await this.chatHistory.addUserMessage((0, __langchain_core_memory.getInputValue)(inputValues, this.inputKey));
+		await this.chatHistory.addAIChatMessage((0, __langchain_core_memory.getOutputValue)(outputValues, this.outputKey));
+	}
+	/**
+	* Method to clear the chat history.
+	* @returns Promise that resolves when the chat history has been cleared.
+	*/
+	async clear() {
+		await this.chatHistory.clear();
+	}
+};
+
+//#endregion
 exports.BaseChatMemory = BaseChatMemory;
+Object.defineProperty(exports, 'chat_memory_exports', {
+  enumerable: true,
+  get: function () {
+    return chat_memory_exports;
+  }
+});
+//# sourceMappingURL=chat_memory.cjs.map

package/dist/memory/chat_memory.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_memory.cjs","names":["BaseMemory","fields?: BaseChatMemoryInput","ChatMessageHistory","inputValues: InputValues","outputValues: OutputValues"],"sources":["../../src/memory/chat_memory.ts"],"sourcesContent":["import {\n  BaseChatMessageHistory,\n  InMemoryChatMessageHistory as ChatMessageHistory,\n} from \"@langchain/core/chat_history\";\nimport {\n  BaseMemory,\n  InputValues,\n  OutputValues,\n  getInputValue,\n  getOutputValue,\n} from \"@langchain/core/memory\";\n\n/**\n * Interface for the input parameters of the BaseChatMemory class.\n */\nexport interface BaseChatMemoryInput {\n  chatHistory?: BaseChatMessageHistory;\n  returnMessages?: boolean;\n  inputKey?: string;\n  outputKey?: string;\n}\n\n/**\n * Abstract class that provides a base for implementing different types of\n * memory systems. It is designed to maintain the state of an application,\n * specifically the history of a conversation. This class is typically\n * extended by other classes to create specific types of memory systems.\n */\nexport abstract class BaseChatMemory extends BaseMemory {\n  chatHistory: BaseChatMessageHistory;\n\n  returnMessages = false;\n\n  inputKey?: string;\n\n  outputKey?: string;\n\n  constructor(fields?: BaseChatMemoryInput) {\n    super();\n    this.chatHistory = fields?.chatHistory ?? new ChatMessageHistory();\n    this.returnMessages = fields?.returnMessages ?? this.returnMessages;\n    this.inputKey = fields?.inputKey ?? this.inputKey;\n    this.outputKey = fields?.outputKey ?? this.outputKey;\n  }\n\n  /**\n   * Method to add user and AI messages to the chat history in sequence.\n   * @param inputValues The input values from the user.\n   * @param outputValues The output values from the AI.\n   * @returns Promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    // this is purposefully done in sequence so they're saved in order\n    await this.chatHistory.addUserMessage(\n      getInputValue(inputValues, this.inputKey)\n    );\n    await this.chatHistory.addAIChatMessage(\n      getOutputValue(outputValues, this.outputKey)\n    );\n  }\n\n  /**\n   * Method to clear the chat history.\n   * @returns Promise that resolves when the chat history has been cleared.\n   */\n  async clear(): Promise<void> {\n    await this.chatHistory.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA4BA,IAAsB,iBAAtB,cAA6CA,mCAAW;CACtD;CAEA,iBAAiB;CAEjB;CAEA;CAEA,YAAYC,QAA8B;EACxC,OAAO;EACP,KAAK,cAAc,QAAQ,eAAe,IAAIC;EAC9C,KAAK,iBAAiB,QAAQ,kBAAkB,KAAK;EACrD,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;CAC5C;;;;;;;CAQD,MAAM,YACJC,aACAC,cACe;EAEf,MAAM,KAAK,YAAY,0DACP,aAAa,KAAK,SAAS,CAC1C;EACD,MAAM,KAAK,YAAY,6DACN,cAAc,KAAK,UAAU,CAC7C;CACF;;;;;CAMD,MAAM,QAAuB;EAC3B,MAAM,KAAK,YAAY,OAAO;CAC/B;AACF"}

package/dist/memory/chat_memory.d.cts

@@ -0,0 +1,42 @@
+import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+import { BaseChatMessageHistory } from "@langchain/core/chat_history";
+
+//#region src/memory/chat_memory.d.ts
+
+/**
+ * Interface for the input parameters of the BaseChatMemory class.
+ */
+interface BaseChatMemoryInput {
+  chatHistory?: BaseChatMessageHistory;
+  returnMessages?: boolean;
+  inputKey?: string;
+  outputKey?: string;
+}
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
+declare abstract class BaseChatMemory extends BaseMemory {
+  chatHistory: BaseChatMessageHistory;
+  returnMessages: boolean;
+  inputKey?: string;
+  outputKey?: string;
+  constructor(fields?: BaseChatMemoryInput);
+  /**
+   * Method to add user and AI messages to the chat history in sequence.
+   * @param inputValues The input values from the user.
+   * @param outputValues The output values from the AI.
+   * @returns Promise that resolves when the context has been saved.
+   */
+  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+  /**
+   * Method to clear the chat history.
+   * @returns Promise that resolves when the chat history has been cleared.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+export { BaseChatMemory, BaseChatMemoryInput };
+//# sourceMappingURL=chat_memory.d.cts.map

package/dist/memory/chat_memory.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_memory.d.cts","names":["BaseChatMessageHistory","BaseMemory","InputValues","OutputValues","BaseChatMemoryInput","BaseChatMemory","Promise"],"sources":["../../src/memory/chat_memory.d.ts"],"sourcesContent":["import { BaseChatMessageHistory } from \"@langchain/core/chat_history\";\nimport { BaseMemory, InputValues, OutputValues } from \"@langchain/core/memory\";\n/**\n * Interface for the input parameters of the BaseChatMemory class.\n */\nexport interface BaseChatMemoryInput {\n    chatHistory?: BaseChatMessageHistory;\n    returnMessages?: boolean;\n    inputKey?: string;\n    outputKey?: string;\n}\n/**\n * Abstract class that provides a base for implementing different types of\n * memory systems. It is designed to maintain the state of an application,\n * specifically the history of a conversation. This class is typically\n * extended by other classes to create specific types of memory systems.\n */\nexport declare abstract class BaseChatMemory extends BaseMemory {\n    chatHistory: BaseChatMessageHistory;\n    returnMessages: boolean;\n    inputKey?: string;\n    outputKey?: string;\n    constructor(fields?: BaseChatMemoryInput);\n    /**\n     * Method to add user and AI messages to the chat history in sequence.\n     * @param inputValues The input values from the user.\n     * @param outputValues The output values from the AI.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Method to clear the chat history.\n     * @returns Promise that resolves when the chat history has been cleared.\n     */\n    clear(): Promise<void>;\n}\n"],"mappings":";;;;;;;AAKA;AAY8BK,UAZbD,mBAAAA,CAY2B;EAAA,WAAA,CAAA,EAX1BJ,sBAW0B;EAAA,cAC3BA,CAAAA,EAAAA,OAAAA;EAAsB,QAIdI,CAAAA,EAAAA,MAAAA;EAAmB,SAOfF,CAAAA,EAAAA,MAAAA;;;;;AAZkC;;;uBAAjCG,cAAAA,SAAuBJ,UAAAA;eACpCD;;;;uBAIQI;;;;;;;2BAOIF,2BAA2BC,eAAeG;;;;;WAK1DA"}

package/dist/memory/chat_memory.d.ts

@@ -1,13 +1,16 @@
 import { BaseChatMessageHistory } from "@langchain/core/chat_history";
 import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+
+//#region src/memory/chat_memory.d.ts
+
 /**
  * Interface for the input parameters of the BaseChatMemory class.
  */
-export interface BaseChatMemoryInput {
-    chatHistory?: BaseChatMessageHistory;
-    returnMessages?: boolean;
-    inputKey?: string;
-    outputKey?: string;
+interface BaseChatMemoryInput {
+  chatHistory?: BaseChatMessageHistory;
+  returnMessages?: boolean;
+  inputKey?: string;
+  outputKey?: string;
 }
 /**
  * Abstract class that provides a base for implementing different types of
@@ -15,22 +18,25 @@ export interface BaseChatMemoryInput {
  * specifically the history of a conversation. This class is typically
  * extended by other classes to create specific types of memory systems.
  */
-export declare abstract class BaseChatMemory extends BaseMemory {
-    chatHistory: BaseChatMessageHistory;
-    returnMessages: boolean;
-    inputKey?: string;
-    outputKey?: string;
-    constructor(fields?: BaseChatMemoryInput);
-    /**
-     * Method to add user and AI messages to the chat history in sequence.
-     * @param inputValues The input values from the user.
-     * @param outputValues The output values from the AI.
-     * @returns Promise that resolves when the context has been saved.
-     */
-    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-    /**
-     * Method to clear the chat history.
-     * @returns Promise that resolves when the chat history has been cleared.
-     */
-    clear(): Promise<void>;
+declare abstract class BaseChatMemory extends BaseMemory {
+  chatHistory: BaseChatMessageHistory;
+  returnMessages: boolean;
+  inputKey?: string;
+  outputKey?: string;
+  constructor(fields?: BaseChatMemoryInput);
+  /**
+   * Method to add user and AI messages to the chat history in sequence.
+   * @param inputValues The input values from the user.
+   * @param outputValues The output values from the AI.
+   * @returns Promise that resolves when the context has been saved.
+   */
+  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+  /**
+   * Method to clear the chat history.
+   * @returns Promise that resolves when the chat history has been cleared.
+   */
+  clear(): Promise<void>;
 }
+//#endregion
+export { BaseChatMemory, BaseChatMemoryInput };
+//# sourceMappingURL=chat_memory.d.ts.map

package/dist/memory/chat_memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_memory.d.ts","names":["BaseChatMessageHistory","BaseMemory","InputValues","OutputValues","BaseChatMemoryInput","BaseChatMemory","Promise"],"sources":["../../src/memory/chat_memory.d.ts"],"sourcesContent":["import { BaseChatMessageHistory } from \"@langchain/core/chat_history\";\nimport { BaseMemory, InputValues, OutputValues } from \"@langchain/core/memory\";\n/**\n * Interface for the input parameters of the BaseChatMemory class.\n */\nexport interface BaseChatMemoryInput {\n    chatHistory?: BaseChatMessageHistory;\n    returnMessages?: boolean;\n    inputKey?: string;\n    outputKey?: string;\n}\n/**\n * Abstract class that provides a base for implementing different types of\n * memory systems. It is designed to maintain the state of an application,\n * specifically the history of a conversation. This class is typically\n * extended by other classes to create specific types of memory systems.\n */\nexport declare abstract class BaseChatMemory extends BaseMemory {\n    chatHistory: BaseChatMessageHistory;\n    returnMessages: boolean;\n    inputKey?: string;\n    outputKey?: string;\n    constructor(fields?: BaseChatMemoryInput);\n    /**\n     * Method to add user and AI messages to the chat history in sequence.\n     * @param inputValues The input values from the user.\n     * @param outputValues The output values from the AI.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Method to clear the chat history.\n     * @returns Promise that resolves when the chat history has been cleared.\n     */\n    clear(): Promise<void>;\n}\n"],"mappings":";;;;;;;AAKA;AAY8BK,UAZbD,mBAAAA,CAY2B;EAAA,WAAA,CAAA,EAX1BJ,sBAW0B;EAAA,cAC3BA,CAAAA,EAAAA,OAAAA;EAAsB,QAIdI,CAAAA,EAAAA,MAAAA;EAAmB,SAOfF,CAAAA,EAAAA,MAAAA;;;;;AAZkC;;;uBAAjCG,cAAAA,SAAuBJ,UAAAA;eACpCD;;;;uBAIQI;;;;;;;2BAOIF,2BAA2BC,eAAeG;;;;;WAK1DA"}

package/dist/memory/chat_memory.js

@@ -1,59 +1,47 @@
-import { BaseMemory, getInputValue, getOutputValue, } from "@langchain/core/memory";
-import { ChatMessageHistory } from "../stores/message/in_memory.js";
+import { __export } from "../_virtual/rolldown_runtime.js";
+import { InMemoryChatMessageHistory } from "@langchain/core/chat_history";
+import { BaseMemory, getInputValue, getOutputValue } from "@langchain/core/memory";
+
+//#region src/memory/chat_memory.ts
+var chat_memory_exports = {};
+__export(chat_memory_exports, { BaseChatMemory: () => BaseChatMemory });
 /**
- * Abstract class that provides a base for implementing different types of
- * memory systems. It is designed to maintain the state of an application,
- * specifically the history of a conversation. This class is typically
- * extended by other classes to create specific types of memory systems.
- */
-export class BaseChatMemory extends BaseMemory {
-    constructor(fields) {
-        super();
-        Object.defineProperty(this, "chatHistory", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "returnMessages", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "inputKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "outputKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.chatHistory = fields?.chatHistory ?? new ChatMessageHistory();
-        this.returnMessages = fields?.returnMessages ?? this.returnMessages;
-        this.inputKey = fields?.inputKey ?? this.inputKey;
-        this.outputKey = fields?.outputKey ?? this.outputKey;
-    }
-    /**
-     * Method to add user and AI messages to the chat history in sequence.
-     * @param inputValues The input values from the user.
-     * @param outputValues The output values from the AI.
-     * @returns Promise that resolves when the context has been saved.
-     */
-    async saveContext(inputValues, outputValues) {
-        // this is purposefully done in sequence so they're saved in order
-        await this.chatHistory.addUserMessage(getInputValue(inputValues, this.inputKey));
-        await this.chatHistory.addAIChatMessage(getOutputValue(outputValues, this.outputKey));
-    }
-    /**
-     * Method to clear the chat history.
-     * @returns Promise that resolves when the chat history has been cleared.
-     */
-    async clear() {
-        await this.chatHistory.clear();
-    }
-}
+* Abstract class that provides a base for implementing different types of
+* memory systems. It is designed to maintain the state of an application,
+* specifically the history of a conversation. This class is typically
+* extended by other classes to create specific types of memory systems.
+*/
+var BaseChatMemory = class extends BaseMemory {
+	chatHistory;
+	returnMessages = false;
+	inputKey;
+	outputKey;
+	constructor(fields) {
+		super();
+		this.chatHistory = fields?.chatHistory ?? new InMemoryChatMessageHistory();
+		this.returnMessages = fields?.returnMessages ?? this.returnMessages;
+		this.inputKey = fields?.inputKey ?? this.inputKey;
+		this.outputKey = fields?.outputKey ?? this.outputKey;
+	}
+	/**
+	* Method to add user and AI messages to the chat history in sequence.
+	* @param inputValues The input values from the user.
+	* @param outputValues The output values from the AI.
+	* @returns Promise that resolves when the context has been saved.
+	*/
+	async saveContext(inputValues, outputValues) {
+		await this.chatHistory.addUserMessage(getInputValue(inputValues, this.inputKey));
+		await this.chatHistory.addAIChatMessage(getOutputValue(outputValues, this.outputKey));
+	}
+	/**
+	* Method to clear the chat history.
+	* @returns Promise that resolves when the chat history has been cleared.
+	*/
+	async clear() {
+		await this.chatHistory.clear();
+	}
+};
+
+//#endregion
+export { BaseChatMemory, chat_memory_exports };
+//# sourceMappingURL=chat_memory.js.map

package/dist/memory/chat_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat_memory.js","names":["fields?: BaseChatMemoryInput","ChatMessageHistory","inputValues: InputValues","outputValues: OutputValues"],"sources":["../../src/memory/chat_memory.ts"],"sourcesContent":["import {\n  BaseChatMessageHistory,\n  InMemoryChatMessageHistory as ChatMessageHistory,\n} from \"@langchain/core/chat_history\";\nimport {\n  BaseMemory,\n  InputValues,\n  OutputValues,\n  getInputValue,\n  getOutputValue,\n} from \"@langchain/core/memory\";\n\n/**\n * Interface for the input parameters of the BaseChatMemory class.\n */\nexport interface BaseChatMemoryInput {\n  chatHistory?: BaseChatMessageHistory;\n  returnMessages?: boolean;\n  inputKey?: string;\n  outputKey?: string;\n}\n\n/**\n * Abstract class that provides a base for implementing different types of\n * memory systems. It is designed to maintain the state of an application,\n * specifically the history of a conversation. This class is typically\n * extended by other classes to create specific types of memory systems.\n */\nexport abstract class BaseChatMemory extends BaseMemory {\n  chatHistory: BaseChatMessageHistory;\n\n  returnMessages = false;\n\n  inputKey?: string;\n\n  outputKey?: string;\n\n  constructor(fields?: BaseChatMemoryInput) {\n    super();\n    this.chatHistory = fields?.chatHistory ?? new ChatMessageHistory();\n    this.returnMessages = fields?.returnMessages ?? this.returnMessages;\n    this.inputKey = fields?.inputKey ?? this.inputKey;\n    this.outputKey = fields?.outputKey ?? this.outputKey;\n  }\n\n  /**\n   * Method to add user and AI messages to the chat history in sequence.\n   * @param inputValues The input values from the user.\n   * @param outputValues The output values from the AI.\n   * @returns Promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    // this is purposefully done in sequence so they're saved in order\n    await this.chatHistory.addUserMessage(\n      getInputValue(inputValues, this.inputKey)\n    );\n    await this.chatHistory.addAIChatMessage(\n      getOutputValue(outputValues, this.outputKey)\n    );\n  }\n\n  /**\n   * Method to clear the chat history.\n   * @returns Promise that resolves when the chat history has been cleared.\n   */\n  async clear(): Promise<void> {\n    await this.chatHistory.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA4BA,IAAsB,iBAAtB,cAA6C,WAAW;CACtD;CAEA,iBAAiB;CAEjB;CAEA;CAEA,YAAYA,QAA8B;EACxC,OAAO;EACP,KAAK,cAAc,QAAQ,eAAe,IAAIC;EAC9C,KAAK,iBAAiB,QAAQ,kBAAkB,KAAK;EACrD,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;CAC5C;;;;;;;CAQD,MAAM,YACJC,aACAC,cACe;EAEf,MAAM,KAAK,YAAY,eACrB,cAAc,aAAa,KAAK,SAAS,CAC1C;EACD,MAAM,KAAK,YAAY,iBACrB,eAAe,cAAc,KAAK,UAAU,CAC7C;CACF;;;;;CAMD,MAAM,QAAuB;EAC3B,MAAM,KAAK,YAAY,OAAO;CAC/B;AACF"}