@langchain/classic 1.0.0-alpha.1

package/dist/memory/buffer_token_memory.d.ts

@@ -0,0 +1,67 @@
+import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
+
+//#region src/memory/buffer_token_memory.d.ts
+
+/**
+ * Interface for the input parameters of the `BufferTokenMemory` class.
+ */
+interface ConversationTokenBufferMemoryInput extends BaseChatMemoryInput {
+  /* Prefix for human messages in the buffer. */
+  humanPrefix?: string;
+  /* Prefix for AI messages in the buffer. */
+  aiPrefix?: string;
+  /* The LLM for this instance. */
+  llm: BaseLanguageModelInterface;
+  /* Memory key for buffer instance. */
+  memoryKey?: string;
+  /* Maximmum number of tokens allowed in the buffer. */
+  maxTokenLimit?: number;
+}
+/**
+ * Class that represents a conversation chat memory with a token buffer.
+ * It extends the `BaseChatMemory` class and implements the
+ * `ConversationTokenBufferMemoryInput` interface.
+ * @example
+ * ```typescript
+ * const memory = new ConversationTokenBufferMemory({
+ *   llm: new ChatOpenAI({ model: "gpt-4o-mini" }),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load memory variables
+ * const result = await memory.loadMemoryVariables({});
+ * console.log(result);
+ * ```
+ */
+declare class ConversationTokenBufferMemory extends BaseChatMemory implements ConversationTokenBufferMemoryInput {
+  humanPrefix: string;
+  aiPrefix: string;
+  memoryKey: string;
+  maxTokenLimit: number; // Default max token limit of 2000 which can be overridden
+  llm: BaseLanguageModelInterface;
+  constructor(fields: ConversationTokenBufferMemoryInput);
+  get memoryKeys(): string[];
+  /**
+   * Loads the memory variables. It takes an `InputValues` object as a
+   * parameter and returns a `Promise` that resolves with a
+   * `MemoryVariables` object.
+   * @param _values `InputValues` object.
+   * @returns A `Promise` that resolves with a `MemoryVariables` object.
+   */
+  loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;
+  /**
+   * Saves the context from this conversation to buffer. If the amount
+   * of tokens required to save the buffer exceeds MAX_TOKEN_LIMIT,
+   * prune it.
+   */
+  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+}
+//#endregion
+export { ConversationTokenBufferMemory, ConversationTokenBufferMemoryInput };
+//# sourceMappingURL=buffer_token_memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_token_memory.d.ts","names":["BaseLanguageModelInterface","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","ConversationTokenBufferMemoryInput","ConversationTokenBufferMemory","Promise"],"sources":["../../src/memory/buffer_token_memory.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface for the input parameters of the `BufferTokenMemory` class.\n */\nexport interface ConversationTokenBufferMemoryInput extends BaseChatMemoryInput {\n    /* Prefix for human messages in the buffer. */\n    humanPrefix?: string;\n    /* Prefix for AI messages in the buffer. */\n    aiPrefix?: string;\n    /* The LLM for this instance. */\n    llm: BaseLanguageModelInterface;\n    /* Memory key for buffer instance. */\n    memoryKey?: string;\n    /* Maximmum number of tokens allowed in the buffer. */\n    maxTokenLimit?: number;\n}\n/**\n * Class that represents a conversation chat memory with a token buffer.\n * It extends the `BaseChatMemory` class and implements the\n * `ConversationTokenBufferMemoryInput` interface.\n * @example\n * ```typescript\n * const memory = new ConversationTokenBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load memory variables\n * const result = await memory.loadMemoryVariables({});\n * console.log(result);\n * ```\n */\nexport declare class ConversationTokenBufferMemory extends BaseChatMemory implements ConversationTokenBufferMemoryInput {\n    humanPrefix: string;\n    aiPrefix: string;\n    memoryKey: string;\n    maxTokenLimit: number; // Default max token limit of 2000 which can be overridden\n    llm: BaseLanguageModelInterface;\n    constructor(fields: ConversationTokenBufferMemoryInput);\n    get memoryKeys(): string[];\n    /**\n     * Loads the memory variables. It takes an `InputValues` object as a\n     * parameter and returns a `Promise` that resolves with a\n     * `MemoryVariables` object.\n     * @param _values `InputValues` object.\n     * @returns A `Promise` that resolves with a `MemoryVariables` object.\n     */\n    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context from this conversation to buffer. If the amount\n     * of tokens required to save the buffer exceeds MAX_TOKEN_LIMIT,\n     * prune it.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n"],"mappings":";;;;;;;;AAMA;AAAmD,UAAlCM,kCAAAA,SAA2CD,mBAAT,CAAA;EAAA;EAMhB,WANyBA,CAAAA,EAAAA,MAAAA;EAAmB;EAgC1DE,QAAAA,CAAAA,EAAAA,MAAAA;EAA6B;EAAA,GAKzCP,EA/BAA,0BA+BAA;EAA0B;EACuB,SASzBC,CAAAA,EAAAA,MAAAA;EAAW;EAA0B,aAAvBO,CAAAA,EAAAA,MAAAA;;;;;;AAfwE;;;;;;;;;;;;;;;;cAAlGD,6BAAAA,SAAsCH,cAAAA,YAA0BE;;;;;OAK5EN;sBACeM;;;;;;;;;+BASSL,cAAcO,QAAQN;;;;;;2BAM1BD,2BAA2BE,eAAeK"}

package/dist/memory/buffer_token_memory.js

@@ -0,0 +1,79 @@
+import { BaseChatMemory } from "./chat_memory.js";
+import { getBufferString } from "@langchain/core/messages";
+
+//#region src/memory/buffer_token_memory.ts
+/**
+* Class that represents a conversation chat memory with a token buffer.
+* It extends the `BaseChatMemory` class and implements the
+* `ConversationTokenBufferMemoryInput` interface.
+* @example
+* ```typescript
+* const memory = new ConversationTokenBufferMemory({
+*   llm: new ChatOpenAI({ model: "gpt-4o-mini" }),
+*   maxTokenLimit: 10,
+* });
+*
+* // Save conversation context
+* await memory.saveContext({ input: "hi" }, { output: "whats up" });
+* await memory.saveContext({ input: "not much you" }, { output: "not much" });
+*
+* // Load memory variables
+* const result = await memory.loadMemoryVariables({});
+* console.log(result);
+* ```
+*/
+var ConversationTokenBufferMemory = class extends BaseChatMemory {
+	humanPrefix = "Human";
+	aiPrefix = "AI";
+	memoryKey = "history";
+	maxTokenLimit = 2e3;
+	llm;
+	constructor(fields) {
+		super(fields);
+		this.llm = fields.llm;
+		this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;
+		this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;
+		this.memoryKey = fields?.memoryKey ?? this.memoryKey;
+		this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;
+	}
+	get memoryKeys() {
+		return [this.memoryKey];
+	}
+	/**
+	* Loads the memory variables. It takes an `InputValues` object as a
+	* parameter and returns a `Promise` that resolves with a
+	* `MemoryVariables` object.
+	* @param _values `InputValues` object.
+	* @returns A `Promise` that resolves with a `MemoryVariables` object.
+	*/
+	async loadMemoryVariables(_values) {
+		const messages = await this.chatHistory.getMessages();
+		if (this.returnMessages) {
+			const result$1 = { [this.memoryKey]: messages };
+			return result$1;
+		}
+		const result = { [this.memoryKey]: getBufferString(messages, this.humanPrefix, this.aiPrefix) };
+		return result;
+	}
+	/**
+	* Saves the context from this conversation to buffer. If the amount
+	* of tokens required to save the buffer exceeds MAX_TOKEN_LIMIT,
+	* prune it.
+	*/
+	async saveContext(inputValues, outputValues) {
+		await super.saveContext(inputValues, outputValues);
+		const buffer = await this.chatHistory.getMessages();
+		let currBufferLength = await this.llm.getNumTokens(getBufferString(buffer, this.humanPrefix, this.aiPrefix));
+		if (currBufferLength > this.maxTokenLimit) {
+			const prunedMemory = [];
+			while (currBufferLength > this.maxTokenLimit) {
+				prunedMemory.push(buffer.shift());
+				currBufferLength = await this.llm.getNumTokens(getBufferString(buffer, this.humanPrefix, this.aiPrefix));
+			}
+		}
+	}
+};
+
+//#endregion
+export { ConversationTokenBufferMemory };
+//# sourceMappingURL=buffer_token_memory.js.map

package/dist/memory/buffer_token_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_token_memory.js","names":["fields: ConversationTokenBufferMemoryInput","_values: InputValues","result","inputValues: InputValues","outputValues: OutputValues"],"sources":["../../src/memory/buffer_token_memory.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} 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 `BufferTokenMemory` class.\n */\n\nexport interface ConversationTokenBufferMemoryInput\n  extends BaseChatMemoryInput {\n  /* Prefix for human messages in the buffer. */\n  humanPrefix?: string;\n\n  /* Prefix for AI messages in the buffer. */\n  aiPrefix?: string;\n\n  /* The LLM for this instance. */\n  llm: BaseLanguageModelInterface;\n\n  /* Memory key for buffer instance. */\n  memoryKey?: string;\n\n  /* Maximmum number of tokens allowed in the buffer. */\n  maxTokenLimit?: number;\n}\n\n/**\n * Class that represents a conversation chat memory with a token buffer.\n * It extends the `BaseChatMemory` class and implements the\n * `ConversationTokenBufferMemoryInput` interface.\n * @example\n * ```typescript\n * const memory = new ConversationTokenBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load memory variables\n * const result = await memory.loadMemoryVariables({});\n * console.log(result);\n * ```\n */\n\nexport class ConversationTokenBufferMemory\n  extends BaseChatMemory\n  implements ConversationTokenBufferMemoryInput\n{\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  maxTokenLimit = 2000; // Default max token limit of 2000 which can be overridden\n\n  llm: BaseLanguageModelInterface;\n\n  constructor(fields: ConversationTokenBufferMemoryInput) {\n    super(fields);\n    this.llm = fields.llm;\n    this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Loads the memory variables. It takes an `InputValues` object as a\n   * parameter and returns a `Promise` that resolves with a\n   * `MemoryVariables` object.\n   * @param _values `InputValues` object.\n   * @returns A `Promise` that resolves with 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,\n      };\n      return result;\n    }\n    const result = {\n      [this.memoryKey]: getBufferString(\n        messages,\n        this.humanPrefix,\n        this.aiPrefix\n      ),\n    };\n    return result;\n  }\n\n  /**\n   * Saves the context from this conversation to buffer. If the amount\n   * of tokens required to save the buffer exceeds MAX_TOKEN_LIMIT,\n   * prune it.\n   */\n  async saveContext(inputValues: InputValues, outputValues: OutputValues) {\n    await super.saveContext(inputValues, outputValues);\n\n    // Prune buffer if it exceeds the max token limit set for this instance.\n    const buffer = await this.chatHistory.getMessages();\n    let currBufferLength = await this.llm.getNumTokens(\n      getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n    );\n\n    if (currBufferLength > this.maxTokenLimit) {\n      const prunedMemory = [];\n      while (currBufferLength > this.maxTokenLimit) {\n        prunedMemory.push(buffer.shift());\n        currBufferLength = await this.llm.getNumTokens(\n          getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n        );\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoDA,IAAa,gCAAb,cACU,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,gBAAgB;CAEhB;CAEA,YAAYA,QAA4C;EACtD,MAAM,OAAO;EACb,KAAK,MAAM,OAAO;EAClB,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,gBAAgB,QAAQ,iBAAiB,KAAK;CACpD;CAED,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,SAAU;CACxB;;;;;;;;CASD,MAAM,oBAAoBC,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,gBAAgB;GACvB,MAAMC,WAAS,GACZ,KAAK,YAAY,SACnB;AACD,UAAOA;EACR;EACD,MAAM,SAAS,GACZ,KAAK,YAAY,gBAChB,UACA,KAAK,aACL,KAAK,SACN,CACF;AACD,SAAO;CACR;;;;;;CAOD,MAAM,YAAYC,aAA0BC,cAA4B;EACtE,MAAM,MAAM,YAAY,aAAa,aAAa;EAGlD,MAAM,SAAS,MAAM,KAAK,YAAY,aAAa;EACnD,IAAI,mBAAmB,MAAM,KAAK,IAAI,aACpC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;AAED,MAAI,mBAAmB,KAAK,eAAe;GACzC,MAAM,eAAe,CAAE;AACvB,UAAO,mBAAmB,KAAK,eAAe;IAC5C,aAAa,KAAK,OAAO,OAAO,CAAC;IACjC,mBAAmB,MAAM,KAAK,IAAI,aAChC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;GACF;EACF;CACF;AACF"}

package/dist/memory/buffer_window_memory.cjs

@@ -0,0 +1,77 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_memory_chat_memory = require('./chat_memory.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@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 });
+* ```
+*/
+var BufferWindowMemory = class extends require_memory_chat_memory.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]: (0, __langchain_core_messages.getBufferString)(messages.slice(-this.k * 2), this.humanPrefix, this.aiPrefix) };
+		return result;
+	}
+};
+
+//#endregion
+exports.BufferWindowMemory = BufferWindowMemory;
+//# sourceMappingURL=buffer_window_memory.cjs.map

package/dist/memory/buffer_window_memory.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_window_memory.cjs","names":["BaseChatMemory","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,cACUA,0CAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,IAAI;CAEJ,YAAYC,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,2DACJ,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAC3B,KAAK,aACL,KAAK,SACN,CACF;AACD,SAAO;CACR;AACF"}

package/dist/memory/buffer_window_memory.d.cts

@@ -0,0 +1,64 @@
+import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.cjs";
+import { InputValues, MemoryVariables } from "@langchain/core/memory";
+
+//#region src/memory/buffer_window_memory.d.ts
+
+/**
+ * Interface for the input parameters of the BufferWindowMemory class.
+ */
+interface BufferWindowMemoryInput extends BaseChatMemoryInput {
+  humanPrefix?: string;
+  aiPrefix?: string;
+  memoryKey?: string;
+  k?: number;
+}
+/**
+ * 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 });
+ * ```
+ */
+declare class BufferWindowMemory extends BaseChatMemory implements BufferWindowMemoryInput {
+  humanPrefix: string;
+  aiPrefix: string;
+  memoryKey: string;
+  k: number;
+  constructor(fields?: BufferWindowMemoryInput);
+  get memoryKeys(): string[];
+  /**
+   * 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.
+   */
+  loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;
+}
+//#endregion
+export { BufferWindowMemory, BufferWindowMemoryInput };
+//# sourceMappingURL=buffer_window_memory.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_window_memory.d.cts","names":["InputValues","MemoryVariables","BaseChatMemory","BaseChatMemoryInput","BufferWindowMemoryInput","BufferWindowMemory","Promise"],"sources":["../../src/memory/buffer_window_memory.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\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 * 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 declare class BufferWindowMemory extends BaseChatMemory implements BufferWindowMemoryInput {\n    humanPrefix: string;\n    aiPrefix: string;\n    memoryKey: string;\n    k: number;\n    constructor(fields?: BufferWindowMemoryInput);\n    get memoryKeys(): string[];\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    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n}\n"],"mappings":";;;;;;;AAKA;AAmCqBK,UAnCJD,uBAAAA,SAAgCD,mBAmCV,CAAA;EAAA,WAAA,CAAA,EAAA,MAAA;EAAA,QAKdC,CAAAA,EAAAA,MAAAA;EAAuB,SAWfJ,CAAAA,EAAAA,MAAAA;EAAW,CAAA,CAAA,EAAWC,MAAAA;;;;AAhB0C;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5EI,kBAAAA,SAA2BH,cAAAA,YAA0BE;;;;;uBAKjDA;;;;;;;;;;;+BAWQJ,cAAcM,QAAQL"}

package/dist/memory/buffer_window_memory.d.ts

@@ -0,0 +1,64 @@
+import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
+import { InputValues, MemoryVariables } from "@langchain/core/memory";
+
+//#region src/memory/buffer_window_memory.d.ts
+
+/**
+ * Interface for the input parameters of the BufferWindowMemory class.
+ */
+interface BufferWindowMemoryInput extends BaseChatMemoryInput {
+  humanPrefix?: string;
+  aiPrefix?: string;
+  memoryKey?: string;
+  k?: number;
+}
+/**
+ * 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 });
+ * ```
+ */
+declare class BufferWindowMemory extends BaseChatMemory implements BufferWindowMemoryInput {
+  humanPrefix: string;
+  aiPrefix: string;
+  memoryKey: string;
+  k: number;
+  constructor(fields?: BufferWindowMemoryInput);
+  get memoryKeys(): string[];
+  /**
+   * 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.
+   */
+  loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;
+}
+//#endregion
+export { BufferWindowMemory, BufferWindowMemoryInput };
+//# sourceMappingURL=buffer_window_memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_window_memory.d.ts","names":["InputValues","MemoryVariables","BaseChatMemory","BaseChatMemoryInput","BufferWindowMemoryInput","BufferWindowMemory","Promise"],"sources":["../../src/memory/buffer_window_memory.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\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 * 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 declare class BufferWindowMemory extends BaseChatMemory implements BufferWindowMemoryInput {\n    humanPrefix: string;\n    aiPrefix: string;\n    memoryKey: string;\n    k: number;\n    constructor(fields?: BufferWindowMemoryInput);\n    get memoryKeys(): string[];\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    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n}\n"],"mappings":";;;;;;;AAKA;AAmCqBK,UAnCJD,uBAAAA,SAAgCD,mBAmCV,CAAA;EAAA,WAAA,CAAA,EAAA,MAAA;EAAA,QAKdC,CAAAA,EAAAA,MAAAA;EAAuB,SAWfJ,CAAAA,EAAAA,MAAAA;EAAW,CAAA,CAAA,EAAWC,MAAAA;;;;AAhB0C;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5EI,kBAAAA,SAA2BH,cAAAA,YAA0BE;;;;;uBAKjDA;;;;;;;;;;;+BAWQJ,cAAcM,QAAQL"}

package/dist/memory/buffer_window_memory.js

@@ -0,0 +1,76 @@
+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 });
+* ```
+*/
+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

@@ -0,0 +1,53 @@
+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.
+*/
+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.addAIMessage((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.addAIMessage(\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,yDACN,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

@@ -0,0 +1,42 @@
+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.
+ */
+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.ts.map