@langchain/classic 1.0.39 → 1.0.41

package/dist/load/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["importMap"],"sources":["../../src/load/index.ts"],"sourcesContent":["import { load as coreLoad } from \"@langchain/core/load\";\nimport { optionalImportEntrypoints } from \"./import_constants.js\";\nimport * as importMap from \"./import_map.js\";\nimport { OptionalImportMap } from \"./import_type.js\";\n\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. Never\n * call this on untrusted or user-supplied input. Only deserialize data that\n * originates from a trusted source you control.\n *\n * See `@langchain/core/load` {@link LoadOptions} for detailed security\n * guidance on `secretsFromEnv`, `secretsMap`, and import maps.\n *\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @returns A loaded instance of a LangChain module.\n */\nexport async function load<T>(\n  text: string,\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  additionalImportsMap: Record<string, any> = {},\n  secretsFromEnv?: boolean\n): Promise<T> {\n  return coreLoad(text, {\n    secretsMap,\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap: { ...importMap, ...additionalImportsMap },\n    secretsFromEnv,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,eAAsB,KACpB,MAEA,aAAkC,EAAE,EAEpC,qBAA8D,EAAE,EAEhE,uBAA4C,EAAE,EAC9C,gBACY;AACZ,SAAA,GAAA,qBAAA,MAAgB,MAAM;EACpB;EACA;EACA,2BAAA,yBAAA;EACA,WAAW;GAAE,GAAGA,mBAAAA;GAAW,GAAG;GAAsB;EACpD;EACD,CAAC"}
+{"version":3,"file":"index.cjs","names":["importMap"],"sources":["../../src/load/index.ts"],"sourcesContent":["import { load as coreLoad } from \"@langchain/core/load\";\nimport { optionalImportEntrypoints } from \"./import_constants.js\";\nimport * as importMap from \"./import_map.js\";\nimport { OptionalImportMap } from \"./import_type.js\";\n\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. Never\n * call this on untrusted or user-supplied input. Only deserialize data that\n * originates from a trusted source you control.\n *\n * See `@langchain/core/load` {@link LoadOptions} for detailed security\n * guidance on `secretsFromEnv`, `secretsMap`, and import maps.\n *\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @returns A loaded instance of a LangChain module.\n */\nexport async function load<T>(\n  text: string,\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  additionalImportsMap: Record<string, any> = {},\n  secretsFromEnv?: boolean\n): Promise<T> {\n  return coreLoad(text, {\n    secretsMap,\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap: { ...importMap, ...additionalImportsMap },\n    secretsFromEnv,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,eAAsB,KACpB,MAEA,aAAkC,CAAC,GAEnC,qBAA8D,CAAC,GAE/D,uBAA4C,CAAC,GAC7C,gBACY;CACZ,QAAA,GAAA,qBAAA,KAAA,CAAgB,MAAM;EACpB;EACA;EACA,2BAAA,yBAAA;EACA,WAAW;GAAE,GAAGA,mBAAAA;GAAW,GAAG;EAAqB;EACnD;CACF,CAAC;AACH"}

package/dist/load/index.d.cts

@@ -1,5 +1,4 @@
 import { OptionalImportMap } from "./import_type.cjs";
-
 //#region src/load/index.d.ts
 /**
  * Load a LangChain module from a serialized text representation.

package/dist/load/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;AAuBA;;;;;;;;;;;;;;;;iBAAsB,IAAA,GAAA,CACpB,IAAA,UAEA,UAAA,GAAY,MAAA,eAEZ,kBAAA,GAAoB,iBAAA,GAAoB,MAAA,eAExC,oBAAA,GAAsB,MAAA,eACtB,cAAA,aACC,OAAA,CAAQ,CAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAuBsB,KAAK,GACzB,cAEA,aAAY,qBAEZ,qBAAoB,oBAAoB,qBAExC,uBAAsB,qBACtB,2BACC,QAAQ"}

package/dist/load/index.d.ts

@@ -1,5 +1,4 @@
 import { OptionalImportMap } from "./import_type.js";
-
 //#region src/load/index.d.ts
 /**
  * Load a LangChain module from a serialized text representation.

package/dist/load/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;AAuBA;;;;;;;;;;;;;;;;iBAAsB,IAAA,GAAA,CACpB,IAAA,UAEA,UAAA,GAAY,MAAA,eAEZ,kBAAA,GAAoB,iBAAA,GAAoB,MAAA,eAExC,oBAAA,GAAsB,MAAA,eACtB,cAAA,aACC,OAAA,CAAQ,CAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBAuBsB,KAAK,GACzB,cAEA,aAAY,qBAEZ,qBAAoB,oBAAoB,qBAExC,uBAAsB,qBACtB,2BACC,QAAQ"}

package/dist/load/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["coreLoad","importMap"],"sources":["../../src/load/index.ts"],"sourcesContent":["import { load as coreLoad } from \"@langchain/core/load\";\nimport { optionalImportEntrypoints } from \"./import_constants.js\";\nimport * as importMap from \"./import_map.js\";\nimport { OptionalImportMap } from \"./import_type.js\";\n\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. Never\n * call this on untrusted or user-supplied input. Only deserialize data that\n * originates from a trusted source you control.\n *\n * See `@langchain/core/load` {@link LoadOptions} for detailed security\n * guidance on `secretsFromEnv`, `secretsMap`, and import maps.\n *\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @returns A loaded instance of a LangChain module.\n */\nexport async function load<T>(\n  text: string,\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  additionalImportsMap: Record<string, any> = {},\n  secretsFromEnv?: boolean\n): Promise<T> {\n  return coreLoad(text, {\n    secretsMap,\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap: { ...importMap, ...additionalImportsMap },\n    secretsFromEnv,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,eAAsB,KACpB,MAEA,aAAkC,EAAE,EAEpC,qBAA8D,EAAE,EAEhE,uBAA4C,EAAE,EAC9C,gBACY;AACZ,QAAOA,OAAS,MAAM;EACpB;EACA;EACA;EACA,WAAW;GAAE,GAAGC;GAAW,GAAG;GAAsB;EACpD;EACD,CAAC"}
+{"version":3,"file":"index.js","names":["coreLoad","importMap"],"sources":["../../src/load/index.ts"],"sourcesContent":["import { load as coreLoad } from \"@langchain/core/load\";\nimport { optionalImportEntrypoints } from \"./import_constants.js\";\nimport * as importMap from \"./import_map.js\";\nimport { OptionalImportMap } from \"./import_type.js\";\n\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. Never\n * call this on untrusted or user-supplied input. Only deserialize data that\n * originates from a trusted source you control.\n *\n * See `@langchain/core/load` {@link LoadOptions} for detailed security\n * guidance on `secretsFromEnv`, `secretsMap`, and import maps.\n *\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @returns A loaded instance of a LangChain module.\n */\nexport async function load<T>(\n  text: string,\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  additionalImportsMap: Record<string, any> = {},\n  secretsFromEnv?: boolean\n): Promise<T> {\n  return coreLoad(text, {\n    secretsMap,\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap: { ...importMap, ...additionalImportsMap },\n    secretsFromEnv,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAuBA,eAAsB,KACpB,MAEA,aAAkC,CAAC,GAEnC,qBAA8D,CAAC,GAE/D,uBAA4C,CAAC,GAC7C,gBACY;CACZ,OAAOA,OAAS,MAAM;EACpB;EACA;EACA;EACA,WAAW;GAAE,GAAGC;GAAW,GAAG;EAAqB;EACnD;CACF,CAAC;AACH"}

package/dist/load/map_keys.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"map_keys.d.cts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";UAAiB,gBAAA;EAAA,CAEd,GAAA;AAAA"}
+{"version":3,"file":"map_keys.d.cts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";UAAiB;GAEd"}

package/dist/load/map_keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map_keys.d.ts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";UAAiB,gBAAA;EAAA,CAEd,GAAA;AAAA"}
+{"version":3,"file":"map_keys.d.ts","names":[],"sources":["../../src/load/map_keys.ts"],"mappings":";UAAiB;GAEd"}

package/dist/memory/buffer_memory.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_memory_chat_memory = require("./chat_memory.cjs");
 let _langchain_core_messages = require("@langchain/core/messages");
 //#region src/memory/buffer_memory.ts

package/dist/memory/buffer_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_memory.cjs","names":["BaseChatMemory"],"sources":["../../src/memory/buffer_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 `BufferMemory` class.\n */\nexport interface BufferMemoryInput extends BaseChatMemoryInput {\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * The `BufferMemory` class is a type of memory component used for storing\n * and managing previous chat messages. It is a wrapper around\n * `ChatMessageHistory` that extracts the messages into an input variable.\n * This class is particularly useful in applications like chatbots where\n * it is essential to remember previous interactions. Note: The memory\n * instance represents the history of a single conversation. Therefore, it\n * is not recommended to share the same history or memory instance between\n * two different chains. If you deploy your LangChain app on a serverless\n * environment, do not store memory instances in a variable, as your\n * hosting provider may reset it by the next time the function is called.\n * @example\n * ```typescript\n * // Initialize the memory to store chat history and set up the language model with a specific temperature.\n * const memory = new BufferMemory({ memoryKey: \"chat_history\" });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n *\n * // Create a prompt template for a friendly conversation between a human and an AI.\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 *\n * // Set up the chain with the language model, prompt, and memory.\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * // Example usage of the chain to continue the conversation.\n * // The `call` method sends the input to the model and returns the AI's response.\n * const res = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res });\n *\n * ```\n */\nexport class BufferMemory extends BaseChatMemory implements BufferMemoryInput {\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  constructor(fields?: BufferMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\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  }\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAa,eAAb,cAAkCA,2BAAAA,eAA4C;CAC5E,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,YAAY,QAA4B;AACtC,QAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACpB,CAAC;AACF,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;;CAG7C,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,UAEP;AASf,SAAO,GANJ,KAAK,aAAA,GAAA,yBAAA,iBACJ,UACA,KAAK,aACL,KAAK,SACN,EAEU"}
+{"version":3,"file":"buffer_memory.cjs","names":["BaseChatMemory"],"sources":["../../src/memory/buffer_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 `BufferMemory` class.\n */\nexport interface BufferMemoryInput extends BaseChatMemoryInput {\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * The `BufferMemory` class is a type of memory component used for storing\n * and managing previous chat messages. It is a wrapper around\n * `ChatMessageHistory` that extracts the messages into an input variable.\n * This class is particularly useful in applications like chatbots where\n * it is essential to remember previous interactions. Note: The memory\n * instance represents the history of a single conversation. Therefore, it\n * is not recommended to share the same history or memory instance between\n * two different chains. If you deploy your LangChain app on a serverless\n * environment, do not store memory instances in a variable, as your\n * hosting provider may reset it by the next time the function is called.\n * @example\n * ```typescript\n * // Initialize the memory to store chat history and set up the language model with a specific temperature.\n * const memory = new BufferMemory({ memoryKey: \"chat_history\" });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n *\n * // Create a prompt template for a friendly conversation between a human and an AI.\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 *\n * // Set up the chain with the language model, prompt, and memory.\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * // Example usage of the chain to continue the conversation.\n * // The `call` method sends the input to the model and returns the AI's response.\n * const res = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res });\n *\n * ```\n */\nexport class BufferMemory extends BaseChatMemory implements BufferMemoryInput {\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  constructor(fields?: BufferMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\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  }\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAa,eAAb,cAAkCA,2BAAAA,eAA4C;CAC5E,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,YAAY,QAA4B;EACtC,MAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACrB,CAAC;EACD,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;CAC7C;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,SAER;EASd,OAAO,GANJ,KAAK,aAAA,GAAA,yBAAA,gBAAA,CACJ,UACA,KAAK,aACL,KAAK,QACP,EAEU;CACd;AACF"}

package/dist/memory/buffer_memory.d.cts

@@ -1,6 +1,5 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.cjs";
 import { InputValues, MemoryVariables } from "@langchain/core/memory";
-
 //#region src/memory/buffer_memory.d.ts
 /**
  * Interface for the input parameters of the `BufferMemory` class.

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_memory.d.cts","names":[],"sources":["../../src/memory/buffer_memory.ts"],"mappings":";;;;;;AAOA;UAAiB,iBAAA,SAA0B,mBAAA;EACzC,WAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;;AAuCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,YAAA,SAAqB,cAAA,YAA0B,iBAAA;EAC1D,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,WAAA,CAAY,MAAA,GAAS,iBAAA;EAAA,IAYjB,UAAA,CAAA;;;;;;;;EAWE,mBAAA,CAAoB,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,eAAA;AAAA"}
+{"version":3,"file":"buffer_memory.d.cts","names":[],"sources":["../../src/memory/buffer_memory.ts"],"mappings":";;;;;;UAOiB,0BAA0B;EACzC;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCW,qBAAqB,0BAA0B;EAC1D;EAEA;EAEA;EAEA,YAAY,SAAS;MAYjB;;;;;;;;EAWE,oBAAoB,SAAS,cAAc,QAAQ"}

package/dist/memory/buffer_memory.d.ts

@@ -1,6 +1,5 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
 import { InputValues, MemoryVariables } from "@langchain/core/memory";
-
 //#region src/memory/buffer_memory.d.ts
 /**
  * Interface for the input parameters of the `BufferMemory` class.

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_memory.d.ts","names":[],"sources":["../../src/memory/buffer_memory.ts"],"mappings":";;;;;;AAOA;UAAiB,iBAAA,SAA0B,mBAAA;EACzC,WAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;;AAuCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,YAAA,SAAqB,cAAA,YAA0B,iBAAA;EAC1D,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,WAAA,CAAY,MAAA,GAAS,iBAAA;EAAA,IAYjB,UAAA,CAAA;;;;;;;;EAWE,mBAAA,CAAoB,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,eAAA;AAAA"}
+{"version":3,"file":"buffer_memory.d.ts","names":[],"sources":["../../src/memory/buffer_memory.ts"],"mappings":";;;;;;UAOiB,0BAA0B;EACzC;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCW,qBAAqB,0BAA0B;EAC1D;EAEA;EAEA;EAEA,YAAY,SAAS;MAYjB;;;;;;;;EAWE,oBAAoB,SAAS,cAAc,QAAQ"}

package/dist/memory/buffer_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_memory.js","names":[],"sources":["../../src/memory/buffer_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 `BufferMemory` class.\n */\nexport interface BufferMemoryInput extends BaseChatMemoryInput {\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * The `BufferMemory` class is a type of memory component used for storing\n * and managing previous chat messages. It is a wrapper around\n * `ChatMessageHistory` that extracts the messages into an input variable.\n * This class is particularly useful in applications like chatbots where\n * it is essential to remember previous interactions. Note: The memory\n * instance represents the history of a single conversation. Therefore, it\n * is not recommended to share the same history or memory instance between\n * two different chains. If you deploy your LangChain app on a serverless\n * environment, do not store memory instances in a variable, as your\n * hosting provider may reset it by the next time the function is called.\n * @example\n * ```typescript\n * // Initialize the memory to store chat history and set up the language model with a specific temperature.\n * const memory = new BufferMemory({ memoryKey: \"chat_history\" });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n *\n * // Create a prompt template for a friendly conversation between a human and an AI.\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 *\n * // Set up the chain with the language model, prompt, and memory.\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * // Example usage of the chain to continue the conversation.\n * // The `call` method sends the input to the model and returns the AI's response.\n * const res = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res });\n *\n * ```\n */\nexport class BufferMemory extends BaseChatMemory implements BufferMemoryInput {\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  constructor(fields?: BufferMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\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  }\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAa,eAAb,cAAkC,eAA4C;CAC5E,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,YAAY,QAA4B;AACtC,QAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACpB,CAAC;AACF,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;;CAG7C,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,UAEP;AASf,SAAO,GANJ,KAAK,YAAY,gBAChB,UACA,KAAK,aACL,KAAK,SACN,EAEU"}
+{"version":3,"file":"buffer_memory.js","names":[],"sources":["../../src/memory/buffer_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 `BufferMemory` class.\n */\nexport interface BufferMemoryInput extends BaseChatMemoryInput {\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * The `BufferMemory` class is a type of memory component used for storing\n * and managing previous chat messages. It is a wrapper around\n * `ChatMessageHistory` that extracts the messages into an input variable.\n * This class is particularly useful in applications like chatbots where\n * it is essential to remember previous interactions. Note: The memory\n * instance represents the history of a single conversation. Therefore, it\n * is not recommended to share the same history or memory instance between\n * two different chains. If you deploy your LangChain app on a serverless\n * environment, do not store memory instances in a variable, as your\n * hosting provider may reset it by the next time the function is called.\n * @example\n * ```typescript\n * // Initialize the memory to store chat history and set up the language model with a specific temperature.\n * const memory = new BufferMemory({ memoryKey: \"chat_history\" });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n *\n * // Create a prompt template for a friendly conversation between a human and an AI.\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 *\n * // Set up the chain with the language model, prompt, and memory.\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * // Example usage of the chain to continue the conversation.\n * // The `call` method sends the input to the model and returns the AI's response.\n * const res = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res });\n *\n * ```\n */\nexport class BufferMemory extends BaseChatMemory implements BufferMemoryInput {\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  constructor(fields?: BufferMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\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  }\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAa,eAAb,cAAkC,eAA4C;CAC5E,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,YAAY,QAA4B;EACtC,MAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACrB,CAAC;EACD,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;CAC7C;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,SAER;EASd,OAAO,GANJ,KAAK,YAAY,gBAChB,UACA,KAAK,aACL,KAAK,QACP,EAEU;CACd;AACF"}

package/dist/memory/buffer_token_memory.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_memory_chat_memory = require("./chat_memory.cjs");
 let _langchain_core_messages = require("@langchain/core/messages");
 //#region src/memory/buffer_token_memory.ts

package/dist/memory/buffer_token_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_token_memory.cjs","names":["BaseChatMemory"],"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 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":";;;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,gCAAb,cACUA,2BAAAA,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,gBAAgB;CAEhB;CAEA,YAAY,QAA4C;AACtD,QAAM,OAAO;AACb,OAAK,MAAM,OAAO;AAClB,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,gBAAgB,QAAQ,iBAAiB,KAAK;;CAGrD,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,UAEP;AASf,SAAO,GANJ,KAAK,aAAA,GAAA,yBAAA,iBACJ,UACA,KAAK,aACL,KAAK,SACN,EAEU;;;;;;;CAQf,MAAM,YAAY,aAA0B,cAA4B;AACtE,QAAM,MAAM,YAAY,aAAa,aAAa;EAGlD,MAAM,SAAS,MAAM,KAAK,YAAY,aAAa;EACnD,IAAI,mBAAmB,MAAM,KAAK,IAAI,cAAA,GAAA,yBAAA,iBACpB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;AAED,MAAI,mBAAmB,KAAK,eAAe;GACzC,MAAM,eAAe,EAAE;AACvB,UAAO,mBAAmB,KAAK,eAAe;AAC5C,iBAAa,KAAK,OAAO,OAAO,CAAC;AACjC,uBAAmB,MAAM,KAAK,IAAI,cAAA,GAAA,yBAAA,iBAChB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD"}
+{"version":3,"file":"buffer_token_memory.cjs","names":["BaseChatMemory"],"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 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":";;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,gCAAb,cACUA,2BAAAA,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,gBAAgB;CAEhB;CAEA,YAAY,QAA4C;EACtD,MAAM,MAAM;EACZ,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;CACrD;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,SAER;EASd,OAAO,GANJ,KAAK,aAAA,GAAA,yBAAA,gBAAA,CACJ,UACA,KAAK,aACL,KAAK,QACP,EAEU;CACd;;;;;;CAOA,MAAM,YAAY,aAA0B,cAA4B;EACtE,MAAM,MAAM,YAAY,aAAa,YAAY;EAGjD,MAAM,SAAS,MAAM,KAAK,YAAY,YAAY;EAClD,IAAI,mBAAmB,MAAM,KAAK,IAAI,cAAA,GAAA,yBAAA,gBAAA,CACpB,QAAQ,KAAK,aAAa,KAAK,QAAQ,CACzD;EAEA,IAAI,mBAAmB,KAAK,eAAe;GACzC,MAAM,eAAe,CAAC;GACtB,OAAO,mBAAmB,KAAK,eAAe;IAC5C,aAAa,KAAK,OAAO,MAAM,CAAC;IAChC,mBAAmB,MAAM,KAAK,IAAI,cAAA,GAAA,yBAAA,gBAAA,CAChB,QAAQ,KAAK,aAAa,KAAK,QAAQ,CACzD;GACF;EACF;CACF;AACF"}

package/dist/memory/buffer_token_memory.d.cts

@@ -1,7 +1,6 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.cjs";
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_token_memory.d.cts","names":[],"sources":["../../src/memory/buffer_token_memory.ts"],"mappings":";;;;;;;AAaA;UAAiB,kCAAA,SAA2C,mBAAA;EAE1D,WAAA;EAGA,QAAA;EAGA,GAAA,EAAK,0BAAA;EAGL,SAAA;EAGA,aAAA;AAAA;;;;;;AAwBF;;;;;;;;;;;;;;;cAAa,6BAAA,SACH,cAAA,YACG,kCAAA;EAEX,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,aAAA;EAEA,GAAA,EAAK,0BAAA;EAEL,WAAA,CAAY,MAAA,EAAQ,kCAAA;EAAA,IAShB,UAAA,CAAA;EATJ;;;;;;;EAoBM,mBAAA,CAAoB,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,eAAA;EAAA;;;;;EAuBnD,WAAA,CAAY,WAAA,EAAa,WAAA,EAAa,YAAA,EAAc,YAAA,GAAY,OAAA;AAAA"}
+{"version":3,"file":"buffer_token_memory.d.cts","names":[],"sources":["../../src/memory/buffer_token_memory.ts"],"mappings":";;;;;;;UAaiB,2CAA2C;EAE1D;EAGA;EAGA,KAAK;EAGL;EAGA;;;;;;;;;;;;;;;;;;;;;;cAwBW,sCACH,0BACG;EAEX;EAEA;EAEA;EAEA;EAEA,KAAK;EAEL,YAAY,QAAQ;MAShB;;;;;;;;EAWE,oBAAoB,SAAS,cAAc,QAAQ;;;;;;EAuBnD,YAAY,aAAa,aAAa,cAAc,eAAY"}

package/dist/memory/buffer_token_memory.d.ts

@@ -1,7 +1,6 @@
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_token_memory.d.ts","names":[],"sources":["../../src/memory/buffer_token_memory.ts"],"mappings":";;;;;;;AAaA;UAAiB,kCAAA,SAA2C,mBAAA;EAE1D,WAAA;EAGA,QAAA;EAGA,GAAA,EAAK,0BAAA;EAGL,SAAA;EAGA,aAAA;AAAA;;;;;;AAwBF;;;;;;;;;;;;;;;cAAa,6BAAA,SACH,cAAA,YACG,kCAAA;EAEX,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,aAAA;EAEA,GAAA,EAAK,0BAAA;EAEL,WAAA,CAAY,MAAA,EAAQ,kCAAA;EAAA,IAShB,UAAA,CAAA;EATJ;;;;;;;EAoBM,mBAAA,CAAoB,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,eAAA;EAAA;;;;;EAuBnD,WAAA,CAAY,WAAA,EAAa,WAAA,EAAa,YAAA,EAAc,YAAA,GAAY,OAAA;AAAA"}
+{"version":3,"file":"buffer_token_memory.d.ts","names":[],"sources":["../../src/memory/buffer_token_memory.ts"],"mappings":";;;;;;;UAaiB,2CAA2C;EAE1D;EAGA;EAGA,KAAK;EAGL;EAGA;;;;;;;;;;;;;;;;;;;;;;cAwBW,sCACH,0BACG;EAEX;EAEA;EAEA;EAEA;EAEA,KAAK;EAEL,YAAY,QAAQ;MAShB;;;;;;;;EAWE,oBAAoB,SAAS,cAAc,QAAQ;;;;;;EAuBnD,YAAY,aAAa,aAAa,cAAc,eAAY"}

package/dist/memory/buffer_token_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_token_memory.js","names":[],"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 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":";;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,gCAAb,cACU,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,gBAAgB;CAEhB;CAEA,YAAY,QAA4C;AACtD,QAAM,OAAO;AACb,OAAK,MAAM,OAAO;AAClB,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,gBAAgB,QAAQ,iBAAiB,KAAK;;CAGrD,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,UAEP;AASf,SAAO,GANJ,KAAK,YAAY,gBAChB,UACA,KAAK,aACL,KAAK,SACN,EAEU;;;;;;;CAQf,MAAM,YAAY,aAA0B,cAA4B;AACtE,QAAM,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,EAAE;AACvB,UAAO,mBAAmB,KAAK,eAAe;AAC5C,iBAAa,KAAK,OAAO,OAAO,CAAC;AACjC,uBAAmB,MAAM,KAAK,IAAI,aAChC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD"}
+{"version":3,"file":"buffer_token_memory.js","names":[],"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 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":";;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,gCAAb,cACU,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,gBAAgB;CAEhB;CAEA,YAAY,QAA4C;EACtD,MAAM,MAAM;EACZ,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;CACrD;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,SAER;EASd,OAAO,GANJ,KAAK,YAAY,gBAChB,UACA,KAAK,aACL,KAAK,QACP,EAEU;CACd;;;;;;CAOA,MAAM,YAAY,aAA0B,cAA4B;EACtE,MAAM,MAAM,YAAY,aAAa,YAAY;EAGjD,MAAM,SAAS,MAAM,KAAK,YAAY,YAAY;EAClD,IAAI,mBAAmB,MAAM,KAAK,IAAI,aACpC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,QAAQ,CACzD;EAEA,IAAI,mBAAmB,KAAK,eAAe;GACzC,MAAM,eAAe,CAAC;GACtB,OAAO,mBAAmB,KAAK,eAAe;IAC5C,aAAa,KAAK,OAAO,MAAM,CAAC;IAChC,mBAAmB,MAAM,KAAK,IAAI,aAChC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,QAAQ,CACzD;GACF;EACF;CACF;AACF"}

package/dist/memory/buffer_window_memory.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_memory_chat_memory = require("./chat_memory.cjs");
 let _langchain_core_messages = require("@langchain/core/messages");
 //#region src/memory/buffer_window_memory.ts

package/dist/memory/buffer_window_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_window_memory.cjs","names":["BaseChatMemory"],"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,2BAAAA,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,IAAI;CAEJ,YAAY,QAAkC;AAC5C,QAAM;GACJ,gBAAgB,QAAQ,kBAAkB;GAC1C,aAAa,QAAQ;GACrB,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACpB,CAAC;AACF,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,IAAI,QAAQ,KAAK,KAAK;;CAG7B,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;;;CAYzB,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAElC;AASf,SAAO,GANJ,KAAK,aAAA,GAAA,yBAAA,iBACJ,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAC3B,KAAK,aACL,KAAK,SACN,EAEU"}
+{"version":3,"file":"buffer_window_memory.cjs","names":["BaseChatMemory"],"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,2BAAAA,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,IAAI;CAEJ,YAAY,QAAkC;EAC5C,MAAM;GACJ,gBAAgB,QAAQ,kBAAkB;GAC1C,aAAa,QAAQ;GACrB,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACrB,CAAC;EACD,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,IAAI,QAAQ,KAAK,KAAK;CAC7B;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;;;CAWA,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC,EAElC;EASd,OAAO,GANJ,KAAK,aAAA,GAAA,yBAAA,gBAAA,CACJ,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC,GAC1B,KAAK,aACL,KAAK,QACP,EAEU;CACd;AACF"}

package/dist/memory/buffer_window_memory.d.cts

@@ -1,6 +1,5 @@
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_window_memory.d.cts","names":[],"sources":["../../src/memory/buffer_window_memory.ts"],"mappings":";;;;;;AAOA;UAAiB,uBAAA,SAAgC,mBAAA;EAC/C,WAAA;EACA,QAAA;EACA,SAAA;EACA,CAAA;AAAA;;;;;AAgCF;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,kBAAA,SACH,cAAA,YACG,uBAAA;EAEX,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,CAAA;EAEA,WAAA,CAAY,MAAA,GAAS,uBAAA;EAAA,IAajB,UAAA,CAAA;;;;;;;;;;EAaE,mBAAA,CAAoB,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,eAAA;AAAA"}
+{"version":3,"file":"buffer_window_memory.d.cts","names":[],"sources":["../../src/memory/buffer_window_memory.ts"],"mappings":";;;;;;UAOiB,gCAAgC;EAC/C;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCW,2BACH,0BACG;EAEX;EAEA;EAEA;EAEA;EAEA,YAAY,SAAS;MAajB;;;;;;;;;;EAaE,oBAAoB,SAAS,cAAc,QAAQ"}

package/dist/memory/buffer_window_memory.d.ts

@@ -1,6 +1,5 @@
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_window_memory.d.ts","names":[],"sources":["../../src/memory/buffer_window_memory.ts"],"mappings":";;;;;;AAOA;UAAiB,uBAAA,SAAgC,mBAAA;EAC/C,WAAA;EACA,QAAA;EACA,SAAA;EACA,CAAA;AAAA;;;;;AAgCF;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,kBAAA,SACH,cAAA,YACG,uBAAA;EAEX,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,CAAA;EAEA,WAAA,CAAY,MAAA,GAAS,uBAAA;EAAA,IAajB,UAAA,CAAA;;;;;;;;;;EAaE,mBAAA,CAAoB,OAAA,EAAS,WAAA,GAAc,OAAA,CAAQ,eAAA;AAAA"}
+{"version":3,"file":"buffer_window_memory.d.ts","names":[],"sources":["../../src/memory/buffer_window_memory.ts"],"mappings":";;;;;;UAOiB,gCAAgC;EAC/C;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCW,2BACH,0BACG;EAEX;EAEA;EAEA;EAEA;EAEA,YAAY,SAAS;MAajB;;;;;;;;;;EAaE,oBAAoB,SAAS,cAAc,QAAQ"}

package/dist/memory/buffer_window_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"buffer_window_memory.js","names":[],"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,YAAY,QAAkC;AAC5C,QAAM;GACJ,gBAAgB,QAAQ,kBAAkB;GAC1C,aAAa,QAAQ;GACrB,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACpB,CAAC;AACF,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,IAAI,QAAQ,KAAK,KAAK;;CAG7B,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;;;CAYzB,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAElC;AASf,SAAO,GANJ,KAAK,YAAY,gBAChB,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAC3B,KAAK,aACL,KAAK,SACN,EAEU"}
+{"version":3,"file":"buffer_window_memory.js","names":[],"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,YAAY,QAAkC;EAC5C,MAAM;GACJ,gBAAgB,QAAQ,kBAAkB;GAC1C,aAAa,QAAQ;GACrB,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACrB,CAAC;EACD,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,IAAI,QAAQ,KAAK,KAAK;CAC7B;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;;;CAWA,MAAM,oBAAoB,SAAgD;EACxE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC,EAElC;EASd,OAAO,GANJ,KAAK,YAAY,gBAChB,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC,GAC1B,KAAK,aACL,KAAK,QACP,EAEU;CACd;AACF"}

package/dist/memory/chat_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"chat_memory.cjs","names":["BaseMemory","ChatMessageHistory"],"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,uBAAAA,WAAW;CACtD;CAEA,iBAAiB;CAEjB;CAEA;CAEA,YAAY,QAA8B;AACxC,SAAO;AACP,OAAK,cAAc,QAAQ,eAAe,IAAIC,6BAAAA,4BAAoB;AAClE,OAAK,iBAAiB,QAAQ,kBAAkB,KAAK;AACrD,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;;;;;;;;CAS7C,MAAM,YACJ,aACA,cACe;AAEf,QAAM,KAAK,YAAY,gBAAA,GAAA,uBAAA,eACP,aAAa,KAAK,SAAS,CAC1C;AACD,QAAM,KAAK,YAAY,cAAA,GAAA,uBAAA,gBACN,cAAc,KAAK,UAAU,CAC7C;;;;;;CAOH,MAAM,QAAuB;AAC3B,QAAM,KAAK,YAAY,OAAO"}
+{"version":3,"file":"chat_memory.cjs","names":["BaseMemory","ChatMessageHistory"],"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,uBAAAA,WAAW;CACtD;CAEA,iBAAiB;CAEjB;CAEA;CAEA,YAAY,QAA8B;EACxC,MAAM;EACN,KAAK,cAAc,QAAQ,eAAe,IAAIC,6BAAAA,2BAAmB;EACjE,KAAK,iBAAiB,QAAQ,kBAAkB,KAAK;EACrD,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;CAC7C;;;;;;;CAQA,MAAM,YACJ,aACA,cACe;EAEf,MAAM,KAAK,YAAY,gBAAA,GAAA,uBAAA,cAAA,CACP,aAAa,KAAK,QAAQ,CAC1C;EACA,MAAM,KAAK,YAAY,cAAA,GAAA,uBAAA,eAAA,CACN,cAAc,KAAK,SAAS,CAC7C;CACF;;;;;CAMA,MAAM,QAAuB;EAC3B,MAAM,KAAK,YAAY,MAAM;CAC/B;AACF"}

package/dist/memory/chat_memory.d.cts

@@ -1,6 +1,5 @@
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"chat_memory.d.cts","names":[],"sources":["../../src/memory/chat_memory.ts"],"mappings":";;;;;;AAeA;UAAiB,mBAAA;EACf,WAAA,GAAc,sBAAA;EACd,cAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;;AASF;;uBAAsB,cAAA,SAAuB,UAAA;EAC3C,WAAA,EAAa,sBAAA;EAEb,cAAA;EAEA,QAAA;EAEA,SAAA;EAEA,WAAA,CAAY,MAAA,GAAS,mBAAA;EA+BN;;;;;;EAjBT,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;EAvBH;;;;EAqCM,KAAA,CAAA,GAAS,OAAA;AAAA"}
+{"version":3,"file":"chat_memory.d.cts","names":[],"sources":["../../src/memory/chat_memory.ts"],"mappings":";;;;;;UAeiB;EACf,cAAc;EACd;EACA;EACA;;;;;;;;uBASoB,uBAAuB;EAC3C,aAAa;EAEb;EAEA;EAEA;EAEA,YAAY,SAAS;;;;;;;EAcf,YACJ,aAAa,aACb,cAAc,eACb;;;;;EAcG,SAAS"}

package/dist/memory/chat_memory.d.ts

@@ -1,6 +1,5 @@
 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.

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

@@ -1 +1 @@
-{"version":3,"file":"chat_memory.d.ts","names":[],"sources":["../../src/memory/chat_memory.ts"],"mappings":";;;;;;AAeA;UAAiB,mBAAA;EACf,WAAA,GAAc,sBAAA;EACd,cAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;;AASF;;uBAAsB,cAAA,SAAuB,UAAA;EAC3C,WAAA,EAAa,sBAAA;EAEb,cAAA;EAEA,QAAA;EAEA,SAAA;EAEA,WAAA,CAAY,MAAA,GAAS,mBAAA;EA+BN;;;;;;EAjBT,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;EAvBH;;;;EAqCM,KAAA,CAAA,GAAS,OAAA;AAAA"}
+{"version":3,"file":"chat_memory.d.ts","names":[],"sources":["../../src/memory/chat_memory.ts"],"mappings":";;;;;;UAeiB;EACf,cAAc;EACd;EACA;EACA;;;;;;;;uBASoB,uBAAuB;EAC3C,aAAa;EAEb;EAEA;EAEA;EAEA,YAAY,SAAS;;;;;;;EAcf,YACJ,aAAa,aACb,cAAc,eACb;;;;;EAcG,SAAS"}

package/dist/memory/chat_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"chat_memory.js","names":["ChatMessageHistory"],"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,cAA6C,WAAW;CACtD;CAEA,iBAAiB;CAEjB;CAEA;CAEA,YAAY,QAA8B;AACxC,SAAO;AACP,OAAK,cAAc,QAAQ,eAAe,IAAIA,4BAAoB;AAClE,OAAK,iBAAiB,QAAQ,kBAAkB,KAAK;AACrD,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;;;;;;;;CAS7C,MAAM,YACJ,aACA,cACe;AAEf,QAAM,KAAK,YAAY,eACrB,cAAc,aAAa,KAAK,SAAS,CAC1C;AACD,QAAM,KAAK,YAAY,aACrB,eAAe,cAAc,KAAK,UAAU,CAC7C;;;;;;CAOH,MAAM,QAAuB;AAC3B,QAAM,KAAK,YAAY,OAAO"}
+{"version":3,"file":"chat_memory.js","names":["ChatMessageHistory"],"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,cAA6C,WAAW;CACtD;CAEA,iBAAiB;CAEjB;CAEA;CAEA,YAAY,QAA8B;EACxC,MAAM;EACN,KAAK,cAAc,QAAQ,eAAe,IAAIA,2BAAmB;EACjE,KAAK,iBAAiB,QAAQ,kBAAkB,KAAK;EACrD,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;CAC7C;;;;;;;CAQA,MAAM,YACJ,aACA,cACe;EAEf,MAAM,KAAK,YAAY,eACrB,cAAc,aAAa,KAAK,QAAQ,CAC1C;EACA,MAAM,KAAK,YAAY,aACrB,eAAe,cAAc,KAAK,SAAS,CAC7C;CACF;;;;;CAMA,MAAM,QAAuB;EAC3B,MAAM,KAAK,YAAY,MAAM;CAC/B;AACF"}

package/dist/memory/combined_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"combined_memory.cjs","names":["BaseChatMemory"],"sources":["../../src/memory/combined_memory.ts"],"sourcesContent":["import {\n  InputValues,\n  MemoryVariables,\n  BaseMemory,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface that defines the shape of the input object that the\n * CombinedMemory constructor accepts. It extends the BaseChatMemoryInput\n * interface and adds additional properties.\n */\nexport interface CombinedMemoryInput extends BaseChatMemoryInput {\n  memories: BaseMemory[];\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * Class that manages and manipulates previous chat messages. It extends\n * from the BaseChatMemory class and implements the CombinedMemoryInput\n * interface.\n */\nexport class CombinedMemory\n  extends BaseChatMemory\n  implements CombinedMemoryInput\n{\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  memories: BaseMemory[] = [];\n\n  constructor(fields?: CombinedMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\n      inputKey: fields?.inputKey,\n      outputKey: fields?.outputKey,\n    });\n\n    this.memories = fields?.memories ?? this.memories;\n    this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.checkRepeatedMemoryVariable();\n    this.checkInputKey();\n  }\n\n  /**\n   * Checks for repeated memory variables across all memory objects. Throws\n   * an error if any are found.\n   */\n  checkRepeatedMemoryVariable() {\n    const allVariables: string[] = [];\n    for (const memory of this.memories) {\n      const overlap = allVariables.filter((x) => memory.memoryKeys.includes(x));\n      if (overlap.length > 0) {\n        throw new Error(\n          `The same variables ${[\n            ...overlap,\n          ]} are found in multiple memory objects, which is not allowed by CombinedMemory.`\n        );\n      }\n      allVariables.push(...memory.memoryKeys);\n    }\n  }\n\n  /**\n   * Checks if input keys are set for all memory objects. Logs a warning if\n   * any are missing.\n   */\n  checkInputKey() {\n    for (const memory of this.memories) {\n      if (\n        (memory as BaseChatMemory).chatHistory !== undefined &&\n        (memory as BaseChatMemory).inputKey === undefined\n      ) {\n        console.warn(\n          `When using CombinedMemory, input keys should be set so the input is known. Was not set on ${memory}.`\n        );\n      }\n    }\n  }\n\n  /**\n   * Loads memory variables from all memory objects.\n   * @param inputValues Input values to load memory variables from.\n   * @returns Promise that resolves with an object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputValues: InputValues\n  ): Promise<MemoryVariables> {\n    let memoryData: Record<string, unknown> = {};\n\n    for (const memory of this.memories) {\n      const data = await memory.loadMemoryVariables(inputValues);\n      memoryData = {\n        ...memoryData,\n        ...data,\n      };\n    }\n    return memoryData;\n  }\n\n  /**\n   * Saves the context to all memory objects.\n   * @param inputValues Input values to save.\n   * @param outputValues Output values to save.\n   * @returns Promise that resolves when the context has been saved to all memory objects.\n   */\n  async saveContext(inputValues: InputValues, outputValues: OutputValues) {\n    for (const memory of this.memories) {\n      await memory.saveContext(inputValues, outputValues);\n    }\n  }\n\n  /**\n   * Clears all memory objects.\n   * @returns Promise that resolves when all memory objects have been cleared.\n   */\n  async clear() {\n    for (const memory of this.memories) {\n      if (typeof (memory as BaseChatMemory).clear === \"function\") {\n        await (memory as BaseChatMemory).clear();\n      }\n    }\n  }\n\n  get memoryKeys() {\n    const memoryKeys: string[] = [];\n    for (const memory of this.memories) {\n      memoryKeys.push(...memory.memoryKeys);\n    }\n    return memoryKeys;\n  }\n}\n"],"mappings":";;;;;;;AAyBA,IAAa,iBAAb,cACUA,2BAAAA,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,WAAyB,EAAE;CAE3B,YAAY,QAA8B;AACxC,QAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACpB,CAAC;AAEF,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,6BAA6B;AAClC,OAAK,eAAe;;;;;;CAOtB,8BAA8B;EAC5B,MAAM,eAAyB,EAAE;AACjC,OAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,UAAU,aAAa,QAAQ,MAAM,OAAO,WAAW,SAAS,EAAE,CAAC;AACzE,OAAI,QAAQ,SAAS,EACnB,OAAM,IAAI,MACR,sBAAsB,CACpB,GAAG,QACJ,CAAC,gFACH;AAEH,gBAAa,KAAK,GAAG,OAAO,WAAW;;;;;;;CAQ3C,gBAAgB;AACd,OAAK,MAAM,UAAU,KAAK,SACxB,KACG,OAA0B,gBAAgB,KAAA,KAC1C,OAA0B,aAAa,KAAA,EAExC,SAAQ,KACN,6FAA6F,OAAO,GACrG;;;;;;;CAUP,MAAM,oBACJ,aAC0B;EAC1B,IAAI,aAAsC,EAAE;AAE5C,OAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,OAAO,MAAM,OAAO,oBAAoB,YAAY;AAC1D,gBAAa;IACX,GAAG;IACH,GAAG;IACJ;;AAEH,SAAO;;;;;;;;CAST,MAAM,YAAY,aAA0B,cAA4B;AACtE,OAAK,MAAM,UAAU,KAAK,SACxB,OAAM,OAAO,YAAY,aAAa,aAAa;;;;;;CAQvD,MAAM,QAAQ;AACZ,OAAK,MAAM,UAAU,KAAK,SACxB,KAAI,OAAQ,OAA0B,UAAU,WAC9C,OAAO,OAA0B,OAAO;;CAK9C,IAAI,aAAa;EACf,MAAM,aAAuB,EAAE;AAC/B,OAAK,MAAM,UAAU,KAAK,SACxB,YAAW,KAAK,GAAG,OAAO,WAAW;AAEvC,SAAO"}
+{"version":3,"file":"combined_memory.cjs","names":["BaseChatMemory"],"sources":["../../src/memory/combined_memory.ts"],"sourcesContent":["import {\n  InputValues,\n  MemoryVariables,\n  BaseMemory,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface that defines the shape of the input object that the\n * CombinedMemory constructor accepts. It extends the BaseChatMemoryInput\n * interface and adds additional properties.\n */\nexport interface CombinedMemoryInput extends BaseChatMemoryInput {\n  memories: BaseMemory[];\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * Class that manages and manipulates previous chat messages. It extends\n * from the BaseChatMemory class and implements the CombinedMemoryInput\n * interface.\n */\nexport class CombinedMemory\n  extends BaseChatMemory\n  implements CombinedMemoryInput\n{\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  memories: BaseMemory[] = [];\n\n  constructor(fields?: CombinedMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\n      inputKey: fields?.inputKey,\n      outputKey: fields?.outputKey,\n    });\n\n    this.memories = fields?.memories ?? this.memories;\n    this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.checkRepeatedMemoryVariable();\n    this.checkInputKey();\n  }\n\n  /**\n   * Checks for repeated memory variables across all memory objects. Throws\n   * an error if any are found.\n   */\n  checkRepeatedMemoryVariable() {\n    const allVariables: string[] = [];\n    for (const memory of this.memories) {\n      const overlap = allVariables.filter((x) => memory.memoryKeys.includes(x));\n      if (overlap.length > 0) {\n        throw new Error(\n          `The same variables ${[\n            ...overlap,\n          ]} are found in multiple memory objects, which is not allowed by CombinedMemory.`\n        );\n      }\n      allVariables.push(...memory.memoryKeys);\n    }\n  }\n\n  /**\n   * Checks if input keys are set for all memory objects. Logs a warning if\n   * any are missing.\n   */\n  checkInputKey() {\n    for (const memory of this.memories) {\n      if (\n        (memory as BaseChatMemory).chatHistory !== undefined &&\n        (memory as BaseChatMemory).inputKey === undefined\n      ) {\n        console.warn(\n          `When using CombinedMemory, input keys should be set so the input is known. Was not set on ${memory}.`\n        );\n      }\n    }\n  }\n\n  /**\n   * Loads memory variables from all memory objects.\n   * @param inputValues Input values to load memory variables from.\n   * @returns Promise that resolves with an object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputValues: InputValues\n  ): Promise<MemoryVariables> {\n    let memoryData: Record<string, unknown> = {};\n\n    for (const memory of this.memories) {\n      const data = await memory.loadMemoryVariables(inputValues);\n      memoryData = {\n        ...memoryData,\n        ...data,\n      };\n    }\n    return memoryData;\n  }\n\n  /**\n   * Saves the context to all memory objects.\n   * @param inputValues Input values to save.\n   * @param outputValues Output values to save.\n   * @returns Promise that resolves when the context has been saved to all memory objects.\n   */\n  async saveContext(inputValues: InputValues, outputValues: OutputValues) {\n    for (const memory of this.memories) {\n      await memory.saveContext(inputValues, outputValues);\n    }\n  }\n\n  /**\n   * Clears all memory objects.\n   * @returns Promise that resolves when all memory objects have been cleared.\n   */\n  async clear() {\n    for (const memory of this.memories) {\n      if (typeof (memory as BaseChatMemory).clear === \"function\") {\n        await (memory as BaseChatMemory).clear();\n      }\n    }\n  }\n\n  get memoryKeys() {\n    const memoryKeys: string[] = [];\n    for (const memory of this.memories) {\n      memoryKeys.push(...memory.memoryKeys);\n    }\n    return memoryKeys;\n  }\n}\n"],"mappings":";;;;;;;AAyBA,IAAa,iBAAb,cACUA,2BAAAA,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,WAAyB,CAAC;CAE1B,YAAY,QAA8B;EACxC,MAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACrB,CAAC;EAED,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,4BAA4B;EACjC,KAAK,cAAc;CACrB;;;;;CAMA,8BAA8B;EAC5B,MAAM,eAAyB,CAAC;EAChC,KAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,UAAU,aAAa,QAAQ,MAAM,OAAO,WAAW,SAAS,CAAC,CAAC;GACxE,IAAI,QAAQ,SAAS,GACnB,MAAM,IAAI,MACR,sBAAsB,CACpB,GAAG,OACL,EAAE,+EACJ;GAEF,aAAa,KAAK,GAAG,OAAO,UAAU;EACxC;CACF;;;;;CAMA,gBAAgB;EACd,KAAK,MAAM,UAAU,KAAK,UACxB,IACG,OAA0B,gBAAgB,KAAA,KAC1C,OAA0B,aAAa,KAAA,GAExC,QAAQ,KACN,6FAA6F,OAAO,EACtG;CAGN;;;;;;CAOA,MAAM,oBACJ,aAC0B;EAC1B,IAAI,aAAsC,CAAC;EAE3C,KAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,OAAO,MAAM,OAAO,oBAAoB,WAAW;GACzD,aAAa;IACX,GAAG;IACH,GAAG;GACL;EACF;EACA,OAAO;CACT;;;;;;;CAQA,MAAM,YAAY,aAA0B,cAA4B;EACtE,KAAK,MAAM,UAAU,KAAK,UACxB,MAAM,OAAO,YAAY,aAAa,YAAY;CAEtD;;;;;CAMA,MAAM,QAAQ;EACZ,KAAK,MAAM,UAAU,KAAK,UACxB,IAAI,OAAQ,OAA0B,UAAU,YAC9C,MAAO,OAA0B,MAAM;CAG7C;CAEA,IAAI,aAAa;EACf,MAAM,aAAuB,CAAC;EAC9B,KAAK,MAAM,UAAU,KAAK,UACxB,WAAW,KAAK,GAAG,OAAO,UAAU;EAEtC,OAAO;CACT;AACF"}

package/dist/memory/combined_memory.d.cts

@@ -1,6 +1,5 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.cjs";
 import { BaseMemory, InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/combined_memory.d.ts
 /**
  * Interface that defines the shape of the input object that the

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

@@ -1 +1 @@
-{"version":3,"file":"combined_memory.d.cts","names":[],"sources":["../../src/memory/combined_memory.ts"],"mappings":";;;;;;AAaA;;;UAAiB,mBAAA,SAA4B,mBAAA;EAC3C,QAAA,EAAU,UAAA;EACV,WAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;AAQF;;cAAa,cAAA,SACH,cAAA,YACG,mBAAA;EAEX,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,QAAA,EAAU,UAAA;EAEV,WAAA,CAAY,MAAA,GAAS,mBAAA;EA8EU;;;;EA1D/B,2BAAA,CAAA;EA9BW;;;;EAiDX,aAAA,CAAA;EA/CA;;;;;EAiEM,mBAAA,CACJ,WAAA,EAAa,WAAA,GACZ,OAAA,CAAQ,eAAA;EA3DU;;;;;;EA8Ef,WAAA,CAAY,WAAA,EAAa,WAAA,EAAa,YAAA,EAAc,YAAA,GAAY,OAAA;EAnBnE;;;;EA6BG,KAAA,CAAA,GAAK,OAAA;EAAA,IAQP,UAAA,CAAA;AAAA"}
+{"version":3,"file":"combined_memory.d.cts","names":[],"sources":["../../src/memory/combined_memory.ts"],"mappings":";;;;;;;;UAaiB,4BAA4B;EAC3C,UAAU;EACV;EACA;EACA;;;;;;;cAQW,uBACH,0BACG;EAEX;EAEA;EAEA;EAEA,UAAU;EAEV,YAAY,SAAS;;;;;EAoBrB;;;;;EAmBA;;;;;;EAkBM,oBACJ,aAAa,cACZ,QAAQ;;;;;;;EAmBL,YAAY,aAAa,aAAa,cAAc,eAAY;;;;;EAUhE,SAAK;MAQP"}

package/dist/memory/combined_memory.d.ts

@@ -1,6 +1,5 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
 import { BaseMemory, InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/combined_memory.d.ts
 /**
  * Interface that defines the shape of the input object that the

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

@@ -1 +1 @@
-{"version":3,"file":"combined_memory.d.ts","names":[],"sources":["../../src/memory/combined_memory.ts"],"mappings":";;;;;;AAaA;;;UAAiB,mBAAA,SAA4B,mBAAA;EAC3C,QAAA,EAAU,UAAA;EACV,WAAA;EACA,QAAA;EACA,SAAA;AAAA;;;;AAQF;;cAAa,cAAA,SACH,cAAA,YACG,mBAAA;EAEX,WAAA;EAEA,QAAA;EAEA,SAAA;EAEA,QAAA,EAAU,UAAA;EAEV,WAAA,CAAY,MAAA,GAAS,mBAAA;EA8EU;;;;EA1D/B,2BAAA,CAAA;EA9BW;;;;EAiDX,aAAA,CAAA;EA/CA;;;;;EAiEM,mBAAA,CACJ,WAAA,EAAa,WAAA,GACZ,OAAA,CAAQ,eAAA;EA3DU;;;;;;EA8Ef,WAAA,CAAY,WAAA,EAAa,WAAA,EAAa,YAAA,EAAc,YAAA,GAAY,OAAA;EAnBnE;;;;EA6BG,KAAA,CAAA,GAAK,OAAA;EAAA,IAQP,UAAA,CAAA;AAAA"}
+{"version":3,"file":"combined_memory.d.ts","names":[],"sources":["../../src/memory/combined_memory.ts"],"mappings":";;;;;;;;UAaiB,4BAA4B;EAC3C,UAAU;EACV;EACA;EACA;;;;;;;cAQW,uBACH,0BACG;EAEX;EAEA;EAEA;EAEA,UAAU;EAEV,YAAY,SAAS;;;;;EAoBrB;;;;;EAmBA;;;;;;EAkBM,oBACJ,aAAa,cACZ,QAAQ;;;;;;;EAmBL,YAAY,aAAa,aAAa,cAAc,eAAY;;;;;EAUhE,SAAK;MAQP"}

package/dist/memory/combined_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"combined_memory.js","names":[],"sources":["../../src/memory/combined_memory.ts"],"sourcesContent":["import {\n  InputValues,\n  MemoryVariables,\n  BaseMemory,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface that defines the shape of the input object that the\n * CombinedMemory constructor accepts. It extends the BaseChatMemoryInput\n * interface and adds additional properties.\n */\nexport interface CombinedMemoryInput extends BaseChatMemoryInput {\n  memories: BaseMemory[];\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * Class that manages and manipulates previous chat messages. It extends\n * from the BaseChatMemory class and implements the CombinedMemoryInput\n * interface.\n */\nexport class CombinedMemory\n  extends BaseChatMemory\n  implements CombinedMemoryInput\n{\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  memories: BaseMemory[] = [];\n\n  constructor(fields?: CombinedMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\n      inputKey: fields?.inputKey,\n      outputKey: fields?.outputKey,\n    });\n\n    this.memories = fields?.memories ?? this.memories;\n    this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.checkRepeatedMemoryVariable();\n    this.checkInputKey();\n  }\n\n  /**\n   * Checks for repeated memory variables across all memory objects. Throws\n   * an error if any are found.\n   */\n  checkRepeatedMemoryVariable() {\n    const allVariables: string[] = [];\n    for (const memory of this.memories) {\n      const overlap = allVariables.filter((x) => memory.memoryKeys.includes(x));\n      if (overlap.length > 0) {\n        throw new Error(\n          `The same variables ${[\n            ...overlap,\n          ]} are found in multiple memory objects, which is not allowed by CombinedMemory.`\n        );\n      }\n      allVariables.push(...memory.memoryKeys);\n    }\n  }\n\n  /**\n   * Checks if input keys are set for all memory objects. Logs a warning if\n   * any are missing.\n   */\n  checkInputKey() {\n    for (const memory of this.memories) {\n      if (\n        (memory as BaseChatMemory).chatHistory !== undefined &&\n        (memory as BaseChatMemory).inputKey === undefined\n      ) {\n        console.warn(\n          `When using CombinedMemory, input keys should be set so the input is known. Was not set on ${memory}.`\n        );\n      }\n    }\n  }\n\n  /**\n   * Loads memory variables from all memory objects.\n   * @param inputValues Input values to load memory variables from.\n   * @returns Promise that resolves with an object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputValues: InputValues\n  ): Promise<MemoryVariables> {\n    let memoryData: Record<string, unknown> = {};\n\n    for (const memory of this.memories) {\n      const data = await memory.loadMemoryVariables(inputValues);\n      memoryData = {\n        ...memoryData,\n        ...data,\n      };\n    }\n    return memoryData;\n  }\n\n  /**\n   * Saves the context to all memory objects.\n   * @param inputValues Input values to save.\n   * @param outputValues Output values to save.\n   * @returns Promise that resolves when the context has been saved to all memory objects.\n   */\n  async saveContext(inputValues: InputValues, outputValues: OutputValues) {\n    for (const memory of this.memories) {\n      await memory.saveContext(inputValues, outputValues);\n    }\n  }\n\n  /**\n   * Clears all memory objects.\n   * @returns Promise that resolves when all memory objects have been cleared.\n   */\n  async clear() {\n    for (const memory of this.memories) {\n      if (typeof (memory as BaseChatMemory).clear === \"function\") {\n        await (memory as BaseChatMemory).clear();\n      }\n    }\n  }\n\n  get memoryKeys() {\n    const memoryKeys: string[] = [];\n    for (const memory of this.memories) {\n      memoryKeys.push(...memory.memoryKeys);\n    }\n    return memoryKeys;\n  }\n}\n"],"mappings":";;;;;;;AAyBA,IAAa,iBAAb,cACU,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,WAAyB,EAAE;CAE3B,YAAY,QAA8B;AACxC,QAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;GACpB,CAAC;AAEF,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,cAAc,QAAQ,eAAe,KAAK;AAC/C,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,6BAA6B;AAClC,OAAK,eAAe;;;;;;CAOtB,8BAA8B;EAC5B,MAAM,eAAyB,EAAE;AACjC,OAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,UAAU,aAAa,QAAQ,MAAM,OAAO,WAAW,SAAS,EAAE,CAAC;AACzE,OAAI,QAAQ,SAAS,EACnB,OAAM,IAAI,MACR,sBAAsB,CACpB,GAAG,QACJ,CAAC,gFACH;AAEH,gBAAa,KAAK,GAAG,OAAO,WAAW;;;;;;;CAQ3C,gBAAgB;AACd,OAAK,MAAM,UAAU,KAAK,SACxB,KACG,OAA0B,gBAAgB,KAAA,KAC1C,OAA0B,aAAa,KAAA,EAExC,SAAQ,KACN,6FAA6F,OAAO,GACrG;;;;;;;CAUP,MAAM,oBACJ,aAC0B;EAC1B,IAAI,aAAsC,EAAE;AAE5C,OAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,OAAO,MAAM,OAAO,oBAAoB,YAAY;AAC1D,gBAAa;IACX,GAAG;IACH,GAAG;IACJ;;AAEH,SAAO;;;;;;;;CAST,MAAM,YAAY,aAA0B,cAA4B;AACtE,OAAK,MAAM,UAAU,KAAK,SACxB,OAAM,OAAO,YAAY,aAAa,aAAa;;;;;;CAQvD,MAAM,QAAQ;AACZ,OAAK,MAAM,UAAU,KAAK,SACxB,KAAI,OAAQ,OAA0B,UAAU,WAC9C,OAAO,OAA0B,OAAO;;CAK9C,IAAI,aAAa;EACf,MAAM,aAAuB,EAAE;AAC/B,OAAK,MAAM,UAAU,KAAK,SACxB,YAAW,KAAK,GAAG,OAAO,WAAW;AAEvC,SAAO"}
+{"version":3,"file":"combined_memory.js","names":[],"sources":["../../src/memory/combined_memory.ts"],"sourcesContent":["import {\n  InputValues,\n  MemoryVariables,\n  BaseMemory,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface that defines the shape of the input object that the\n * CombinedMemory constructor accepts. It extends the BaseChatMemoryInput\n * interface and adds additional properties.\n */\nexport interface CombinedMemoryInput extends BaseChatMemoryInput {\n  memories: BaseMemory[];\n  humanPrefix?: string;\n  aiPrefix?: string;\n  memoryKey?: string;\n}\n\n/**\n * Class that manages and manipulates previous chat messages. It extends\n * from the BaseChatMemory class and implements the CombinedMemoryInput\n * interface.\n */\nexport class CombinedMemory\n  extends BaseChatMemory\n  implements CombinedMemoryInput\n{\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  memoryKey = \"history\";\n\n  memories: BaseMemory[] = [];\n\n  constructor(fields?: CombinedMemoryInput) {\n    super({\n      chatHistory: fields?.chatHistory,\n      returnMessages: fields?.returnMessages ?? false,\n      inputKey: fields?.inputKey,\n      outputKey: fields?.outputKey,\n    });\n\n    this.memories = fields?.memories ?? this.memories;\n    this.humanPrefix = fields?.humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = fields?.aiPrefix ?? this.aiPrefix;\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.checkRepeatedMemoryVariable();\n    this.checkInputKey();\n  }\n\n  /**\n   * Checks for repeated memory variables across all memory objects. Throws\n   * an error if any are found.\n   */\n  checkRepeatedMemoryVariable() {\n    const allVariables: string[] = [];\n    for (const memory of this.memories) {\n      const overlap = allVariables.filter((x) => memory.memoryKeys.includes(x));\n      if (overlap.length > 0) {\n        throw new Error(\n          `The same variables ${[\n            ...overlap,\n          ]} are found in multiple memory objects, which is not allowed by CombinedMemory.`\n        );\n      }\n      allVariables.push(...memory.memoryKeys);\n    }\n  }\n\n  /**\n   * Checks if input keys are set for all memory objects. Logs a warning if\n   * any are missing.\n   */\n  checkInputKey() {\n    for (const memory of this.memories) {\n      if (\n        (memory as BaseChatMemory).chatHistory !== undefined &&\n        (memory as BaseChatMemory).inputKey === undefined\n      ) {\n        console.warn(\n          `When using CombinedMemory, input keys should be set so the input is known. Was not set on ${memory}.`\n        );\n      }\n    }\n  }\n\n  /**\n   * Loads memory variables from all memory objects.\n   * @param inputValues Input values to load memory variables from.\n   * @returns Promise that resolves with an object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputValues: InputValues\n  ): Promise<MemoryVariables> {\n    let memoryData: Record<string, unknown> = {};\n\n    for (const memory of this.memories) {\n      const data = await memory.loadMemoryVariables(inputValues);\n      memoryData = {\n        ...memoryData,\n        ...data,\n      };\n    }\n    return memoryData;\n  }\n\n  /**\n   * Saves the context to all memory objects.\n   * @param inputValues Input values to save.\n   * @param outputValues Output values to save.\n   * @returns Promise that resolves when the context has been saved to all memory objects.\n   */\n  async saveContext(inputValues: InputValues, outputValues: OutputValues) {\n    for (const memory of this.memories) {\n      await memory.saveContext(inputValues, outputValues);\n    }\n  }\n\n  /**\n   * Clears all memory objects.\n   * @returns Promise that resolves when all memory objects have been cleared.\n   */\n  async clear() {\n    for (const memory of this.memories) {\n      if (typeof (memory as BaseChatMemory).clear === \"function\") {\n        await (memory as BaseChatMemory).clear();\n      }\n    }\n  }\n\n  get memoryKeys() {\n    const memoryKeys: string[] = [];\n    for (const memory of this.memories) {\n      memoryKeys.push(...memory.memoryKeys);\n    }\n    return memoryKeys;\n  }\n}\n"],"mappings":";;;;;;;AAyBA,IAAa,iBAAb,cACU,eAEV;CACE,cAAc;CAEd,WAAW;CAEX,YAAY;CAEZ,WAAyB,CAAC;CAE1B,YAAY,QAA8B;EACxC,MAAM;GACJ,aAAa,QAAQ;GACrB,gBAAgB,QAAQ,kBAAkB;GAC1C,UAAU,QAAQ;GAClB,WAAW,QAAQ;EACrB,CAAC;EAED,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,cAAc,QAAQ,eAAe,KAAK;EAC/C,KAAK,WAAW,QAAQ,YAAY,KAAK;EACzC,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,4BAA4B;EACjC,KAAK,cAAc;CACrB;;;;;CAMA,8BAA8B;EAC5B,MAAM,eAAyB,CAAC;EAChC,KAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,UAAU,aAAa,QAAQ,MAAM,OAAO,WAAW,SAAS,CAAC,CAAC;GACxE,IAAI,QAAQ,SAAS,GACnB,MAAM,IAAI,MACR,sBAAsB,CACpB,GAAG,OACL,EAAE,+EACJ;GAEF,aAAa,KAAK,GAAG,OAAO,UAAU;EACxC;CACF;;;;;CAMA,gBAAgB;EACd,KAAK,MAAM,UAAU,KAAK,UACxB,IACG,OAA0B,gBAAgB,KAAA,KAC1C,OAA0B,aAAa,KAAA,GAExC,QAAQ,KACN,6FAA6F,OAAO,EACtG;CAGN;;;;;;CAOA,MAAM,oBACJ,aAC0B;EAC1B,IAAI,aAAsC,CAAC;EAE3C,KAAK,MAAM,UAAU,KAAK,UAAU;GAClC,MAAM,OAAO,MAAM,OAAO,oBAAoB,WAAW;GACzD,aAAa;IACX,GAAG;IACH,GAAG;GACL;EACF;EACA,OAAO;CACT;;;;;;;CAQA,MAAM,YAAY,aAA0B,cAA4B;EACtE,KAAK,MAAM,UAAU,KAAK,UACxB,MAAM,OAAO,YAAY,aAAa,YAAY;CAEtD;;;;;CAMA,MAAM,QAAQ;EACZ,KAAK,MAAM,UAAU,KAAK,UACxB,IAAI,OAAQ,OAA0B,UAAU,YAC9C,MAAO,OAA0B,MAAM;CAG7C;CAEA,IAAI,aAAa;EACf,MAAM,aAAuB,CAAC;EAC9B,KAAK,MAAM,UAAU,KAAK,UACxB,WAAW,KAAK,GAAG,OAAO,UAAU;EAEtC,OAAO;CACT;AACF"}

package/dist/memory/entity_memory.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_llm_chain = require("../chains/llm_chain.cjs");
 const require_prompt = require("./prompt.cjs");
 const require_memory_chat_memory = require("./chat_memory.cjs");

package/dist/memory/entity_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"entity_memory.cjs","names":["BaseChatMemory","LLMChain","ENTITY_EXTRACTION_PROMPT","ENTITY_SUMMARIZATION_PROMPT","InMemoryEntityStore"],"sources":["../../src/memory/entity_memory.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\n\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n  getPromptInputKey,\n} from \"@langchain/core/memory\";\nimport { getBufferString } from \"@langchain/core/messages\";\nimport { InMemoryEntityStore } from \"./stores/entity/in_memory.js\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport {\n  ENTITY_EXTRACTION_PROMPT,\n  ENTITY_SUMMARIZATION_PROMPT,\n} from \"./prompt.js\";\nimport { BaseEntityStore } from \"./stores/entity/base.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters required by the EntityMemory class.\n */\nexport interface EntityMemoryInput extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  entityExtractionPrompt?: PromptTemplate;\n  entitySummarizationPrompt?: PromptTemplate;\n  entityCache?: string[];\n  k?: number;\n  chatHistoryKey?: string;\n  entitiesKey?: string;\n  entityStore?: BaseEntityStore;\n}\n\n// Entity extractor & summarizer to memory.\n/**\n * Class for managing entity extraction and summarization to memory in\n * chatbot applications. Extends the BaseChatMemory class and implements\n * the EntityMemoryInput interface.\n * @example\n * ```typescript\n * const memory = new EntityMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   chatHistoryKey: \"history\",\n *   entitiesKey: \"entities\",\n * });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n * const chain = new LLMChain({\n *   llm: model,\n *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,\n *   memory,\n * });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({\n *   res1,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * const res2 = await chain.call({\n *   input: \"I work in construction. What about you?\",\n * });\n * console.log({\n *   res2,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * ```\n */\nexport class EntityMemory extends BaseChatMemory implements EntityMemoryInput {\n  private entityExtractionChain: LLMChain;\n\n  private entitySummarizationChain: LLMChain;\n\n  entityStore: BaseEntityStore;\n\n  entityCache: string[] = [];\n\n  k = 3;\n\n  chatHistoryKey = \"history\";\n\n  llm: BaseLanguageModelInterface;\n\n  entitiesKey = \"entities\";\n\n  humanPrefix?: string;\n\n  aiPrefix?: string;\n\n  constructor(fields: EntityMemoryInput) {\n    super({\n      chatHistory: fields.chatHistory,\n      returnMessages: fields.returnMessages ?? false,\n      inputKey: fields.inputKey,\n      outputKey: fields.outputKey,\n    });\n    this.llm = fields.llm;\n    this.humanPrefix = fields.humanPrefix;\n    this.aiPrefix = fields.aiPrefix;\n    this.chatHistoryKey = fields.chatHistoryKey ?? this.chatHistoryKey;\n    this.entitiesKey = fields.entitiesKey ?? this.entitiesKey;\n    this.entityExtractionChain = new LLMChain({\n      llm: this.llm,\n      prompt: fields.entityExtractionPrompt ?? ENTITY_EXTRACTION_PROMPT,\n    });\n    this.entitySummarizationChain = new LLMChain({\n      llm: this.llm,\n      prompt: fields.entitySummarizationPrompt ?? ENTITY_SUMMARIZATION_PROMPT,\n    });\n    this.entityStore = fields.entityStore ?? new InMemoryEntityStore();\n    this.entityCache = fields.entityCache ?? this.entityCache;\n    this.k = fields.k ?? this.k;\n  }\n\n  get memoryKeys() {\n    return [this.chatHistoryKey];\n  }\n\n  // Will always return list of memory variables.\n  get memoryVariables(): string[] {\n    return [this.entitiesKey, this.chatHistoryKey];\n  }\n\n  // Return history buffer.\n  /**\n   * Method to load memory variables and perform entity extraction.\n   * @param inputs Input values for the method.\n   * @returns Promise resolving to an object containing memory variables.\n   */\n  async loadMemoryVariables(inputs: InputValues): Promise<MemoryVariables> {\n    const promptInputKey =\n      this.inputKey ?? getPromptInputKey(inputs, this.memoryVariables);\n    const messages = await this.chatHistory.getMessages();\n    const serializedMessages = getBufferString(\n      messages.slice(-this.k * 2),\n      this.humanPrefix,\n      this.aiPrefix\n    );\n    const output = await this.entityExtractionChain.predict({\n      history: serializedMessages,\n      input: inputs[promptInputKey],\n    });\n    const entities: string[] =\n      output.trim() === \"NONE\" ? [] : output.split(\",\").map((w) => w.trim());\n    const entitySummaries: { [key: string]: string | undefined } = {};\n\n    for (const entity of entities) {\n      entitySummaries[entity] = await this.entityStore.get(\n        entity,\n        \"No current information known.\"\n      );\n    }\n    this.entityCache = [...entities];\n    const buffer = this.returnMessages\n      ? messages.slice(-this.k * 2)\n      : serializedMessages;\n\n    return {\n      [this.chatHistoryKey]: buffer,\n      [this.entitiesKey]: entitySummaries,\n    };\n  }\n\n  // Save context from this conversation to buffer.\n  /**\n   * Method to save the context from a conversation to a buffer and perform\n   * entity summarization.\n   * @param inputs Input values for the method.\n   * @param outputs Output values from the method.\n   * @returns Promise resolving to void.\n   */\n  async saveContext(inputs: InputValues, outputs: OutputValues): Promise<void> {\n    await super.saveContext(inputs, outputs);\n\n    const promptInputKey =\n      this.inputKey ?? getPromptInputKey(inputs, this.memoryVariables);\n    const messages = await this.chatHistory.getMessages();\n    const serializedMessages = getBufferString(\n      messages.slice(-this.k * 2),\n      this.humanPrefix,\n      this.aiPrefix\n    );\n    const inputData = inputs[promptInputKey];\n\n    for (const entity of this.entityCache) {\n      const existingSummary = await this.entityStore.get(\n        entity,\n        \"No current information known.\"\n      );\n      const output = await this.entitySummarizationChain.predict({\n        summary: existingSummary,\n        entity,\n        history: serializedMessages,\n        input: inputData,\n      });\n      if (output.trim() !== \"UNCHANGED\") {\n        await this.entityStore.set(entity, output.trim());\n      }\n    }\n  }\n\n  // Clear memory contents.\n  /**\n   * Method to clear the memory contents.\n   * @returns Promise resolving to void.\n   */\n  async clear() {\n    await super.clear();\n    await this.entityStore.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,IAAa,eAAb,cAAkCA,2BAAAA,eAA4C;CAC5E;CAEA;CAEA;CAEA,cAAwB,EAAE;CAE1B,IAAI;CAEJ,iBAAiB;CAEjB;CAEA,cAAc;CAEd;CAEA;CAEA,YAAY,QAA2B;AACrC,QAAM;GACJ,aAAa,OAAO;GACpB,gBAAgB,OAAO,kBAAkB;GACzC,UAAU,OAAO;GACjB,WAAW,OAAO;GACnB,CAAC;AACF,OAAK,MAAM,OAAO;AAClB,OAAK,cAAc,OAAO;AAC1B,OAAK,WAAW,OAAO;AACvB,OAAK,iBAAiB,OAAO,kBAAkB,KAAK;AACpD,OAAK,cAAc,OAAO,eAAe,KAAK;AAC9C,OAAK,wBAAwB,IAAIC,kBAAAA,SAAS;GACxC,KAAK,KAAK;GACV,QAAQ,OAAO,0BAA0BC,eAAAA;GAC1C,CAAC;AACF,OAAK,2BAA2B,IAAID,kBAAAA,SAAS;GAC3C,KAAK,KAAK;GACV,QAAQ,OAAO,6BAA6BE,eAAAA;GAC7C,CAAC;AACF,OAAK,cAAc,OAAO,eAAe,IAAIC,kBAAAA,qBAAqB;AAClE,OAAK,cAAc,OAAO,eAAe,KAAK;AAC9C,OAAK,IAAI,OAAO,KAAK,KAAK;;CAG5B,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,eAAe;;CAI9B,IAAI,kBAA4B;AAC9B,SAAO,CAAC,KAAK,aAAa,KAAK,eAAe;;;;;;;CAShD,MAAM,oBAAoB,QAA+C;EACvE,MAAM,iBACJ,KAAK,aAAA,GAAA,uBAAA,mBAA8B,QAAQ,KAAK,gBAAgB;EAClE,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;EACrD,MAAM,sBAAA,GAAA,yBAAA,iBACJ,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,EAC3B,KAAK,aACL,KAAK,SACN;EACD,MAAM,SAAS,MAAM,KAAK,sBAAsB,QAAQ;GACtD,SAAS;GACT,OAAO,OAAO;GACf,CAAC;EACF,MAAM,WACJ,OAAO,MAAM,KAAK,SAAS,EAAE,GAAG,OAAO,MAAM,IAAI,CAAC,KAAK,MAAM,EAAE,MAAM,CAAC;EACxE,MAAM,kBAAyD,EAAE;AAEjE,OAAK,MAAM,UAAU,SACnB,iBAAgB,UAAU,MAAM,KAAK,YAAY,IAC/C,QACA,gCACD;AAEH,OAAK,cAAc,CAAC,GAAG,SAAS;EAChC,MAAM,SAAS,KAAK,iBAChB,SAAS,MAAM,CAAC,KAAK,IAAI,EAAE,GAC3B;AAEJ,SAAO;IACJ,KAAK,iBAAiB;IACtB,KAAK,cAAc;GACrB;;;;;;;;;CAWH,MAAM,YAAY,QAAqB,SAAsC;AAC3E,QAAM,MAAM,YAAY,QAAQ,QAAQ;EAExC,MAAM,iBACJ,KAAK,aAAA,GAAA,uBAAA,mBAA8B,QAAQ,KAAK,gBAAgB;EAElE,MAAM,sBAAA,GAAA,yBAAA,kBACJ,MAFqB,KAAK,YAAY,aAAa,EAE1C,MAAM,CAAC,KAAK,IAAI,EAAE,EAC3B,KAAK,aACL,KAAK,SACN;EACD,MAAM,YAAY,OAAO;AAEzB,OAAK,MAAM,UAAU,KAAK,aAAa;GACrC,MAAM,kBAAkB,MAAM,KAAK,YAAY,IAC7C,QACA,gCACD;GACD,MAAM,SAAS,MAAM,KAAK,yBAAyB,QAAQ;IACzD,SAAS;IACT;IACA,SAAS;IACT,OAAO;IACR,CAAC;AACF,OAAI,OAAO,MAAM,KAAK,YACpB,OAAM,KAAK,YAAY,IAAI,QAAQ,OAAO,MAAM,CAAC;;;;;;;CAUvD,MAAM,QAAQ;AACZ,QAAM,MAAM,OAAO;AACnB,QAAM,KAAK,YAAY,OAAO"}
+{"version":3,"file":"entity_memory.cjs","names":["BaseChatMemory","LLMChain","ENTITY_EXTRACTION_PROMPT","ENTITY_SUMMARIZATION_PROMPT","InMemoryEntityStore"],"sources":["../../src/memory/entity_memory.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\n\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n  getPromptInputKey,\n} from \"@langchain/core/memory\";\nimport { getBufferString } from \"@langchain/core/messages\";\nimport { InMemoryEntityStore } from \"./stores/entity/in_memory.js\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport {\n  ENTITY_EXTRACTION_PROMPT,\n  ENTITY_SUMMARIZATION_PROMPT,\n} from \"./prompt.js\";\nimport { BaseEntityStore } from \"./stores/entity/base.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters required by the EntityMemory class.\n */\nexport interface EntityMemoryInput extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  entityExtractionPrompt?: PromptTemplate;\n  entitySummarizationPrompt?: PromptTemplate;\n  entityCache?: string[];\n  k?: number;\n  chatHistoryKey?: string;\n  entitiesKey?: string;\n  entityStore?: BaseEntityStore;\n}\n\n// Entity extractor & summarizer to memory.\n/**\n * Class for managing entity extraction and summarization to memory in\n * chatbot applications. Extends the BaseChatMemory class and implements\n * the EntityMemoryInput interface.\n * @example\n * ```typescript\n * const memory = new EntityMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   chatHistoryKey: \"history\",\n *   entitiesKey: \"entities\",\n * });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n * const chain = new LLMChain({\n *   llm: model,\n *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,\n *   memory,\n * });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({\n *   res1,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * const res2 = await chain.call({\n *   input: \"I work in construction. What about you?\",\n * });\n * console.log({\n *   res2,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * ```\n */\nexport class EntityMemory extends BaseChatMemory implements EntityMemoryInput {\n  private entityExtractionChain: LLMChain;\n\n  private entitySummarizationChain: LLMChain;\n\n  entityStore: BaseEntityStore;\n\n  entityCache: string[] = [];\n\n  k = 3;\n\n  chatHistoryKey = \"history\";\n\n  llm: BaseLanguageModelInterface;\n\n  entitiesKey = \"entities\";\n\n  humanPrefix?: string;\n\n  aiPrefix?: string;\n\n  constructor(fields: EntityMemoryInput) {\n    super({\n      chatHistory: fields.chatHistory,\n      returnMessages: fields.returnMessages ?? false,\n      inputKey: fields.inputKey,\n      outputKey: fields.outputKey,\n    });\n    this.llm = fields.llm;\n    this.humanPrefix = fields.humanPrefix;\n    this.aiPrefix = fields.aiPrefix;\n    this.chatHistoryKey = fields.chatHistoryKey ?? this.chatHistoryKey;\n    this.entitiesKey = fields.entitiesKey ?? this.entitiesKey;\n    this.entityExtractionChain = new LLMChain({\n      llm: this.llm,\n      prompt: fields.entityExtractionPrompt ?? ENTITY_EXTRACTION_PROMPT,\n    });\n    this.entitySummarizationChain = new LLMChain({\n      llm: this.llm,\n      prompt: fields.entitySummarizationPrompt ?? ENTITY_SUMMARIZATION_PROMPT,\n    });\n    this.entityStore = fields.entityStore ?? new InMemoryEntityStore();\n    this.entityCache = fields.entityCache ?? this.entityCache;\n    this.k = fields.k ?? this.k;\n  }\n\n  get memoryKeys() {\n    return [this.chatHistoryKey];\n  }\n\n  // Will always return list of memory variables.\n  get memoryVariables(): string[] {\n    return [this.entitiesKey, this.chatHistoryKey];\n  }\n\n  // Return history buffer.\n  /**\n   * Method to load memory variables and perform entity extraction.\n   * @param inputs Input values for the method.\n   * @returns Promise resolving to an object containing memory variables.\n   */\n  async loadMemoryVariables(inputs: InputValues): Promise<MemoryVariables> {\n    const promptInputKey =\n      this.inputKey ?? getPromptInputKey(inputs, this.memoryVariables);\n    const messages = await this.chatHistory.getMessages();\n    const serializedMessages = getBufferString(\n      messages.slice(-this.k * 2),\n      this.humanPrefix,\n      this.aiPrefix\n    );\n    const output = await this.entityExtractionChain.predict({\n      history: serializedMessages,\n      input: inputs[promptInputKey],\n    });\n    const entities: string[] =\n      output.trim() === \"NONE\" ? [] : output.split(\",\").map((w) => w.trim());\n    const entitySummaries: { [key: string]: string | undefined } = {};\n\n    for (const entity of entities) {\n      entitySummaries[entity] = await this.entityStore.get(\n        entity,\n        \"No current information known.\"\n      );\n    }\n    this.entityCache = [...entities];\n    const buffer = this.returnMessages\n      ? messages.slice(-this.k * 2)\n      : serializedMessages;\n\n    return {\n      [this.chatHistoryKey]: buffer,\n      [this.entitiesKey]: entitySummaries,\n    };\n  }\n\n  // Save context from this conversation to buffer.\n  /**\n   * Method to save the context from a conversation to a buffer and perform\n   * entity summarization.\n   * @param inputs Input values for the method.\n   * @param outputs Output values from the method.\n   * @returns Promise resolving to void.\n   */\n  async saveContext(inputs: InputValues, outputs: OutputValues): Promise<void> {\n    await super.saveContext(inputs, outputs);\n\n    const promptInputKey =\n      this.inputKey ?? getPromptInputKey(inputs, this.memoryVariables);\n    const messages = await this.chatHistory.getMessages();\n    const serializedMessages = getBufferString(\n      messages.slice(-this.k * 2),\n      this.humanPrefix,\n      this.aiPrefix\n    );\n    const inputData = inputs[promptInputKey];\n\n    for (const entity of this.entityCache) {\n      const existingSummary = await this.entityStore.get(\n        entity,\n        \"No current information known.\"\n      );\n      const output = await this.entitySummarizationChain.predict({\n        summary: existingSummary,\n        entity,\n        history: serializedMessages,\n        input: inputData,\n      });\n      if (output.trim() !== \"UNCHANGED\") {\n        await this.entityStore.set(entity, output.trim());\n      }\n    }\n  }\n\n  // Clear memory contents.\n  /**\n   * Method to clear the memory contents.\n   * @returns Promise resolving to void.\n   */\n  async clear() {\n    await super.clear();\n    await this.entityStore.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEA,IAAa,eAAb,cAAkCA,2BAAAA,eAA4C;CAC5E;CAEA;CAEA;CAEA,cAAwB,CAAC;CAEzB,IAAI;CAEJ,iBAAiB;CAEjB;CAEA,cAAc;CAEd;CAEA;CAEA,YAAY,QAA2B;EACrC,MAAM;GACJ,aAAa,OAAO;GACpB,gBAAgB,OAAO,kBAAkB;GACzC,UAAU,OAAO;GACjB,WAAW,OAAO;EACpB,CAAC;EACD,KAAK,MAAM,OAAO;EAClB,KAAK,cAAc,OAAO;EAC1B,KAAK,WAAW,OAAO;EACvB,KAAK,iBAAiB,OAAO,kBAAkB,KAAK;EACpD,KAAK,cAAc,OAAO,eAAe,KAAK;EAC9C,KAAK,wBAAwB,IAAIC,kBAAAA,SAAS;GACxC,KAAK,KAAK;GACV,QAAQ,OAAO,0BAA0BC,eAAAA;EAC3C,CAAC;EACD,KAAK,2BAA2B,IAAID,kBAAAA,SAAS;GAC3C,KAAK,KAAK;GACV,QAAQ,OAAO,6BAA6BE,eAAAA;EAC9C,CAAC;EACD,KAAK,cAAc,OAAO,eAAe,IAAIC,kBAAAA,oBAAoB;EACjE,KAAK,cAAc,OAAO,eAAe,KAAK;EAC9C,KAAK,IAAI,OAAO,KAAK,KAAK;CAC5B;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,cAAc;CAC7B;CAGA,IAAI,kBAA4B;EAC9B,OAAO,CAAC,KAAK,aAAa,KAAK,cAAc;CAC/C;;;;;;CAQA,MAAM,oBAAoB,QAA+C;EACvE,MAAM,iBACJ,KAAK,aAAA,GAAA,uBAAA,kBAAA,CAA8B,QAAQ,KAAK,eAAe;EACjE,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,MAAM,sBAAA,GAAA,yBAAA,gBAAA,CACJ,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC,GAC1B,KAAK,aACL,KAAK,QACP;EACA,MAAM,SAAS,MAAM,KAAK,sBAAsB,QAAQ;GACtD,SAAS;GACT,OAAO,OAAO;EAChB,CAAC;EACD,MAAM,WACJ,OAAO,KAAK,MAAM,SAAS,CAAC,IAAI,OAAO,MAAM,GAAG,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK,CAAC;EACvE,MAAM,kBAAyD,CAAC;EAEhE,KAAK,MAAM,UAAU,UACnB,gBAAgB,UAAU,MAAM,KAAK,YAAY,IAC/C,QACA,+BACF;EAEF,KAAK,cAAc,CAAC,GAAG,QAAQ;EAC/B,MAAM,SAAS,KAAK,iBAChB,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC,IAC1B;EAEJ,OAAO;IACJ,KAAK,iBAAiB;IACtB,KAAK,cAAc;EACtB;CACF;;;;;;;;CAUA,MAAM,YAAY,QAAqB,SAAsC;EAC3E,MAAM,MAAM,YAAY,QAAQ,OAAO;EAEvC,MAAM,iBACJ,KAAK,aAAA,GAAA,uBAAA,kBAAA,CAA8B,QAAQ,KAAK,eAAe;EAEjE,MAAM,sBAAA,GAAA,yBAAA,gBAAA,EACJ,MAFqB,KAAK,YAAY,YAAY,EAAA,CAEzC,MAAM,CAAC,KAAK,IAAI,CAAC,GAC1B,KAAK,aACL,KAAK,QACP;EACA,MAAM,YAAY,OAAO;EAEzB,KAAK,MAAM,UAAU,KAAK,aAAa;GACrC,MAAM,kBAAkB,MAAM,KAAK,YAAY,IAC7C,QACA,+BACF;GACA,MAAM,SAAS,MAAM,KAAK,yBAAyB,QAAQ;IACzD,SAAS;IACT;IACA,SAAS;IACT,OAAO;GACT,CAAC;GACD,IAAI,OAAO,KAAK,MAAM,aACpB,MAAM,KAAK,YAAY,IAAI,QAAQ,OAAO,KAAK,CAAC;EAEpD;CACF;;;;;CAOA,MAAM,QAAQ;EACZ,MAAM,MAAM,MAAM;EAClB,MAAM,KAAK,YAAY,MAAM;CAC/B;AACF"}

package/dist/memory/entity_memory.d.cts

@@ -3,7 +3,6 @@ import { BaseEntityStore } from "./stores/entity/base.cjs";
 import { PromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/entity_memory.d.ts
 /**
  * Interface for the input parameters required by the EntityMemory class.
@@ -89,5 +88,5 @@ declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {
   clear(): Promise<void>;
 }
 //#endregion
-export { EntityMemory };
+export { EntityMemory, EntityMemoryInput };
 //# sourceMappingURL=entity_memory.d.cts.map