@langchain/classic 1.0.40 → 1.0.41

package/dist/memory/summary.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"summary.cjs","names":["BaseChatMemory","SUMMARY_PROMPT","SystemMessage","LLMChain"],"sources":["../../src/memory/summary.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport {\n  BaseMessage,\n  SystemMessage,\n  getBufferString,\n} from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { SUMMARY_PROMPT } from \"./prompt.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {}\n\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  memoryKey?: string;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  prompt?: BasePromptTemplate;\n  summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n  memoryKey = \"history\";\n\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  llm: BaseLanguageModelInterface;\n\n  prompt: BasePromptTemplate = SUMMARY_PROMPT;\n\n  summaryChatMessageClass: new (content: string) => BaseMessage = SystemMessage;\n\n  constructor(fields: BaseConversationSummaryMemoryInput) {\n    const {\n      returnMessages,\n      inputKey,\n      outputKey,\n      chatHistory,\n      humanPrefix,\n      aiPrefix,\n      llm,\n      prompt,\n      summaryChatMessageClass,\n    } = fields;\n\n    super({ returnMessages, inputKey, outputKey, chatHistory });\n\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.humanPrefix = humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = aiPrefix ?? this.aiPrefix;\n    this.llm = llm;\n    this.prompt = prompt ?? this.prompt;\n    this.summaryChatMessageClass =\n      summaryChatMessageClass ?? this.summaryChatMessageClass;\n  }\n\n  /**\n   * Predicts a new summary for the conversation given the existing messages\n   * and summary.\n   * @param messages Existing messages in the conversation.\n   * @param existingSummary Current summary of the conversation.\n   * @returns A promise that resolves to a new summary string.\n   */\n  async predictNewSummary(\n    messages: BaseMessage[],\n    existingSummary: string\n  ): Promise<string> {\n    const newLines = getBufferString(messages, this.humanPrefix, this.aiPrefix);\n    const chain = new LLMChain({ llm: this.llm, prompt: this.prompt });\n    return await chain.predict({\n      summary: existingSummary,\n      new_lines: newLines,\n    });\n  }\n}\n\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n  buffer = \"\";\n\n  constructor(fields: ConversationSummaryMemoryInput) {\n    super(fields);\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Loads the memory variables for the conversation memory.\n   * @returns A promise that resolves to an object containing the memory variables.\n   */\n  async loadMemoryVariables(_: InputValues): Promise<MemoryVariables> {\n    if (this.returnMessages) {\n      const result = {\n        [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)],\n      };\n      return result;\n    }\n    const result = { [this.memoryKey]: this.buffer };\n    return result;\n  }\n\n  /**\n   * Saves the context of the conversation memory.\n   * @param inputValues Input values for the conversation.\n   * @param outputValues Output values from the conversation.\n   * @returns A promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    const messages = await this.chatHistory.getMessages();\n    this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);\n  }\n\n  /**\n   * Clears the conversation memory.\n   * @returns A promise that resolves when the memory has been cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.buffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;AAwCA,IAAsB,gCAAtB,cAA4DA,2BAAAA,eAAe;CACzE,YAAY;CAEZ,cAAc;CAEd,WAAW;CAEX;CAEA,SAA6BC,eAAAA;CAE7B,0BAAgEC,yBAAAA;CAEhE,YAAY,QAA4C;EACtD,MAAM,EACJ,gBACA,UACA,WACA,aACA,aACA,UACA,KACA,QACA,4BACE;AAEJ,QAAM;GAAE;GAAgB;GAAU;GAAW;GAAa,CAAC;AAE3D,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,cAAc,eAAe,KAAK;AACvC,OAAK,WAAW,YAAY,KAAK;AACjC,OAAK,MAAM;AACX,OAAK,SAAS,UAAU,KAAK;AAC7B,OAAK,0BACH,2BAA2B,KAAK;;;;;;;;;CAUpC,MAAM,kBACJ,UACA,iBACiB;EACjB,MAAM,YAAA,GAAA,yBAAA,iBAA2B,UAAU,KAAK,aAAa,KAAK,SAAS;AAE3E,SAAO,MAAM,IADKC,kBAAAA,SAAS;GAAE,KAAK,KAAK;GAAK,QAAQ,KAAK;GAAQ,CAC/C,CAAC,QAAQ;GACzB,SAAS;GACT,WAAW;GACZ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCN,IAAa,4BAAb,cAA+C,8BAA8B;CAC3E,SAAS;CAET,YAAY,QAAwC;AAClD,QAAM,OAAO;;CAGf,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;CAOzB,MAAM,oBAAoB,GAA0C;AAClE,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,CAAC,IAAI,KAAK,wBAAwB,KAAK,OAAO,CAAC,EAEtD;AAGf,SAAO,GADW,KAAK,YAAY,KAAK,QAC3B;;;;;;;;CASf,MAAM,YACJ,aACA,cACe;AACf,QAAM,MAAM,YAAY,aAAa,aAAa;EAClD,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,OAAK,SAAS,MAAM,KAAK,kBAAkB,SAAS,MAAM,GAAG,EAAE,KAAK,OAAO;;;;;;CAO7E,MAAM,QAAQ;AACZ,QAAM,MAAM,OAAO;AACnB,OAAK,SAAS"}
+{"version":3,"file":"summary.cjs","names":["BaseChatMemory","SUMMARY_PROMPT","SystemMessage","LLMChain"],"sources":["../../src/memory/summary.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport {\n  BaseMessage,\n  SystemMessage,\n  getBufferString,\n} from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { SUMMARY_PROMPT } from \"./prompt.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {}\n\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  memoryKey?: string;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  prompt?: BasePromptTemplate;\n  summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n  memoryKey = \"history\";\n\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  llm: BaseLanguageModelInterface;\n\n  prompt: BasePromptTemplate = SUMMARY_PROMPT;\n\n  summaryChatMessageClass: new (content: string) => BaseMessage = SystemMessage;\n\n  constructor(fields: BaseConversationSummaryMemoryInput) {\n    const {\n      returnMessages,\n      inputKey,\n      outputKey,\n      chatHistory,\n      humanPrefix,\n      aiPrefix,\n      llm,\n      prompt,\n      summaryChatMessageClass,\n    } = fields;\n\n    super({ returnMessages, inputKey, outputKey, chatHistory });\n\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.humanPrefix = humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = aiPrefix ?? this.aiPrefix;\n    this.llm = llm;\n    this.prompt = prompt ?? this.prompt;\n    this.summaryChatMessageClass =\n      summaryChatMessageClass ?? this.summaryChatMessageClass;\n  }\n\n  /**\n   * Predicts a new summary for the conversation given the existing messages\n   * and summary.\n   * @param messages Existing messages in the conversation.\n   * @param existingSummary Current summary of the conversation.\n   * @returns A promise that resolves to a new summary string.\n   */\n  async predictNewSummary(\n    messages: BaseMessage[],\n    existingSummary: string\n  ): Promise<string> {\n    const newLines = getBufferString(messages, this.humanPrefix, this.aiPrefix);\n    const chain = new LLMChain({ llm: this.llm, prompt: this.prompt });\n    return await chain.predict({\n      summary: existingSummary,\n      new_lines: newLines,\n    });\n  }\n}\n\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n  buffer = \"\";\n\n  constructor(fields: ConversationSummaryMemoryInput) {\n    super(fields);\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Loads the memory variables for the conversation memory.\n   * @returns A promise that resolves to an object containing the memory variables.\n   */\n  async loadMemoryVariables(_: InputValues): Promise<MemoryVariables> {\n    if (this.returnMessages) {\n      const result = {\n        [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)],\n      };\n      return result;\n    }\n    const result = { [this.memoryKey]: this.buffer };\n    return result;\n  }\n\n  /**\n   * Saves the context of the conversation memory.\n   * @param inputValues Input values for the conversation.\n   * @param outputValues Output values from the conversation.\n   * @returns A promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    const messages = await this.chatHistory.getMessages();\n    this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);\n  }\n\n  /**\n   * Clears the conversation memory.\n   * @returns A promise that resolves when the memory has been cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.buffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;AAwCA,IAAsB,gCAAtB,cAA4DA,2BAAAA,eAAe;CACzE,YAAY;CAEZ,cAAc;CAEd,WAAW;CAEX;CAEA,SAA6BC,eAAAA;CAE7B,0BAAgEC,yBAAAA;CAEhE,YAAY,QAA4C;EACtD,MAAM,EACJ,gBACA,UACA,WACA,aACA,aACA,UACA,KACA,QACA,4BACE;EAEJ,MAAM;GAAE;GAAgB;GAAU;GAAW;EAAY,CAAC;EAE1D,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,cAAc,eAAe,KAAK;EACvC,KAAK,WAAW,YAAY,KAAK;EACjC,KAAK,MAAM;EACX,KAAK,SAAS,UAAU,KAAK;EAC7B,KAAK,0BACH,2BAA2B,KAAK;CACpC;;;;;;;;CASA,MAAM,kBACJ,UACA,iBACiB;EACjB,MAAM,YAAA,GAAA,yBAAA,gBAAA,CAA2B,UAAU,KAAK,aAAa,KAAK,QAAQ;EAE1E,OAAO,MAAM,IADKC,kBAAAA,SAAS;GAAE,KAAK,KAAK;GAAK,QAAQ,KAAK;EAAO,CAC/C,CAAC,CAAC,QAAQ;GACzB,SAAS;GACT,WAAW;EACb,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,4BAAb,cAA+C,8BAA8B;CAC3E,SAAS;CAET,YAAY,QAAwC;EAClD,MAAM,MAAM;CACd;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;CAMA,MAAM,oBAAoB,GAA0C;EAClE,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,CAAC,IAAI,KAAK,wBAAwB,KAAK,MAAM,CAAC,EAEtD;EAGd,OAAO,GADW,KAAK,YAAY,KAAK,OAC5B;CACd;;;;;;;CAQA,MAAM,YACJ,aACA,cACe;EACf,MAAM,MAAM,YAAY,aAAa,YAAY;EACjD,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,KAAK,SAAS,MAAM,KAAK,kBAAkB,SAAS,MAAM,EAAE,GAAG,KAAK,MAAM;CAC5E;;;;;CAMA,MAAM,QAAQ;EACZ,MAAM,MAAM,MAAM;EAClB,KAAK,SAAS;CAChB;AACF"}

package/dist/memory/summary.d.cts

@@ -3,7 +3,6 @@ import { BaseMessage } from "@langchain/core/messages";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/summary.d.ts
 /**
  * Interface for the input parameters of the ConversationSummaryMemory

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

@@ -1 +1 @@
-{"version":3,"file":"summary.d.cts","names":[],"sources":["../../src/memory/summary.ts"],"mappings":";;;;;;;;;AAoBA;;UAAiB,8BAAA,SAAuC,kCAAA;;AAMxD;;;UAAiB,kCAAA,SAA2C,mBAAA;EAC1D,GAAA,EAAK,0BAAA;EACL,SAAA;EACA,WAAA;EACA,QAAA;EACA,MAAA,GAAS,kBAAA;EACT,uBAAA,QAA+B,OAAA,aAAoB,WAAA;AAAA;;;;;;uBAQ/B,6BAAA,SAAsC,cAAA;EAC1D,SAAA;EAEA,WAAA;EAEA,QAAA;EAEA,GAAA,EAAK,0BAAA;EAEL,MAAA,EAAQ,kBAAA;EAER,uBAAA,OAA8B,OAAA,aAAoB,WAAA;EAElD,WAAA,CAAY,MAAA,EAAQ,kCAAA;;;;;;;;EA+Bd,iBAAA,CACJ,QAAA,EAAU,WAAA,IACV,eAAA,WACC,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuCL;;;;;;;cAAa,yBAAA,SAAkC,6BAAA;EAC7C,MAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,8BAAA;EAAA,IAIhB,UAAA,CAAA;EAPyC;;;;EAevC,mBAAA,CAAoB,CAAA,EAAG,WAAA,GAAc,OAAA,CAAQ,eAAA;EAZnD;;;;;;EA6BM,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;EApBwC;;;;EA8BrC,KAAA,CAAA,GAAK,OAAA;AAAA"}
+{"version":3,"file":"summary.d.cts","names":[],"sources":["../../src/memory/summary.ts"],"mappings":";;;;;;;;;;UAoBiB,uCAAuC;;;;;UAMvC,2CAA2C;EAC1D,KAAK;EACL;EACA;EACA;EACA,SAAS;EACT,+BAA+B,oBAAoB;;;;;;;uBAQ/B,sCAAsC;EAC1D;EAEA;EAEA;EAEA,KAAK;EAEL,QAAQ;EAER,8BAA8B,oBAAoB;EAElD,YAAY,QAAQ;;;;;;;;EA+Bd,kBACJ,UAAU,eACV,0BACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCQ,kCAAkC;EAC7C;EAEA,YAAY,QAAQ;MAIhB;;;;;EAQE,oBAAoB,GAAG,cAAc,QAAQ;;;;;;;EAiB7C,YACJ,aAAa,aACb,cAAc,eACb;;;;;EAUG,SAAK"}

package/dist/memory/summary.d.ts

@@ -3,7 +3,6 @@ import { BaseMessage } from "@langchain/core/messages";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/summary.d.ts
 /**
  * Interface for the input parameters of the ConversationSummaryMemory

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

@@ -1 +1 @@
-{"version":3,"file":"summary.d.ts","names":[],"sources":["../../src/memory/summary.ts"],"mappings":";;;;;;;;;AAoBA;;UAAiB,8BAAA,SAAuC,kCAAA;;AAMxD;;;UAAiB,kCAAA,SAA2C,mBAAA;EAC1D,GAAA,EAAK,0BAAA;EACL,SAAA;EACA,WAAA;EACA,QAAA;EACA,MAAA,GAAS,kBAAA;EACT,uBAAA,QAA+B,OAAA,aAAoB,WAAA;AAAA;;;;;;uBAQ/B,6BAAA,SAAsC,cAAA;EAC1D,SAAA;EAEA,WAAA;EAEA,QAAA;EAEA,GAAA,EAAK,0BAAA;EAEL,MAAA,EAAQ,kBAAA;EAER,uBAAA,OAA8B,OAAA,aAAoB,WAAA;EAElD,WAAA,CAAY,MAAA,EAAQ,kCAAA;;;;;;;;EA+Bd,iBAAA,CACJ,QAAA,EAAU,WAAA,IACV,eAAA,WACC,OAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuCL;;;;;;;cAAa,yBAAA,SAAkC,6BAAA;EAC7C,MAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,8BAAA;EAAA,IAIhB,UAAA,CAAA;EAPyC;;;;EAevC,mBAAA,CAAoB,CAAA,EAAG,WAAA,GAAc,OAAA,CAAQ,eAAA;EAZnD;;;;;;EA6BM,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;EApBwC;;;;EA8BrC,KAAA,CAAA,GAAK,OAAA;AAAA"}
+{"version":3,"file":"summary.d.ts","names":[],"sources":["../../src/memory/summary.ts"],"mappings":";;;;;;;;;;UAoBiB,uCAAuC;;;;;UAMvC,2CAA2C;EAC1D,KAAK;EACL;EACA;EACA;EACA,SAAS;EACT,+BAA+B,oBAAoB;;;;;;;uBAQ/B,sCAAsC;EAC1D;EAEA;EAEA;EAEA,KAAK;EAEL,QAAQ;EAER,8BAA8B,oBAAoB;EAElD,YAAY,QAAQ;;;;;;;;EA+Bd,kBACJ,UAAU,eACV,0BACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuCQ,kCAAkC;EAC7C;EAEA,YAAY,QAAQ;MAIhB;;;;;EAQE,oBAAoB,GAAG,cAAc,QAAQ;;;;;;;EAiB7C,YACJ,aAAa,aACb,cAAc,eACb;;;;;EAUG,SAAK"}

package/dist/memory/summary.js.map

@@ -1 +1 @@
-{"version":3,"file":"summary.js","names":[],"sources":["../../src/memory/summary.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport {\n  BaseMessage,\n  SystemMessage,\n  getBufferString,\n} from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { SUMMARY_PROMPT } from \"./prompt.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {}\n\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  memoryKey?: string;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  prompt?: BasePromptTemplate;\n  summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n  memoryKey = \"history\";\n\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  llm: BaseLanguageModelInterface;\n\n  prompt: BasePromptTemplate = SUMMARY_PROMPT;\n\n  summaryChatMessageClass: new (content: string) => BaseMessage = SystemMessage;\n\n  constructor(fields: BaseConversationSummaryMemoryInput) {\n    const {\n      returnMessages,\n      inputKey,\n      outputKey,\n      chatHistory,\n      humanPrefix,\n      aiPrefix,\n      llm,\n      prompt,\n      summaryChatMessageClass,\n    } = fields;\n\n    super({ returnMessages, inputKey, outputKey, chatHistory });\n\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.humanPrefix = humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = aiPrefix ?? this.aiPrefix;\n    this.llm = llm;\n    this.prompt = prompt ?? this.prompt;\n    this.summaryChatMessageClass =\n      summaryChatMessageClass ?? this.summaryChatMessageClass;\n  }\n\n  /**\n   * Predicts a new summary for the conversation given the existing messages\n   * and summary.\n   * @param messages Existing messages in the conversation.\n   * @param existingSummary Current summary of the conversation.\n   * @returns A promise that resolves to a new summary string.\n   */\n  async predictNewSummary(\n    messages: BaseMessage[],\n    existingSummary: string\n  ): Promise<string> {\n    const newLines = getBufferString(messages, this.humanPrefix, this.aiPrefix);\n    const chain = new LLMChain({ llm: this.llm, prompt: this.prompt });\n    return await chain.predict({\n      summary: existingSummary,\n      new_lines: newLines,\n    });\n  }\n}\n\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n  buffer = \"\";\n\n  constructor(fields: ConversationSummaryMemoryInput) {\n    super(fields);\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Loads the memory variables for the conversation memory.\n   * @returns A promise that resolves to an object containing the memory variables.\n   */\n  async loadMemoryVariables(_: InputValues): Promise<MemoryVariables> {\n    if (this.returnMessages) {\n      const result = {\n        [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)],\n      };\n      return result;\n    }\n    const result = { [this.memoryKey]: this.buffer };\n    return result;\n  }\n\n  /**\n   * Saves the context of the conversation memory.\n   * @param inputValues Input values for the conversation.\n   * @param outputValues Output values from the conversation.\n   * @returns A promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    const messages = await this.chatHistory.getMessages();\n    this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);\n  }\n\n  /**\n   * Clears the conversation memory.\n   * @returns A promise that resolves when the memory has been cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.buffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;AAwCA,IAAsB,gCAAtB,cAA4D,eAAe;CACzE,YAAY;CAEZ,cAAc;CAEd,WAAW;CAEX;CAEA,SAA6B;CAE7B,0BAAgE;CAEhE,YAAY,QAA4C;EACtD,MAAM,EACJ,gBACA,UACA,WACA,aACA,aACA,UACA,KACA,QACA,4BACE;AAEJ,QAAM;GAAE;GAAgB;GAAU;GAAW;GAAa,CAAC;AAE3D,OAAK,YAAY,QAAQ,aAAa,KAAK;AAC3C,OAAK,cAAc,eAAe,KAAK;AACvC,OAAK,WAAW,YAAY,KAAK;AACjC,OAAK,MAAM;AACX,OAAK,SAAS,UAAU,KAAK;AAC7B,OAAK,0BACH,2BAA2B,KAAK;;;;;;;;;CAUpC,MAAM,kBACJ,UACA,iBACiB;EACjB,MAAM,WAAW,gBAAgB,UAAU,KAAK,aAAa,KAAK,SAAS;AAE3E,SAAO,MAAM,IADK,SAAS;GAAE,KAAK,KAAK;GAAK,QAAQ,KAAK;GAAQ,CAC/C,CAAC,QAAQ;GACzB,SAAS;GACT,WAAW;GACZ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCN,IAAa,4BAAb,cAA+C,8BAA8B;CAC3E,SAAS;CAET,YAAY,QAAwC;AAClD,QAAM,OAAO;;CAGf,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;CAOzB,MAAM,oBAAoB,GAA0C;AAClE,MAAI,KAAK,eAIP,QAAO,GAFJ,KAAK,YAAY,CAAC,IAAI,KAAK,wBAAwB,KAAK,OAAO,CAAC,EAEtD;AAGf,SAAO,GADW,KAAK,YAAY,KAAK,QAC3B;;;;;;;;CASf,MAAM,YACJ,aACA,cACe;AACf,QAAM,MAAM,YAAY,aAAa,aAAa;EAClD,MAAM,WAAW,MAAM,KAAK,YAAY,aAAa;AACrD,OAAK,SAAS,MAAM,KAAK,kBAAkB,SAAS,MAAM,GAAG,EAAE,KAAK,OAAO;;;;;;CAO7E,MAAM,QAAQ;AACZ,QAAM,MAAM,OAAO;AACnB,OAAK,SAAS"}
+{"version":3,"file":"summary.js","names":[],"sources":["../../src/memory/summary.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport {\n  BaseMessage,\n  SystemMessage,\n  getBufferString,\n} from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { SUMMARY_PROMPT } from \"./prompt.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {}\n\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n  llm: BaseLanguageModelInterface;\n  memoryKey?: string;\n  humanPrefix?: string;\n  aiPrefix?: string;\n  prompt?: BasePromptTemplate;\n  summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n  memoryKey = \"history\";\n\n  humanPrefix = \"Human\";\n\n  aiPrefix = \"AI\";\n\n  llm: BaseLanguageModelInterface;\n\n  prompt: BasePromptTemplate = SUMMARY_PROMPT;\n\n  summaryChatMessageClass: new (content: string) => BaseMessage = SystemMessage;\n\n  constructor(fields: BaseConversationSummaryMemoryInput) {\n    const {\n      returnMessages,\n      inputKey,\n      outputKey,\n      chatHistory,\n      humanPrefix,\n      aiPrefix,\n      llm,\n      prompt,\n      summaryChatMessageClass,\n    } = fields;\n\n    super({ returnMessages, inputKey, outputKey, chatHistory });\n\n    this.memoryKey = fields?.memoryKey ?? this.memoryKey;\n    this.humanPrefix = humanPrefix ?? this.humanPrefix;\n    this.aiPrefix = aiPrefix ?? this.aiPrefix;\n    this.llm = llm;\n    this.prompt = prompt ?? this.prompt;\n    this.summaryChatMessageClass =\n      summaryChatMessageClass ?? this.summaryChatMessageClass;\n  }\n\n  /**\n   * Predicts a new summary for the conversation given the existing messages\n   * and summary.\n   * @param messages Existing messages in the conversation.\n   * @param existingSummary Current summary of the conversation.\n   * @returns A promise that resolves to a new summary string.\n   */\n  async predictNewSummary(\n    messages: BaseMessage[],\n    existingSummary: string\n  ): Promise<string> {\n    const newLines = getBufferString(messages, this.humanPrefix, this.aiPrefix);\n    const chain = new LLMChain({ llm: this.llm, prompt: this.prompt });\n    return await chain.predict({\n      summary: existingSummary,\n      new_lines: newLines,\n    });\n  }\n}\n\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n  buffer = \"\";\n\n  constructor(fields: ConversationSummaryMemoryInput) {\n    super(fields);\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Loads the memory variables for the conversation memory.\n   * @returns A promise that resolves to an object containing the memory variables.\n   */\n  async loadMemoryVariables(_: InputValues): Promise<MemoryVariables> {\n    if (this.returnMessages) {\n      const result = {\n        [this.memoryKey]: [new this.summaryChatMessageClass(this.buffer)],\n      };\n      return result;\n    }\n    const result = { [this.memoryKey]: this.buffer };\n    return result;\n  }\n\n  /**\n   * Saves the context of the conversation memory.\n   * @param inputValues Input values for the conversation.\n   * @param outputValues Output values from the conversation.\n   * @returns A promise that resolves when the context has been saved.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    const messages = await this.chatHistory.getMessages();\n    this.buffer = await this.predictNewSummary(messages.slice(-2), this.buffer);\n  }\n\n  /**\n   * Clears the conversation memory.\n   * @returns A promise that resolves when the memory has been cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.buffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;AAwCA,IAAsB,gCAAtB,cAA4D,eAAe;CACzE,YAAY;CAEZ,cAAc;CAEd,WAAW;CAEX;CAEA,SAA6B;CAE7B,0BAAgE;CAEhE,YAAY,QAA4C;EACtD,MAAM,EACJ,gBACA,UACA,WACA,aACA,aACA,UACA,KACA,QACA,4BACE;EAEJ,MAAM;GAAE;GAAgB;GAAU;GAAW;EAAY,CAAC;EAE1D,KAAK,YAAY,QAAQ,aAAa,KAAK;EAC3C,KAAK,cAAc,eAAe,KAAK;EACvC,KAAK,WAAW,YAAY,KAAK;EACjC,KAAK,MAAM;EACX,KAAK,SAAS,UAAU,KAAK;EAC7B,KAAK,0BACH,2BAA2B,KAAK;CACpC;;;;;;;;CASA,MAAM,kBACJ,UACA,iBACiB;EACjB,MAAM,WAAW,gBAAgB,UAAU,KAAK,aAAa,KAAK,QAAQ;EAE1E,OAAO,MAAM,IADK,SAAS;GAAE,KAAK,KAAK;GAAK,QAAQ,KAAK;EAAO,CAC/C,CAAC,CAAC,QAAQ;GACzB,SAAS;GACT,WAAW;EACb,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,4BAAb,cAA+C,8BAA8B;CAC3E,SAAS;CAET,YAAY,QAAwC;EAClD,MAAM,MAAM;CACd;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;CAMA,MAAM,oBAAoB,GAA0C;EAClE,IAAI,KAAK,gBAIP,OAAO,GAFJ,KAAK,YAAY,CAAC,IAAI,KAAK,wBAAwB,KAAK,MAAM,CAAC,EAEtD;EAGd,OAAO,GADW,KAAK,YAAY,KAAK,OAC5B;CACd;;;;;;;CAQA,MAAM,YACJ,aACA,cACe;EACf,MAAM,MAAM,YAAY,aAAa,YAAY;EACjD,MAAM,WAAW,MAAM,KAAK,YAAY,YAAY;EACpD,KAAK,SAAS,MAAM,KAAK,kBAAkB,SAAS,MAAM,EAAE,GAAG,KAAK,MAAM;CAC5E;;;;;CAMA,MAAM,QAAQ;EACZ,MAAM,MAAM,MAAM;EAClB,KAAK,SAAS;CAChB;AACF"}

package/dist/memory/summary_buffer.cjs

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

package/dist/memory/summary_buffer.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"summary_buffer.cjs","names":["BaseConversationSummaryMemory"],"sources":["../../src/memory/summary_buffer.ts"],"sourcesContent":["import { getBufferString } from \"@langchain/core/messages\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport {\n  BaseConversationSummaryMemory,\n  BaseConversationSummaryMemoryInput,\n} from \"./summary.js\";\n\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n  maxTokenLimit?: number;\n}\n\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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 *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport class ConversationSummaryBufferMemory\n  extends BaseConversationSummaryMemory\n  implements ConversationSummaryBufferMemoryInput\n{\n  movingSummaryBuffer = \"\";\n\n  maxTokenLimit = 2000;\n\n  constructor(fields: ConversationSummaryBufferMemoryInput) {\n    super(fields);\n\n    this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method that loads the chat messages from the memory and returns them as\n   * a string or as a list of messages, depending on the returnMessages\n   * property.\n   * @param _ InputValues object, not used in this method.\n   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n   */\n  async loadMemoryVariables(_?: InputValues): Promise<MemoryVariables> {\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\n    let finalBuffer;\n    if (this.returnMessages) {\n      finalBuffer = buffer;\n    } else {\n      finalBuffer = getBufferString(buffer, this.humanPrefix, this.aiPrefix);\n    }\n\n    return { [this.memoryKey]: finalBuffer };\n  }\n\n  /**\n   * Method that saves the context of the conversation, including the input\n   * and output values, and prunes the memory if it exceeds the maximum\n   * token limit.\n   * @param inputValues InputValues object containing the input values of the conversation.\n   * @param outputValues OutputValues object containing the output values of the conversation.\n   * @returns Promise that resolves when the context is saved and the memory is pruned.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    await this.prune();\n  }\n\n  /**\n   * Method that prunes the memory if the total number of tokens in the\n   * buffer exceeds the maxTokenLimit. It removes messages from the\n   * beginning of the buffer until the total number of tokens is within the\n   * limit.\n   * @returns Promise that resolves when the memory is pruned.\n   */\n  async prune() {\n    // Prune buffer if it exceeds max token limit\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\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        const poppedMessage = buffer.shift();\n        if (poppedMessage) {\n          prunedMemory.push(poppedMessage);\n          currBufferLength = await this.llm.getNumTokens(\n            getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n          );\n        }\n      }\n      this.movingSummaryBuffer = await this.predictNewSummary(\n        prunedMemory,\n        this.movingSummaryBuffer\n      );\n    }\n  }\n\n  /**\n   * Method that clears the memory and resets the movingSummaryBuffer.\n   * @returns Promise that resolves when the memory is cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.movingSummaryBuffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,kCAAb,cACUA,gBAAAA,8BAEV;CACE,sBAAsB;CAEtB,gBAAgB;CAEhB,YAAY,QAA8C;AACxD,QAAM,OAAO;AAEb,OAAK,gBAAgB,QAAQ,iBAAiB,KAAK;;CAGrD,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,GAA2C;EACnE,IAAI,SAAS,MAAM,KAAK,YAAY,aAAa;AACjD,MAAI,KAAK,oBACP,UAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,oBAAoB,EAC1D,GAAG,OACJ;EAGH,IAAI;AACJ,MAAI,KAAK,eACP,eAAc;MAEd,gBAAA,GAAA,yBAAA,iBAA8B,QAAQ,KAAK,aAAa,KAAK,SAAS;AAGxE,SAAO,GAAG,KAAK,YAAY,aAAa;;;;;;;;;;CAW1C,MAAM,YACJ,aACA,cACe;AACf,QAAM,MAAM,YAAY,aAAa,aAAa;AAClD,QAAM,KAAK,OAAO;;;;;;;;;CAUpB,MAAM,QAAQ;EAEZ,IAAI,SAAS,MAAM,KAAK,YAAY,aAAa;AACjD,MAAI,KAAK,oBACP,UAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,oBAAoB,EAC1D,GAAG,OACJ;EAGH,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;IAC5C,MAAM,gBAAgB,OAAO,OAAO;AACpC,QAAI,eAAe;AACjB,kBAAa,KAAK,cAAc;AAChC,wBAAmB,MAAM,KAAK,IAAI,cAAA,GAAA,yBAAA,iBAChB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;;;AAGL,QAAK,sBAAsB,MAAM,KAAK,kBACpC,cACA,KAAK,oBACN;;;;;;;CAQL,MAAM,QAAQ;AACZ,QAAM,MAAM,OAAO;AACnB,OAAK,sBAAsB"}
+{"version":3,"file":"summary_buffer.cjs","names":["BaseConversationSummaryMemory"],"sources":["../../src/memory/summary_buffer.ts"],"sourcesContent":["import { getBufferString } from \"@langchain/core/messages\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport {\n  BaseConversationSummaryMemory,\n  BaseConversationSummaryMemoryInput,\n} from \"./summary.js\";\n\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n  maxTokenLimit?: number;\n}\n\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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 *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport class ConversationSummaryBufferMemory\n  extends BaseConversationSummaryMemory\n  implements ConversationSummaryBufferMemoryInput\n{\n  movingSummaryBuffer = \"\";\n\n  maxTokenLimit = 2000;\n\n  constructor(fields: ConversationSummaryBufferMemoryInput) {\n    super(fields);\n\n    this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method that loads the chat messages from the memory and returns them as\n   * a string or as a list of messages, depending on the returnMessages\n   * property.\n   * @param _ InputValues object, not used in this method.\n   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n   */\n  async loadMemoryVariables(_?: InputValues): Promise<MemoryVariables> {\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\n    let finalBuffer;\n    if (this.returnMessages) {\n      finalBuffer = buffer;\n    } else {\n      finalBuffer = getBufferString(buffer, this.humanPrefix, this.aiPrefix);\n    }\n\n    return { [this.memoryKey]: finalBuffer };\n  }\n\n  /**\n   * Method that saves the context of the conversation, including the input\n   * and output values, and prunes the memory if it exceeds the maximum\n   * token limit.\n   * @param inputValues InputValues object containing the input values of the conversation.\n   * @param outputValues OutputValues object containing the output values of the conversation.\n   * @returns Promise that resolves when the context is saved and the memory is pruned.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    await this.prune();\n  }\n\n  /**\n   * Method that prunes the memory if the total number of tokens in the\n   * buffer exceeds the maxTokenLimit. It removes messages from the\n   * beginning of the buffer until the total number of tokens is within the\n   * limit.\n   * @returns Promise that resolves when the memory is pruned.\n   */\n  async prune() {\n    // Prune buffer if it exceeds max token limit\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\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        const poppedMessage = buffer.shift();\n        if (poppedMessage) {\n          prunedMemory.push(poppedMessage);\n          currBufferLength = await this.llm.getNumTokens(\n            getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n          );\n        }\n      }\n      this.movingSummaryBuffer = await this.predictNewSummary(\n        prunedMemory,\n        this.movingSummaryBuffer\n      );\n    }\n  }\n\n  /**\n   * Method that clears the memory and resets the movingSummaryBuffer.\n   * @returns Promise that resolves when the memory is cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.movingSummaryBuffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,kCAAb,cACUA,gBAAAA,8BAEV;CACE,sBAAsB;CAEtB,gBAAgB;CAEhB,YAAY,QAA8C;EACxD,MAAM,MAAM;EAEZ,KAAK,gBAAgB,QAAQ,iBAAiB,KAAK;CACrD;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,GAA2C;EACnE,IAAI,SAAS,MAAM,KAAK,YAAY,YAAY;EAChD,IAAI,KAAK,qBACP,SAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,mBAAmB,GACzD,GAAG,MACL;EAGF,IAAI;EACJ,IAAI,KAAK,gBACP,cAAc;OAEd,eAAA,GAAA,yBAAA,gBAAA,CAA8B,QAAQ,KAAK,aAAa,KAAK,QAAQ;EAGvE,OAAO,GAAG,KAAK,YAAY,YAAY;CACzC;;;;;;;;;CAUA,MAAM,YACJ,aACA,cACe;EACf,MAAM,MAAM,YAAY,aAAa,YAAY;EACjD,MAAM,KAAK,MAAM;CACnB;;;;;;;;CASA,MAAM,QAAQ;EAEZ,IAAI,SAAS,MAAM,KAAK,YAAY,YAAY;EAChD,IAAI,KAAK,qBACP,SAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,mBAAmB,GACzD,GAAG,MACL;EAGF,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,MAAM,gBAAgB,OAAO,MAAM;IACnC,IAAI,eAAe;KACjB,aAAa,KAAK,aAAa;KAC/B,mBAAmB,MAAM,KAAK,IAAI,cAAA,GAAA,yBAAA,gBAAA,CAChB,QAAQ,KAAK,aAAa,KAAK,QAAQ,CACzD;IACF;GACF;GACA,KAAK,sBAAsB,MAAM,KAAK,kBACpC,cACA,KAAK,mBACP;EACF;CACF;;;;;CAMA,MAAM,QAAQ;EACZ,MAAM,MAAM,MAAM;EAClB,KAAK,sBAAsB;CAC7B;AACF"}

package/dist/memory/summary_buffer.d.cts

@@ -1,6 +1,5 @@
 import { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from "./summary.cjs";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/summary_buffer.d.ts
 /**
  * Interface for the input parameters of the

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

@@ -1 +1 @@
-{"version":3,"file":"summary_buffer.d.cts","names":[],"sources":["../../src/memory/summary_buffer.ts"],"mappings":";;;;;;AAeA;;UAAiB,oCAAA,SAA6C,kCAAA;EAC5D,aAAA;AAAA;AA0CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,cAAa,+BAAA,SACH,6BAAA,YACG,oCAAA;EAEX,mBAAA;EAEA,aAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,oCAAA;EAAA,IAMhB,UAAA,CAAA;;;;;;;;EAWE,mBAAA,CAAoB,CAAA,GAAI,WAAA,GAAc,OAAA,CAAQ,eAAA;;;;;;;;;EA2B9C,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;;;;;;;;EAYG,KAAA,CAAA,GAAK,OAAA;;;;;EAoCL,KAAA,CAAA,GAAK,OAAA;AAAA"}
+{"version":3,"file":"summary_buffer.d.cts","names":[],"sources":["../../src/memory/summary_buffer.ts"],"mappings":";;;;;;;UAeiB,6CAA6C;EAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0CW,wCACH,yCACG;EAEX;EAEA;EAEA,YAAY,QAAQ;MAMhB;;;;;;;;EAWE,oBAAoB,IAAI,cAAc,QAAQ;;;;;;;;;EA2B9C,YACJ,aAAa,aACb,cAAc,eACb;;;;;;;;EAYG,SAAK;;;;;EAoCL,SAAK"}

package/dist/memory/summary_buffer.d.ts

@@ -1,6 +1,5 @@
 import { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from "./summary.js";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
 //#region src/memory/summary_buffer.d.ts
 /**
  * Interface for the input parameters of the

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

@@ -1 +1 @@
-{"version":3,"file":"summary_buffer.d.ts","names":[],"sources":["../../src/memory/summary_buffer.ts"],"mappings":";;;;;;AAeA;;UAAiB,oCAAA,SAA6C,kCAAA;EAC5D,aAAA;AAAA;AA0CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,cAAa,+BAAA,SACH,6BAAA,YACG,oCAAA;EAEX,mBAAA;EAEA,aAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,oCAAA;EAAA,IAMhB,UAAA,CAAA;;;;;;;;EAWE,mBAAA,CAAoB,CAAA,GAAI,WAAA,GAAc,OAAA,CAAQ,eAAA;;;;;;;;;EA2B9C,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;;;;;;;;EAYG,KAAA,CAAA,GAAK,OAAA;;;;;EAoCL,KAAA,CAAA,GAAK,OAAA;AAAA"}
+{"version":3,"file":"summary_buffer.d.ts","names":[],"sources":["../../src/memory/summary_buffer.ts"],"mappings":";;;;;;;UAeiB,6CAA6C;EAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0CW,wCACH,yCACG;EAEX;EAEA;EAEA,YAAY,QAAQ;MAMhB;;;;;;;;EAWE,oBAAoB,IAAI,cAAc,QAAQ;;;;;;;;;EA2B9C,YACJ,aAAa,aACb,cAAc,eACb;;;;;;;;EAYG,SAAK;;;;;EAoCL,SAAK"}

package/dist/memory/summary_buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"summary_buffer.js","names":[],"sources":["../../src/memory/summary_buffer.ts"],"sourcesContent":["import { getBufferString } from \"@langchain/core/messages\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport {\n  BaseConversationSummaryMemory,\n  BaseConversationSummaryMemoryInput,\n} from \"./summary.js\";\n\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n  maxTokenLimit?: number;\n}\n\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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 *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport class ConversationSummaryBufferMemory\n  extends BaseConversationSummaryMemory\n  implements ConversationSummaryBufferMemoryInput\n{\n  movingSummaryBuffer = \"\";\n\n  maxTokenLimit = 2000;\n\n  constructor(fields: ConversationSummaryBufferMemoryInput) {\n    super(fields);\n\n    this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method that loads the chat messages from the memory and returns them as\n   * a string or as a list of messages, depending on the returnMessages\n   * property.\n   * @param _ InputValues object, not used in this method.\n   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n   */\n  async loadMemoryVariables(_?: InputValues): Promise<MemoryVariables> {\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\n    let finalBuffer;\n    if (this.returnMessages) {\n      finalBuffer = buffer;\n    } else {\n      finalBuffer = getBufferString(buffer, this.humanPrefix, this.aiPrefix);\n    }\n\n    return { [this.memoryKey]: finalBuffer };\n  }\n\n  /**\n   * Method that saves the context of the conversation, including the input\n   * and output values, and prunes the memory if it exceeds the maximum\n   * token limit.\n   * @param inputValues InputValues object containing the input values of the conversation.\n   * @param outputValues OutputValues object containing the output values of the conversation.\n   * @returns Promise that resolves when the context is saved and the memory is pruned.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    await this.prune();\n  }\n\n  /**\n   * Method that prunes the memory if the total number of tokens in the\n   * buffer exceeds the maxTokenLimit. It removes messages from the\n   * beginning of the buffer until the total number of tokens is within the\n   * limit.\n   * @returns Promise that resolves when the memory is pruned.\n   */\n  async prune() {\n    // Prune buffer if it exceeds max token limit\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\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        const poppedMessage = buffer.shift();\n        if (poppedMessage) {\n          prunedMemory.push(poppedMessage);\n          currBufferLength = await this.llm.getNumTokens(\n            getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n          );\n        }\n      }\n      this.movingSummaryBuffer = await this.predictNewSummary(\n        prunedMemory,\n        this.movingSummaryBuffer\n      );\n    }\n  }\n\n  /**\n   * Method that clears the memory and resets the movingSummaryBuffer.\n   * @returns Promise that resolves when the memory is cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.movingSummaryBuffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,kCAAb,cACU,8BAEV;CACE,sBAAsB;CAEtB,gBAAgB;CAEhB,YAAY,QAA8C;AACxD,QAAM,OAAO;AAEb,OAAK,gBAAgB,QAAQ,iBAAiB,KAAK;;CAGrD,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,GAA2C;EACnE,IAAI,SAAS,MAAM,KAAK,YAAY,aAAa;AACjD,MAAI,KAAK,oBACP,UAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,oBAAoB,EAC1D,GAAG,OACJ;EAGH,IAAI;AACJ,MAAI,KAAK,eACP,eAAc;MAEd,eAAc,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS;AAGxE,SAAO,GAAG,KAAK,YAAY,aAAa;;;;;;;;;;CAW1C,MAAM,YACJ,aACA,cACe;AACf,QAAM,MAAM,YAAY,aAAa,aAAa;AAClD,QAAM,KAAK,OAAO;;;;;;;;;CAUpB,MAAM,QAAQ;EAEZ,IAAI,SAAS,MAAM,KAAK,YAAY,aAAa;AACjD,MAAI,KAAK,oBACP,UAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,oBAAoB,EAC1D,GAAG,OACJ;EAGH,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;IAC5C,MAAM,gBAAgB,OAAO,OAAO;AACpC,QAAI,eAAe;AACjB,kBAAa,KAAK,cAAc;AAChC,wBAAmB,MAAM,KAAK,IAAI,aAChC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;;;AAGL,QAAK,sBAAsB,MAAM,KAAK,kBACpC,cACA,KAAK,oBACN;;;;;;;CAQL,MAAM,QAAQ;AACZ,QAAM,MAAM,OAAO;AACnB,OAAK,sBAAsB"}
+{"version":3,"file":"summary_buffer.js","names":[],"sources":["../../src/memory/summary_buffer.ts"],"sourcesContent":["import { getBufferString } from \"@langchain/core/messages\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport {\n  BaseConversationSummaryMemory,\n  BaseConversationSummaryMemoryInput,\n} from \"./summary.js\";\n\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n  maxTokenLimit?: number;\n}\n\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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 *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport class ConversationSummaryBufferMemory\n  extends BaseConversationSummaryMemory\n  implements ConversationSummaryBufferMemoryInput\n{\n  movingSummaryBuffer = \"\";\n\n  maxTokenLimit = 2000;\n\n  constructor(fields: ConversationSummaryBufferMemoryInput) {\n    super(fields);\n\n    this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method that loads the chat messages from the memory and returns them as\n   * a string or as a list of messages, depending on the returnMessages\n   * property.\n   * @param _ InputValues object, not used in this method.\n   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n   */\n  async loadMemoryVariables(_?: InputValues): Promise<MemoryVariables> {\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\n    let finalBuffer;\n    if (this.returnMessages) {\n      finalBuffer = buffer;\n    } else {\n      finalBuffer = getBufferString(buffer, this.humanPrefix, this.aiPrefix);\n    }\n\n    return { [this.memoryKey]: finalBuffer };\n  }\n\n  /**\n   * Method that saves the context of the conversation, including the input\n   * and output values, and prunes the memory if it exceeds the maximum\n   * token limit.\n   * @param inputValues InputValues object containing the input values of the conversation.\n   * @param outputValues OutputValues object containing the output values of the conversation.\n   * @returns Promise that resolves when the context is saved and the memory is pruned.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    await this.prune();\n  }\n\n  /**\n   * Method that prunes the memory if the total number of tokens in the\n   * buffer exceeds the maxTokenLimit. It removes messages from the\n   * beginning of the buffer until the total number of tokens is within the\n   * limit.\n   * @returns Promise that resolves when the memory is pruned.\n   */\n  async prune() {\n    // Prune buffer if it exceeds max token limit\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\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        const poppedMessage = buffer.shift();\n        if (poppedMessage) {\n          prunedMemory.push(poppedMessage);\n          currBufferLength = await this.llm.getNumTokens(\n            getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n          );\n        }\n      }\n      this.movingSummaryBuffer = await this.predictNewSummary(\n        prunedMemory,\n        this.movingSummaryBuffer\n      );\n    }\n  }\n\n  /**\n   * Method that clears the memory and resets the movingSummaryBuffer.\n   * @returns Promise that resolves when the memory is cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.movingSummaryBuffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,kCAAb,cACU,8BAEV;CACE,sBAAsB;CAEtB,gBAAgB;CAEhB,YAAY,QAA8C;EACxD,MAAM,MAAM;EAEZ,KAAK,gBAAgB,QAAQ,iBAAiB,KAAK;CACrD;CAEA,IAAI,aAAa;EACf,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,GAA2C;EACnE,IAAI,SAAS,MAAM,KAAK,YAAY,YAAY;EAChD,IAAI,KAAK,qBACP,SAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,mBAAmB,GACzD,GAAG,MACL;EAGF,IAAI;EACJ,IAAI,KAAK,gBACP,cAAc;OAEd,cAAc,gBAAgB,QAAQ,KAAK,aAAa,KAAK,QAAQ;EAGvE,OAAO,GAAG,KAAK,YAAY,YAAY;CACzC;;;;;;;;;CAUA,MAAM,YACJ,aACA,cACe;EACf,MAAM,MAAM,YAAY,aAAa,YAAY;EACjD,MAAM,KAAK,MAAM;CACnB;;;;;;;;CASA,MAAM,QAAQ;EAEZ,IAAI,SAAS,MAAM,KAAK,YAAY,YAAY;EAChD,IAAI,KAAK,qBACP,SAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,mBAAmB,GACzD,GAAG,MACL;EAGF,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,MAAM,gBAAgB,OAAO,MAAM;IACnC,IAAI,eAAe;KACjB,aAAa,KAAK,aAAa;KAC/B,mBAAmB,MAAM,KAAK,IAAI,aAChC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,QAAQ,CACzD;IACF;GACF;GACA,KAAK,sBAAsB,MAAM,KAAK,kBACpC,cACA,KAAK,mBACP;EACF;CACF;;;;;CAMA,MAAM,QAAQ;EACZ,MAAM,MAAM,MAAM;EAClB,KAAK,sBAAsB;CAC7B;AACF"}

package/dist/memory/vector_store.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_util_document = require("../util/document.cjs");
 let _langchain_core_memory = require("@langchain/core/memory");
 let _langchain_core_documents = require("@langchain/core/documents");

package/dist/memory/vector_store.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"vector_store.cjs","names":["BaseMemory","formatDocumentsAsString","Document"],"sources":["../../src/memory/vector_store.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport {\n  BaseMemory,\n  getInputValue,\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { formatDocumentsAsString } from \"../util/document.js\";\n\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (\n  inputValues?: InputValues,\n  outputValues?: OutputValues\n) => Metadata;\n\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n  inputKey?: string;\n  outputKey?: string;\n  memoryKey?: string;\n  returnDocs?: boolean;\n  /**\n   * Metadata to be added to the document when saving context.\n   */\n  metadata?: Metadata | MetadataFunction;\n}\n\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport class VectorStoreRetrieverMemory\n  extends BaseMemory\n  implements VectorStoreRetrieverMemoryParams\n{\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n\n  inputKey?: string;\n\n  memoryKey: string;\n\n  returnDocs: boolean;\n\n  metadata?: Metadata | MetadataFunction;\n\n  constructor(fields: VectorStoreRetrieverMemoryParams) {\n    super();\n    this.vectorStoreRetriever = fields.vectorStoreRetriever;\n    this.inputKey = fields.inputKey;\n    this.memoryKey = fields.memoryKey ?? \"memory\";\n    this.returnDocs = fields.returnDocs ?? false;\n    this.metadata = fields.metadata;\n  }\n\n  get memoryKeys(): string[] {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method to load memory variables. It uses the vectorStoreRetriever to\n   * get relevant documents based on the query obtained from the input\n   * values.\n   * @param values An InputValues object.\n   * @returns A Promise that resolves to a MemoryVariables object.\n   */\n  async loadMemoryVariables(values: InputValues): Promise<MemoryVariables> {\n    const query = getInputValue(values, this.inputKey);\n    const results = await this.vectorStoreRetriever.invoke(query);\n    return {\n      [this.memoryKey]: this.returnDocs\n        ? results\n        : formatDocumentsAsString(results),\n    };\n  }\n\n  /**\n   * Method to save context. It constructs a document from the input and\n   * output values (excluding the memory key) and adds it to the vector\n   * store database using the vectorStoreRetriever.\n   * @param inputValues An InputValues object.\n   * @param outputValues An OutputValues object.\n   * @returns A Promise that resolves to void.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    const metadata =\n      typeof this.metadata === \"function\"\n        ? this.metadata(inputValues, outputValues)\n        : this.metadata;\n    const text = Object.entries(inputValues)\n      .filter(([k]) => k !== this.memoryKey)\n      .concat(Object.entries(outputValues))\n      .map(([k, v]) => `${k}: ${v}`)\n      .join(\"\\n\");\n    await this.vectorStoreRetriever.addDocuments([\n      new Document({ pageContent: text, metadata }),\n    ]);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,IAAa,6BAAb,cACUA,uBAAAA,WAEV;CACE;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAA0C;AACpD,SAAO;AACP,OAAK,uBAAuB,OAAO;AACnC,OAAK,WAAW,OAAO;AACvB,OAAK,YAAY,OAAO,aAAa;AACrC,OAAK,aAAa,OAAO,cAAc;AACvC,OAAK,WAAW,OAAO;;CAGzB,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,QAA+C;EACvE,MAAM,SAAA,GAAA,uBAAA,eAAsB,QAAQ,KAAK,SAAS;EAClD,MAAM,UAAU,MAAM,KAAK,qBAAqB,OAAO,MAAM;AAC7D,SAAO,GACJ,KAAK,YAAY,KAAK,aACnB,UACAC,sBAAAA,wBAAwB,QAAQ,EACrC;;;;;;;;;;CAWH,MAAM,YACJ,aACA,cACe;EACf,MAAM,WACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,aAAa,aAAa,GACxC,KAAK;EACX,MAAM,OAAO,OAAO,QAAQ,YAAY,CACrC,QAAQ,CAAC,OAAO,MAAM,KAAK,UAAU,CACrC,OAAO,OAAO,QAAQ,aAAa,CAAC,CACpC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,IAAI,IAAI,CAC7B,KAAK,KAAK;AACb,QAAM,KAAK,qBAAqB,aAAa,CAC3C,IAAIC,0BAAAA,SAAS;GAAE,aAAa;GAAM;GAAU,CAAC,CAC9C,CAAC"}
+{"version":3,"file":"vector_store.cjs","names":["BaseMemory","formatDocumentsAsString","Document"],"sources":["../../src/memory/vector_store.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport {\n  BaseMemory,\n  getInputValue,\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { formatDocumentsAsString } from \"../util/document.js\";\n\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (\n  inputValues?: InputValues,\n  outputValues?: OutputValues\n) => Metadata;\n\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n  inputKey?: string;\n  outputKey?: string;\n  memoryKey?: string;\n  returnDocs?: boolean;\n  /**\n   * Metadata to be added to the document when saving context.\n   */\n  metadata?: Metadata | MetadataFunction;\n}\n\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport class VectorStoreRetrieverMemory\n  extends BaseMemory\n  implements VectorStoreRetrieverMemoryParams\n{\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n\n  inputKey?: string;\n\n  memoryKey: string;\n\n  returnDocs: boolean;\n\n  metadata?: Metadata | MetadataFunction;\n\n  constructor(fields: VectorStoreRetrieverMemoryParams) {\n    super();\n    this.vectorStoreRetriever = fields.vectorStoreRetriever;\n    this.inputKey = fields.inputKey;\n    this.memoryKey = fields.memoryKey ?? \"memory\";\n    this.returnDocs = fields.returnDocs ?? false;\n    this.metadata = fields.metadata;\n  }\n\n  get memoryKeys(): string[] {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method to load memory variables. It uses the vectorStoreRetriever to\n   * get relevant documents based on the query obtained from the input\n   * values.\n   * @param values An InputValues object.\n   * @returns A Promise that resolves to a MemoryVariables object.\n   */\n  async loadMemoryVariables(values: InputValues): Promise<MemoryVariables> {\n    const query = getInputValue(values, this.inputKey);\n    const results = await this.vectorStoreRetriever.invoke(query);\n    return {\n      [this.memoryKey]: this.returnDocs\n        ? results\n        : formatDocumentsAsString(results),\n    };\n  }\n\n  /**\n   * Method to save context. It constructs a document from the input and\n   * output values (excluding the memory key) and adds it to the vector\n   * store database using the vectorStoreRetriever.\n   * @param inputValues An InputValues object.\n   * @param outputValues An OutputValues object.\n   * @returns A Promise that resolves to void.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    const metadata =\n      typeof this.metadata === \"function\"\n        ? this.metadata(inputValues, outputValues)\n        : this.metadata;\n    const text = Object.entries(inputValues)\n      .filter(([k]) => k !== this.memoryKey)\n      .concat(Object.entries(outputValues))\n      .map(([k, v]) => `${k}: ${v}`)\n      .join(\"\\n\");\n    await this.vectorStoreRetriever.addDocuments([\n      new Document({ pageContent: text, metadata }),\n    ]);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,IAAa,6BAAb,cACUA,uBAAAA,WAEV;CACE;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAA0C;EACpD,MAAM;EACN,KAAK,uBAAuB,OAAO;EACnC,KAAK,WAAW,OAAO;EACvB,KAAK,YAAY,OAAO,aAAa;EACrC,KAAK,aAAa,OAAO,cAAc;EACvC,KAAK,WAAW,OAAO;CACzB;CAEA,IAAI,aAAuB;EACzB,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,QAA+C;EACvE,MAAM,SAAA,GAAA,uBAAA,cAAA,CAAsB,QAAQ,KAAK,QAAQ;EACjD,MAAM,UAAU,MAAM,KAAK,qBAAqB,OAAO,KAAK;EAC5D,OAAO,GACJ,KAAK,YAAY,KAAK,aACnB,UACAC,sBAAAA,wBAAwB,OAAO,EACrC;CACF;;;;;;;;;CAUA,MAAM,YACJ,aACA,cACe;EACf,MAAM,WACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,aAAa,YAAY,IACvC,KAAK;EACX,MAAM,OAAO,OAAO,QAAQ,WAAW,CAAC,CACrC,QAAQ,CAAC,OAAO,MAAM,KAAK,SAAS,CAAC,CACrC,OAAO,OAAO,QAAQ,YAAY,CAAC,CAAC,CACpC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,IAAI,GAAG,CAAC,CAC7B,KAAK,IAAI;EACZ,MAAM,KAAK,qBAAqB,aAAa,CAC3C,IAAIC,0BAAAA,SAAS;GAAE,aAAa;GAAM;EAAS,CAAC,CAC9C,CAAC;CACH;AACF"}

package/dist/memory/vector_store.d.cts

@@ -1,6 +1,5 @@
 import { BaseMemory, InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
 import { VectorStoreRetrieverInterface } from "@langchain/core/vectorstores";
-
 //#region src/memory/vector_store.d.ts
 type Metadata = Record<string, unknown>;
 type MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;

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

@@ -1 +1 @@
-{"version":3,"file":"vector_store.d.cts","names":[],"sources":["../../src/memory/vector_store.ts"],"mappings":";;;;KAWK,QAAA,GAAW,MAAA;AAAA,KACX,gBAAA,IACH,WAAA,GAAc,WAAA,EACd,YAAA,GAAe,YAAA,KACZ,QAAA;AAP2B;;;;AAAA,UAaf,gCAAA;EACf,oBAAA,EAAsB,6BAAA;EACtB,QAAA;EACA,SAAA;EACA,SAAA;EACA,UAAA;EAXG;;;EAeH,QAAA,GAAW,QAAA,GAAW,gBAAA;AAAA;;;;;;AATxB;;;;;;;;;;;;;;;;;;;AA2CA;;;;;;;cAAa,0BAAA,SACH,UAAA,YACG,gCAAA;EAEX,oBAAA,EAAsB,6BAAA;EAEtB,QAAA;EAEA,SAAA;EAEA,UAAA;EAEA,QAAA,GAAW,QAAA,GAAW,gBAAA;EAEtB,WAAA,CAAY,MAAA,EAAQ,gCAAA;EAAA,IAShB,UAAA,CAAA;EArBuC;;;;;;;EAgCrC,mBAAA,CAAoB,MAAA,EAAQ,WAAA,GAAc,OAAA,CAAQ,eAAA;EAxBxD;;;;;;;;EA0CM,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;AAAA"}
+{"version":3,"file":"vector_store.d.cts","names":[],"sources":["../../src/memory/vector_store.ts"],"mappings":";;;KAWK,WAAW;KACX,oBACH,cAAc,aACd,eAAe,iBACZ;;;;;UAMY;EACf,sBAAsB;EACtB;EACA;EACA;EACA;;;;EAIA,WAAW,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCX,mCACH,sBACG;EAEX,sBAAsB;EAEtB;EAEA;EAEA;EAEA,WAAW,WAAW;EAEtB,YAAY,QAAQ;MAShB;;;;;;;;EAWE,oBAAoB,QAAQ,cAAc,QAAQ;;;;;;;;;EAkBlD,YACJ,aAAa,aACb,cAAc,eACb"}

package/dist/memory/vector_store.d.ts

@@ -1,6 +1,5 @@
 import { BaseMemory, InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
 import { VectorStoreRetrieverInterface } from "@langchain/core/vectorstores";
-
 //#region src/memory/vector_store.d.ts
 type Metadata = Record<string, unknown>;
 type MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;

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

@@ -1 +1 @@
-{"version":3,"file":"vector_store.d.ts","names":[],"sources":["../../src/memory/vector_store.ts"],"mappings":";;;;KAWK,QAAA,GAAW,MAAA;AAAA,KACX,gBAAA,IACH,WAAA,GAAc,WAAA,EACd,YAAA,GAAe,YAAA,KACZ,QAAA;AAP2B;;;;AAAA,UAaf,gCAAA;EACf,oBAAA,EAAsB,6BAAA;EACtB,QAAA;EACA,SAAA;EACA,SAAA;EACA,UAAA;EAXG;;;EAeH,QAAA,GAAW,QAAA,GAAW,gBAAA;AAAA;;;;;;AATxB;;;;;;;;;;;;;;;;;;;AA2CA;;;;;;;cAAa,0BAAA,SACH,UAAA,YACG,gCAAA;EAEX,oBAAA,EAAsB,6BAAA;EAEtB,QAAA;EAEA,SAAA;EAEA,UAAA;EAEA,QAAA,GAAW,QAAA,GAAW,gBAAA;EAEtB,WAAA,CAAY,MAAA,EAAQ,gCAAA;EAAA,IAShB,UAAA,CAAA;EArBuC;;;;;;;EAgCrC,mBAAA,CAAoB,MAAA,EAAQ,WAAA,GAAc,OAAA,CAAQ,eAAA;EAxBxD;;;;;;;;EA0CM,WAAA,CACJ,WAAA,EAAa,WAAA,EACb,YAAA,EAAc,YAAA,GACb,OAAA;AAAA"}
+{"version":3,"file":"vector_store.d.ts","names":[],"sources":["../../src/memory/vector_store.ts"],"mappings":";;;KAWK,WAAW;KACX,oBACH,cAAc,aACd,eAAe,iBACZ;;;;;UAMY;EACf,sBAAsB;EACtB;EACA;EACA;EACA;;;;EAIA,WAAW,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCX,mCACH,sBACG;EAEX,sBAAsB;EAEtB;EAEA;EAEA;EAEA,WAAW,WAAW;EAEtB,YAAY,QAAQ;MAShB;;;;;;;;EAWE,oBAAoB,QAAQ,cAAc,QAAQ;;;;;;;;;EAkBlD,YACJ,aAAa,aACb,cAAc,eACb"}

package/dist/memory/vector_store.js.map

@@ -1 +1 @@
-{"version":3,"file":"vector_store.js","names":[],"sources":["../../src/memory/vector_store.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport {\n  BaseMemory,\n  getInputValue,\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { formatDocumentsAsString } from \"../util/document.js\";\n\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (\n  inputValues?: InputValues,\n  outputValues?: OutputValues\n) => Metadata;\n\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n  inputKey?: string;\n  outputKey?: string;\n  memoryKey?: string;\n  returnDocs?: boolean;\n  /**\n   * Metadata to be added to the document when saving context.\n   */\n  metadata?: Metadata | MetadataFunction;\n}\n\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport class VectorStoreRetrieverMemory\n  extends BaseMemory\n  implements VectorStoreRetrieverMemoryParams\n{\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n\n  inputKey?: string;\n\n  memoryKey: string;\n\n  returnDocs: boolean;\n\n  metadata?: Metadata | MetadataFunction;\n\n  constructor(fields: VectorStoreRetrieverMemoryParams) {\n    super();\n    this.vectorStoreRetriever = fields.vectorStoreRetriever;\n    this.inputKey = fields.inputKey;\n    this.memoryKey = fields.memoryKey ?? \"memory\";\n    this.returnDocs = fields.returnDocs ?? false;\n    this.metadata = fields.metadata;\n  }\n\n  get memoryKeys(): string[] {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method to load memory variables. It uses the vectorStoreRetriever to\n   * get relevant documents based on the query obtained from the input\n   * values.\n   * @param values An InputValues object.\n   * @returns A Promise that resolves to a MemoryVariables object.\n   */\n  async loadMemoryVariables(values: InputValues): Promise<MemoryVariables> {\n    const query = getInputValue(values, this.inputKey);\n    const results = await this.vectorStoreRetriever.invoke(query);\n    return {\n      [this.memoryKey]: this.returnDocs\n        ? results\n        : formatDocumentsAsString(results),\n    };\n  }\n\n  /**\n   * Method to save context. It constructs a document from the input and\n   * output values (excluding the memory key) and adds it to the vector\n   * store database using the vectorStoreRetriever.\n   * @param inputValues An InputValues object.\n   * @param outputValues An OutputValues object.\n   * @returns A Promise that resolves to void.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    const metadata =\n      typeof this.metadata === \"function\"\n        ? this.metadata(inputValues, outputValues)\n        : this.metadata;\n    const text = Object.entries(inputValues)\n      .filter(([k]) => k !== this.memoryKey)\n      .concat(Object.entries(outputValues))\n      .map(([k, v]) => `${k}: ${v}`)\n      .join(\"\\n\");\n    await this.vectorStoreRetriever.addDocuments([\n      new Document({ pageContent: text, metadata }),\n    ]);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,IAAa,6BAAb,cACU,WAEV;CACE;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAA0C;AACpD,SAAO;AACP,OAAK,uBAAuB,OAAO;AACnC,OAAK,WAAW,OAAO;AACvB,OAAK,YAAY,OAAO,aAAa;AACrC,OAAK,aAAa,OAAO,cAAc;AACvC,OAAK,WAAW,OAAO;;CAGzB,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,UAAU;;;;;;;;;CAUzB,MAAM,oBAAoB,QAA+C;EACvE,MAAM,QAAQ,cAAc,QAAQ,KAAK,SAAS;EAClD,MAAM,UAAU,MAAM,KAAK,qBAAqB,OAAO,MAAM;AAC7D,SAAO,GACJ,KAAK,YAAY,KAAK,aACnB,UACA,wBAAwB,QAAQ,EACrC;;;;;;;;;;CAWH,MAAM,YACJ,aACA,cACe;EACf,MAAM,WACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,aAAa,aAAa,GACxC,KAAK;EACX,MAAM,OAAO,OAAO,QAAQ,YAAY,CACrC,QAAQ,CAAC,OAAO,MAAM,KAAK,UAAU,CACrC,OAAO,OAAO,QAAQ,aAAa,CAAC,CACpC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,IAAI,IAAI,CAC7B,KAAK,KAAK;AACb,QAAM,KAAK,qBAAqB,aAAa,CAC3C,IAAI,SAAS;GAAE,aAAa;GAAM;GAAU,CAAC,CAC9C,CAAC"}
+{"version":3,"file":"vector_store.js","names":[],"sources":["../../src/memory/vector_store.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport {\n  BaseMemory,\n  getInputValue,\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { formatDocumentsAsString } from \"../util/document.js\";\n\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (\n  inputValues?: InputValues,\n  outputValues?: OutputValues\n) => Metadata;\n\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n  inputKey?: string;\n  outputKey?: string;\n  memoryKey?: string;\n  returnDocs?: boolean;\n  /**\n   * Metadata to be added to the document when saving context.\n   */\n  metadata?: Metadata | MetadataFunction;\n}\n\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport class VectorStoreRetrieverMemory\n  extends BaseMemory\n  implements VectorStoreRetrieverMemoryParams\n{\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n\n  inputKey?: string;\n\n  memoryKey: string;\n\n  returnDocs: boolean;\n\n  metadata?: Metadata | MetadataFunction;\n\n  constructor(fields: VectorStoreRetrieverMemoryParams) {\n    super();\n    this.vectorStoreRetriever = fields.vectorStoreRetriever;\n    this.inputKey = fields.inputKey;\n    this.memoryKey = fields.memoryKey ?? \"memory\";\n    this.returnDocs = fields.returnDocs ?? false;\n    this.metadata = fields.metadata;\n  }\n\n  get memoryKeys(): string[] {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method to load memory variables. It uses the vectorStoreRetriever to\n   * get relevant documents based on the query obtained from the input\n   * values.\n   * @param values An InputValues object.\n   * @returns A Promise that resolves to a MemoryVariables object.\n   */\n  async loadMemoryVariables(values: InputValues): Promise<MemoryVariables> {\n    const query = getInputValue(values, this.inputKey);\n    const results = await this.vectorStoreRetriever.invoke(query);\n    return {\n      [this.memoryKey]: this.returnDocs\n        ? results\n        : formatDocumentsAsString(results),\n    };\n  }\n\n  /**\n   * Method to save context. It constructs a document from the input and\n   * output values (excluding the memory key) and adds it to the vector\n   * store database using the vectorStoreRetriever.\n   * @param inputValues An InputValues object.\n   * @param outputValues An OutputValues object.\n   * @returns A Promise that resolves to void.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    const metadata =\n      typeof this.metadata === \"function\"\n        ? this.metadata(inputValues, outputValues)\n        : this.metadata;\n    const text = Object.entries(inputValues)\n      .filter(([k]) => k !== this.memoryKey)\n      .concat(Object.entries(outputValues))\n      .map(([k, v]) => `${k}: ${v}`)\n      .join(\"\\n\");\n    await this.vectorStoreRetriever.addDocuments([\n      new Document({ pageContent: text, metadata }),\n    ]);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,IAAa,6BAAb,cACU,WAEV;CACE;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAA0C;EACpD,MAAM;EACN,KAAK,uBAAuB,OAAO;EACnC,KAAK,WAAW,OAAO;EACvB,KAAK,YAAY,OAAO,aAAa;EACrC,KAAK,aAAa,OAAO,cAAc;EACvC,KAAK,WAAW,OAAO;CACzB;CAEA,IAAI,aAAuB;EACzB,OAAO,CAAC,KAAK,SAAS;CACxB;;;;;;;;CASA,MAAM,oBAAoB,QAA+C;EACvE,MAAM,QAAQ,cAAc,QAAQ,KAAK,QAAQ;EACjD,MAAM,UAAU,MAAM,KAAK,qBAAqB,OAAO,KAAK;EAC5D,OAAO,GACJ,KAAK,YAAY,KAAK,aACnB,UACA,wBAAwB,OAAO,EACrC;CACF;;;;;;;;;CAUA,MAAM,YACJ,aACA,cACe;EACf,MAAM,WACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,aAAa,YAAY,IACvC,KAAK;EACX,MAAM,OAAO,OAAO,QAAQ,WAAW,CAAC,CACrC,QAAQ,CAAC,OAAO,MAAM,KAAK,SAAS,CAAC,CACrC,OAAO,OAAO,QAAQ,YAAY,CAAC,CAAC,CACpC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,IAAI,GAAG,CAAC,CAC7B,KAAK,IAAI;EACZ,MAAM,KAAK,qBAAqB,aAAa,CAC3C,IAAI,SAAS;GAAE,aAAa;GAAM;EAAS,CAAC,CAC9C,CAAC;CACH;AACF"}

package/dist/output_parsers/combining.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 //#region src/output_parsers/combining.ts
 /**

package/dist/output_parsers/combining.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"combining.cjs","names":["BaseOutputParser"],"sources":["../../src/output_parsers/combining.ts"],"sourcesContent":["import { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\n\n/**\n * Type for the combined output of the CombiningOutputParser class.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport type CombinedOutput = Record<string, any>;\n\n/**\n * Interface for the fields required by the CombiningOutputParser class.\n */\nexport interface CombiningOutputParserFields {\n  parsers: BaseOutputParser[];\n}\n\n/**\n * Class to combine multiple output parsers\n * @augments BaseOutputParser\n */\nexport class CombiningOutputParser extends BaseOutputParser<object> {\n  static lc_name() {\n    return \"CombiningOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"combining\"];\n\n  lc_serializable = true;\n\n  parsers: BaseOutputParser[];\n\n  outputDelimiter = \"-----\";\n\n  constructor(fields: CombiningOutputParserFields);\n\n  constructor(...parsers: BaseOutputParser[]);\n\n  constructor(\n    fields: BaseOutputParser | CombiningOutputParserFields,\n    ...parsers: BaseOutputParser[]\n  ) {\n    if (parsers.length > 0 || !(\"parsers\" in fields)) {\n      // oxlint-disable-next-line no-param-reassign\n      fields = {\n        parsers: [fields as BaseOutputParser, ...parsers],\n      };\n    }\n    super(fields);\n    this.parsers = fields.parsers;\n  }\n\n  /**\n   * Method to parse an input string using the parsers in the parsers array.\n   * The parsed outputs are combined into a single object and returned.\n   * @param input The input string to parse.\n   * @param callbacks Optional Callbacks object.\n   * @returns A Promise that resolves to a CombinedOutput object.\n   */\n  async parse(input: string, callbacks?: Callbacks): Promise<CombinedOutput> {\n    const inputs = input\n      .trim()\n      .split(\n        new RegExp(`${this.outputDelimiter}Output \\\\d+${this.outputDelimiter}`)\n      )\n      .slice(1);\n    const ret: CombinedOutput = {};\n    for (const [i, p] of this.parsers.entries()) {\n      let parsed;\n      try {\n        let extracted = inputs[i].includes(\"```\")\n          ? inputs[i].trim().split(/```/)[1]\n          : inputs[i].trim();\n        if (extracted.endsWith(this.outputDelimiter)) {\n          extracted = extracted.slice(0, -this.outputDelimiter.length);\n        }\n        parsed = await p.parse(extracted, callbacks);\n      } catch {\n        parsed = await p.parse(input.trim(), callbacks);\n      }\n      Object.assign(ret, parsed);\n    }\n    return ret;\n  }\n\n  /**\n   * Method to get instructions on how to format the LLM output. The\n   * instructions are based on the parsers array and the outputDelimiter.\n   * @returns A string with format instructions.\n   */\n  getFormatInstructions(): string {\n    return `${[\n      `Return the following ${this.parsers.length} outputs, each formatted as described below. Include the delimiter characters \"${this.outputDelimiter}\" in your response:`,\n      ...this.parsers.map(\n        (p, i) =>\n          `${this.outputDelimiter}Output ${i + 1}${this.outputDelimiter}\\n${p\n            .getFormatInstructions()\n            .trim()}\\n${this.outputDelimiter}`\n      ),\n    ].join(\"\\n\\n\")}\\n`;\n  }\n}\n"],"mappings":";;;;;;;AAoBA,IAAa,wBAAb,cAA2CA,+BAAAA,iBAAyB;CAClE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAY;CAE3D,kBAAkB;CAElB;CAEA,kBAAkB;CAMlB,YACE,QACA,GAAG,SACH;AACA,MAAI,QAAQ,SAAS,KAAK,EAAE,aAAa,QAEvC,UAAS,EACP,SAAS,CAAC,QAA4B,GAAG,QAAQ,EAClD;AAEH,QAAM,OAAO;AACb,OAAK,UAAU,OAAO;;;;;;;;;CAUxB,MAAM,MAAM,OAAe,WAAgD;EACzE,MAAM,SAAS,MACZ,MAAM,CACN,MACC,IAAI,OAAO,GAAG,KAAK,gBAAgB,aAAa,KAAK,kBAAkB,CACxE,CACA,MAAM,EAAE;EACX,MAAM,MAAsB,EAAE;AAC9B,OAAK,MAAM,CAAC,GAAG,MAAM,KAAK,QAAQ,SAAS,EAAE;GAC3C,IAAI;AACJ,OAAI;IACF,IAAI,YAAY,OAAO,GAAG,SAAS,MAAM,GACrC,OAAO,GAAG,MAAM,CAAC,MAAM,MAAM,CAAC,KAC9B,OAAO,GAAG,MAAM;AACpB,QAAI,UAAU,SAAS,KAAK,gBAAgB,CAC1C,aAAY,UAAU,MAAM,GAAG,CAAC,KAAK,gBAAgB,OAAO;AAE9D,aAAS,MAAM,EAAE,MAAM,WAAW,UAAU;WACtC;AACN,aAAS,MAAM,EAAE,MAAM,MAAM,MAAM,EAAE,UAAU;;AAEjD,UAAO,OAAO,KAAK,OAAO;;AAE5B,SAAO;;;;;;;CAQT,wBAAgC;AAC9B,SAAO,GAAG,CACR,wBAAwB,KAAK,QAAQ,OAAO,iFAAiF,KAAK,gBAAgB,sBAClJ,GAAG,KAAK,QAAQ,KACb,GAAG,MACF,GAAG,KAAK,gBAAgB,SAAS,IAAI,IAAI,KAAK,gBAAgB,IAAI,EAC/D,uBAAuB,CACvB,MAAM,CAAC,IAAI,KAAK,kBACtB,CACF,CAAC,KAAK,OAAO,CAAC"}
+{"version":3,"file":"combining.cjs","names":["BaseOutputParser"],"sources":["../../src/output_parsers/combining.ts"],"sourcesContent":["import { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\n\n/**\n * Type for the combined output of the CombiningOutputParser class.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport type CombinedOutput = Record<string, any>;\n\n/**\n * Interface for the fields required by the CombiningOutputParser class.\n */\nexport interface CombiningOutputParserFields {\n  parsers: BaseOutputParser[];\n}\n\n/**\n * Class to combine multiple output parsers\n * @augments BaseOutputParser\n */\nexport class CombiningOutputParser extends BaseOutputParser<object> {\n  static lc_name() {\n    return \"CombiningOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"combining\"];\n\n  lc_serializable = true;\n\n  parsers: BaseOutputParser[];\n\n  outputDelimiter = \"-----\";\n\n  constructor(fields: CombiningOutputParserFields);\n\n  constructor(...parsers: BaseOutputParser[]);\n\n  constructor(\n    fields: BaseOutputParser | CombiningOutputParserFields,\n    ...parsers: BaseOutputParser[]\n  ) {\n    if (parsers.length > 0 || !(\"parsers\" in fields)) {\n      // oxlint-disable-next-line no-param-reassign\n      fields = {\n        parsers: [fields as BaseOutputParser, ...parsers],\n      };\n    }\n    super(fields);\n    this.parsers = fields.parsers;\n  }\n\n  /**\n   * Method to parse an input string using the parsers in the parsers array.\n   * The parsed outputs are combined into a single object and returned.\n   * @param input The input string to parse.\n   * @param callbacks Optional Callbacks object.\n   * @returns A Promise that resolves to a CombinedOutput object.\n   */\n  async parse(input: string, callbacks?: Callbacks): Promise<CombinedOutput> {\n    const inputs = input\n      .trim()\n      .split(\n        new RegExp(`${this.outputDelimiter}Output \\\\d+${this.outputDelimiter}`)\n      )\n      .slice(1);\n    const ret: CombinedOutput = {};\n    for (const [i, p] of this.parsers.entries()) {\n      let parsed;\n      try {\n        let extracted = inputs[i].includes(\"```\")\n          ? inputs[i].trim().split(/```/)[1]\n          : inputs[i].trim();\n        if (extracted.endsWith(this.outputDelimiter)) {\n          extracted = extracted.slice(0, -this.outputDelimiter.length);\n        }\n        parsed = await p.parse(extracted, callbacks);\n      } catch {\n        parsed = await p.parse(input.trim(), callbacks);\n      }\n      Object.assign(ret, parsed);\n    }\n    return ret;\n  }\n\n  /**\n   * Method to get instructions on how to format the LLM output. The\n   * instructions are based on the parsers array and the outputDelimiter.\n   * @returns A string with format instructions.\n   */\n  getFormatInstructions(): string {\n    return `${[\n      `Return the following ${this.parsers.length} outputs, each formatted as described below. Include the delimiter characters \"${this.outputDelimiter}\" in your response:`,\n      ...this.parsers.map(\n        (p, i) =>\n          `${this.outputDelimiter}Output ${i + 1}${this.outputDelimiter}\\n${p\n            .getFormatInstructions()\n            .trim()}\\n${this.outputDelimiter}`\n      ),\n    ].join(\"\\n\\n\")}\\n`;\n  }\n}\n"],"mappings":";;;;;;AAoBA,IAAa,wBAAb,cAA2CA,+BAAAA,iBAAyB;CAClE,OAAO,UAAU;EACf,OAAO;CACT;CAEA,eAAe;EAAC;EAAa;EAAkB;CAAW;CAE1D,kBAAkB;CAElB;CAEA,kBAAkB;CAMlB,YACE,QACA,GAAG,SACH;EACA,IAAI,QAAQ,SAAS,KAAK,EAAE,aAAa,SAEvC,SAAS,EACP,SAAS,CAAC,QAA4B,GAAG,OAAO,EAClD;EAEF,MAAM,MAAM;EACZ,KAAK,UAAU,OAAO;CACxB;;;;;;;;CASA,MAAM,MAAM,OAAe,WAAgD;EACzE,MAAM,SAAS,MACZ,KAAK,CAAC,CACN,MACC,IAAI,OAAO,GAAG,KAAK,gBAAgB,aAAa,KAAK,iBAAiB,CACxE,CAAC,CACA,MAAM,CAAC;EACV,MAAM,MAAsB,CAAC;EAC7B,KAAK,MAAM,CAAC,GAAG,MAAM,KAAK,QAAQ,QAAQ,GAAG;GAC3C,IAAI;GACJ,IAAI;IACF,IAAI,YAAY,OAAO,EAAE,CAAC,SAAS,KAAK,IACpC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,KAC9B,OAAO,EAAE,CAAC,KAAK;IACnB,IAAI,UAAU,SAAS,KAAK,eAAe,GACzC,YAAY,UAAU,MAAM,GAAG,CAAC,KAAK,gBAAgB,MAAM;IAE7D,SAAS,MAAM,EAAE,MAAM,WAAW,SAAS;GAC7C,QAAQ;IACN,SAAS,MAAM,EAAE,MAAM,MAAM,KAAK,GAAG,SAAS;GAChD;GACA,OAAO,OAAO,KAAK,MAAM;EAC3B;EACA,OAAO;CACT;;;;;;CAOA,wBAAgC;EAC9B,OAAO,GAAG,CACR,wBAAwB,KAAK,QAAQ,OAAO,iFAAiF,KAAK,gBAAgB,sBAClJ,GAAG,KAAK,QAAQ,KACb,GAAG,MACF,GAAG,KAAK,gBAAgB,SAAS,IAAI,IAAI,KAAK,gBAAgB,IAAI,EAC/D,sBAAsB,CAAC,CACvB,KAAK,EAAE,IAAI,KAAK,iBACvB,CACF,CAAC,CAAC,KAAK,MAAM,EAAE;CACjB;AACF"}

package/dist/output_parsers/combining.d.cts

@@ -1,6 +1,5 @@
 import { BaseOutputParser } from "@langchain/core/output_parsers";
 import { Callbacks } from "@langchain/core/callbacks/manager";
-
 //#region src/output_parsers/combining.d.ts
 /**
  * Type for the combined output of the CombiningOutputParser class.
@@ -40,5 +39,5 @@ declare class CombiningOutputParser extends BaseOutputParser<object> {
   getFormatInstructions(): string;
 }
 //#endregion
-export { CombiningOutputParser };
+export { CombinedOutput, CombiningOutputParser, CombiningOutputParserFields };
 //# sourceMappingURL=combining.d.cts.map

package/dist/output_parsers/combining.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"combining.d.cts","names":[],"sources":["../../src/output_parsers/combining.ts"],"mappings":";;;;;;AAOA;KAAY,cAAA,GAAiB,MAAA;;;;UAKZ,2BAAA;EACf,OAAA,EAAS,gBAAA;AAAA;;;AAOX;;cAAa,qBAAA,SAA8B,gBAAA;EAAA,OAClC,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,OAAA,EAAS,gBAAA;EAET,eAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,2BAAA;EAEpB,WAAA,CAAA,GAAe,OAAA,EAAS,gBAAA;EAfiC;;;;;;;EAsCnD,KAAA,CAAM,KAAA,UAAe,SAAA,GAAY,SAAA,GAAY,OAAA,CAAQ,cAAA;EA3B3D;;;;;EA0DA,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"combining.d.cts","names":[],"sources":["../../src/output_parsers/combining.ts"],"mappings":";;;;;;KAOY,iBAAiB;;;;UAKZ;EACf,SAAS;;;;;;cAOE,8BAA8B;SAClC;EAIP;EAEA;EAEA,SAAS;EAET;EAEA,YAAY,QAAQ;EAEpB,eAAe,SAAS;;;;;;;;EAuBlB,MAAM,eAAe,YAAY,YAAY,QAAQ;;;;;;EA+B3D"}

package/dist/output_parsers/combining.d.ts

@@ -1,6 +1,5 @@
 import { Callbacks } from "@langchain/core/callbacks/manager";
 import { BaseOutputParser } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/combining.d.ts
 /**
  * Type for the combined output of the CombiningOutputParser class.
@@ -40,5 +39,5 @@ declare class CombiningOutputParser extends BaseOutputParser<object> {
   getFormatInstructions(): string;
 }
 //#endregion
-export { CombiningOutputParser };
+export { CombinedOutput, CombiningOutputParser, CombiningOutputParserFields };
 //# sourceMappingURL=combining.d.ts.map

package/dist/output_parsers/combining.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combining.d.ts","names":[],"sources":["../../src/output_parsers/combining.ts"],"mappings":";;;;;;AAOA;KAAY,cAAA,GAAiB,MAAA;;;;UAKZ,2BAAA;EACf,OAAA,EAAS,gBAAA;AAAA;;;AAOX;;cAAa,qBAAA,SAA8B,gBAAA;EAAA,OAClC,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,OAAA,EAAS,gBAAA;EAET,eAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,2BAAA;EAEpB,WAAA,CAAA,GAAe,OAAA,EAAS,gBAAA;EAfiC;;;;;;;EAsCnD,KAAA,CAAM,KAAA,UAAe,SAAA,GAAY,SAAA,GAAY,OAAA,CAAQ,cAAA;EA3B3D;;;;;EA0DA,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"combining.d.ts","names":[],"sources":["../../src/output_parsers/combining.ts"],"mappings":";;;;;;KAOY,iBAAiB;;;;UAKZ;EACf,SAAS;;;;;;cAOE,8BAA8B;SAClC;EAIP;EAEA;EAEA,SAAS;EAET;EAEA,YAAY,QAAQ;EAEpB,eAAe,SAAS;;;;;;;;EAuBlB,MAAM,eAAe,YAAY,YAAY,QAAQ;;;;;;EA+B3D"}

package/dist/output_parsers/combining.js.map

@@ -1 +1 @@
-{"version":3,"file":"combining.js","names":[],"sources":["../../src/output_parsers/combining.ts"],"sourcesContent":["import { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\n\n/**\n * Type for the combined output of the CombiningOutputParser class.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport type CombinedOutput = Record<string, any>;\n\n/**\n * Interface for the fields required by the CombiningOutputParser class.\n */\nexport interface CombiningOutputParserFields {\n  parsers: BaseOutputParser[];\n}\n\n/**\n * Class to combine multiple output parsers\n * @augments BaseOutputParser\n */\nexport class CombiningOutputParser extends BaseOutputParser<object> {\n  static lc_name() {\n    return \"CombiningOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"combining\"];\n\n  lc_serializable = true;\n\n  parsers: BaseOutputParser[];\n\n  outputDelimiter = \"-----\";\n\n  constructor(fields: CombiningOutputParserFields);\n\n  constructor(...parsers: BaseOutputParser[]);\n\n  constructor(\n    fields: BaseOutputParser | CombiningOutputParserFields,\n    ...parsers: BaseOutputParser[]\n  ) {\n    if (parsers.length > 0 || !(\"parsers\" in fields)) {\n      // oxlint-disable-next-line no-param-reassign\n      fields = {\n        parsers: [fields as BaseOutputParser, ...parsers],\n      };\n    }\n    super(fields);\n    this.parsers = fields.parsers;\n  }\n\n  /**\n   * Method to parse an input string using the parsers in the parsers array.\n   * The parsed outputs are combined into a single object and returned.\n   * @param input The input string to parse.\n   * @param callbacks Optional Callbacks object.\n   * @returns A Promise that resolves to a CombinedOutput object.\n   */\n  async parse(input: string, callbacks?: Callbacks): Promise<CombinedOutput> {\n    const inputs = input\n      .trim()\n      .split(\n        new RegExp(`${this.outputDelimiter}Output \\\\d+${this.outputDelimiter}`)\n      )\n      .slice(1);\n    const ret: CombinedOutput = {};\n    for (const [i, p] of this.parsers.entries()) {\n      let parsed;\n      try {\n        let extracted = inputs[i].includes(\"```\")\n          ? inputs[i].trim().split(/```/)[1]\n          : inputs[i].trim();\n        if (extracted.endsWith(this.outputDelimiter)) {\n          extracted = extracted.slice(0, -this.outputDelimiter.length);\n        }\n        parsed = await p.parse(extracted, callbacks);\n      } catch {\n        parsed = await p.parse(input.trim(), callbacks);\n      }\n      Object.assign(ret, parsed);\n    }\n    return ret;\n  }\n\n  /**\n   * Method to get instructions on how to format the LLM output. The\n   * instructions are based on the parsers array and the outputDelimiter.\n   * @returns A string with format instructions.\n   */\n  getFormatInstructions(): string {\n    return `${[\n      `Return the following ${this.parsers.length} outputs, each formatted as described below. Include the delimiter characters \"${this.outputDelimiter}\" in your response:`,\n      ...this.parsers.map(\n        (p, i) =>\n          `${this.outputDelimiter}Output ${i + 1}${this.outputDelimiter}\\n${p\n            .getFormatInstructions()\n            .trim()}\\n${this.outputDelimiter}`\n      ),\n    ].join(\"\\n\\n\")}\\n`;\n  }\n}\n"],"mappings":";;;;;;AAoBA,IAAa,wBAAb,cAA2C,iBAAyB;CAClE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAY;CAE3D,kBAAkB;CAElB;CAEA,kBAAkB;CAMlB,YACE,QACA,GAAG,SACH;AACA,MAAI,QAAQ,SAAS,KAAK,EAAE,aAAa,QAEvC,UAAS,EACP,SAAS,CAAC,QAA4B,GAAG,QAAQ,EAClD;AAEH,QAAM,OAAO;AACb,OAAK,UAAU,OAAO;;;;;;;;;CAUxB,MAAM,MAAM,OAAe,WAAgD;EACzE,MAAM,SAAS,MACZ,MAAM,CACN,MACC,IAAI,OAAO,GAAG,KAAK,gBAAgB,aAAa,KAAK,kBAAkB,CACxE,CACA,MAAM,EAAE;EACX,MAAM,MAAsB,EAAE;AAC9B,OAAK,MAAM,CAAC,GAAG,MAAM,KAAK,QAAQ,SAAS,EAAE;GAC3C,IAAI;AACJ,OAAI;IACF,IAAI,YAAY,OAAO,GAAG,SAAS,MAAM,GACrC,OAAO,GAAG,MAAM,CAAC,MAAM,MAAM,CAAC,KAC9B,OAAO,GAAG,MAAM;AACpB,QAAI,UAAU,SAAS,KAAK,gBAAgB,CAC1C,aAAY,UAAU,MAAM,GAAG,CAAC,KAAK,gBAAgB,OAAO;AAE9D,aAAS,MAAM,EAAE,MAAM,WAAW,UAAU;WACtC;AACN,aAAS,MAAM,EAAE,MAAM,MAAM,MAAM,EAAE,UAAU;;AAEjD,UAAO,OAAO,KAAK,OAAO;;AAE5B,SAAO;;;;;;;CAQT,wBAAgC;AAC9B,SAAO,GAAG,CACR,wBAAwB,KAAK,QAAQ,OAAO,iFAAiF,KAAK,gBAAgB,sBAClJ,GAAG,KAAK,QAAQ,KACb,GAAG,MACF,GAAG,KAAK,gBAAgB,SAAS,IAAI,IAAI,KAAK,gBAAgB,IAAI,EAC/D,uBAAuB,CACvB,MAAM,CAAC,IAAI,KAAK,kBACtB,CACF,CAAC,KAAK,OAAO,CAAC"}
+{"version":3,"file":"combining.js","names":[],"sources":["../../src/output_parsers/combining.ts"],"sourcesContent":["import { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\n\n/**\n * Type for the combined output of the CombiningOutputParser class.\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport type CombinedOutput = Record<string, any>;\n\n/**\n * Interface for the fields required by the CombiningOutputParser class.\n */\nexport interface CombiningOutputParserFields {\n  parsers: BaseOutputParser[];\n}\n\n/**\n * Class to combine multiple output parsers\n * @augments BaseOutputParser\n */\nexport class CombiningOutputParser extends BaseOutputParser<object> {\n  static lc_name() {\n    return \"CombiningOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"combining\"];\n\n  lc_serializable = true;\n\n  parsers: BaseOutputParser[];\n\n  outputDelimiter = \"-----\";\n\n  constructor(fields: CombiningOutputParserFields);\n\n  constructor(...parsers: BaseOutputParser[]);\n\n  constructor(\n    fields: BaseOutputParser | CombiningOutputParserFields,\n    ...parsers: BaseOutputParser[]\n  ) {\n    if (parsers.length > 0 || !(\"parsers\" in fields)) {\n      // oxlint-disable-next-line no-param-reassign\n      fields = {\n        parsers: [fields as BaseOutputParser, ...parsers],\n      };\n    }\n    super(fields);\n    this.parsers = fields.parsers;\n  }\n\n  /**\n   * Method to parse an input string using the parsers in the parsers array.\n   * The parsed outputs are combined into a single object and returned.\n   * @param input The input string to parse.\n   * @param callbacks Optional Callbacks object.\n   * @returns A Promise that resolves to a CombinedOutput object.\n   */\n  async parse(input: string, callbacks?: Callbacks): Promise<CombinedOutput> {\n    const inputs = input\n      .trim()\n      .split(\n        new RegExp(`${this.outputDelimiter}Output \\\\d+${this.outputDelimiter}`)\n      )\n      .slice(1);\n    const ret: CombinedOutput = {};\n    for (const [i, p] of this.parsers.entries()) {\n      let parsed;\n      try {\n        let extracted = inputs[i].includes(\"```\")\n          ? inputs[i].trim().split(/```/)[1]\n          : inputs[i].trim();\n        if (extracted.endsWith(this.outputDelimiter)) {\n          extracted = extracted.slice(0, -this.outputDelimiter.length);\n        }\n        parsed = await p.parse(extracted, callbacks);\n      } catch {\n        parsed = await p.parse(input.trim(), callbacks);\n      }\n      Object.assign(ret, parsed);\n    }\n    return ret;\n  }\n\n  /**\n   * Method to get instructions on how to format the LLM output. The\n   * instructions are based on the parsers array and the outputDelimiter.\n   * @returns A string with format instructions.\n   */\n  getFormatInstructions(): string {\n    return `${[\n      `Return the following ${this.parsers.length} outputs, each formatted as described below. Include the delimiter characters \"${this.outputDelimiter}\" in your response:`,\n      ...this.parsers.map(\n        (p, i) =>\n          `${this.outputDelimiter}Output ${i + 1}${this.outputDelimiter}\\n${p\n            .getFormatInstructions()\n            .trim()}\\n${this.outputDelimiter}`\n      ),\n    ].join(\"\\n\\n\")}\\n`;\n  }\n}\n"],"mappings":";;;;;;AAoBA,IAAa,wBAAb,cAA2C,iBAAyB;CAClE,OAAO,UAAU;EACf,OAAO;CACT;CAEA,eAAe;EAAC;EAAa;EAAkB;CAAW;CAE1D,kBAAkB;CAElB;CAEA,kBAAkB;CAMlB,YACE,QACA,GAAG,SACH;EACA,IAAI,QAAQ,SAAS,KAAK,EAAE,aAAa,SAEvC,SAAS,EACP,SAAS,CAAC,QAA4B,GAAG,OAAO,EAClD;EAEF,MAAM,MAAM;EACZ,KAAK,UAAU,OAAO;CACxB;;;;;;;;CASA,MAAM,MAAM,OAAe,WAAgD;EACzE,MAAM,SAAS,MACZ,KAAK,CAAC,CACN,MACC,IAAI,OAAO,GAAG,KAAK,gBAAgB,aAAa,KAAK,iBAAiB,CACxE,CAAC,CACA,MAAM,CAAC;EACV,MAAM,MAAsB,CAAC;EAC7B,KAAK,MAAM,CAAC,GAAG,MAAM,KAAK,QAAQ,QAAQ,GAAG;GAC3C,IAAI;GACJ,IAAI;IACF,IAAI,YAAY,OAAO,EAAE,CAAC,SAAS,KAAK,IACpC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,KAC9B,OAAO,EAAE,CAAC,KAAK;IACnB,IAAI,UAAU,SAAS,KAAK,eAAe,GACzC,YAAY,UAAU,MAAM,GAAG,CAAC,KAAK,gBAAgB,MAAM;IAE7D,SAAS,MAAM,EAAE,MAAM,WAAW,SAAS;GAC7C,QAAQ;IACN,SAAS,MAAM,EAAE,MAAM,MAAM,KAAK,GAAG,SAAS;GAChD;GACA,OAAO,OAAO,KAAK,MAAM;EAC3B;EACA,OAAO;CACT;;;;;;CAOA,wBAAgC;EAC9B,OAAO,GAAG,CACR,wBAAwB,KAAK,QAAQ,OAAO,iFAAiF,KAAK,gBAAgB,sBAClJ,GAAG,KAAK,QAAQ,KACb,GAAG,MACF,GAAG,KAAK,gBAAgB,SAAS,IAAI,IAAI,KAAK,gBAAgB,IAAI,EAC/D,sBAAsB,CAAC,CACvB,KAAK,EAAE,IAAI,KAAK,iBACvB,CACF,CAAC,CAAC,KAAK,MAAM,EAAE;CACjB;AACF"}

package/dist/output_parsers/datetime.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 //#region src/output_parsers/datetime.ts
 /**

package/dist/output_parsers/datetime.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.cjs","names":["BaseOutputParser","OutputParserException"],"sources":["../../src/output_parsers/datetime.ts"],"sourcesContent":["import {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\n\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport class DatetimeOutputParser extends BaseOutputParser<Date> {\n  static lc_name() {\n    return \"DatetimeOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /**\n   * ISO 8601 date time standard.\n   */\n  format = \"YYYY-MM-DDTHH:mm:ssZ\";\n\n  /**\n   * Parses the given text into a Date.\n   * If the parsing fails, throws an OutputParserException.\n   * @param text The text to parse.\n   * @returns A date object.\n   */\n  async parse(text: string): Promise<Date> {\n    const parsedDate = new Date(text.trim());\n    if (Number.isNaN(parsedDate.getTime())) {\n      throw new OutputParserException(`Could not parse output: ${text}`, text);\n    }\n    return parsedDate;\n  }\n\n  /**\n   * Provides instructions on the expected format of the response for the\n   * CommaSeparatedListOutputParser.\n   * @returns A string containing instructions on the expected format of the response.\n   */\n  getFormatInstructions(): string {\n    return [\n      `Your response should be a datetime string that matches the following pattern: \"${this.format}\".`,\n      `Examples: 2011-10-05T14:48:00Z, 2019-01-01T00:00:00Z, 1932-04-21T04:42:23Z`,\n      `Return ONLY this string, no other words!`,\n    ].join(\"\\n\\n\");\n  }\n}\n"],"mappings":";;;;;;;AASA,IAAa,uBAAb,cAA0CA,+BAAAA,iBAAuB;CAC/D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,iBAAiB;CAE9C,kBAAkB;;;;CAKlB,SAAS;;;;;;;CAQT,MAAM,MAAM,MAA6B;EACvC,MAAM,aAAa,IAAI,KAAK,KAAK,MAAM,CAAC;AACxC,MAAI,OAAO,MAAM,WAAW,SAAS,CAAC,CACpC,OAAM,IAAIC,+BAAAA,sBAAsB,2BAA2B,QAAQ,KAAK;AAE1E,SAAO;;;;;;;CAQT,wBAAgC;AAC9B,SAAO;GACL,kFAAkF,KAAK,OAAO;GAC9F;GACA;GACD,CAAC,KAAK,OAAO"}
+{"version":3,"file":"datetime.cjs","names":["BaseOutputParser","OutputParserException"],"sources":["../../src/output_parsers/datetime.ts"],"sourcesContent":["import {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\n\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport class DatetimeOutputParser extends BaseOutputParser<Date> {\n  static lc_name() {\n    return \"DatetimeOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /**\n   * ISO 8601 date time standard.\n   */\n  format = \"YYYY-MM-DDTHH:mm:ssZ\";\n\n  /**\n   * Parses the given text into a Date.\n   * If the parsing fails, throws an OutputParserException.\n   * @param text The text to parse.\n   * @returns A date object.\n   */\n  async parse(text: string): Promise<Date> {\n    const parsedDate = new Date(text.trim());\n    if (Number.isNaN(parsedDate.getTime())) {\n      throw new OutputParserException(`Could not parse output: ${text}`, text);\n    }\n    return parsedDate;\n  }\n\n  /**\n   * Provides instructions on the expected format of the response for the\n   * CommaSeparatedListOutputParser.\n   * @returns A string containing instructions on the expected format of the response.\n   */\n  getFormatInstructions(): string {\n    return [\n      `Your response should be a datetime string that matches the following pattern: \"${this.format}\".`,\n      `Examples: 2011-10-05T14:48:00Z, 2019-01-01T00:00:00Z, 1932-04-21T04:42:23Z`,\n      `Return ONLY this string, no other words!`,\n    ].join(\"\\n\\n\");\n  }\n}\n"],"mappings":";;;;;;AASA,IAAa,uBAAb,cAA0CA,+BAAAA,iBAAuB;CAC/D,OAAO,UAAU;EACf,OAAO;CACT;CAEA,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;;;;CAKlB,SAAS;;;;;;;CAQT,MAAM,MAAM,MAA6B;EACvC,MAAM,aAAa,IAAI,KAAK,KAAK,KAAK,CAAC;EACvC,IAAI,OAAO,MAAM,WAAW,QAAQ,CAAC,GACnC,MAAM,IAAIC,+BAAAA,sBAAsB,2BAA2B,QAAQ,IAAI;EAEzE,OAAO;CACT;;;;;;CAOA,wBAAgC;EAC9B,OAAO;GACL,kFAAkF,KAAK,OAAO;GAC9F;GACA;EACF,CAAC,CAAC,KAAK,MAAM;CACf;AACF"}

package/dist/output_parsers/datetime.d.cts

@@ -1,5 +1,4 @@
 import { BaseOutputParser } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/datetime.d.ts
 /**
  * Class to parse the output of an LLM call to a date.

package/dist/output_parsers/datetime.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.d.cts","names":[],"sources":["../../src/output_parsers/datetime.ts"],"mappings":";;;;;AASA;;cAAa,oBAAA,SAA6B,gBAAA,CAAiB,IAAA;EAAA,OAClD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAPwC;;;EAYxC,MAAA;EAZyD;;;;;;EAoBnD,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,IAAA;EAAR;;;;;EAa3B,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"datetime.d.cts","names":[],"sources":["../../src/output_parsers/datetime.ts"],"mappings":";;;;;;cASa,6BAA6B,iBAAiB;SAClD;EAIP;EAEA;;;;EAKA;;;;;;;EAQM,MAAM,eAAe,QAAQ;;;;;;EAanC"}

package/dist/output_parsers/datetime.d.ts

@@ -1,5 +1,4 @@
 import { BaseOutputParser } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/datetime.d.ts
 /**
  * Class to parse the output of an LLM call to a date.

package/dist/output_parsers/datetime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.d.ts","names":[],"sources":["../../src/output_parsers/datetime.ts"],"mappings":";;;;;AASA;;cAAa,oBAAA,SAA6B,gBAAA,CAAiB,IAAA;EAAA,OAClD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAPwC;;;EAYxC,MAAA;EAZyD;;;;;;EAoBnD,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,IAAA;EAAR;;;;;EAa3B,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"datetime.d.ts","names":[],"sources":["../../src/output_parsers/datetime.ts"],"mappings":";;;;;;cASa,6BAA6B,iBAAiB;SAClD;EAIP;EAEA;;;;EAKA;;;;;;;EAQM,MAAM,eAAe,QAAQ;;;;;;EAanC"}

package/dist/output_parsers/datetime.js.map

@@ -1 +1 @@
-{"version":3,"file":"datetime.js","names":[],"sources":["../../src/output_parsers/datetime.ts"],"sourcesContent":["import {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\n\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport class DatetimeOutputParser extends BaseOutputParser<Date> {\n  static lc_name() {\n    return \"DatetimeOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /**\n   * ISO 8601 date time standard.\n   */\n  format = \"YYYY-MM-DDTHH:mm:ssZ\";\n\n  /**\n   * Parses the given text into a Date.\n   * If the parsing fails, throws an OutputParserException.\n   * @param text The text to parse.\n   * @returns A date object.\n   */\n  async parse(text: string): Promise<Date> {\n    const parsedDate = new Date(text.trim());\n    if (Number.isNaN(parsedDate.getTime())) {\n      throw new OutputParserException(`Could not parse output: ${text}`, text);\n    }\n    return parsedDate;\n  }\n\n  /**\n   * Provides instructions on the expected format of the response for the\n   * CommaSeparatedListOutputParser.\n   * @returns A string containing instructions on the expected format of the response.\n   */\n  getFormatInstructions(): string {\n    return [\n      `Your response should be a datetime string that matches the following pattern: \"${this.format}\".`,\n      `Examples: 2011-10-05T14:48:00Z, 2019-01-01T00:00:00Z, 1932-04-21T04:42:23Z`,\n      `Return ONLY this string, no other words!`,\n    ].join(\"\\n\\n\");\n  }\n}\n"],"mappings":";;;;;;AASA,IAAa,uBAAb,cAA0C,iBAAuB;CAC/D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,iBAAiB;CAE9C,kBAAkB;;;;CAKlB,SAAS;;;;;;;CAQT,MAAM,MAAM,MAA6B;EACvC,MAAM,aAAa,IAAI,KAAK,KAAK,MAAM,CAAC;AACxC,MAAI,OAAO,MAAM,WAAW,SAAS,CAAC,CACpC,OAAM,IAAI,sBAAsB,2BAA2B,QAAQ,KAAK;AAE1E,SAAO;;;;;;;CAQT,wBAAgC;AAC9B,SAAO;GACL,kFAAkF,KAAK,OAAO;GAC9F;GACA;GACD,CAAC,KAAK,OAAO"}
+{"version":3,"file":"datetime.js","names":[],"sources":["../../src/output_parsers/datetime.ts"],"sourcesContent":["import {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\n\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport class DatetimeOutputParser extends BaseOutputParser<Date> {\n  static lc_name() {\n    return \"DatetimeOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /**\n   * ISO 8601 date time standard.\n   */\n  format = \"YYYY-MM-DDTHH:mm:ssZ\";\n\n  /**\n   * Parses the given text into a Date.\n   * If the parsing fails, throws an OutputParserException.\n   * @param text The text to parse.\n   * @returns A date object.\n   */\n  async parse(text: string): Promise<Date> {\n    const parsedDate = new Date(text.trim());\n    if (Number.isNaN(parsedDate.getTime())) {\n      throw new OutputParserException(`Could not parse output: ${text}`, text);\n    }\n    return parsedDate;\n  }\n\n  /**\n   * Provides instructions on the expected format of the response for the\n   * CommaSeparatedListOutputParser.\n   * @returns A string containing instructions on the expected format of the response.\n   */\n  getFormatInstructions(): string {\n    return [\n      `Your response should be a datetime string that matches the following pattern: \"${this.format}\".`,\n      `Examples: 2011-10-05T14:48:00Z, 2019-01-01T00:00:00Z, 1932-04-21T04:42:23Z`,\n      `Return ONLY this string, no other words!`,\n    ].join(\"\\n\\n\");\n  }\n}\n"],"mappings":";;;;;;AASA,IAAa,uBAAb,cAA0C,iBAAuB;CAC/D,OAAO,UAAU;EACf,OAAO;CACT;CAEA,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;;;;CAKlB,SAAS;;;;;;;CAQT,MAAM,MAAM,MAA6B;EACvC,MAAM,aAAa,IAAI,KAAK,KAAK,KAAK,CAAC;EACvC,IAAI,OAAO,MAAM,WAAW,QAAQ,CAAC,GACnC,MAAM,IAAI,sBAAsB,2BAA2B,QAAQ,IAAI;EAEzE,OAAO;CACT;;;;;;CAOA,wBAAgC;EAC9B,OAAO;GACL,kFAAkF,KAAK,OAAO;GAC9F;GACA;EACF,CAAC,CAAC,KAAK,MAAM;CACf;AACF"}

package/dist/output_parsers/expression.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"expression.cjs","names":["BaseOutputParser","ASTParser","MasterHandler"],"sources":["../../src/output_parsers/expression.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { MasterHandler } from \"./expression_type_handlers/factory.js\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nimport type { ExpressionNode } from \"../types/expression-parser.js\";\n\nexport type ParseFunction = Awaited<\n  ReturnType<typeof ASTParser.importASTParser>\n>;\n\n/**\n * We need to be able to handle the following cases:\n * ExpressionStatement\n *  CallExpression\n *      Identifier | MemberExpression\n *      ExpressionLiterals: [\n *          CallExpression\n *          StringLiteral\n *          NumericLiteral\n *          ArrayLiteralExpression\n *              ExpressionLiterals\n *          ObjectLiteralExpression\n *              PropertyAssignment\n *                  Identifier\n *                  ExpressionLiterals\n *      ]\n */\n\nexport class ExpressionParser extends BaseOutputParser<ParsedType> {\n  lc_namespace = [\"langchain\", \"output_parsers\", \"expression\"];\n\n  parser: ParseFunction;\n\n  /**\n   * We should separate loading the parser into its own function\n   * because loading the grammar takes some time. If there are\n   * multiple concurrent parse calls, it's faster to just wait\n   * for building the parser once and then use it for all\n   * subsequent calls. See expression.test.ts for an example.\n   */\n  async ensureParser() {\n    if (!this.parser) {\n      this.parser = await ASTParser.importASTParser();\n    }\n  }\n\n  /**\n   * Parses the given text. It first ensures the parser is loaded, then\n   * tries to parse the text. If the parsing fails, it throws an error. If\n   * the parsing is successful, it returns the parsed expression.\n   * @param text The text to be parsed.\n   * @returns The parsed expression\n   */\n  async parse(text: string) {\n    await this.ensureParser();\n\n    try {\n      const program = this.parser(text);\n\n      const node = program.body;\n      if (!ASTParser.isExpressionStatement(node)) {\n        throw new Error(\n          `Expected ExpressionStatement, got ${(node as ExpressionNode).type}`\n        );\n      }\n\n      const { expression: expressionStatement } = node;\n      if (!ASTParser.isCallExpression(expressionStatement)) {\n        throw new Error(\"Expected CallExpression\");\n      }\n      const masterHandler = MasterHandler.createMasterHandler();\n      return await masterHandler.handle(expressionStatement);\n    } catch (err) {\n      throw new Error(`Error parsing ${err}: ${text}`);\n    }\n  }\n\n  /**\n   * This method is currently empty, but it could be used to provide\n   * instructions on the format of the input text.\n   * @returns string\n   */\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport * from \"./expression_type_handlers/types.js\";\n\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsCA,+BAAAA,iBAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;EAAa;CAE5D;;;;;;;;CASA,MAAM,eAAe;AACnB,MAAI,CAAC,KAAK,OACR,MAAK,SAAS,MAAMC,aAAAA,UAAU,iBAAiB;;;;;;;;;CAWnD,MAAM,MAAM,MAAc;AACxB,QAAM,KAAK,cAAc;AAEzB,MAAI;GAGF,MAAM,OAFU,KAAK,OAAO,KAER,CAAC;AACrB,OAAI,CAACA,aAAAA,UAAU,sBAAsB,KAAK,CACxC,OAAM,IAAI,MACR,qCAAsC,KAAwB,OAC/D;GAGH,MAAM,EAAE,YAAY,wBAAwB;AAC5C,OAAI,CAACA,aAAAA,UAAU,iBAAiB,oBAAoB,CAClD,OAAM,IAAI,MAAM,0BAA0B;AAG5C,UAAO,MADeC,gBAAAA,cAAc,qBACV,CAAC,OAAO,oBAAoB;WAC/C,KAAK;AACZ,SAAM,IAAI,MAAM,iBAAiB,IAAI,IAAI,OAAO;;;;;;;;CASpD,wBAAgC;AAC9B,SAAO"}
+{"version":3,"file":"expression.cjs","names":["BaseOutputParser","ASTParser","MasterHandler"],"sources":["../../src/output_parsers/expression.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { MasterHandler } from \"./expression_type_handlers/factory.js\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nimport type { ExpressionNode } from \"../types/expression-parser.js\";\n\nexport type ParseFunction = Awaited<\n  ReturnType<typeof ASTParser.importASTParser>\n>;\n\n/**\n * We need to be able to handle the following cases:\n * ExpressionStatement\n *  CallExpression\n *      Identifier | MemberExpression\n *      ExpressionLiterals: [\n *          CallExpression\n *          StringLiteral\n *          NumericLiteral\n *          ArrayLiteralExpression\n *              ExpressionLiterals\n *          ObjectLiteralExpression\n *              PropertyAssignment\n *                  Identifier\n *                  ExpressionLiterals\n *      ]\n */\n\nexport class ExpressionParser extends BaseOutputParser<ParsedType> {\n  lc_namespace = [\"langchain\", \"output_parsers\", \"expression\"];\n\n  parser: ParseFunction;\n\n  /**\n   * We should separate loading the parser into its own function\n   * because loading the grammar takes some time. If there are\n   * multiple concurrent parse calls, it's faster to just wait\n   * for building the parser once and then use it for all\n   * subsequent calls. See expression.test.ts for an example.\n   */\n  async ensureParser() {\n    if (!this.parser) {\n      this.parser = await ASTParser.importASTParser();\n    }\n  }\n\n  /**\n   * Parses the given text. It first ensures the parser is loaded, then\n   * tries to parse the text. If the parsing fails, it throws an error. If\n   * the parsing is successful, it returns the parsed expression.\n   * @param text The text to be parsed.\n   * @returns The parsed expression\n   */\n  async parse(text: string) {\n    await this.ensureParser();\n\n    try {\n      const program = this.parser(text);\n\n      const node = program.body;\n      if (!ASTParser.isExpressionStatement(node)) {\n        throw new Error(\n          `Expected ExpressionStatement, got ${(node as ExpressionNode).type}`\n        );\n      }\n\n      const { expression: expressionStatement } = node;\n      if (!ASTParser.isCallExpression(expressionStatement)) {\n        throw new Error(\"Expected CallExpression\");\n      }\n      const masterHandler = MasterHandler.createMasterHandler();\n      return await masterHandler.handle(expressionStatement);\n    } catch (err) {\n      throw new Error(`Error parsing ${err}: ${text}`);\n    }\n  }\n\n  /**\n   * This method is currently empty, but it could be used to provide\n   * instructions on the format of the input text.\n   * @returns string\n   */\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport * from \"./expression_type_handlers/types.js\";\n\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsCA,+BAAAA,iBAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;CAAY;CAE3D;;;;;;;;CASA,MAAM,eAAe;EACnB,IAAI,CAAC,KAAK,QACR,KAAK,SAAS,MAAMC,aAAAA,UAAU,gBAAgB;CAElD;;;;;;;;CASA,MAAM,MAAM,MAAc;EACxB,MAAM,KAAK,aAAa;EAExB,IAAI;GAGF,MAAM,OAFU,KAAK,OAAO,IAET,CAAC,CAAC;GACrB,IAAI,CAACA,aAAAA,UAAU,sBAAsB,IAAI,GACvC,MAAM,IAAI,MACR,qCAAsC,KAAwB,MAChE;GAGF,MAAM,EAAE,YAAY,wBAAwB;GAC5C,IAAI,CAACA,aAAAA,UAAU,iBAAiB,mBAAmB,GACjD,MAAM,IAAI,MAAM,yBAAyB;GAG3C,OAAO,MADeC,gBAAAA,cAAc,oBACX,CAAC,CAAC,OAAO,mBAAmB;EACvD,SAAS,KAAK;GACZ,MAAM,IAAI,MAAM,iBAAiB,IAAI,IAAI,MAAM;EACjD;CACF;;;;;;CAOA,wBAAgC;EAC9B,OAAO;CACT;AACF"}

package/dist/output_parsers/expression.d.cts

@@ -2,7 +2,6 @@ import { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType
 import { ASTParser } from "./expression_type_handlers/base.cjs";
 import { MasterHandler } from "./expression_type_handlers/factory.cjs";
 import { BaseOutputParser } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/expression.d.ts
 type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;
 /**

package/dist/output_parsers/expression.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.cts","names":[],"sources":["../../src/output_parsers/expression.ts"],"mappings":";;;;;;KAMY,aAAA,GAAgB,OAAA,CAC1B,UAAA,QAAkB,SAAA,CAAU,eAAA;;;AAD9B;;;;;;;;;;;;;;AAsBA;cAAa,gBAAA,SAAyB,gBAAA,CAAiB,UAAA;EACrD,YAAA;EAEA,MAAA,EAAQ,aAAA;EAAA;;;;;;;EASF,YAAA,CAAA,GAAY,OAAA;EAZmC;;;;;;;EAyB/C,KAAA,CAAM,IAAA,WAAY,OAAA,CAAA,UAAA;EAAA;;;;;EA6BxB,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"expression.d.cts","names":[],"sources":["../../src/output_parsers/expression.ts"],"mappings":";;;;;KAMY,gBAAgB,QAC1B,kBAAkB,UAAU;;;;;;;;;;;;;;;;;;cAqBjB,yBAAyB,iBAAiB;EACrD;EAEA,QAAQ;;;;;;;;EASF,gBAAY;;;;;;;;EAaZ,MAAM,eAAY,QAAA;;;;;;EA6BxB"}

package/dist/output_parsers/expression.d.ts

@@ -2,7 +2,6 @@ import { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType
 import { ASTParser } from "./expression_type_handlers/base.js";
 import { MasterHandler } from "./expression_type_handlers/factory.js";
 import { BaseOutputParser } from "@langchain/core/output_parsers";
-
 //#region src/output_parsers/expression.d.ts
 type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;
 /**

package/dist/output_parsers/expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.ts","names":[],"sources":["../../src/output_parsers/expression.ts"],"mappings":";;;;;;KAMY,aAAA,GAAgB,OAAA,CAC1B,UAAA,QAAkB,SAAA,CAAU,eAAA;;;AAD9B;;;;;;;;;;;;;;AAsBA;cAAa,gBAAA,SAAyB,gBAAA,CAAiB,UAAA;EACrD,YAAA;EAEA,MAAA,EAAQ,aAAA;EAAA;;;;;;;EASF,YAAA,CAAA,GAAY,OAAA;EAZmC;;;;;;;EAyB/C,KAAA,CAAM,IAAA,WAAY,OAAA,CAAA,UAAA;EAAA;;;;;EA6BxB,qBAAA,CAAA;AAAA"}
+{"version":3,"file":"expression.d.ts","names":[],"sources":["../../src/output_parsers/expression.ts"],"mappings":";;;;;KAMY,gBAAgB,QAC1B,kBAAkB,UAAU;;;;;;;;;;;;;;;;;;cAqBjB,yBAAyB,iBAAiB;EACrD;EAEA,QAAQ;;;;;;;;EASF,gBAAY;;;;;;;;EAaZ,MAAM,eAAY,QAAA;;;;;;EA6BxB"}

package/dist/output_parsers/expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"expression.js","names":[],"sources":["../../src/output_parsers/expression.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { MasterHandler } from \"./expression_type_handlers/factory.js\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nimport type { ExpressionNode } from \"../types/expression-parser.js\";\n\nexport type ParseFunction = Awaited<\n  ReturnType<typeof ASTParser.importASTParser>\n>;\n\n/**\n * We need to be able to handle the following cases:\n * ExpressionStatement\n *  CallExpression\n *      Identifier | MemberExpression\n *      ExpressionLiterals: [\n *          CallExpression\n *          StringLiteral\n *          NumericLiteral\n *          ArrayLiteralExpression\n *              ExpressionLiterals\n *          ObjectLiteralExpression\n *              PropertyAssignment\n *                  Identifier\n *                  ExpressionLiterals\n *      ]\n */\n\nexport class ExpressionParser extends BaseOutputParser<ParsedType> {\n  lc_namespace = [\"langchain\", \"output_parsers\", \"expression\"];\n\n  parser: ParseFunction;\n\n  /**\n   * We should separate loading the parser into its own function\n   * because loading the grammar takes some time. If there are\n   * multiple concurrent parse calls, it's faster to just wait\n   * for building the parser once and then use it for all\n   * subsequent calls. See expression.test.ts for an example.\n   */\n  async ensureParser() {\n    if (!this.parser) {\n      this.parser = await ASTParser.importASTParser();\n    }\n  }\n\n  /**\n   * Parses the given text. It first ensures the parser is loaded, then\n   * tries to parse the text. If the parsing fails, it throws an error. If\n   * the parsing is successful, it returns the parsed expression.\n   * @param text The text to be parsed.\n   * @returns The parsed expression\n   */\n  async parse(text: string) {\n    await this.ensureParser();\n\n    try {\n      const program = this.parser(text);\n\n      const node = program.body;\n      if (!ASTParser.isExpressionStatement(node)) {\n        throw new Error(\n          `Expected ExpressionStatement, got ${(node as ExpressionNode).type}`\n        );\n      }\n\n      const { expression: expressionStatement } = node;\n      if (!ASTParser.isCallExpression(expressionStatement)) {\n        throw new Error(\"Expected CallExpression\");\n      }\n      const masterHandler = MasterHandler.createMasterHandler();\n      return await masterHandler.handle(expressionStatement);\n    } catch (err) {\n      throw new Error(`Error parsing ${err}: ${text}`);\n    }\n  }\n\n  /**\n   * This method is currently empty, but it could be used to provide\n   * instructions on the format of the input text.\n   * @returns string\n   */\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport * from \"./expression_type_handlers/types.js\";\n\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsC,iBAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;EAAa;CAE5D;;;;;;;;CASA,MAAM,eAAe;AACnB,MAAI,CAAC,KAAK,OACR,MAAK,SAAS,MAAM,UAAU,iBAAiB;;;;;;;;;CAWnD,MAAM,MAAM,MAAc;AACxB,QAAM,KAAK,cAAc;AAEzB,MAAI;GAGF,MAAM,OAFU,KAAK,OAAO,KAER,CAAC;AACrB,OAAI,CAAC,UAAU,sBAAsB,KAAK,CACxC,OAAM,IAAI,MACR,qCAAsC,KAAwB,OAC/D;GAGH,MAAM,EAAE,YAAY,wBAAwB;AAC5C,OAAI,CAAC,UAAU,iBAAiB,oBAAoB,CAClD,OAAM,IAAI,MAAM,0BAA0B;AAG5C,UAAO,MADe,cAAc,qBACV,CAAC,OAAO,oBAAoB;WAC/C,KAAK;AACZ,SAAM,IAAI,MAAM,iBAAiB,IAAI,IAAI,OAAO;;;;;;;;CASpD,wBAAgC;AAC9B,SAAO"}
+{"version":3,"file":"expression.js","names":[],"sources":["../../src/output_parsers/expression.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { MasterHandler } from \"./expression_type_handlers/factory.js\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nimport type { ExpressionNode } from \"../types/expression-parser.js\";\n\nexport type ParseFunction = Awaited<\n  ReturnType<typeof ASTParser.importASTParser>\n>;\n\n/**\n * We need to be able to handle the following cases:\n * ExpressionStatement\n *  CallExpression\n *      Identifier | MemberExpression\n *      ExpressionLiterals: [\n *          CallExpression\n *          StringLiteral\n *          NumericLiteral\n *          ArrayLiteralExpression\n *              ExpressionLiterals\n *          ObjectLiteralExpression\n *              PropertyAssignment\n *                  Identifier\n *                  ExpressionLiterals\n *      ]\n */\n\nexport class ExpressionParser extends BaseOutputParser<ParsedType> {\n  lc_namespace = [\"langchain\", \"output_parsers\", \"expression\"];\n\n  parser: ParseFunction;\n\n  /**\n   * We should separate loading the parser into its own function\n   * because loading the grammar takes some time. If there are\n   * multiple concurrent parse calls, it's faster to just wait\n   * for building the parser once and then use it for all\n   * subsequent calls. See expression.test.ts for an example.\n   */\n  async ensureParser() {\n    if (!this.parser) {\n      this.parser = await ASTParser.importASTParser();\n    }\n  }\n\n  /**\n   * Parses the given text. It first ensures the parser is loaded, then\n   * tries to parse the text. If the parsing fails, it throws an error. If\n   * the parsing is successful, it returns the parsed expression.\n   * @param text The text to be parsed.\n   * @returns The parsed expression\n   */\n  async parse(text: string) {\n    await this.ensureParser();\n\n    try {\n      const program = this.parser(text);\n\n      const node = program.body;\n      if (!ASTParser.isExpressionStatement(node)) {\n        throw new Error(\n          `Expected ExpressionStatement, got ${(node as ExpressionNode).type}`\n        );\n      }\n\n      const { expression: expressionStatement } = node;\n      if (!ASTParser.isCallExpression(expressionStatement)) {\n        throw new Error(\"Expected CallExpression\");\n      }\n      const masterHandler = MasterHandler.createMasterHandler();\n      return await masterHandler.handle(expressionStatement);\n    } catch (err) {\n      throw new Error(`Error parsing ${err}: ${text}`);\n    }\n  }\n\n  /**\n   * This method is currently empty, but it could be used to provide\n   * instructions on the format of the input text.\n   * @returns string\n   */\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport * from \"./expression_type_handlers/types.js\";\n\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,mBAAb,cAAsC,iBAA6B;CACjE,eAAe;EAAC;EAAa;EAAkB;CAAY;CAE3D;;;;;;;;CASA,MAAM,eAAe;EACnB,IAAI,CAAC,KAAK,QACR,KAAK,SAAS,MAAM,UAAU,gBAAgB;CAElD;;;;;;;;CASA,MAAM,MAAM,MAAc;EACxB,MAAM,KAAK,aAAa;EAExB,IAAI;GAGF,MAAM,OAFU,KAAK,OAAO,IAET,CAAC,CAAC;GACrB,IAAI,CAAC,UAAU,sBAAsB,IAAI,GACvC,MAAM,IAAI,MACR,qCAAsC,KAAwB,MAChE;GAGF,MAAM,EAAE,YAAY,wBAAwB;GAC5C,IAAI,CAAC,UAAU,iBAAiB,mBAAmB,GACjD,MAAM,IAAI,MAAM,yBAAyB;GAG3C,OAAO,MADe,cAAc,oBACX,CAAC,CAAC,OAAO,mBAAmB;EACvD,SAAS,KAAK;GACZ,MAAM,IAAI,MAAM,iBAAiB,IAAI,IAAI,MAAM;EACjD;CACF;;;;;;CAOA,wBAAgC;EAC9B,OAAO;CACT;AACF"}