@langchain/classic 1.0.39 → 1.0.41

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"}

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"array_literal_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmDA,aAAAA,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;AACtE,MAAIC,aAAAA,UAAU,kBAAkB,KAAK,CACnC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAkD;AAC7D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;GACF"}
+{"version":3,"file":"array_literal_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmDA,aAAAA,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;EACtE,IAAIC,aAAAA,UAAU,kBAAkB,IAAI,GAClC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAAkD;EAC7D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,SAA2B,CACxD,CACF;EACF;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"array_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmD,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;AACtE,MAAI,UAAU,kBAAkB,KAAK,CACnC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAkD;AAC7D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,UAA4B,CACxD,CACF;GACF"}
+{"version":3,"file":"array_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/array_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { ArrayLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ArrayExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles array expressions in the LangChain Expression Language (LCEL).\n * It extends the NodeHandler base class, providing functionality to\n * accept and handle array expressions.\n */\nexport class ArrayLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if the given node is an array expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<ArrayExpression | boolean> {\n    if (ASTParser.isArrayExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Handles the given array expression node. If the handler doesn't have a\n   * parent handler, it throws an error. Otherwise, it returns an object\n   * representing the array literal.\n   * @param node The ArrayExpression node to handle.\n   * @returns A Promise that resolves to an object representing the array literal.\n   */\n  async handle(node: ArrayExpression): Promise<ArrayLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"array_literal\",\n      values: await Promise.all(\n        node.elements.map((innerNode) =>\n          this.parentHandler!.handle(innerNode as ExpressionNode)\n        )\n      ),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,gCAAb,cAAmD,YAAY;;;;;;;CAO7D,MAAM,QAAQ,MAA0D;EACtE,IAAI,UAAU,kBAAkB,IAAI,GAClC,OAAO;OAEP,OAAO;CAEX;;;;;;;;CASA,MAAM,OAAO,MAAkD;EAC7D,IAAI,CAAC,KAAK,eACR,MAAM,IAAI,MACR,0DACF;EAEF,OAAO;GACL,MAAM;GACN,QAAQ,MAAM,QAAQ,IACpB,KAAK,SAAS,KAAK,cACjB,KAAK,cAAe,OAAO,SAA2B,CACxD,CACF;EACF;CACF;AACF"}

package/dist/output_parsers/expression_type_handlers/base.cjs

@@ -5,6 +5,7 @@ const require_parser_grammar = require("./grammar/parser_grammar.cjs");
 * must implement the `accepts` and `handle` methods.
 */
 var NodeHandler = class {
+	parentHandler;
 	constructor(parentHandler) {
 		this.parentHandler = parentHandler;
 	}

package/dist/output_parsers/expression_type_handlers/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["GRAMMAR"],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CAChC,YAAY,eAAuC;AAA7B,OAAA,gBAAA;;;;;;;;AAwBxB,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAASA,uBAAAA,QACN;AACxB,cAAU,mBAAmB;;AAE/B,UAAO,UAAU;UACX;AACN,SAAM,IAAI,MACR,mGACD;;;;;;;;CASL,OAAO,UAAU,MAAuC;AACtD,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,sBACL,MAC6B;AAC7B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,gBAAgB,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;;;;;;;CAQhE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,aAAa,MAA0C;AAC5D,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,kBAAkB,MAA+C;AACtE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,qBACL,MAC4B;AAC5B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS"}
+{"version":3,"file":"base.cjs","names":["GRAMMAR"],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CACV;CAAtB,YAAY,eAAuC;EAA7B,KAAA,gBAAA;CAA8B;AAiBtD;;;;;;AAOA,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;EAC7B,IAAI;GACF,IAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAASA,uBAAAA,OACP;IACvB,UAAU,mBAAmB;GAC/B;GACA,OAAO,UAAU;EACnB,QAAQ;GACN,MAAM,IAAI,MACR,kGACF;EACF;CACF;;;;;;CAOA,OAAO,UAAU,MAAuC;EACtD,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,sBACL,MAC6B;EAC7B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,iBAAiB,MAA8C;EACpE,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,gBAAgB,MAA6C;EAClE,OAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;CAChE;;;;;;CAOA,OAAO,iBAAiB,MAA8C;EACpE,OAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CACjE;;;;;;CAOA,OAAO,iBAAiB,MAA8C;EACpE,OAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;CACjE;;;;;;CAOA,OAAO,aAAa,MAA0C;EAC5D,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,mBAAmB,MAAgD;EACxE,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,kBAAkB,MAA+C;EACtE,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,qBACL,MAC4B;EAC5B,OAAO,KAAK,SAAS;CACvB;;;;;;CAOA,OAAO,mBAAmB,MAAgD;EACxE,OAAO,KAAK,SAAS;CACvB;AACF"}

package/dist/output_parsers/expression_type_handlers/base.d.cts

@@ -1,5 +1,4 @@
 import { ArrayExpression, BooleanLiteral, CallExpression, ExpressionNode, ExpressionStatement, Identifier, MemberExpression, NumericLiteral, ObjectExpression, ParseFunction, Program, PropertyAssignment, StringLiteral } from "../../types/expression-parser.cjs";
-
 //#region src/output_parsers/expression_type_handlers/base.d.ts
 /**
  * Abstract class for handling nodes in an expression language. Subclasses

package/dist/output_parsers/expression_type_handlers/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;AAqBA;;uBAAsB,WAAA;EAAA,UACE,aAAA,GAAgB,WAAA;EAAtC,WAAA,CAAsB,aAAA,GAAgB,WAAA;EAOf;;;;;EAAA,SAAd,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,cAAA;EASF;;;;;;EAAA,SAArC,MAAA,CAAO,IAAA,EAAM,cAAA,GAAiB,OAAA;AAAA;;;;;;cAQ5B,SAAA;EAAA,OACJ,gBAAA,EAAkB,aAAA;EATqB;;AAQhD;;EARgD,OAejC,eAAA,CAAA,GAAe,OAAA,CAAA,aAAA;EANH;;;;;EAAA,OA2BlB,SAAA,CAAU,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,OAAA;EAWrC;;;;;EAAA,OAFJ,qBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,mBAAA;EA2B4C;;;;;EAAA,OAlBhD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA6CE;;;;;EAAA,OApClD,eAAA,CAAgB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,aAAA;EAiEG;;;;;EAAA,OAxDlD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA3D3B;;;;;EAAA,OAoErB,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA/CP;;;;;EAAA,OAwDzC,YAAA,CAAa,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,UAAA;EApC5C;;;;;EAAA,OA6CA,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;EApC5B;;;;;EAAA,OA6CtB,iBAAA,CAAkB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,eAAA;EApChC;;;;;EAAA,OA6CjB,oBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,kBAAA;EAtCoC;;;;;EAAA,OA+CxC,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;AAAA"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;;uBAqBsB;YACE,gBAAgB;EAAtC,YAAsB,gBAAgB;;;;;;WAO7B,QAAQ,MAAM,iBAAiB,QAAQ;;;;;;;WASvC,OAAO,MAAM,iBAAiB;;;;;;;cAQ5B;SACJ,kBAAkB;;;;;SAMZ,mBAAe,QAAA;;;;;;SAqBrB,UAAU,MAAM,iBAAiB,QAAQ;;;;;;SASzC,sBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,gBAAgB,MAAM,iBAAiB,QAAQ;;;;;;SAS/C,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,aAAa,MAAM,iBAAiB,QAAQ;;;;;;SAS5C,mBAAmB,MAAM,iBAAiB,QAAQ;;;;;;SASlD,kBAAkB,MAAM,iBAAiB,QAAQ;;;;;;SASjD,qBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,mBAAmB,MAAM,iBAAiB,QAAQ"}

package/dist/output_parsers/expression_type_handlers/base.d.ts

@@ -1,5 +1,4 @@
 import { ArrayExpression, BooleanLiteral, CallExpression, ExpressionNode, ExpressionStatement, Identifier, MemberExpression, NumericLiteral, ObjectExpression, ParseFunction, Program, PropertyAssignment, StringLiteral } from "../../types/expression-parser.js";
-
 //#region src/output_parsers/expression_type_handlers/base.d.ts
 /**
  * Abstract class for handling nodes in an expression language. Subclasses

package/dist/output_parsers/expression_type_handlers/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;AAqBA;;uBAAsB,WAAA;EAAA,UACE,aAAA,GAAgB,WAAA;EAAtC,WAAA,CAAsB,aAAA,GAAgB,WAAA;EAOf;;;;;EAAA,SAAd,OAAA,CAAQ,IAAA,EAAM,cAAA,GAAiB,OAAA,CAAQ,cAAA;EASF;;;;;;EAAA,SAArC,MAAA,CAAO,IAAA,EAAM,cAAA,GAAiB,OAAA;AAAA;;;;;;cAQ5B,SAAA;EAAA,OACJ,gBAAA,EAAkB,aAAA;EATqB;;AAQhD;;EARgD,OAejC,eAAA,CAAA,GAAe,OAAA,CAAA,aAAA;EANH;;;;;EAAA,OA2BlB,SAAA,CAAU,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,OAAA;EAWrC;;;;;EAAA,OAFJ,qBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,mBAAA;EA2B4C;;;;;EAAA,OAlBhD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA6CE;;;;;EAAA,OApClD,eAAA,CAAgB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,aAAA;EAiEG;;;;;EAAA,OAxDlD,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA3D3B;;;;;EAAA,OAoErB,gBAAA,CAAiB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,cAAA;EA/CP;;;;;EAAA,OAwDzC,YAAA,CAAa,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,UAAA;EApC5C;;;;;EAAA,OA6CA,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;EApC5B;;;;;EAAA,OA6CtB,iBAAA,CAAkB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,eAAA;EApChC;;;;;EAAA,OA6CjB,oBAAA,CACL,IAAA,EAAM,cAAA,GACL,IAAA,IAAQ,kBAAA;EAtCoC;;;;;EAAA,OA+CxC,kBAAA,CAAmB,IAAA,EAAM,cAAA,GAAiB,IAAA,IAAQ,gBAAA;AAAA"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"mappings":";;;;;;uBAqBsB;YACE,gBAAgB;EAAtC,YAAsB,gBAAgB;;;;;;WAO7B,QAAQ,MAAM,iBAAiB,QAAQ;;;;;;;WASvC,OAAO,MAAM,iBAAiB;;;;;;;cAQ5B;SACJ,kBAAkB;;;;;SAMZ,mBAAe,QAAA;;;;;;SAqBrB,UAAU,MAAM,iBAAiB,QAAQ;;;;;;SASzC,sBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,gBAAgB,MAAM,iBAAiB,QAAQ;;;;;;SAS/C,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,iBAAiB,MAAM,iBAAiB,QAAQ;;;;;;SAShD,aAAa,MAAM,iBAAiB,QAAQ;;;;;;SAS5C,mBAAmB,MAAM,iBAAiB,QAAQ;;;;;;SASlD,kBAAkB,MAAM,iBAAiB,QAAQ;;;;;;SASjD,qBACL,MAAM,iBACL,QAAQ;;;;;;SASJ,mBAAmB,MAAM,iBAAiB,QAAQ"}