langchain 0.3.31 → 1.0.0-alpha.2

package/dist/memory/stores/entity/in_memory.js

@@ -1,63 +1,64 @@
 import { BaseEntityStore } from "./base.js";
+
+//#region src/memory/stores/entity/in_memory.ts
 /**
- * An entity store that keeps data in memory. It extends from the
- * `BaseEntityStore` class and is used to store and manage entities.
- */
-export class InMemoryEntityStore extends BaseEntityStore {
-    constructor() {
-        super();
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "stores", "entity", "in_memory"]
-        });
-        Object.defineProperty(this, "store", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.store = Object.create(null);
-    }
-    /**
-     * Retrieves the value associated with the given key from the store. If
-     * the key does not exist in the store, it returns the provided default
-     * value.
-     * @param key The key to retrieve the value for.
-     * @param defaultValue The default value to return if the key does not exist in the store.
-     * @returns The value associated with the key, or the default value if the key does not exist in the store.
-     */
-    async get(key, defaultValue) {
-        return key in this.store ? this.store[key] : defaultValue;
-    }
-    /**
-     * Sets the value associated with the given key in the store.
-     * @param key The key to set the value for.
-     * @param value The value to set.
-     */
-    async set(key, value) {
-        this.store[key] = value;
-    }
-    /**
-     * Removes the key and its associated value from the store.
-     * @param key The key to remove.
-     */
-    async delete(key) {
-        delete this.store[key];
-    }
-    /**
-     * Checks if a key exists in the store.
-     * @param key The key to check.
-     * @returns A boolean indicating whether the key exists in the store.
-     */
-    async exists(key) {
-        return key in this.store;
-    }
-    /**
-     * Removes all keys and their associated values from the store.
-     */
-    async clear() {
-        this.store = Object.create(null);
-    }
-}
+* An entity store that keeps data in memory. It extends from the
+* `BaseEntityStore` class and is used to store and manage entities.
+*/
+var InMemoryEntityStore = class extends BaseEntityStore {
+	lc_namespace = [
+		"langchain",
+		"stores",
+		"entity",
+		"in_memory"
+	];
+	store;
+	constructor() {
+		super();
+		this.store = Object.create(null);
+	}
+	/**
+	* Retrieves the value associated with the given key from the store. If
+	* the key does not exist in the store, it returns the provided default
+	* value.
+	* @param key The key to retrieve the value for.
+	* @param defaultValue The default value to return if the key does not exist in the store.
+	* @returns The value associated with the key, or the default value if the key does not exist in the store.
+	*/
+	async get(key, defaultValue) {
+		return key in this.store ? this.store[key] : defaultValue;
+	}
+	/**
+	* Sets the value associated with the given key in the store.
+	* @param key The key to set the value for.
+	* @param value The value to set.
+	*/
+	async set(key, value) {
+		this.store[key] = value;
+	}
+	/**
+	* Removes the key and its associated value from the store.
+	* @param key The key to remove.
+	*/
+	async delete(key) {
+		delete this.store[key];
+	}
+	/**
+	* Checks if a key exists in the store.
+	* @param key The key to check.
+	* @returns A boolean indicating whether the key exists in the store.
+	*/
+	async exists(key) {
+		return key in this.store;
+	}
+	/**
+	* Removes all keys and their associated values from the store.
+	*/
+	async clear() {
+		this.store = Object.create(null);
+	}
+};
+
+//#endregion
+export { InMemoryEntityStore };
+//# sourceMappingURL=in_memory.js.map

package/dist/memory/stores/entity/in_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.js","names":["key: string","defaultValue: string | undefined","value: string | undefined"],"sources":["../../../../src/memory/stores/entity/in_memory.ts"],"sourcesContent":["import { BaseEntityStore } from \"./base.js\";\n\n/**\n * An entity store that keeps data in memory. It extends from the\n * `BaseEntityStore` class and is used to store and manage entities.\n */\nexport class InMemoryEntityStore extends BaseEntityStore {\n  lc_namespace = [\"langchain\", \"stores\", \"entity\", \"in_memory\"];\n\n  private store: Record<string, string | undefined>;\n\n  constructor() {\n    super();\n    this.store = Object.create(null);\n  }\n\n  /**\n   * Retrieves the value associated with the given key from the store. If\n   * the key does not exist in the store, it returns the provided default\n   * value.\n   * @param key The key to retrieve the value for.\n   * @param defaultValue The default value to return if the key does not exist in the store.\n   * @returns The value associated with the key, or the default value if the key does not exist in the store.\n   */\n  async get(\n    key: string,\n    defaultValue: string | undefined\n  ): Promise<string | undefined> {\n    return key in this.store ? this.store[key] : defaultValue;\n  }\n\n  /**\n   * Sets the value associated with the given key in the store.\n   * @param key The key to set the value for.\n   * @param value The value to set.\n   */\n  async set(key: string, value: string | undefined): Promise<void> {\n    this.store[key] = value;\n  }\n\n  /**\n   * Removes the key and its associated value from the store.\n   * @param key The key to remove.\n   */\n  async delete(key: string): Promise<void> {\n    delete this.store[key];\n  }\n\n  /**\n   * Checks if a key exists in the store.\n   * @param key The key to check.\n   * @returns A boolean indicating whether the key exists in the store.\n   */\n  async exists(key: string): Promise<boolean> {\n    return key in this.store;\n  }\n\n  /**\n   * Removes all keys and their associated values from the store.\n   */\n  async clear(): Promise<void> {\n    this.store = Object.create(null);\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,sBAAb,cAAyC,gBAAgB;CACvD,eAAe;EAAC;EAAa;EAAU;EAAU;CAAY;CAE7D,AAAQ;CAER,cAAc;EACZ,OAAO;EACP,KAAK,QAAQ,OAAO,OAAO,KAAK;CACjC;;;;;;;;;CAUD,MAAM,IACJA,KACAC,cAC6B;AAC7B,SAAO,OAAO,KAAK,QAAQ,KAAK,MAAM,OAAO;CAC9C;;;;;;CAOD,MAAM,IAAID,KAAaE,OAA0C;EAC/D,KAAK,MAAM,OAAO;CACnB;;;;;CAMD,MAAM,OAAOF,KAA4B;EACvC,OAAO,KAAK,MAAM;CACnB;;;;;;CAOD,MAAM,OAAOA,KAA+B;AAC1C,SAAO,OAAO,KAAK;CACpB;;;;CAKD,MAAM,QAAuB;EAC3B,KAAK,QAAQ,OAAO,OAAO,KAAK;CACjC;AACF"}

package/dist/memory/summary.cjs

@@ -1,154 +1,127 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationSummaryMemory = exports.BaseConversationSummaryMemory = void 0;
-const messages_1 = require("@langchain/core/messages");
-const llm_chain_js_1 = require("../chains/llm_chain.cjs");
-const prompt_js_1 = require("./prompt.cjs");
-const chat_memory_js_1 = require("./chat_memory.cjs");
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_llm_chain = require('../chains/llm_chain.cjs');
+const require_memory_chat_memory = require('./chat_memory.cjs');
+const require_prompt = require('./prompt.cjs');
+const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+
+//#region src/memory/summary.ts
 /**
- * Abstract class that provides a structure for storing and managing the
- * memory of a conversation. It includes methods for predicting a new
- * summary for the conversation given the existing messages and summary.
- */
-class BaseConversationSummaryMemory extends chat_memory_js_1.BaseChatMemory {
-    constructor(fields) {
-        const { returnMessages, inputKey, outputKey, chatHistory, humanPrefix, aiPrefix, llm, prompt, summaryChatMessageClass, } = fields;
-        super({ returnMessages, inputKey, outputKey, chatHistory });
-        Object.defineProperty(this, "memoryKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "history"
-        });
-        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, "llm", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "prompt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: prompt_js_1.SUMMARY_PROMPT
-        });
-        Object.defineProperty(this, "summaryChatMessageClass", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: messages_1.SystemMessage
-        });
-        this.memoryKey = fields?.memoryKey ?? this.memoryKey;
-        this.humanPrefix = humanPrefix ?? this.humanPrefix;
-        this.aiPrefix = aiPrefix ?? this.aiPrefix;
-        this.llm = llm;
-        this.prompt = prompt ?? this.prompt;
-        this.summaryChatMessageClass =
-            summaryChatMessageClass ?? this.summaryChatMessageClass;
-    }
-    /**
-     * Predicts a new summary for the conversation given the existing messages
-     * and summary.
-     * @param messages Existing messages in the conversation.
-     * @param existingSummary Current summary of the conversation.
-     * @returns A promise that resolves to a new summary string.
-     */
-    async predictNewSummary(messages, existingSummary) {
-        const newLines = (0, messages_1.getBufferString)(messages, this.humanPrefix, this.aiPrefix);
-        const chain = new llm_chain_js_1.LLMChain({ llm: this.llm, prompt: this.prompt });
-        return await chain.predict({
-            summary: existingSummary,
-            new_lines: newLines,
-        });
-    }
-}
-exports.BaseConversationSummaryMemory = BaseConversationSummaryMemory;
+* Abstract class that provides a structure for storing and managing the
+* memory of a conversation. It includes methods for predicting a new
+* summary for the conversation given the existing messages and summary.
+*/
+var BaseConversationSummaryMemory = class extends require_memory_chat_memory.BaseChatMemory {
+	memoryKey = "history";
+	humanPrefix = "Human";
+	aiPrefix = "AI";
+	llm;
+	prompt = require_prompt.SUMMARY_PROMPT;
+	summaryChatMessageClass = __langchain_core_messages.SystemMessage;
+	constructor(fields) {
+		const { returnMessages, inputKey, outputKey, chatHistory, humanPrefix, aiPrefix, llm, prompt, summaryChatMessageClass } = fields;
+		super({
+			returnMessages,
+			inputKey,
+			outputKey,
+			chatHistory
+		});
+		this.memoryKey = fields?.memoryKey ?? this.memoryKey;
+		this.humanPrefix = humanPrefix ?? this.humanPrefix;
+		this.aiPrefix = aiPrefix ?? this.aiPrefix;
+		this.llm = llm;
+		this.prompt = prompt ?? this.prompt;
+		this.summaryChatMessageClass = summaryChatMessageClass ?? this.summaryChatMessageClass;
+	}
+	/**
+	* Predicts a new summary for the conversation given the existing messages
+	* and summary.
+	* @param messages Existing messages in the conversation.
+	* @param existingSummary Current summary of the conversation.
+	* @returns A promise that resolves to a new summary string.
+	*/
+	async predictNewSummary(messages, existingSummary) {
+		const newLines = (0, __langchain_core_messages.getBufferString)(messages, this.humanPrefix, this.aiPrefix);
+		const chain = new require_llm_chain.LLMChain({
+			llm: this.llm,
+			prompt: this.prompt
+		});
+		return await chain.predict({
+			summary: existingSummary,
+			new_lines: newLines
+		});
+	}
+};
 /**
- * Class that provides a concrete implementation of the conversation
- * memory. It includes methods for loading memory variables, saving
- * context, and clearing the memory.
- * @example
- * ```typescript
- * const memory = new ConversationSummaryMemory({
- *   memoryKey: "chat_history",
- *   llm: new ChatOpenAI({ model: "gpt-3.5-turbo", temperature: 0 }),
- * });
- *
- * const model = new ChatOpenAI({ model: "gpt-4o-mini" });
- * 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: model, prompt, memory });
- *
- * const res1 = await chain.call({ input: "Hi! I'm Jim." });
- * console.log({ res1, memory: await memory.loadMemoryVariables({}) });
- *
- * const res2 = await chain.call({ input: "What's my name?" });
- * console.log({ res2, memory: await memory.loadMemoryVariables({}) });
- *
- * ```
- */
-class ConversationSummaryMemory extends BaseConversationSummaryMemory {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "buffer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ""
-        });
-    }
-    get memoryKeys() {
-        return [this.memoryKey];
-    }
-    /**
-     * Loads the memory variables for the conversation memory.
-     * @returns A promise that resolves to an object containing the memory variables.
-     */
-    async loadMemoryVariables(_) {
-        if (this.returnMessages) {
-            const result = {
-                [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)],
-            };
-            return result;
-        }
-        const result = { [this.memoryKey]: this.buffer };
-        return result;
-    }
-    /**
-     * Saves the context of the conversation memory.
-     * @param inputValues Input values for the conversation.
-     * @param outputValues Output values from the conversation.
-     * @returns A promise that resolves when the context has been saved.
-     */
-    async saveContext(inputValues, outputValues) {
-        await super.saveContext(inputValues, outputValues);
-        const messages = await this.chatHistory.getMessages();
-        this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);
-    }
-    /**
-     * Clears the conversation memory.
-     * @returns A promise that resolves when the memory has been cleared.
-     */
-    async clear() {
-        await super.clear();
-        this.buffer = "";
-    }
-}
+* Class that provides a concrete implementation of the conversation
+* memory. It includes methods for loading memory variables, saving
+* context, and clearing the memory.
+* @example
+* ```typescript
+* const memory = new ConversationSummaryMemory({
+*   memoryKey: "chat_history",
+*   llm: new ChatOpenAI({ model: "gpt-3.5-turbo", temperature: 0 }),
+* });
+*
+* const model = new ChatOpenAI({ model: "gpt-4o-mini" });
+* 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: model, prompt, memory });
+*
+* const res1 = await chain.call({ input: "Hi! I'm Jim." });
+* console.log({ res1, memory: await memory.loadMemoryVariables({}) });
+*
+* const res2 = await chain.call({ input: "What's my name?" });
+* console.log({ res2, memory: await memory.loadMemoryVariables({}) });
+*
+* ```
+*/
+var ConversationSummaryMemory = class extends BaseConversationSummaryMemory {
+	buffer = "";
+	constructor(fields) {
+		super(fields);
+	}
+	get memoryKeys() {
+		return [this.memoryKey];
+	}
+	/**
+	* Loads the memory variables for the conversation memory.
+	* @returns A promise that resolves to an object containing the memory variables.
+	*/
+	async loadMemoryVariables(_) {
+		if (this.returnMessages) {
+			const result$1 = { [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)] };
+			return result$1;
+		}
+		const result = { [this.memoryKey]: this.buffer };
+		return result;
+	}
+	/**
+	* Saves the context of the conversation memory.
+	* @param inputValues Input values for the conversation.
+	* @param outputValues Output values from the conversation.
+	* @returns A promise that resolves when the context has been saved.
+	*/
+	async saveContext(inputValues, outputValues) {
+		await super.saveContext(inputValues, outputValues);
+		const messages = await this.chatHistory.getMessages();
+		this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);
+	}
+	/**
+	* Clears the conversation memory.
+	* @returns A promise that resolves when the memory has been cleared.
+	*/
+	async clear() {
+		await super.clear();
+		this.buffer = "";
+	}
+};
+
+//#endregion
+exports.BaseConversationSummaryMemory = BaseConversationSummaryMemory;
 exports.ConversationSummaryMemory = ConversationSummaryMemory;
+//# sourceMappingURL=summary.cjs.map

package/dist/memory/summary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.cjs","names":["BaseChatMemory","SUMMARY_PROMPT","SystemMessage","fields: BaseConversationSummaryMemoryInput","messages: BaseMessage[]","existingSummary: string","LLMChain","fields: ConversationSummaryMemoryInput","_: InputValues","result","inputValues: InputValues","outputValues: OutputValues"],"sources":["../../src/memory/summary.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport {\n  BaseMessage,\n  SystemMessage,\n  getBufferString,\n} from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { SUMMARY_PROMPT } from \"./prompt.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput\n  extends BaseConversationSummaryMemoryInput {}\n\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput\n  extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  memoryKey?: string;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  prompt?: BasePromptTemplate;\n  summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n  memoryKey = \"history\";\n\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  llm: BaseLanguageModelInterface;\n\n  prompt: BasePromptTemplate = SUMMARY_PROMPT;\n\n  summaryChatMessageClass: new (content: string) => BaseMessage = SystemMessage;\n\n  constructor(fields: BaseConversationSummaryMemoryInput) {\n    const {\n      returnMessages,\n      inputKey,\n      outputKey,\n      chatHistory,\n      humanPrefix,\n      aiPrefix,\n      llm,\n      prompt,\n      summaryChatMessageClass,\n    } = fields;\n\n    super({ returnMessages, inputKey, outputKey, chatHistory });\n\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.humanPrefix = humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = aiPrefix ?? this.aiPrefix;\n    this.llm = llm;\n    this.prompt = prompt ?? this.prompt;\n    this.summaryChatMessageClass =\n      summaryChatMessageClass ?? this.summaryChatMessageClass;\n  }\n\n  /**\n   * Predicts a new summary for the conversation given the existing messages\n   * and summary.\n   * @param messages Existing messages in the conversation.\n   * @param existingSummary Current summary of the conversation.\n   * @returns A promise that resolves to a new summary string.\n   */\n  async predictNewSummary(\n    messages: BaseMessage[],\n    existingSummary: string\n  ): Promise<string> {\n    const newLines = getBufferString(messages, this.humanPrefix, this.aiPrefix);\n    const chain = new LLMChain({ llm: this.llm, prompt: this.prompt });\n    return await chain.predict({\n      summary: existingSummary,\n      new_lines: newLines,\n    });\n  }\n}\n\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\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 *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n  buffer = \"\";\n\n  constructor(fields: ConversationSummaryMemoryInput) {\n    super(fields);\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Loads the memory variables for the conversation memory.\n   * @returns A promise that resolves to an object containing the memory variables.\n   */\n  async loadMemoryVariables(_: InputValues): Promise<MemoryVariables> {\n    if (this.returnMessages) {\n      const result = {\n        [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)],\n      };\n      return result;\n    }\n    const result = { [this.memoryKey]: this.buffer };\n    return result;\n  }\n\n  /**\n   * Saves the context of the conversation memory.\n   * @param inputValues Input values for the conversation.\n   * @param outputValues Output values from the conversation.\n   * @returns A promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    const messages = await this.chatHistory.getMessages();\n    this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);\n  }\n\n  /**\n   * Clears the conversation memory.\n   * @returns A promise that resolves when the memory has been cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.buffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;AA0CA,IAAsB,gCAAtB,cAA4DA,0CAAe;CACzE,YAAY;CAEZ,cAAc;CAEd,WAAW;CAEX;CAEA,SAA6BC;CAE7B,0BAAgEC;CAEhE,YAAYC,QAA4C;EACtD,MAAM,EACJ,gBACA,UACA,WACA,aACA,aACA,UACA,KACA,QACA,yBACD,GAAG;EAEJ,MAAM;GAAE;GAAgB;GAAU;GAAW;EAAa,EAAC;EAE3D,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,cAAc,eAAe,KAAK;EACvC,KAAK,WAAW,YAAY,KAAK;EACjC,KAAK,MAAM;EACX,KAAK,SAAS,UAAU,KAAK;EAC7B,KAAK,0BACH,2BAA2B,KAAK;CACnC;;;;;;;;CASD,MAAM,kBACJC,UACAC,iBACiB;EACjB,MAAM,0DAA2B,UAAU,KAAK,aAAa,KAAK,SAAS;EAC3E,MAAM,QAAQ,IAAIC,2BAAS;GAAE,KAAK,KAAK;GAAK,QAAQ,KAAK;EAAQ;AACjE,SAAO,MAAM,MAAM,QAAQ;GACzB,SAAS;GACT,WAAW;EACZ,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BD,IAAa,4BAAb,cAA+C,8BAA8B;CAC3E,SAAS;CAET,YAAYC,QAAwC;EAClD,MAAM,OAAO;CACd;CAED,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,SAAU;CACxB;;;;;CAMD,MAAM,oBAAoBC,GAA0C;AAClE,MAAI,KAAK,gBAAgB;GACvB,MAAMC,WAAS,GACZ,KAAK,YAAY,CAAC,IAAI,KAAK,wBAAwB,KAAK,OAAQ,EAClE;AACD,UAAOA;EACR;EACD,MAAM,SAAS,GAAG,KAAK,YAAY,KAAK,OAAQ;AAChD,SAAO;CACR;;;;;;;CAQD,MAAM,YACJC,aACAC,cACe;EACf,MAAM,MAAM,YAAY,aAAa,aAAa;EAClD,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;EACrD,KAAK,SAAS,MAAM,KAAK,kBAAkB,SAAS,MAAM,GAAG,EAAE,KAAK,OAAO;CAC5E;;;;;CAMD,MAAM,QAAQ;EACZ,MAAM,MAAM,OAAO;EACnB,KAAK,SAAS;CACf;AACF"}

package/dist/memory/summary.d.cts

@@ -0,0 +1,101 @@
+import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.cjs";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { BaseMessage } from "@langchain/core/messages";
+import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
+
+//#region src/memory/summary.d.ts
+
+/**
+ * Interface for the input parameters of the ConversationSummaryMemory
+ * class.
+ */
+interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {}
+/**
+ * Interface for the input parameters of the BaseConversationSummaryMemory
+ * class.
+ */
+interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {
+  llm: BaseLanguageModelInterface;
+  memoryKey?: string;
+  humanPrefix?: string;
+  aiPrefix?: string;
+  prompt?: BasePromptTemplate;
+  summaryChatMessageClass?: new (content: string) => BaseMessage;
+}
+/**
+ * Abstract class that provides a structure for storing and managing the
+ * memory of a conversation. It includes methods for predicting a new
+ * summary for the conversation given the existing messages and summary.
+ */
+declare abstract class BaseConversationSummaryMemory extends BaseChatMemory {
+  memoryKey: string;
+  humanPrefix: string;
+  aiPrefix: string;
+  llm: BaseLanguageModelInterface;
+  prompt: BasePromptTemplate;
+  summaryChatMessageClass: new (content: string) => BaseMessage;
+  constructor(fields: BaseConversationSummaryMemoryInput);
+  /**
+   * Predicts a new summary for the conversation given the existing messages
+   * and summary.
+   * @param messages Existing messages in the conversation.
+   * @param existingSummary Current summary of the conversation.
+   * @returns A promise that resolves to a new summary string.
+   */
+  predictNewSummary(messages: BaseMessage[], existingSummary: string): Promise<string>;
+}
+/**
+ * Class that provides a concrete implementation of the conversation
+ * memory. It includes methods for loading memory variables, saving
+ * context, and clearing the memory.
+ * @example
+ * ```typescript
+ * const memory = new ConversationSummaryMemory({
+ *   memoryKey: "chat_history",
+ *   llm: new ChatOpenAI({ model: "gpt-3.5-turbo", temperature: 0 }),
+ * });
+ *
+ * const model = new ChatOpenAI({ model: "gpt-4o-mini" });
+ * 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: model, prompt, memory });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1, memory: await memory.loadMemoryVariables({}) });
+ *
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2, memory: await memory.loadMemoryVariables({}) });
+ *
+ * ```
+ */
+declare class ConversationSummaryMemory extends BaseConversationSummaryMemory {
+  buffer: string;
+  constructor(fields: ConversationSummaryMemoryInput);
+  get memoryKeys(): string[];
+  /**
+   * Loads the memory variables for the conversation memory.
+   * @returns A promise that resolves to an object containing the memory variables.
+   */
+  loadMemoryVariables(_: InputValues): Promise<MemoryVariables>;
+  /**
+   * Saves the context of the conversation memory.
+   * @param inputValues Input values for the conversation.
+   * @param outputValues Output values from the conversation.
+   * @returns A promise that resolves when the context has been saved.
+   */
+  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+  /**
+   * Clears the conversation memory.
+   * @returns A promise that resolves when the memory has been cleared.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+export { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput, ConversationSummaryMemory, ConversationSummaryMemoryInput };
+//# sourceMappingURL=summary.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.cts","names":["BaseLanguageModelInterface","BaseMessage","BasePromptTemplate","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","ConversationSummaryMemoryInput","BaseConversationSummaryMemoryInput","BaseConversationSummaryMemory","Promise","ConversationSummaryMemory"],"sources":["../../src/memory/summary.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {\n}\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n    llm: BaseLanguageModelInterface;\n    memoryKey?: string;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    prompt?: BasePromptTemplate;\n    summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport declare abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n    memoryKey: string;\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: BaseLanguageModelInterface;\n    prompt: BasePromptTemplate;\n    summaryChatMessageClass: new (content: string) => BaseMessage;\n    constructor(fields: BaseConversationSummaryMemoryInput);\n    /**\n     * Predicts a new summary for the conversation given the existing messages\n     * and summary.\n     * @param messages Existing messages in the conversation.\n     * @param existingSummary Current summary of the conversation.\n     * @returns A promise that resolves to a new summary string.\n     */\n    predictNewSummary(messages: BaseMessage[], existingSummary: string): Promise<string>;\n}\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\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 *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport declare class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n    buffer: string;\n    constructor(fields: ConversationSummaryMemoryInput);\n    get memoryKeys(): string[];\n    /**\n     * Loads the memory variables for the conversation memory.\n     * @returns A promise that resolves to an object containing the memory variables.\n     */\n    loadMemoryVariables(_: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the conversation memory.\n     * @param inputValues Input values for the conversation.\n     * @param outputValues Output values from the conversation.\n     * @returns A promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Clears the conversation memory.\n     * @returns A promise that resolves when the memory has been cleared.\n     */\n    clear(): Promise<void>;\n}\n"],"mappings":";;;;;;;;;;AASA;AAMA;AAAmD,UANlCQ,8BAAAA,SAAuCC,kCAML,CAAA;;;;AAA4B;AAajDC,UAbbD,kCAAAA,SAA2CF,mBAaD,CAAA;EAAA,GAAA,EAZlDP,0BAYkD;EAAA,SAIlDA,CAAAA,EAAAA,MAAAA;EAA0B,WACvBE,CAAAA,EAAAA,MAAAA;EAAkB,QACwBD,CAAAA,EAAAA,MAAAA;EAAW,MACzCQ,CAAAA,EAfXP,kBAeWO;EAAkC,uBAQ1BR,CAAAA,EAAAA,KAAAA,OAAAA,EAAAA,MAAAA,EAAAA,GAtBuBA,WAsBvBA;;;AAfkD;AA8ClF;;;AAQ2BE,uBAtDGO,6BAAAA,SAAsCJ,cAAAA,CAsDzCH;EAAW,SAAWC,EAAAA,MAAAA;EAAe,WAAvBO,EAAAA,MAAAA;EAAO,QAOnBR,EAAAA,MAAAA;EAAW,GAAgBE,EAzD/CL,0BAyD+CK;EAAY,MAAGM,EAxD3DT,kBAwD2DS;EAAO,uBAKjEA,EAAAA,KAAAA,OAAAA,EAAAA,MAAAA,EAAAA,GA5DyCV,WA4DzCU;EAAO,WApBmCD,CAAAA,MAAAA,EAvC/BD,kCAuC+BC;EAA6B;;;;;;;8BA/BpDT,yCAAyCU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BpDC,yBAAAA,SAAkCF,6BAAAA;;sBAE/BF;;;;;;yBAMGL,cAAcQ,QAAQP;;;;;;;2BAOpBD,2BAA2BE,eAAeM;;;;;WAK1DA"}