@langchain/classic 1.0.5 → 1.0.6-dev-1765432861398

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

@@ -0,0 +1 @@
+{"version":3,"file":"combined_memory.d.ts","names":["InputValues","MemoryVariables","BaseMemory","OutputValues","BaseChatMemory","BaseChatMemoryInput","CombinedMemoryInput","CombinedMemory","Promise"],"sources":["../../src/memory/combined_memory.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables, BaseMemory, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface that defines the shape of the input object that the\n * CombinedMemory constructor accepts. It extends the BaseChatMemoryInput\n * interface and adds additional properties.\n */\nexport interface CombinedMemoryInput extends BaseChatMemoryInput {\n    memories: BaseMemory[];\n    humanPrefix?: string;\n    aiPrefix?: string;\n    memoryKey?: string;\n}\n/**\n * Class that manages and manipulates previous chat messages. It extends\n * from the BaseChatMemory class and implements the CombinedMemoryInput\n * interface.\n */\nexport declare class CombinedMemory extends BaseChatMemory implements CombinedMemoryInput {\n    humanPrefix: string;\n    aiPrefix: string;\n    memoryKey: string;\n    memories: BaseMemory[];\n    constructor(fields?: CombinedMemoryInput);\n    /**\n     * Checks for repeated memory variables across all memory objects. Throws\n     * an error if any are found.\n     */\n    checkRepeatedMemoryVariable(): void;\n    /**\n     * Checks if input keys are set for all memory objects. Logs a warning if\n     * any are missing.\n     */\n    checkInputKey(): void;\n    /**\n     * Loads memory variables from all memory objects.\n     * @param inputValues Input values to load memory variables from.\n     * @returns Promise that resolves with an object containing the loaded memory variables.\n     */\n    loadMemoryVariables(inputValues: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context to all memory objects.\n     * @param inputValues Input values to save.\n     * @param outputValues Output values to save.\n     * @returns Promise that resolves when the context has been saved to all memory objects.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Clears all memory objects.\n     * @returns Promise that resolves when all memory objects have been cleared.\n     */\n    clear(): Promise<void>;\n    get memoryKeys(): string[];\n}\n//# sourceMappingURL=combined_memory.d.ts.map"],"mappings":";;;;;;;AAOA;AAWA;;AAKyBM,UAhBRA,mBAAAA,SAA4BD,mBAgBpBC,CAAAA;EAgBYN,QAAAA,EA/BvBE,UA+BuBF,EAAAA;EAAsBC,WAAAA,CAAAA,EAAAA,MAAAA;EAARO,QAAAA,CAAAA,EAAAA,MAAAA;EAOtBR,SAAAA,CAAAA,EAAAA,MAAAA;;;;;;AA5B4D;cAApEO,cAAAA,SAAuBH,cAAAA,YAA0BE;;;;YAIxDJ;uBACWI;;;;;;;;;;;;;;;;mCAgBYN,cAAcQ,QAAQP;;;;;;;2BAO9BD,2BAA2BG,eAAeK;;;;;WAK1DA"}

package/dist/memory/entity_memory.d.cts

@@ -21,7 +21,6 @@ interface EntityMemoryInput extends BaseChatMemoryInput {
   entitiesKey?: string;
   entityStore?: BaseEntityStore;
 }
-// Entity extractor & summarizer to memory.
 /**
  * Class for managing entity extraction and summarization to memory in
  * chatbot applications. Extends the BaseChatMemory class and implements
@@ -69,16 +68,13 @@ declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {
   aiPrefix?: string;
   constructor(fields: EntityMemoryInput);
   get memoryKeys(): string[];
-  // Will always return list of memory variables.
   get memoryVariables(): string[];
-  // Return history buffer.
   /**
    * Method to load memory variables and perform entity extraction.
    * @param inputs Input values for the method.
    * @returns Promise resolving to an object containing memory variables.
    */
   loadMemoryVariables(inputs: InputValues): Promise<MemoryVariables>;
-  // Save context from this conversation to buffer.
   /**
    * Method to save the context from a conversation to a buffer and perform
    * entity summarization.
@@ -87,7 +83,6 @@ declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {
    * @returns Promise resolving to void.
    */
   saveContext(inputs: InputValues, outputs: OutputValues): Promise<void>;
-  // Clear memory contents.
   /**
    * Method to clear the memory contents.
    * @returns Promise resolving to void.

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity_memory.d.cts","names":["BaseLanguageModelInterface","PromptTemplate","InputValues","MemoryVariables","OutputValues","BaseEntityStore","BaseChatMemory","BaseChatMemoryInput","EntityMemoryInput","EntityMemory","Promise"],"sources":["../../src/memory/entity_memory.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseEntityStore } from \"./stores/entity/base.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface for the input parameters required by the EntityMemory class.\n */\nexport interface EntityMemoryInput extends BaseChatMemoryInput {\n    llm: BaseLanguageModelInterface;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    entityExtractionPrompt?: PromptTemplate;\n    entitySummarizationPrompt?: PromptTemplate;\n    entityCache?: string[];\n    k?: number;\n    chatHistoryKey?: string;\n    entitiesKey?: string;\n    entityStore?: BaseEntityStore;\n}\n/**\n * Class for managing entity extraction and summarization to memory in\n * chatbot applications. Extends the BaseChatMemory class and implements\n * the EntityMemoryInput interface.\n * @example\n * ```typescript\n * const memory = new EntityMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   chatHistoryKey: \"history\",\n *   entitiesKey: \"entities\",\n * });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n * const chain = new LLMChain({\n *   llm: model,\n *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,\n *   memory,\n * });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({\n *   res1,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * const res2 = await chain.call({\n *   input: \"I work in construction. What about you?\",\n * });\n * console.log({\n *   res2,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * ```\n */\nexport declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {\n    private entityExtractionChain;\n    private entitySummarizationChain;\n    entityStore: BaseEntityStore;\n    entityCache: string[];\n    k: number;\n    chatHistoryKey: string;\n    llm: BaseLanguageModelInterface;\n    entitiesKey: string;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    constructor(fields: EntityMemoryInput);\n    get memoryKeys(): string[];\n    get memoryVariables(): string[];\n    /**\n     * Method to load memory variables and perform entity extraction.\n     * @param inputs Input values for the method.\n     * @returns Promise resolving to an object containing memory variables.\n     */\n    loadMemoryVariables(inputs: InputValues): Promise<MemoryVariables>;\n    /**\n     * Method to save the context from a conversation to a buffer and perform\n     * entity summarization.\n     * @param inputs Input values for the method.\n     * @param outputs Output values from the method.\n     * @returns Promise resolving to void.\n     */\n    saveContext(inputs: InputValues, outputs: OutputValues): Promise<void>;\n    /**\n     * Method to clear the memory contents.\n     * @returns Promise resolving to void.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=entity_memory.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AACSA,UADQQ,iBAAAA,SAA0BD,mBAClCP,CAAAA;EAGoBC,GAAAA,EAHpBD,0BAGoBC;EACGA,WAAAA,CAAAA,EAAAA,MAAAA;EAKdI,QAAAA,CAAAA,EAAAA,MAAAA;EAVyBE,sBAAAA,CAAAA,EAIdN,cAJcM;EAAmB,yBAAA,CAAA,EAK9BN,cAL8B;EA8CzCQ,WAAAA,CAAAA,EAAAA,MAAY,EAAA;EAGhBJ,CAAAA,CAAAA,EAAAA,MAAAA;EAIRL,cAAAA,CAAAA,EAAAA,MAAAA;EAIeQ,WAAAA,CAAAA,EAAAA,MAAAA;EAQQN,WAAAA,CAAAA,EAvDdG,eAuDcH;;;;;;;;;AAnBqD;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAhEO,YAAAA,SAAqBH,cAAAA,YAA0BE;;;eAGnDH;;;;OAIRL;;;;sBAIeQ;;;;;;;;8BAQQN,cAAcQ,QAAQP;;;;;;;;sBAQ9BD,sBAAsBE,eAAeM;;;;;WAKhDA"}

package/dist/memory/entity_memory.d.ts

@@ -21,7 +21,6 @@ interface EntityMemoryInput extends BaseChatMemoryInput {
   entitiesKey?: string;
   entityStore?: BaseEntityStore;
 }
-// Entity extractor & summarizer to memory.
 /**
  * Class for managing entity extraction and summarization to memory in
  * chatbot applications. Extends the BaseChatMemory class and implements
@@ -69,16 +68,13 @@ declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {
   aiPrefix?: string;
   constructor(fields: EntityMemoryInput);
   get memoryKeys(): string[];
-  // Will always return list of memory variables.
   get memoryVariables(): string[];
-  // Return history buffer.
   /**
    * Method to load memory variables and perform entity extraction.
    * @param inputs Input values for the method.
    * @returns Promise resolving to an object containing memory variables.
    */
   loadMemoryVariables(inputs: InputValues): Promise<MemoryVariables>;
-  // Save context from this conversation to buffer.
   /**
    * Method to save the context from a conversation to a buffer and perform
    * entity summarization.
@@ -87,7 +83,6 @@ declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {
    * @returns Promise resolving to void.
    */
   saveContext(inputs: InputValues, outputs: OutputValues): Promise<void>;
-  // Clear memory contents.
   /**
    * Method to clear the memory contents.
    * @returns Promise resolving to void.

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

@@ -0,0 +1 @@
+{"version":3,"file":"entity_memory.d.ts","names":["BaseLanguageModelInterface","PromptTemplate","InputValues","MemoryVariables","OutputValues","BaseEntityStore","BaseChatMemory","BaseChatMemoryInput","EntityMemoryInput","EntityMemory","Promise"],"sources":["../../src/memory/entity_memory.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseEntityStore } from \"./stores/entity/base.js\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface for the input parameters required by the EntityMemory class.\n */\nexport interface EntityMemoryInput extends BaseChatMemoryInput {\n    llm: BaseLanguageModelInterface;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    entityExtractionPrompt?: PromptTemplate;\n    entitySummarizationPrompt?: PromptTemplate;\n    entityCache?: string[];\n    k?: number;\n    chatHistoryKey?: string;\n    entitiesKey?: string;\n    entityStore?: BaseEntityStore;\n}\n/**\n * Class for managing entity extraction and summarization to memory in\n * chatbot applications. Extends the BaseChatMemory class and implements\n * the EntityMemoryInput interface.\n * @example\n * ```typescript\n * const memory = new EntityMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   chatHistoryKey: \"history\",\n *   entitiesKey: \"entities\",\n * });\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9 });\n * const chain = new LLMChain({\n *   llm: model,\n *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,\n *   memory,\n * });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({\n *   res1,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * const res2 = await chain.call({\n *   input: \"I work in construction. What about you?\",\n * });\n * console.log({\n *   res2,\n *   memory: await memory.loadMemoryVariables({ input: \"Who is Jim?\" }),\n * });\n *\n * ```\n */\nexport declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {\n    private entityExtractionChain;\n    private entitySummarizationChain;\n    entityStore: BaseEntityStore;\n    entityCache: string[];\n    k: number;\n    chatHistoryKey: string;\n    llm: BaseLanguageModelInterface;\n    entitiesKey: string;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    constructor(fields: EntityMemoryInput);\n    get memoryKeys(): string[];\n    get memoryVariables(): string[];\n    /**\n     * Method to load memory variables and perform entity extraction.\n     * @param inputs Input values for the method.\n     * @returns Promise resolving to an object containing memory variables.\n     */\n    loadMemoryVariables(inputs: InputValues): Promise<MemoryVariables>;\n    /**\n     * Method to save the context from a conversation to a buffer and perform\n     * entity summarization.\n     * @param inputs Input values for the method.\n     * @param outputs Output values from the method.\n     * @returns Promise resolving to void.\n     */\n    saveContext(inputs: InputValues, outputs: OutputValues): Promise<void>;\n    /**\n     * Method to clear the memory contents.\n     * @returns Promise resolving to void.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=entity_memory.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AACSA,UADQQ,iBAAAA,SAA0BD,mBAClCP,CAAAA;EAGoBC,GAAAA,EAHpBD,0BAGoBC;EACGA,WAAAA,CAAAA,EAAAA,MAAAA;EAKdI,QAAAA,CAAAA,EAAAA,MAAAA;EAVyBE,sBAAAA,CAAAA,EAIdN,cAJcM;EAAmB,yBAAA,CAAA,EAK9BN,cAL8B;EA8CzCQ,WAAAA,CAAAA,EAAAA,MAAY,EAAA;EAGhBJ,CAAAA,CAAAA,EAAAA,MAAAA;EAIRL,cAAAA,CAAAA,EAAAA,MAAAA;EAIeQ,WAAAA,CAAAA,EAAAA,MAAAA;EAQQN,WAAAA,CAAAA,EAvDdG,eAuDcH;;;;;;;;;AAnBqD;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAhEO,YAAAA,SAAqBH,cAAAA,YAA0BE;;;eAGnDH;;;;OAIRL;;;;sBAIeQ;;;;;;;;8BAQQN,cAAcQ,QAAQP;;;;;;;;sBAQ9BD,sBAAsBE,eAAeM;;;;;WAKhDA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.cts","names":["PromptTemplate","SUMMARY_PROMPT","_DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE","ENTITY_MEMORY_CONVERSATION_TEMPLATE","_DEFAULT_ENTITY_EXTRACTION_TEMPLATE","ENTITY_EXTRACTION_PROMPT","_DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE","ENTITY_SUMMARIZATION_PROMPT"],"sources":["../../src/memory/prompt.d.ts"],"sourcesContent":["import { PromptTemplate } from \"@langchain/core/prompts\";\nexport declare const SUMMARY_PROMPT: PromptTemplate<{\n    new_lines: any;\n    summary: any;\n}, any>;\nexport declare const _DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE = \"You are an assistant to a human, powered by a large language model trained by OpenAI.\\n\\nYou are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\\n\\nYou are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.\\n\\nOverall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.\\n\\nContext:\\n{entities}\\n\\nCurrent conversation:\\n{history}\\nLast line:\\nHuman: {input}\\nYou:\";\nexport declare const ENTITY_MEMORY_CONVERSATION_TEMPLATE: PromptTemplate<{\n    entities: any;\n    history: any;\n    input: any;\n}, any>;\nexport declare const _DEFAULT_ENTITY_EXTRACTION_TEMPLATE = \"You are an AI assistant reading the transcript of a conversation between an AI and a human. Extract all of the proper nouns from the last line of conversation. As a guideline, a proper noun is generally capitalized. You should definitely extract all names and places.\\n\\nThe conversation history is provided just in case of a coreference (e.g. \\\"What do you know about him\\\" where \\\"him\\\" is defined in a previous line) -- ignore items mentioned there that are not in the last line.\\n\\nReturn the output as a single comma-separated list, or NONE if there is nothing of note to return (e.g. the user is just issuing a greeting or having a simple conversation).\\n\\nEXAMPLE\\nConversation history:\\nPerson #1: my name is Jacob. how's it going today?\\nAI: \\\"It's going great! How about you?\\\"\\nPerson #1: good! busy working on Langchain. lots to do.\\nAI: \\\"That sounds like a lot of work! What kind of things are you doing to make Langchain better?\\\"\\nLast line:\\nPerson #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff.\\nOutput: Jacob,Langchain\\nEND OF EXAMPLE\\n\\nEXAMPLE\\nConversation history:\\nPerson #1: how's it going today?\\nAI: \\\"It's going great! How about you?\\\"\\nPerson #1: good! busy working on Langchain. lots to do.\\nAI: \\\"That sounds like a lot of work! What kind of things are you doing to make Langchain better?\\\"\\nLast line:\\nPerson #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff. I'm working with Person #2.\\nOutput: Langchain, Person #2\\nEND OF EXAMPLE\\n\\nConversation history (for reference only):\\n{history}\\nLast line of conversation (for extraction):\\nHuman: {input}\\n\\nOutput:\";\nexport declare const ENTITY_EXTRACTION_PROMPT: PromptTemplate<{\n    history: any;\n    input: any;\n}, any>;\nexport declare const _DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE = \"You are an AI assistant helping a human keep track of facts about relevant people, places, and concepts in their life. Update and add to the summary of the provided entity in the \\\"Entity\\\" section based on the last line of your conversation with the human. If you are writing the summary for the first time, return a single sentence.\\nThe update should only include facts that are relayed in the last line of conversation about the provided entity, and should only contain facts about the provided entity.\\n\\nIf there is no new information about the provided entity or the information is not worth noting (not an important or relevant fact to remember long-term), output the exact string \\\"UNCHANGED\\\" below.\\n\\nFull conversation history (for context):\\n{history}\\n\\nEntity to summarize:\\n{entity}\\n\\nExisting summary of {entity}:\\n{summary}\\n\\nLast line of conversation:\\nHuman: {input}\\nUpdated summary (or the exact string \\\"UNCHANGED\\\" if there is no new information about {entity} above):\";\nexport declare const ENTITY_SUMMARIZATION_PROMPT: PromptTemplate<{\n    entity: any;\n    history: any;\n    input: any;\n    summary: any;\n}, any>;\n//# sourceMappingURL=prompt.d.ts.map"],"mappings":";;;;cAMqBG,qCAAqCH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","names":["PromptTemplate","SUMMARY_PROMPT","_DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE","ENTITY_MEMORY_CONVERSATION_TEMPLATE","_DEFAULT_ENTITY_EXTRACTION_TEMPLATE","ENTITY_EXTRACTION_PROMPT","_DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE","ENTITY_SUMMARIZATION_PROMPT"],"sources":["../../src/memory/prompt.d.ts"],"sourcesContent":["import { PromptTemplate } from \"@langchain/core/prompts\";\nexport declare const SUMMARY_PROMPT: PromptTemplate<{\n    new_lines: any;\n    summary: any;\n}, any>;\nexport declare const _DEFAULT_ENTITY_MEMORY_CONVERSATION_TEMPLATE = \"You are an assistant to a human, powered by a large language model trained by OpenAI.\\n\\nYou are designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, you are able to generate human-like text based on the input you receive, allowing you to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\\n\\nYou are constantly learning and improving, and your capabilities are constantly evolving. You are able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. You have access to some personalized information provided by the human in the Context section below. Additionally, you are able to generate your own text based on the input you receive, allowing you to engage in discussions and provide explanations and descriptions on a wide range of topics.\\n\\nOverall, you are a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether the human needs help with a specific question or just wants to have a conversation about a particular topic, you are here to assist.\\n\\nContext:\\n{entities}\\n\\nCurrent conversation:\\n{history}\\nLast line:\\nHuman: {input}\\nYou:\";\nexport declare const ENTITY_MEMORY_CONVERSATION_TEMPLATE: PromptTemplate<{\n    entities: any;\n    history: any;\n    input: any;\n}, any>;\nexport declare const _DEFAULT_ENTITY_EXTRACTION_TEMPLATE = \"You are an AI assistant reading the transcript of a conversation between an AI and a human. Extract all of the proper nouns from the last line of conversation. As a guideline, a proper noun is generally capitalized. You should definitely extract all names and places.\\n\\nThe conversation history is provided just in case of a coreference (e.g. \\\"What do you know about him\\\" where \\\"him\\\" is defined in a previous line) -- ignore items mentioned there that are not in the last line.\\n\\nReturn the output as a single comma-separated list, or NONE if there is nothing of note to return (e.g. the user is just issuing a greeting or having a simple conversation).\\n\\nEXAMPLE\\nConversation history:\\nPerson #1: my name is Jacob. how's it going today?\\nAI: \\\"It's going great! How about you?\\\"\\nPerson #1: good! busy working on Langchain. lots to do.\\nAI: \\\"That sounds like a lot of work! What kind of things are you doing to make Langchain better?\\\"\\nLast line:\\nPerson #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff.\\nOutput: Jacob,Langchain\\nEND OF EXAMPLE\\n\\nEXAMPLE\\nConversation history:\\nPerson #1: how's it going today?\\nAI: \\\"It's going great! How about you?\\\"\\nPerson #1: good! busy working on Langchain. lots to do.\\nAI: \\\"That sounds like a lot of work! What kind of things are you doing to make Langchain better?\\\"\\nLast line:\\nPerson #1: i'm trying to improve Langchain's interfaces, the UX, its integrations with various products the user might want ... a lot of stuff. I'm working with Person #2.\\nOutput: Langchain, Person #2\\nEND OF EXAMPLE\\n\\nConversation history (for reference only):\\n{history}\\nLast line of conversation (for extraction):\\nHuman: {input}\\n\\nOutput:\";\nexport declare const ENTITY_EXTRACTION_PROMPT: PromptTemplate<{\n    history: any;\n    input: any;\n}, any>;\nexport declare const _DEFAULT_ENTITY_SUMMARIZATION_TEMPLATE = \"You are an AI assistant helping a human keep track of facts about relevant people, places, and concepts in their life. Update and add to the summary of the provided entity in the \\\"Entity\\\" section based on the last line of your conversation with the human. If you are writing the summary for the first time, return a single sentence.\\nThe update should only include facts that are relayed in the last line of conversation about the provided entity, and should only contain facts about the provided entity.\\n\\nIf there is no new information about the provided entity or the information is not worth noting (not an important or relevant fact to remember long-term), output the exact string \\\"UNCHANGED\\\" below.\\n\\nFull conversation history (for context):\\n{history}\\n\\nEntity to summarize:\\n{entity}\\n\\nExisting summary of {entity}:\\n{summary}\\n\\nLast line of conversation:\\nHuman: {input}\\nUpdated summary (or the exact string \\\"UNCHANGED\\\" if there is no new information about {entity} above):\";\nexport declare const ENTITY_SUMMARIZATION_PROMPT: PromptTemplate<{\n    entity: any;\n    history: any;\n    input: any;\n    summary: any;\n}, any>;\n//# sourceMappingURL=prompt.d.ts.map"],"mappings":";;;;cAMqBG,qCAAqCH"}

package/dist/memory/stores/entity/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["Serializable","BaseEntityStore","Promise"],"sources":["../../../../src/memory/stores/entity/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all entity stores. All entity stores should extend this\n * class.\n */\nexport declare abstract class BaseEntityStore extends Serializable {\n    abstract get(key: string, defaultValue?: string): Promise<string | undefined>;\n    abstract set(key: string, value?: string): Promise<void>;\n    abstract delete(key: string): Promise<void>;\n    abstract exists(key: string): Promise<boolean>;\n    abstract clear(): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAE+CE,uBAFjBD,eAAAA,SAAwBD,YAAAA,CAEPE;EACbA,SAAAA,GAAAA,CAAAA,GAAAA,EAAAA,MAAAA,EAAAA,YAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAFoBA,OAEpBA,CAAAA,MAAAA,GAAAA,SAAAA,CAAAA;EACAA,SAAAA,GAAAA,CAAAA,GAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAFaA,OAEbA,CAAAA,IAAAA,CAAAA;EACZA,SAAAA,MAAAA,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAFYA,OAEZA,CAAAA,IAAAA,CAAAA;EALgCF,SAAAA,MAAAA,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAIpBE,OAJoBF,CAAAA,OAAAA,CAAAA;EAAY,SAAA,KAAA,CAAA,CAAA,EAK5CE,OAL4C,CAAA,IAAA,CAAA"}

package/dist/memory/stores/entity/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Serializable","BaseEntityStore","Promise"],"sources":["../../../../src/memory/stores/entity/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all entity stores. All entity stores should extend this\n * class.\n */\nexport declare abstract class BaseEntityStore extends Serializable {\n    abstract get(key: string, defaultValue?: string): Promise<string | undefined>;\n    abstract set(key: string, value?: string): Promise<void>;\n    abstract delete(key: string): Promise<void>;\n    abstract exists(key: string): Promise<boolean>;\n    abstract clear(): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAE+CE,uBAFjBD,eAAAA,SAAwBD,YAAAA,CAEPE;EACbA,SAAAA,GAAAA,CAAAA,GAAAA,EAAAA,MAAAA,EAAAA,YAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAFoBA,OAEpBA,CAAAA,MAAAA,GAAAA,SAAAA,CAAAA;EACAA,SAAAA,GAAAA,CAAAA,GAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAFaA,OAEbA,CAAAA,IAAAA,CAAAA;EACZA,SAAAA,MAAAA,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAFYA,OAEZA,CAAAA,IAAAA,CAAAA;EALgCF,SAAAA,MAAAA,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAIpBE,OAJoBF,CAAAA,OAAAA,CAAAA;EAAY,SAAA,KAAA,CAAA,CAAA,EAK5CE,OAL4C,CAAA,IAAA,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.cts","names":["BaseLanguageModelInterface","BaseMessage","BasePromptTemplate","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","ConversationSummaryMemoryInput","BaseConversationSummaryMemoryInput","BaseConversationSummaryMemory","Promise","ConversationSummaryMemory"],"sources":["../../src/memory/summary.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {\n}\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n    llm: BaseLanguageModelInterface;\n    memoryKey?: string;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    prompt?: BasePromptTemplate;\n    summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport declare abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n    memoryKey: string;\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: BaseLanguageModelInterface;\n    prompt: BasePromptTemplate;\n    summaryChatMessageClass: new (content: string) => BaseMessage;\n    constructor(fields: BaseConversationSummaryMemoryInput);\n    /**\n     * Predicts a new summary for the conversation given the existing messages\n     * and summary.\n     * @param messages Existing messages in the conversation.\n     * @param existingSummary Current summary of the conversation.\n     * @returns A promise that resolves to a new summary string.\n     */\n    predictNewSummary(messages: BaseMessage[], existingSummary: string): Promise<string>;\n}\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport declare class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n    buffer: string;\n    constructor(fields: ConversationSummaryMemoryInput);\n    get memoryKeys(): string[];\n    /**\n     * Loads the memory variables for the conversation memory.\n     * @returns A promise that resolves to an object containing the memory variables.\n     */\n    loadMemoryVariables(_: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the conversation memory.\n     * @param inputValues Input values for the conversation.\n     * @param outputValues Output values from the conversation.\n     * @returns A promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Clears the conversation memory.\n     * @returns A promise that resolves when the memory has been cleared.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=summary.d.ts.map"],"mappings":";;;;;;;;;;AASA;AAMA;AACSA,UAPQQ,8BAAAA,SAAuCC,kCAO/CT,CAAAA;;;AADsE;AAa/E;AAISA,UAjBQS,kCAAAA,SAA2CF,mBAiBnDP,CAAAA;EACGE,GAAAA,EAjBHF,0BAiBGE;EAC0CD,SAAAA,CAAAA,EAAAA,MAAAA;EAC9BQ,WAAAA,CAAAA,EAAAA,MAAAA;EAQQR,QAAAA,CAAAA,EAAAA,MAAAA;EAAyCU,MAAAA,CAAAA,EAvB5DT,kBAuB4DS;EAfLL,uBAAAA,CAAAA,EAAAA,KAAAA,OAAAA,EAAAA,MAAAA,EAAAA,GAPbL,WAOaK;AAAc;AA8ClF;;;;;AAe6BH,uBA7DCO,6BAAAA,SAAsCJ,cAAAA,CA6DvCH;EAA2BE,SAAAA,EAAAA,MAAAA;EAAeM,WAAAA,EAAAA,MAAAA;EAK1DA,QAAAA,EAAAA,MAAAA;EApB0CD,GAAAA,EA1C9CV,0BA0C8CU;EAA6B,MAAA,EAzCxER,kBAyCwE;oDAxC9BD;sBAC9BQ;;;;;;;;8BAQQR,yCAAyCU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BpDC,yBAAAA,SAAkCF,6BAAAA;;sBAE/BF;;;;;;yBAMGL,cAAcQ,QAAQP;;;;;;;2BAOpBD,2BAA2BE,eAAeM;;;;;WAK1DA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"summary.d.ts","names":["BaseLanguageModelInterface","BaseMessage","BasePromptTemplate","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","ConversationSummaryMemoryInput","BaseConversationSummaryMemoryInput","BaseConversationSummaryMemory","Promise","ConversationSummaryMemory"],"sources":["../../src/memory/summary.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"./chat_memory.js\";\n/**\n * Interface for the input parameters of the ConversationSummaryMemory\n * class.\n */\nexport interface ConversationSummaryMemoryInput extends BaseConversationSummaryMemoryInput {\n}\n/**\n * Interface for the input parameters of the BaseConversationSummaryMemory\n * class.\n */\nexport interface BaseConversationSummaryMemoryInput extends BaseChatMemoryInput {\n    llm: BaseLanguageModelInterface;\n    memoryKey?: string;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    prompt?: BasePromptTemplate;\n    summaryChatMessageClass?: new (content: string) => BaseMessage;\n}\n/**\n * Abstract class that provides a structure for storing and managing the\n * memory of a conversation. It includes methods for predicting a new\n * summary for the conversation given the existing messages and summary.\n */\nexport declare abstract class BaseConversationSummaryMemory extends BaseChatMemory {\n    memoryKey: string;\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: BaseLanguageModelInterface;\n    prompt: BasePromptTemplate;\n    summaryChatMessageClass: new (content: string) => BaseMessage;\n    constructor(fields: BaseConversationSummaryMemoryInput);\n    /**\n     * Predicts a new summary for the conversation given the existing messages\n     * and summary.\n     * @param messages Existing messages in the conversation.\n     * @param existingSummary Current summary of the conversation.\n     * @returns A promise that resolves to a new summary string.\n     */\n    predictNewSummary(messages: BaseMessage[], existingSummary: string): Promise<string>;\n}\n/**\n * Class that provides a concrete implementation of the conversation\n * memory. It includes methods for loading memory variables, saving\n * context, and clearing the memory.\n * @example\n * ```typescript\n * const memory = new ConversationSummaryMemory({\n *   memoryKey: \"chat_history\",\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo\", temperature: 0 }),\n * });\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt =\n *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n *\n * Current conversation:\n * {chat_history}\n * Human: {input}\n * AI:`);\n * const chain = new LLMChain({ llm: model, prompt, memory });\n *\n * const res1 = await chain.call({ input: \"Hi! I'm Jim.\" });\n * console.log({ res1, memory: await memory.loadMemoryVariables({}) });\n *\n * const res2 = await chain.call({ input: \"What's my name?\" });\n * console.log({ res2, memory: await memory.loadMemoryVariables({}) });\n *\n * ```\n */\nexport declare class ConversationSummaryMemory extends BaseConversationSummaryMemory {\n    buffer: string;\n    constructor(fields: ConversationSummaryMemoryInput);\n    get memoryKeys(): string[];\n    /**\n     * Loads the memory variables for the conversation memory.\n     * @returns A promise that resolves to an object containing the memory variables.\n     */\n    loadMemoryVariables(_: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the conversation memory.\n     * @param inputValues Input values for the conversation.\n     * @param outputValues Output values from the conversation.\n     * @returns A promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Clears the conversation memory.\n     * @returns A promise that resolves when the memory has been cleared.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=summary.d.ts.map"],"mappings":";;;;;;;;;;AASA;AAMA;AACSA,UAPQQ,8BAAAA,SAAuCC,kCAO/CT,CAAAA;;;AADsE;AAa/E;AAISA,UAjBQS,kCAAAA,SAA2CF,mBAiBnDP,CAAAA;EACGE,GAAAA,EAjBHF,0BAiBGE;EAC0CD,SAAAA,CAAAA,EAAAA,MAAAA;EAC9BQ,WAAAA,CAAAA,EAAAA,MAAAA;EAQQR,QAAAA,CAAAA,EAAAA,MAAAA;EAAyCU,MAAAA,CAAAA,EAvB5DT,kBAuB4DS;EAfLL,uBAAAA,CAAAA,EAAAA,KAAAA,OAAAA,EAAAA,MAAAA,EAAAA,GAPbL,WAOaK;AAAc;AA8ClF;;;;;AAe6BH,uBA7DCO,6BAAAA,SAAsCJ,cAAAA,CA6DvCH;EAA2BE,SAAAA,EAAAA,MAAAA;EAAeM,WAAAA,EAAAA,MAAAA;EAK1DA,QAAAA,EAAAA,MAAAA;EApB0CD,GAAAA,EA1C9CV,0BA0C8CU;EAA6B,MAAA,EAzCxER,kBAyCwE;oDAxC9BD;sBAC9BQ;;;;;;;;8BAQQR,yCAAyCU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BpDC,yBAAAA,SAAkCF,6BAAAA;;sBAE/BF;;;;;;yBAMGL,cAAcQ,QAAQP;;;;;;;2BAOpBD,2BAA2BE,eAAeM;;;;;WAK1DA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"summary_buffer.d.cts","names":["InputValues","MemoryVariables","OutputValues","BaseConversationSummaryMemory","BaseConversationSummaryMemoryInput","ConversationSummaryBufferMemoryInput","ConversationSummaryBufferMemory","Promise"],"sources":["../../src/memory/summary_buffer.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from \"./summary.js\";\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n    maxTokenLimit?: number;\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 declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {\n    movingSummaryBuffer: string;\n    maxTokenLimit: number;\n    constructor(fields: ConversationSummaryBufferMemoryInput);\n    get memoryKeys(): string[];\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    loadMemoryVariables(_?: InputValues): Promise<MemoryVariables>;\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    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\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    prune(): Promise<void>;\n    /**\n     * Method that clears the memory and resets the movingSummaryBuffer.\n     * @returns Promise that resolves when the memory is cleared.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=summary_buffer.d.ts.map"],"mappings":";;;;;;;AAMA;AA0CA;AAGwBK,UA7CPA,oCAAAA,SAA6CD,kCA6CtCC,CAAAA;EASIL,aAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;;;AAZ8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArHM,+BAAAA,SAAwCH,6BAAAA,YAAyCE;;;sBAG9EA;;;;;;;;;0BASIL,cAAcO,QAAQN;;;;;;;;;2BASrBD,2BAA2BE,eAAeK;;;;;;;;WAQ1DA;;;;;WAKAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"summary_buffer.d.ts","names":["InputValues","MemoryVariables","OutputValues","BaseConversationSummaryMemory","BaseConversationSummaryMemoryInput","ConversationSummaryBufferMemoryInput","ConversationSummaryBufferMemory","Promise"],"sources":["../../src/memory/summary_buffer.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from \"./summary.js\";\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n    maxTokenLimit?: number;\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 declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {\n    movingSummaryBuffer: string;\n    maxTokenLimit: number;\n    constructor(fields: ConversationSummaryBufferMemoryInput);\n    get memoryKeys(): string[];\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    loadMemoryVariables(_?: InputValues): Promise<MemoryVariables>;\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    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\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    prune(): Promise<void>;\n    /**\n     * Method that clears the memory and resets the movingSummaryBuffer.\n     * @returns Promise that resolves when the memory is cleared.\n     */\n    clear(): Promise<void>;\n}\n//# sourceMappingURL=summary_buffer.d.ts.map"],"mappings":";;;;;;;AAMA;AA0CA;AAGwBK,UA7CPA,oCAAAA,SAA6CD,kCA6CtCC,CAAAA;EASIL,aAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;;;AAZ8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArHM,+BAAAA,SAAwCH,6BAAAA,YAAyCE;;;sBAG9EA;;;;;;;;;0BASIL,cAAcO,QAAQN;;;;;;;;;2BASrBD,2BAA2BE,eAAeK;;;;;;;;WAQ1DA;;;;;WAKAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector_store.d.cts","names":["VectorStoreRetrieverInterface","BaseMemory","InputValues","MemoryVariables","OutputValues","Metadata","Record","MetadataFunction","VectorStoreRetrieverMemoryParams","VectorStoreRetrieverMemory","Promise"],"sources":["../../src/memory/vector_store.d.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { BaseMemory, InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;\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 * 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 declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {\n    vectorStoreRetriever: VectorStoreRetrieverInterface;\n    inputKey?: string;\n    memoryKey: string;\n    returnDocs: boolean;\n    metadata?: Metadata | MetadataFunction;\n    constructor(fields: VectorStoreRetrieverMemoryParams);\n    get memoryKeys(): string[];\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    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\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    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\nexport {};\n//# sourceMappingURL=vector_store.d.ts.map"],"mappings":";;;;KAEKK,QAAAA,GAAWC;KACXC,gBAAAA,kBAAkCL,4BAA4BE,iBAAiBC;AAFY;AAC1E;;;AAC8DA,UAKnEG,gCAAAA,CALmEH;EAAQ,oBAAA,EAMlEL,6BANkE;EAK3EQ,QAAAA,CAAAA,EAAAA,MAAAA;EACSR,SAAAA,CAAAA,EAAAA,MAAAA;EAQXK,SAAAA,CAAAA,EAAAA,MAAAA;EAAWE,UAAAA,CAAAA,EAAAA,OAAAA;EAAgB;AAiC1C;;EAKeF,QAAAA,CAAAA,EAtCAA,QAsCAA,GAtCWE,gBAsCXF;;;;;;;;;;;AAL+F;;;;;;;;;;;;;;;;;;;;;;cAAzFI,0BAAAA,SAAmCR,UAAAA,YAAsBO;wBACpDR;;;;aAIXK,WAAWE;sBACFC;;;;;;;;;8BASQN,cAAcQ,QAAQP;;;;;;;;;2BASzBD,2BAA2BE,eAAeM"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"vector_store.d.ts","names":["VectorStoreRetrieverInterface","BaseMemory","InputValues","MemoryVariables","OutputValues","Metadata","Record","MetadataFunction","VectorStoreRetrieverMemoryParams","VectorStoreRetrieverMemory","Promise"],"sources":["../../src/memory/vector_store.d.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { BaseMemory, InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;\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 * 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 declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {\n    vectorStoreRetriever: VectorStoreRetrieverInterface;\n    inputKey?: string;\n    memoryKey: string;\n    returnDocs: boolean;\n    metadata?: Metadata | MetadataFunction;\n    constructor(fields: VectorStoreRetrieverMemoryParams);\n    get memoryKeys(): string[];\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    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\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    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\nexport {};\n//# sourceMappingURL=vector_store.d.ts.map"],"mappings":";;;;KAEKK,QAAAA,GAAWC;KACXC,gBAAAA,kBAAkCL,4BAA4BE,iBAAiBC;AAFY;AAC1E;;;AAC8DA,UAKnEG,gCAAAA,CALmEH;EAAQ,oBAAA,EAMlEL,6BANkE;EAK3EQ,QAAAA,CAAAA,EAAAA,MAAAA;EACSR,SAAAA,CAAAA,EAAAA,MAAAA;EAQXK,SAAAA,CAAAA,EAAAA,MAAAA;EAAWE,UAAAA,CAAAA,EAAAA,OAAAA;EAAgB;AAiC1C;;EAKeF,QAAAA,CAAAA,EAtCAA,QAsCAA,GAtCWE,gBAsCXF;;;;;;;;;;;AAL+F;;;;;;;;;;;;;;;;;;;;;;cAAzFI,0BAAAA,SAAmCR,UAAAA,YAAsBO;wBACpDR;;;;aAIXK,WAAWE;sBACFC;;;;;;;;;8BASQN,cAAcQ,QAAQP;;;;;;;;;2BASzBD,2BAA2BE,eAAeM"}

package/dist/output_parsers/combining.d.cts

@@ -6,7 +6,6 @@ import { Callbacks } from "@langchain/core/callbacks/manager";
 /**
  * Type for the combined output of the CombiningOutputParser class.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type CombinedOutput = Record<string, any>;
 /**
  * Interface for the fields required by the CombiningOutputParser class.

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

@@ -0,0 +1 @@
+{"version":3,"file":"combining.d.cts","names":["Callbacks","BaseOutputParser","CombinedOutput","Record","CombiningOutputParserFields","CombiningOutputParser","Promise"],"sources":["../../src/output_parsers/combining.d.ts"],"sourcesContent":["import { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\n/**\n * Type for the combined output of the CombiningOutputParser class.\n */\nexport type CombinedOutput = Record<string, any>;\n/**\n * Interface for the fields required by the CombiningOutputParser class.\n */\nexport interface CombiningOutputParserFields {\n    parsers: BaseOutputParser[];\n}\n/**\n * Class to combine multiple output parsers\n * @augments BaseOutputParser\n */\nexport declare class CombiningOutputParser extends BaseOutputParser<object> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    parsers: BaseOutputParser[];\n    outputDelimiter: string;\n    constructor(fields: CombiningOutputParserFields);\n    constructor(...parsers: BaseOutputParser[]);\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    parse(input: string, callbacks?: Callbacks): Promise<CombinedOutput>;\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}\n//# sourceMappingURL=combining.d.ts.map"],"mappings":";;;;;;;AAKA;AAIiBI,KAJLF,cAAAA,GAAiBC,MAIe,CAAA,MAAA,EAAA,GAC/BF,CAAAA;AAMb;;;AAO4BA,UAdXG,2BAAAA,CAcWH;EAQSD,OAAAA,EArBxBC,gBAqBwBD,EAAAA;;;;AAf8B;;cAA9CK,qBAAAA,SAA8BJ;;;;WAItCA;;sBAEWG;0BACIH;;;;;;;;mCAQSD,YAAYM,QAAQJ"}

package/dist/output_parsers/combining.d.ts

@@ -6,7 +6,6 @@ import { BaseOutputParser } from "@langchain/core/output_parsers";
 /**
  * Type for the combined output of the CombiningOutputParser class.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type CombinedOutput = Record<string, any>;
 /**
  * Interface for the fields required by the CombiningOutputParser class.

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

@@ -0,0 +1 @@
+{"version":3,"file":"combining.d.ts","names":["Callbacks","BaseOutputParser","CombinedOutput","Record","CombiningOutputParserFields","CombiningOutputParser","Promise"],"sources":["../../src/output_parsers/combining.d.ts"],"sourcesContent":["import { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\n/**\n * Type for the combined output of the CombiningOutputParser class.\n */\nexport type CombinedOutput = Record<string, any>;\n/**\n * Interface for the fields required by the CombiningOutputParser class.\n */\nexport interface CombiningOutputParserFields {\n    parsers: BaseOutputParser[];\n}\n/**\n * Class to combine multiple output parsers\n * @augments BaseOutputParser\n */\nexport declare class CombiningOutputParser extends BaseOutputParser<object> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    parsers: BaseOutputParser[];\n    outputDelimiter: string;\n    constructor(fields: CombiningOutputParserFields);\n    constructor(...parsers: BaseOutputParser[]);\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    parse(input: string, callbacks?: Callbacks): Promise<CombinedOutput>;\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}\n//# sourceMappingURL=combining.d.ts.map"],"mappings":";;;;;;;AAKA;AAIiBI,KAJLF,cAAAA,GAAiBC,MAIe,CAAA,MAAA,EAAA,GAC/BF,CAAAA;AAMb;;;AAO4BA,UAdXG,2BAAAA,CAcWH;EAQSD,OAAAA,EArBxBC,gBAqBwBD,EAAAA;;;;AAf8B;;cAA9CK,qBAAAA,SAA8BJ;;;;WAItCA;;sBAEWG;0BACIH;;;;;;;;mCAQSD,YAAYM,QAAQJ"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.cts","names":["BaseOutputParser","DatetimeOutputParser","Date","Promise"],"sources":["../../src/output_parsers/datetime.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport declare class DatetimeOutputParser extends BaseOutputParser<Date> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * ISO 8601 date time standard.\n     */\n    format: string;\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    parse(text: string): Promise<Date>;\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}\n//# sourceMappingURL=datetime.d.ts.map"],"mappings":";;;;;;AAKA;;AAciCE,cAdZD,oBAAAA,SAA6BD,gBAcjBE,CAdkCA,IAclCA,CAAAA,CAAAA;EAARC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAdyBH,YAAAA,EAAAA,MAAAA,EAAAA;EAAgB,eAAA,EAAA,OAAA;;;;;;;;;;;uBAczCG,QAAQD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","names":["BaseOutputParser","DatetimeOutputParser","Date","Promise"],"sources":["../../src/output_parsers/datetime.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\n/**\n * Class to parse the output of an LLM call to a date.\n * @augments BaseOutputParser\n */\nexport declare class DatetimeOutputParser extends BaseOutputParser<Date> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /**\n     * ISO 8601 date time standard.\n     */\n    format: string;\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    parse(text: string): Promise<Date>;\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}\n//# sourceMappingURL=datetime.d.ts.map"],"mappings":";;;;;;AAKA;;AAciCE,cAdZD,oBAAAA,SAA6BD,gBAcjBE,CAdkCA,IAclCA,CAAAA,CAAAA;EAARC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAdyBH,YAAAA,EAAAA,MAAAA,EAAAA;EAAgB,eAAA,EAAA,OAAA;;;;;;;;;;;uBAczCG,QAAQD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.cts","names":["BaseOutputParser","ParsedType","ASTParser","ParseFunction","importASTParser","ReturnType","Awaited","ExpressionParser","Promise","MasterHandler"],"sources":["../../src/output_parsers/expression.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nexport type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;\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 */\nexport declare class ExpressionParser extends BaseOutputParser<ParsedType> {\n    lc_namespace: string[];\n    parser: ParseFunction;\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    ensureParser(): Promise<void>;\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    parse(text: string): Promise<ParsedType>;\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}\nexport * from \"./expression_type_handlers/types.js\";\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n//# sourceMappingURL=expression.d.ts.map"],"mappings":";;;;;;KAGYG,aAAAA,GAAgBG,QAAQD,kBAAkBH,SAAAA,CAAUE;;;AAAhE;;;;AAAmC;AAkBnC;;;;;;;AAA8D;;;cAAzCG,gBAAAA,SAAyBP,iBAAiBC;;UAEnDE;;;;;;;;kBAQQK;;;;;;;;uBAQKA,QAAQP"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","names":["BaseOutputParser","ParsedType","ASTParser","ParseFunction","importASTParser","ReturnType","Awaited","ExpressionParser","Promise","MasterHandler"],"sources":["../../src/output_parsers/expression.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { ParsedType } from \"./expression_type_handlers/types.js\";\nimport { ASTParser } from \"./expression_type_handlers/base.js\";\nexport type ParseFunction = Awaited<ReturnType<typeof ASTParser.importASTParser>>;\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 */\nexport declare class ExpressionParser extends BaseOutputParser<ParsedType> {\n    lc_namespace: string[];\n    parser: ParseFunction;\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    ensureParser(): Promise<void>;\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    parse(text: string): Promise<ParsedType>;\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}\nexport * from \"./expression_type_handlers/types.js\";\nexport { MasterHandler } from \"./expression_type_handlers/factory.js\";\n//# sourceMappingURL=expression.d.ts.map"],"mappings":";;;;;;KAGYG,aAAAA,GAAgBG,QAAQD,kBAAkBH,SAAAA,CAAUE;;;AAAhE;;;;AAAmC;AAkBnC;;;;;;;AAA8D;;;cAAzCG,gBAAAA,SAAyBP,iBAAiBC;;UAEnDE;;;;;;;;kBAQQK;;;;;;;;uBAQKA,QAAQP"}

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

@@ -21,7 +21,6 @@ declare abstract class NodeHandler {
    * @param node The node to be handled.
    * @returns A Promise that resolves to the result of handling the node.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   abstract handle(node: ExpressionNode): Promise<any>;
 }
 /**

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\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     * 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    abstract handle(node: ExpressionNode): Promise<any>;\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 declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\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    /**\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(node: ExpressionNode): node is ExpressionStatement;\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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(node: ExpressionNode): node is PropertyAssignment;\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}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEgCa,uBAFFA,WAAAA,CAEEA;EAMLb,UAAAA,aAAAA,CAAAA,EAPGa,WAOHb,GAAAA,SAAAA;EAAyBA,WAAAA,CAAAA,aAAAA,CAAAA,EANpBa,WAMoBb,GAAAA,SAAAA;EAARc;;;AAOM;AAOlD;EAC6BF,SAAAA,OAAAA,CAAAA,IAAAA,EAfFZ,cAeEY,CAAAA,EAfeE,OAefF,CAfuBZ,cAevBY,GAAAA,OAAAA,CAAAA;EAKSA;;;;;;EAkBJZ,SAAAA,MAAAA,CAAAA,IAAAA,EA/BRA,cA+BQA,CAAAA,EA/BSc,OA+BTd,CAAAA,GAAAA,CAAAA;;;;;;;AAkByBM,cA1CtCS,SAAAA,CA0CsCT;EAM7BN,OAAAA,gBAAAA,EA/CDY,aA+CCZ;EAAyBO;;;;EAYKE,OAAAA,eAAAA,CAAAA,CAAAA,EAtD9BK,OAsD8BL,CAtDtBG,aAsDsBH,CAAAA;EAMtBT;;;;AAMuC;yBA5DlDA,yBAAyBC;;;;;;qCAMbD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}

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

@@ -21,7 +21,6 @@ declare abstract class NodeHandler {
    * @param node The node to be handled.
    * @returns A Promise that resolves to the result of handling the node.
    */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   abstract handle(node: ExpressionNode): Promise<any>;
 }
 /**

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

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["ExpressionNode","Program","ExpressionStatement","CallExpression","StringLiteral","NumericLiteral","BooleanLiteral","Identifier","ObjectExpression","ArrayExpression","PropertyAssignment","MemberExpression","ParseFunction","NodeHandler","Promise","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/base.d.ts"],"sourcesContent":["import type { ExpressionNode, Program, ExpressionStatement, CallExpression, StringLiteral, NumericLiteral, BooleanLiteral, Identifier, ObjectExpression, ArrayExpression, PropertyAssignment, MemberExpression, ParseFunction } from \"../../types/expression-parser.js\";\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport declare abstract class NodeHandler {\n    protected parentHandler?: NodeHandler | undefined;\n    constructor(parentHandler?: NodeHandler | undefined);\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     * 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    abstract handle(node: ExpressionNode): Promise<any>;\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 declare class ASTParser {\n    static astParseInstance: ParseFunction;\n    /**\n     * Imports and generates a parser using the Peggy library.\n     * @returns A Promise that resolves to the parser instance.\n     */\n    static importASTParser(): Promise<ParseFunction>;\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    /**\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(node: ExpressionNode): node is ExpressionStatement;\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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    /**\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(node: ExpressionNode): node is PropertyAssignment;\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}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEgCa,uBAFFA,WAAAA,CAEEA;EAMLb,UAAAA,aAAAA,CAAAA,EAPGa,WAOHb,GAAAA,SAAAA;EAAyBA,WAAAA,CAAAA,aAAAA,CAAAA,EANpBa,WAMoBb,GAAAA,SAAAA;EAARc;;;AAOM;AAOlD;EAC6BF,SAAAA,OAAAA,CAAAA,IAAAA,EAfFZ,cAeEY,CAAAA,EAfeE,OAefF,CAfuBZ,cAevBY,GAAAA,OAAAA,CAAAA;EAKSA;;;;;;EAkBJZ,SAAAA,MAAAA,CAAAA,IAAAA,EA/BRA,cA+BQA,CAAAA,EA/BSc,OA+BTd,CAAAA,GAAAA,CAAAA;;;;;;;AAkByBM,cA1CtCS,SAAAA,CA0CsCT;EAM7BN,OAAAA,gBAAAA,EA/CDY,aA+CCZ;EAAyBO;;;;EAYKE,OAAAA,eAAAA,CAAAA,CAAAA,EAtD9BK,OAsD8BL,CAtDtBG,aAsDsBH,CAAAA;EAMtBT;;;;AAMuC;yBA5DlDA,yBAAyBC;;;;;;qCAMbD,yBAAyBE;;;;;;gCAM9BF,yBAAyBG;;;;;;+BAM1BH,yBAAyBI;;;;;;gCAMxBJ,yBAAyBK;;;;;;gCAMzBL,yBAAyBM;;;;;;4BAM7BN,yBAAyBO;;;;;;kCAMnBP,yBAAyBQ;;;;;;iCAM1BR,yBAAyBS;;;;;;oCAMtBT,yBAAyBU;;;;;;kCAM3BV,yBAAyBW"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.cts","names":["NodeHandler","ParsedType","ExpressionNode","CallExpression","MasterHandler","Promise"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.d.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ParsedType } from \"./types.js\";\nimport type { ExpressionNode, CallExpression } from \"../../types/expression-parser.js\";\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport declare class MasterHandler extends NodeHandler {\n    nodeHandlers: NodeHandler[];\n    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * This method is responsible for handling a node. It iterates over the\n     * collection of node handlers and uses the first handler that accepts the\n     * node to handle it. If no handler accepts the node, the method throws an\n     * error.\n     * @param node The node to be handled.\n     * @returns The result of the node handling, or throws an error if no handler can handle the node.\n     */\n    handle(node: CallExpression): Promise<ParsedType>;\n    /**\n     * This static method creates an instance of the MasterHandler class and\n     * initializes it with instances of all the node handlers.\n     * @returns An instance of the MasterHandler class.\n     */\n    static createMasterHandler(): MasterHandler;\n}\n//# sourceMappingURL=factory.d.ts.map"],"mappings":";;;;;;;;AAUA;;;;;AAWiBG,cAXIC,aAAAA,SAAsBJ,WAAAA,CAW1BG;EAAyBF,YAAAA,EAVxBD,WAUwBC,EAAAA;EAARI,OAAAA,CAAAA,IAAAA,EAThBH,cASgBG,CAAAA,EATCA,OASDA,CATSH,cASTG,GAAAA,OAAAA,CAAAA;EAMAD;;AAjBoB;;;;;;eAWrCD,iBAAiBE,QAAQJ;;;;;;gCAMRG"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","names":["NodeHandler","ParsedType","ExpressionNode","CallExpression","MasterHandler","Promise"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.d.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ParsedType } from \"./types.js\";\nimport type { ExpressionNode, CallExpression } from \"../../types/expression-parser.js\";\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport declare class MasterHandler extends NodeHandler {\n    nodeHandlers: NodeHandler[];\n    accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n    /**\n     * This method is responsible for handling a node. It iterates over the\n     * collection of node handlers and uses the first handler that accepts the\n     * node to handle it. If no handler accepts the node, the method throws an\n     * error.\n     * @param node The node to be handled.\n     * @returns The result of the node handling, or throws an error if no handler can handle the node.\n     */\n    handle(node: CallExpression): Promise<ParsedType>;\n    /**\n     * This static method creates an instance of the MasterHandler class and\n     * initializes it with instances of all the node handlers.\n     * @returns An instance of the MasterHandler class.\n     */\n    static createMasterHandler(): MasterHandler;\n}\n//# sourceMappingURL=factory.d.ts.map"],"mappings":";;;;;;;;AAUA;;;;;AAWiBG,cAXIC,aAAAA,SAAsBJ,WAAAA,CAW1BG;EAAyBF,YAAAA,EAVxBD,WAUwBC,EAAAA;EAARI,OAAAA,CAAAA,IAAAA,EAThBH,cASgBG,CAAAA,EATCA,OASDA,CATSH,cASTG,GAAAA,OAAAA,CAAAA;EAMAD;;AAjBoB;;;;;;eAWrCD,iBAAiBE,QAAQJ;;;;;;gCAMRG"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":["ArgumentsType","IdentifierType","StringLiteralType","NumericLiteralType","ArrayLiteralType","ObjectLiteralType","CallExpressionType","BooleanLiteralType","ParsedType","PropertyAssignmentType","MemberExpressionType"],"sources":["../../../src/output_parsers/expression_type_handlers/types.d.ts"],"sourcesContent":["/**\n * Represents the different types of arguments that can be used in\n * LangChain.\n */\nexport type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;\n/**\n * Represents the parsed types in LangChain, which can be either an\n * ArgumentsType or a PropertyAssignmentType.\n */\nexport type ParsedType = ArgumentsType | PropertyAssignmentType;\n/**\n * Represents an array literal in LangChain. It has a type property set to\n * 'array_literal' and a values property which is an array of\n * ArgumentsType.\n */\nexport type ArrayLiteralType = {\n    type: \"array_literal\";\n    values: ArgumentsType[];\n};\n/**\n * Represents a boolean literal in LangChain. It has a type property set\n * to 'boolean_literal' and a value property which is a boolean.\n */\nexport type BooleanLiteralType = {\n    type: \"boolean_literal\";\n    value: boolean;\n};\n/**\n * Represents a call expression in LangChain. It has a type property set\n * to 'call_expression', a funcCall property which can be a string or a\n * MemberExpressionType, and an optional args property which is an array\n * of ArgumentsType.\n */\nexport type CallExpressionType = {\n    type: \"call_expression\";\n    funcCall: string | MemberExpressionType;\n    args?: ArgumentsType[];\n};\n/**\n * Represents a numeric literal in LangChain. It has a type property set\n * to 'numeric_literal' and a value property which is a number.\n */\nexport type NumericLiteralType = {\n    type: \"numeric_literal\";\n    value: number;\n};\n/**\n * Represents an object literal in LangChain. It has a type property set\n * to 'object_literal' and a values property which is an array of\n * PropertyAssignmentType.\n */\nexport type ObjectLiteralType = {\n    type: \"object_literal\";\n    values: PropertyAssignmentType[];\n};\n/**\n * Represents a member expression in LangChain. It has a type property set\n * to 'member_expression', an identifier property which is a string, and a\n * property property which is also a string.\n */\nexport type MemberExpressionType = {\n    type: \"member_expression\";\n    identifier: string;\n    property: string;\n};\n/**\n * Represents a property assignment in LangChain. It has a type property\n * set to 'property_assignment', an identifier property which is a string,\n * and a value property which is an ArgumentsType.\n */\nexport type PropertyAssignmentType = {\n    type: \"property_assignment\";\n    identifier: string;\n    value: ArgumentsType;\n};\n/**\n * Represents a string literal in LangChain. It has a type property set to\n * 'string_literal' and a value property which is a string.\n */\nexport type StringLiteralType = {\n    type: \"string_literal\";\n    value: string;\n};\n/**\n * Represents an identifier in LangChain. It has a type property set to\n * 'identifier' and a value property which is a string.\n */\nexport type IdentifierType = {\n    type: \"identifier\";\n    value: string;\n};\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;AAIA;;;AAAiEG,KAArDH,aAAAA,GAAgBC,cAAqCE,GAApBD,iBAAoBC,GAAAA,kBAAAA,GAAqBC,gBAArBD,GAAwCE,iBAAxCF,GAA4DG,kBAA5DH,GAAiFI,kBAAjFJ;;;;;AAAmG,KAKxJK,UAAAA,GAAaR,aAL2I,GAK3HS,sBAL2H;AAKpK;AAMA;AAQA;AAUA;AASA;AASYJ,KApCAD,gBAAAA,GAoCiB;EASjBM,IAAAA,EAAAA,eAAAA;EAUAD,MAAAA,EArDAT,aAqDAS,EAAAA;AASZ,CAAA;AAQA;;;;KAhEYF,kBAAAA;;;;;;;;;;KAUAD,kBAAAA;;qBAEWI;SACZV;;;;;;KAMCG,kBAAAA;;;;;;;;;KASAE,iBAAAA;;UAEAI;;;;;;;KAOAC,oBAAAA;;;;;;;;;;KAUAD,sBAAAA;;;SAGDT;;;;;;KAMCE,iBAAAA;;;;;;;;KAQAD,cAAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":["ArgumentsType","IdentifierType","StringLiteralType","NumericLiteralType","ArrayLiteralType","ObjectLiteralType","CallExpressionType","BooleanLiteralType","ParsedType","PropertyAssignmentType","MemberExpressionType"],"sources":["../../../src/output_parsers/expression_type_handlers/types.d.ts"],"sourcesContent":["/**\n * Represents the different types of arguments that can be used in\n * LangChain.\n */\nexport type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;\n/**\n * Represents the parsed types in LangChain, which can be either an\n * ArgumentsType or a PropertyAssignmentType.\n */\nexport type ParsedType = ArgumentsType | PropertyAssignmentType;\n/**\n * Represents an array literal in LangChain. It has a type property set to\n * 'array_literal' and a values property which is an array of\n * ArgumentsType.\n */\nexport type ArrayLiteralType = {\n    type: \"array_literal\";\n    values: ArgumentsType[];\n};\n/**\n * Represents a boolean literal in LangChain. It has a type property set\n * to 'boolean_literal' and a value property which is a boolean.\n */\nexport type BooleanLiteralType = {\n    type: \"boolean_literal\";\n    value: boolean;\n};\n/**\n * Represents a call expression in LangChain. It has a type property set\n * to 'call_expression', a funcCall property which can be a string or a\n * MemberExpressionType, and an optional args property which is an array\n * of ArgumentsType.\n */\nexport type CallExpressionType = {\n    type: \"call_expression\";\n    funcCall: string | MemberExpressionType;\n    args?: ArgumentsType[];\n};\n/**\n * Represents a numeric literal in LangChain. It has a type property set\n * to 'numeric_literal' and a value property which is a number.\n */\nexport type NumericLiteralType = {\n    type: \"numeric_literal\";\n    value: number;\n};\n/**\n * Represents an object literal in LangChain. It has a type property set\n * to 'object_literal' and a values property which is an array of\n * PropertyAssignmentType.\n */\nexport type ObjectLiteralType = {\n    type: \"object_literal\";\n    values: PropertyAssignmentType[];\n};\n/**\n * Represents a member expression in LangChain. It has a type property set\n * to 'member_expression', an identifier property which is a string, and a\n * property property which is also a string.\n */\nexport type MemberExpressionType = {\n    type: \"member_expression\";\n    identifier: string;\n    property: string;\n};\n/**\n * Represents a property assignment in LangChain. It has a type property\n * set to 'property_assignment', an identifier property which is a string,\n * and a value property which is an ArgumentsType.\n */\nexport type PropertyAssignmentType = {\n    type: \"property_assignment\";\n    identifier: string;\n    value: ArgumentsType;\n};\n/**\n * Represents a string literal in LangChain. It has a type property set to\n * 'string_literal' and a value property which is a string.\n */\nexport type StringLiteralType = {\n    type: \"string_literal\";\n    value: string;\n};\n/**\n * Represents an identifier in LangChain. It has a type property set to\n * 'identifier' and a value property which is a string.\n */\nexport type IdentifierType = {\n    type: \"identifier\";\n    value: string;\n};\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;AAIA;;;AAAiEG,KAArDH,aAAAA,GAAgBC,cAAqCE,GAApBD,iBAAoBC,GAAAA,kBAAAA,GAAqBC,gBAArBD,GAAwCE,iBAAxCF,GAA4DG,kBAA5DH,GAAiFI,kBAAjFJ;;;;;AAAmG,KAKxJK,UAAAA,GAAaR,aAL2I,GAK3HS,sBAL2H;AAKpK;AAMA;AAQA;AAUA;AASA;AASYJ,KApCAD,gBAAAA,GAoCiB;EASjBM,IAAAA,EAAAA,eAAAA;EAUAD,MAAAA,EArDAT,aAqDAS,EAAAA;AASZ,CAAA;AAQA;;;;KAhEYF,kBAAAA;;;;;;;;;;KAUAD,kBAAAA;;qBAEWI;SACZV;;;;;;KAMCG,kBAAAA;;;;;;;;;KASAE,iBAAAA;;UAEAI;;;;;;;KAOAC,oBAAAA;;;;;;;;;;KAUAD,sBAAAA;;;SAGDT;;;;;;KAMCE,iBAAAA;;;;;;;;KAQAD,cAAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.cts","names":["BaseLanguageModelInterface","Callbacks","BaseOutputParser","OutputParserException","BasePromptTemplate","Runnable","LLMChain","OutputFixingParserRetryInput","OutputFixingParser","T","parser","retryChain","Promise"],"sources":["../../src/output_parsers/fix.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser, OutputParserException } from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\ninterface OutputFixingParserRetryInput {\n    instructions: string;\n    completion: string;\n    error: OutputParserException;\n}\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport declare class OutputFixingParser<T> extends BaseOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n    /**\n     * Static method to create a new instance of OutputFixingParser using a\n     * given language model, parser, and optional fields.\n     * @param llm The language model to be used.\n     * @param parser The parser to be used.\n     * @param fields Optional fields which may contain a prompt.\n     * @returns A new instance of OutputFixingParser.\n     */\n    static fromLLM<T>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {\n        prompt?: BasePromptTemplate;\n    }): OutputFixingParser<T>;\n    constructor({ parser, retryChain }: {\n        parser: BaseOutputParser<T>;\n        retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n    });\n    /**\n     * Method to parse the completion using the parser. If the initial parsing\n     * fails, it uses the retryChain to attempt to fix the output and retry\n     * the parsing process.\n     * @param completion The completion to be parsed.\n     * @param callbacks Optional callbacks to be used during parsing.\n     * @returns The parsed output.\n     */\n    parse(completion: string, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Method to get the format instructions for the parser.\n     * @returns The format instructions for the parser.\n     */\n    getFormatInstructions(): string;\n}\nexport {};\n//# sourceMappingURL=fix.d.ts.map"],"mappings":";;;;;;;;UAMUO,4BAAAA;;EAAAA,UAAAA,EAAAA,MAAAA;EAUWC,KAAAA,EAPVL,qBAO4BM;;;;;;;AAKZJ,cALNG,kBAKMH,CAAAA,CAAAA,CAAAA,SALwBH,gBAKxBG,CALyCI,CAKzCJ,CAAAA,CAAAA;EASAL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAqDS,YAAAA,EAAAA,MAAAA,EAAAA;EAAjBP,eAAAA,EAAAA,OAAAA;EAC9CE,MAAAA,EAXLF,gBAWKE,CAXYK,CAWZL,CAAAA;EACUK,UAAAA,EAXXH,QAWWG,GAXAJ,QAWAI,CAXSF,4BAWTE,EAXuCA,CAWvCA,CAAAA;EAAnBD;;;;;;;;EAGuBH,OAAAA,OAAAA,CAAAA,CAAAA,CAAAA,CAAAA,GAAAA,EALJL,0BAKIK,EAAAA,MAAAA,EALgCH,gBAKhCG,CALiDI,CAKjDJ,CAAAA,EAAAA,MAU+BI,CAV/BJ,EAAAA;IAUWJ,MAAAA,CAAAA,EAdzBG,kBAcyBH;EAAoBQ,CAAAA,CAAAA,EAbtDD,kBAasDC,CAbnCA,CAamCA,CAAAA;EAARG,WAAAA,CAAAA;IAAAA,MAAAA;IAAAA;GAAAA,EAAAA;IA7BHV,MAAAA,EAkBnCA,gBAlBmCA,CAkBlBO,CAlBkBP,CAAAA;IAAgB,UAAA,EAmB/CI,QAnB+C,GAmBpCD,QAnBoC,CAmB3BE,4BAnB2B,EAmBGE,CAnBH,CAAA;;;;;;;;;;wCA6BzBR,YAAYW,QAAQH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix.d.ts","names":["BaseLanguageModelInterface","Callbacks","BaseOutputParser","OutputParserException","BasePromptTemplate","Runnable","LLMChain","OutputFixingParserRetryInput","OutputFixingParser","T","parser","retryChain","Promise"],"sources":["../../src/output_parsers/fix.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser, OutputParserException } from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\ninterface OutputFixingParserRetryInput {\n    instructions: string;\n    completion: string;\n    error: OutputParserException;\n}\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport declare class OutputFixingParser<T> extends BaseOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n    /**\n     * Static method to create a new instance of OutputFixingParser using a\n     * given language model, parser, and optional fields.\n     * @param llm The language model to be used.\n     * @param parser The parser to be used.\n     * @param fields Optional fields which may contain a prompt.\n     * @returns A new instance of OutputFixingParser.\n     */\n    static fromLLM<T>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {\n        prompt?: BasePromptTemplate;\n    }): OutputFixingParser<T>;\n    constructor({ parser, retryChain }: {\n        parser: BaseOutputParser<T>;\n        retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n    });\n    /**\n     * Method to parse the completion using the parser. If the initial parsing\n     * fails, it uses the retryChain to attempt to fix the output and retry\n     * the parsing process.\n     * @param completion The completion to be parsed.\n     * @param callbacks Optional callbacks to be used during parsing.\n     * @returns The parsed output.\n     */\n    parse(completion: string, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Method to get the format instructions for the parser.\n     * @returns The format instructions for the parser.\n     */\n    getFormatInstructions(): string;\n}\nexport {};\n//# sourceMappingURL=fix.d.ts.map"],"mappings":";;;;;;;;UAMUO,4BAAAA;;EAAAA,UAAAA,EAAAA,MAAAA;EAUWC,KAAAA,EAPVL,qBAO4BM;;;;;;;AAKZJ,cALNG,kBAKMH,CAAAA,CAAAA,CAAAA,SALwBH,gBAKxBG,CALyCI,CAKzCJ,CAAAA,CAAAA;EASAL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAqDS,YAAAA,EAAAA,MAAAA,EAAAA;EAAjBP,eAAAA,EAAAA,OAAAA;EAC9CE,MAAAA,EAXLF,gBAWKE,CAXYK,CAWZL,CAAAA;EACUK,UAAAA,EAXXH,QAWWG,GAXAJ,QAWAI,CAXSF,4BAWTE,EAXuCA,CAWvCA,CAAAA;EAAnBD;;;;;;;;EAGuBH,OAAAA,OAAAA,CAAAA,CAAAA,CAAAA,CAAAA,GAAAA,EALJL,0BAKIK,EAAAA,MAAAA,EALgCH,gBAKhCG,CALiDI,CAKjDJ,CAAAA,EAAAA,MAU+BI,CAV/BJ,EAAAA;IAUWJ,MAAAA,CAAAA,EAdzBG,kBAcyBH;EAAoBQ,CAAAA,CAAAA,EAbtDD,kBAasDC,CAbnCA,CAamCA,CAAAA;EAARG,WAAAA,CAAAA;IAAAA,MAAAA;IAAAA;GAAAA,EAAAA;IA7BHV,MAAAA,EAkBnCA,gBAlBmCA,CAkBlBO,CAlBkBP,CAAAA;IAAgB,UAAA,EAmB/CI,QAnB+C,GAmBpCD,QAnBoC,CAmB3BE,4BAnB2B,EAmBGE,CAnBH,CAAA;;;;;;;;;;wCA6BzBR,YAAYW,QAAQH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"http_response.d.cts","names":["BaseMessage","BaseTransformOutputParser","HttpResponseOutputParserInput","HttpResponseOutputParser","Uint8Array","AsyncGenerator","Promise"],"sources":["../../src/output_parsers/http_response.d.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseTransformOutputParser } from \"@langchain/core/output_parsers\";\nexport type HttpResponseOutputParserInput = {\n    outputParser?: BaseTransformOutputParser;\n    contentType?: \"text/plain\" | \"text/event-stream\";\n};\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport declare class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: BaseTransformOutputParser;\n    contentType: \"text/plain\" | \"text/event-stream\";\n    constructor(fields?: HttpResponseOutputParserInput);\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<Uint8Array>;\n    /**\n     * Parses a string output from an LLM call. This method is meant to be\n     * implemented by subclasses to define how a string output from an LLM\n     * should be parsed.\n     * @param text The string output from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=http_response.d.ts.map"],"mappings":";;;;KAEYE,6BAAAA;iBACOD;EADPC,WAAAA,CAAAA,EAAAA,YAAAA,GAAAA,mBACOD;AAMnB,CAAA;;;;AAOuDD,cAPlCG,wBAAAA,SAAiCF,yBAOCD,CAPyBI,UAOzBJ,CAAAA,CAAAA;EAAxBK,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsDD,YAAAA,EAAAA,MAAAA,EAAAA;EAAfC,eAAAA,EAAAA,OAAAA;EASrCD,YAAAA,EAZfH,yBAYeG;EAARE,WAAAA,EAAAA,YAAAA,GAAAA,mBAAAA;EAhB6BL,WAAAA,CAAAA,MAAAA,CAAAA,EAM7BC,6BAN6BD;EAAyB,UAAA,CAAA,cAAA,EAOhDI,cAPgD,CAAA,MAAA,GAOxBL,WAPwB,CAAA,CAAA,EAOTK,cAPS,CAOMD,UAPN,CAAA;;;;;;;;;uBAgBtDE,QAAQF"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"http_response.d.ts","names":["BaseMessage","BaseTransformOutputParser","HttpResponseOutputParserInput","HttpResponseOutputParser","Uint8Array","AsyncGenerator","Promise"],"sources":["../../src/output_parsers/http_response.d.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseTransformOutputParser } from \"@langchain/core/output_parsers\";\nexport type HttpResponseOutputParserInput = {\n    outputParser?: BaseTransformOutputParser;\n    contentType?: \"text/plain\" | \"text/event-stream\";\n};\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport declare class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: BaseTransformOutputParser;\n    contentType: \"text/plain\" | \"text/event-stream\";\n    constructor(fields?: HttpResponseOutputParserInput);\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<Uint8Array>;\n    /**\n     * Parses a string output from an LLM call. This method is meant to be\n     * implemented by subclasses to define how a string output from an LLM\n     * should be parsed.\n     * @param text The string output from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=http_response.d.ts.map"],"mappings":";;;;KAEYE,6BAAAA;iBACOD;EADPC,WAAAA,CAAAA,EAAAA,YAAAA,GAAAA,mBACOD;AAMnB,CAAA;;;;AAOuDD,cAPlCG,wBAAAA,SAAiCF,yBAOCD,CAPyBI,UAOzBJ,CAAAA,CAAAA;EAAxBK,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsDD,YAAAA,EAAAA,MAAAA,EAAAA;EAAfC,eAAAA,EAAAA,OAAAA;EASrCD,YAAAA,EAZfH,yBAYeG;EAARE,WAAAA,EAAAA,YAAAA,GAAAA,mBAAAA;EAhB6BL,WAAAA,CAAAA,MAAAA,CAAAA,EAM7BC,6BAN6BD;EAAyB,UAAA,CAAA,cAAA,EAOhDI,cAPgD,CAAA,MAAA,GAOxBL,WAPwB,CAAA,CAAA,EAOTK,cAPS,CAOMD,UAPN,CAAA;;;;;;;;;uBAgBtDE,QAAQF"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai_functions.d.cts","names":["JsonSchema7ObjectType","Operation","JSONPatchOperation","ChatGeneration","Generation","BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","BaseLLMOutputParser","Optional","FunctionParameters","OutputFunctionsParser","Promise","JsonOutputFunctionsParser","Output","JsonKeyOutputFunctionsParser","T"],"sources":["../../src/output_parsers/openai_functions.d.ts"],"sourcesContent":["import { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport { type Operation as JSONPatchOperation } from \"@langchain/core/utils/json_patch\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BaseCumulativeTransformOutputParser, type BaseCumulativeTransformOutputParserInput, BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { Optional } from \"../types/type-utils.js\";\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<JsonSchema7ObjectType, \"additionalProperties\">;\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    });\n    /**\n     * Parses the output and returns a string representation of the function\n     * call or its arguments.\n     * @param generations The output of the LLM to parse.\n     * @returns A string representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<string>;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport declare class JsonOutputFunctionsParser<Output extends object = object> extends BaseCumulativeTransformOutputParser<Output> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: OutputFunctionsParser;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    } & BaseCumulativeTransformOutputParserInput);\n    protected _diff(prev: unknown | undefined, next: unknown): JSONPatchOperation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[]): Promise<Output | undefined>;\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<Output>;\n    parse(text: string): Promise<Output>;\n    getFormatInstructions(): string;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport declare class JsonKeyOutputFunctionsParser<T = object> extends BaseLLMOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: JsonOutputFunctionsParser<object>;\n    attrName: string;\n    get lc_aliases(): {\n        attrName: string;\n    };\n    constructor(fields: {\n        attrName: string;\n    });\n    /**\n     * Parses the output and returns a specific attribute of the parsed JSON\n     * object.\n     * @param generations The output of the LLM to parse.\n     * @returns The value of a specific attribute of the parsed JSON object.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<T>;\n}\n//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAKqBU,KALTD,kBAAAA,GAAqBD,QAKS,CALAR,qBAKA,EAAA,sBAAA,CAAA;;;;;AAA4B,cAAjDU,qBAAAA,SAA8BH,mBAAmB,CAAA,MAAA,CAAA,CAAA;EAoBjDK,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsGC,YAAAA,EAAAA,MAAAA,EAAAA;EAIzGH,eAAAA,EAAAA,OAAAA;EAIVJ,QAAAA,EAAAA,OAAAA;EACuDJ,WAAAA,CAAAA,MACAW,CADAX,EAAAA;IAC3BC,QAAAA,CAAAA,EAAAA,OAAAA;EAA2BU,CAAAA;EAARF;;;;;;EAQ9BA,WAAAA,CAAAA,WAAAA,EAxBIP,UAwBJO,EAAAA,GAxBmBR,cAwBnBQ,EAAAA,CAAAA,EAxBsCA,OAwBtCA,CAAAA,MAAAA,CAAAA;;AAlBiG;AA0B1H;;;AAkB6BP,cA5CRQ,yBA4CQR,CAAAA,eAAAA,MAAAA,GAAAA,MAAAA,CAAAA,SA5C0DC,mCA4C1DD,CA5C8FS,MA4C9FT,CAAAA,CAAAA;EAAeD,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA2BY,YAAAA,EAAAA,MAAAA,EAAAA;EAARJ,eAAAA,EAAAA,OAAAA;EAlBOJ,YAAAA,EAtBpDG,qBAsBoDH;EAAmB,QAAA,EAAA,OAAA;;;MAlBjFD;6DACuDJ;kCAC3BC,mBAAmBQ,QAAQE;;;;;;;2BAOlCT,eAAeD,mBAAmBQ,QAAQE;uBAC9CF,QAAQE;;;;;;;;cAQZC,iDAAiDP,oBAAoBQ;;;;gBAIxEH;;;;;;;;;;;;;;2BAcWR,eAAeD,mBAAmBQ,QAAQI"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai_functions.d.ts","names":["JsonSchema7ObjectType","Operation","JSONPatchOperation","ChatGeneration","Generation","BaseCumulativeTransformOutputParser","BaseCumulativeTransformOutputParserInput","BaseLLMOutputParser","Optional","FunctionParameters","OutputFunctionsParser","Promise","JsonOutputFunctionsParser","Output","JsonKeyOutputFunctionsParser","T"],"sources":["../../src/output_parsers/openai_functions.d.ts"],"sourcesContent":["import { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport { type Operation as JSONPatchOperation } from \"@langchain/core/utils/json_patch\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BaseCumulativeTransformOutputParser, type BaseCumulativeTransformOutputParserInput, BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { Optional } from \"../types/type-utils.js\";\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<JsonSchema7ObjectType, \"additionalProperties\">;\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport declare class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    });\n    /**\n     * Parses the output and returns a string representation of the function\n     * call or its arguments.\n     * @param generations The output of the LLM to parse.\n     * @returns A string representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<string>;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport declare class JsonOutputFunctionsParser<Output extends object = object> extends BaseCumulativeTransformOutputParser<Output> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: OutputFunctionsParser;\n    argsOnly: boolean;\n    constructor(config?: {\n        argsOnly?: boolean;\n    } & BaseCumulativeTransformOutputParserInput);\n    protected _diff(prev: unknown | undefined, next: unknown): JSONPatchOperation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[]): Promise<Output | undefined>;\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<Output>;\n    parse(text: string): Promise<Output>;\n    getFormatInstructions(): string;\n}\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport declare class JsonKeyOutputFunctionsParser<T = object> extends BaseLLMOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: JsonOutputFunctionsParser<object>;\n    attrName: string;\n    get lc_aliases(): {\n        attrName: string;\n    };\n    constructor(fields: {\n        attrName: string;\n    });\n    /**\n     * Parses the output and returns a specific attribute of the parsed JSON\n     * object.\n     * @param generations The output of the LLM to parse.\n     * @returns The value of a specific attribute of the parsed JSON object.\n     */\n    parseResult(generations: Generation[] | ChatGeneration[]): Promise<T>;\n}\n//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAKqBU,KALTD,kBAAAA,GAAqBD,QAKS,CALAR,qBAKA,EAAA,sBAAA,CAAA;;;;;AAA4B,cAAjDU,qBAAAA,SAA8BH,mBAAmB,CAAA,MAAA,CAAA,CAAA;EAoBjDK,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsGC,YAAAA,EAAAA,MAAAA,EAAAA;EAIzGH,eAAAA,EAAAA,OAAAA;EAIVJ,QAAAA,EAAAA,OAAAA;EACuDJ,WAAAA,CAAAA,MACAW,CADAX,EAAAA;IAC3BC,QAAAA,CAAAA,EAAAA,OAAAA;EAA2BU,CAAAA;EAARF;;;;;;EAQ9BA,WAAAA,CAAAA,WAAAA,EAxBIP,UAwBJO,EAAAA,GAxBmBR,cAwBnBQ,EAAAA,CAAAA,EAxBsCA,OAwBtCA,CAAAA,MAAAA,CAAAA;;AAlBiG;AA0B1H;;;AAkB6BP,cA5CRQ,yBA4CQR,CAAAA,eAAAA,MAAAA,GAAAA,MAAAA,CAAAA,SA5C0DC,mCA4C1DD,CA5C8FS,MA4C9FT,CAAAA,CAAAA;EAAeD,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA2BY,YAAAA,EAAAA,MAAAA,EAAAA;EAARJ,eAAAA,EAAAA,OAAAA;EAlBOJ,YAAAA,EAtBpDG,qBAsBoDH;EAAmB,QAAA,EAAA,OAAA;;;MAlBjFD;6DACuDJ;kCAC3BC,mBAAmBQ,QAAQE;;;;;;;2BAOlCT,eAAeD,mBAAmBQ,QAAQE;uBAC9CF,QAAQE;;;;;;;;cAQZC,iDAAiDP,oBAAoBQ;;;;gBAIxEH;;;;;;;;;;;;;;2BAcWR,eAAeD,mBAAmBQ,QAAQI"}

package/dist/output_parsers/openai_tools.d.cts

@@ -9,12 +9,11 @@ import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 type ParsedToolCall = {
   id?: string;
   type: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   args: Record<string, any>;
   /** @deprecated Use `type` instead. Will be removed in 0.2.0. */
   name: string;
   /** @deprecated Use `args` instead. Will be removed in 0.2.0. */
-  arguments: Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
+  arguments: Record<string, any>;
 };
 /**
  * @deprecated Import from "@langchain/core/output_parsers/openai_tools"
@@ -49,7 +48,6 @@ type JsonOutputKeyToolsParserParams = {
 /**
  * @deprecated Import from "@langchain/core/output_parsers/openai_tools"
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
   static lc_name(): string;
   lc_namespace: string[];
@@ -61,7 +59,6 @@ declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
   returnSingle: boolean;
   initialParser: JsonOutputToolsParser;
   constructor(params: JsonOutputKeyToolsParserParams);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parseResult(generations: ChatGeneration[]): Promise<any>;
 }
 //#endregion

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai_tools.d.cts","names":["BaseLLMOutputParser","ChatGeneration","ParsedToolCall","Record","JsonOutputToolsParserParams","JsonOutputToolsParser","Promise","JsonOutputKeyToolsParserParams","JsonOutputKeyToolsParser"],"sources":["../../src/output_parsers/openai_tools.d.ts"],"sourcesContent":["import { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport type { ChatGeneration } from \"@langchain/core/outputs\";\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type ParsedToolCall = {\n    id?: string;\n    type: string;\n    args: Record<string, any>;\n    /** @deprecated Use `type` instead. Will be removed in 0.2.0. */\n    name: string;\n    /** @deprecated Use `args` instead. Will be removed in 0.2.0. */\n    arguments: Record<string, any>;\n};\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type JsonOutputToolsParserParams = {\n    /** Whether to return the tool call id. */\n    returnId?: boolean;\n};\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport declare class JsonOutputToolsParser extends BaseLLMOutputParser<ParsedToolCall[]> {\n    static lc_name(): string;\n    returnId: boolean;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    constructor(fields?: JsonOutputToolsParserParams);\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]>;\n}\nexport type JsonOutputKeyToolsParserParams = {\n    keyName: string;\n    returnSingle?: boolean;\n    /** Whether to return the tool call id. */\n    returnId?: boolean;\n};\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    returnId: boolean;\n    /** The type of tool calls to return. */\n    keyName: string;\n    /** Whether to return only the first tool call. */\n    returnSingle: boolean;\n    initialParser: JsonOutputToolsParser;\n    constructor(params: JsonOutputKeyToolsParserParams);\n    parseResult(generations: ChatGeneration[]): Promise<any>;\n}\n//# sourceMappingURL=openai_tools.d.ts.map"],"mappings":";;;;;;;AAKA;AAYYI,KAZAF,cAAAA,GAYAE;EAOSC,EAAAA,CAAAA,EAAAA,MAAAA;EAAkDH,IAAAA,EAAAA,MAAAA;EAK9CE,IAAAA,EArBfD,MAqBeC,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAOIH;EAA2BC,IAAAA,EAAAA,MAAAA;EAARI;EAZGN,SAAAA,EAZpCG,MAYoCH,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAAmB,CAAA;AActE;AASA;;AAUwBO,KAxCZH,2BAAAA,GAwCYG;EACKN;EAAmBK,QAAAA,CAAAA,EAAAA,OAAAA;CAXMN;AAAmB;;;cAvBpDK,qBAAAA,SAA8BL,oBAAoBE;;;;;uBAK9CE;;;;;;;2BAOIH,mBAAmBK,QAAQJ;;KAE5CK,8BAAAA;;;;;;;;;cASSC,wBAAAA,SAAiCR;;;;;;;;;iBASnCK;sBACKE;2BACKN,mBAAmBK"}

package/dist/output_parsers/openai_tools.d.ts

@@ -9,12 +9,11 @@ import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 type ParsedToolCall = {
   id?: string;
   type: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   args: Record<string, any>;
   /** @deprecated Use `type` instead. Will be removed in 0.2.0. */
   name: string;
   /** @deprecated Use `args` instead. Will be removed in 0.2.0. */
-  arguments: Record<string, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
+  arguments: Record<string, any>;
 };
 /**
  * @deprecated Import from "@langchain/core/output_parsers/openai_tools"
@@ -49,7 +48,6 @@ type JsonOutputKeyToolsParserParams = {
 /**
  * @deprecated Import from "@langchain/core/output_parsers/openai_tools"
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
   static lc_name(): string;
   lc_namespace: string[];
@@ -61,7 +59,6 @@ declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {
   returnSingle: boolean;
   initialParser: JsonOutputToolsParser;
   constructor(params: JsonOutputKeyToolsParserParams);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   parseResult(generations: ChatGeneration[]): Promise<any>;
 }
 //#endregion

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

@@ -0,0 +1 @@
+{"version":3,"file":"openai_tools.d.ts","names":["BaseLLMOutputParser","ChatGeneration","ParsedToolCall","Record","JsonOutputToolsParserParams","JsonOutputToolsParser","Promise","JsonOutputKeyToolsParserParams","JsonOutputKeyToolsParser"],"sources":["../../src/output_parsers/openai_tools.d.ts"],"sourcesContent":["import { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport type { ChatGeneration } from \"@langchain/core/outputs\";\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type ParsedToolCall = {\n    id?: string;\n    type: string;\n    args: Record<string, any>;\n    /** @deprecated Use `type` instead. Will be removed in 0.2.0. */\n    name: string;\n    /** @deprecated Use `args` instead. Will be removed in 0.2.0. */\n    arguments: Record<string, any>;\n};\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type JsonOutputToolsParserParams = {\n    /** Whether to return the tool call id. */\n    returnId?: boolean;\n};\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport declare class JsonOutputToolsParser extends BaseLLMOutputParser<ParsedToolCall[]> {\n    static lc_name(): string;\n    returnId: boolean;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    constructor(fields?: JsonOutputToolsParserParams);\n    /**\n     * Parses the output and returns a JSON object. If `argsOnly` is true,\n     * only the arguments of the function call are returned.\n     * @param generations The output of the LLM to parse.\n     * @returns A JSON object representation of the function call or its arguments.\n     */\n    parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]>;\n}\nexport type JsonOutputKeyToolsParserParams = {\n    keyName: string;\n    returnSingle?: boolean;\n    /** Whether to return the tool call id. */\n    returnId?: boolean;\n};\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport declare class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    returnId: boolean;\n    /** The type of tool calls to return. */\n    keyName: string;\n    /** Whether to return only the first tool call. */\n    returnSingle: boolean;\n    initialParser: JsonOutputToolsParser;\n    constructor(params: JsonOutputKeyToolsParserParams);\n    parseResult(generations: ChatGeneration[]): Promise<any>;\n}\n//# sourceMappingURL=openai_tools.d.ts.map"],"mappings":";;;;;;;AAKA;AAYYI,KAZAF,cAAAA,GAYAE;EAOSC,EAAAA,CAAAA,EAAAA,MAAAA;EAAkDH,IAAAA,EAAAA,MAAAA;EAK9CE,IAAAA,EArBfD,MAqBeC,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;EAOIH;EAA2BC,IAAAA,EAAAA,MAAAA;EAARI;EAZGN,SAAAA,EAZpCG,MAYoCH,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;AAAmB,CAAA;AActE;AASA;;AAUwBO,KAxCZH,2BAAAA,GAwCYG;EACKN;EAAmBK,QAAAA,CAAAA,EAAAA,OAAAA;CAXMN;AAAmB;;;cAvBpDK,qBAAAA,SAA8BL,oBAAoBE;;;;;uBAK9CE;;;;;;;2BAOIH,mBAAmBK,QAAQJ;;KAE5CK,8BAAAA;;;;;;;;;cASSC,wBAAAA,SAAiCR;;;;;;;;;iBASnCK;sBACKE;2BACKN,mBAAmBK"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.cts","names":["BaseOutputParser","SerializedFields","RegExpFields","RegexParserFields","RegExp","RegexParser","Record","Promise"],"sources":["../../src/output_parsers/regex.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport type { SerializedFields } from \"../load/map_keys.js\";\nexport interface RegExpFields {\n    pattern: string;\n    flags?: string;\n}\n/**\n * Interface for the fields required to create a RegexParser instance.\n */\nexport interface RegexParserFields {\n    regex: string | RegExp | RegExpFields;\n    outputKeys: string[];\n    defaultOutputKey?: string;\n}\n/**\n * Class to parse the output of an LLM call into a dictionary.\n * @augments BaseOutputParser\n */\nexport declare class RegexParser extends BaseOutputParser<Record<string, string>> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    get lc_attributes(): SerializedFields | undefined;\n    regex: string | RegExp;\n    outputKeys: string[];\n    defaultOutputKey?: string;\n    constructor(fields: RegexParserFields);\n    constructor(regex: string | RegExp, outputKeys: string[], defaultOutputKey?: string);\n    _type(): string;\n    /**\n     * Parses the given text using the regex pattern and returns a dictionary\n     * with the parsed output. If the regex pattern does not match the text\n     * and no defaultOutputKey is provided, throws an OutputParserException.\n     * @param text The text to be parsed.\n     * @returns A dictionary with the parsed output.\n     */\n    parse(text: string): Promise<Record<string, string>>;\n    /**\n     * Returns a string with instructions on how the LLM output should be\n     * formatted to match the regex pattern.\n     * @returns A string with formatting instructions.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=regex.d.ts.map"],"mappings":";;;;UAEiBE,YAAAA;;EAAAA,KAAAA,CAAAA,EAAAA,MAAAA;AAOjB;AASA;;;AAKoBE,UAdHD,iBAAAA,CAcGC;EAGID,KAAAA,EAAAA,MAAAA,GAhBJC,MAgBID,GAhBKD,YAgBLC;EACQC,UAAAA,EAAAA,MAAAA,EAAAA;EASCE,gBAAAA,CAAAA,EAAAA,MAAAA;;;AAlBwB;;;cAApCD,WAAAA,SAAoBL,iBAAiBM;;;;uBAIjCL;kBACLG;;;sBAGID;8BACQC;;;;;;;;;uBASPG,QAAQD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","names":["BaseOutputParser","SerializedFields","RegExpFields","RegexParserFields","RegExp","RegexParser","Record","Promise"],"sources":["../../src/output_parsers/regex.d.ts"],"sourcesContent":["import { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport type { SerializedFields } from \"../load/map_keys.js\";\nexport interface RegExpFields {\n    pattern: string;\n    flags?: string;\n}\n/**\n * Interface for the fields required to create a RegexParser instance.\n */\nexport interface RegexParserFields {\n    regex: string | RegExp | RegExpFields;\n    outputKeys: string[];\n    defaultOutputKey?: string;\n}\n/**\n * Class to parse the output of an LLM call into a dictionary.\n * @augments BaseOutputParser\n */\nexport declare class RegexParser extends BaseOutputParser<Record<string, string>> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    get lc_attributes(): SerializedFields | undefined;\n    regex: string | RegExp;\n    outputKeys: string[];\n    defaultOutputKey?: string;\n    constructor(fields: RegexParserFields);\n    constructor(regex: string | RegExp, outputKeys: string[], defaultOutputKey?: string);\n    _type(): string;\n    /**\n     * Parses the given text using the regex pattern and returns a dictionary\n     * with the parsed output. If the regex pattern does not match the text\n     * and no defaultOutputKey is provided, throws an OutputParserException.\n     * @param text The text to be parsed.\n     * @returns A dictionary with the parsed output.\n     */\n    parse(text: string): Promise<Record<string, string>>;\n    /**\n     * Returns a string with instructions on how the LLM output should be\n     * formatted to match the regex pattern.\n     * @returns A string with formatting instructions.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=regex.d.ts.map"],"mappings":";;;;UAEiBE,YAAAA;;EAAAA,KAAAA,CAAAA,EAAAA,MAAAA;AAOjB;AASA;;;AAKoBE,UAdHD,iBAAAA,CAcGC;EAGID,KAAAA,EAAAA,MAAAA,GAhBJC,MAgBID,GAhBKD,YAgBLC;EACQC,UAAAA,EAAAA,MAAAA,EAAAA;EASCE,gBAAAA,CAAAA,EAAAA,MAAAA;;;AAlBwB;;;cAApCD,WAAAA,SAAoBL,iBAAiBM;;;;uBAIjCL;kBACLG;;;sBAGID;8BACQC;;;;;;;;;uBASPG,QAAQD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.cts","names":["InferInteropZodOutput","InteropZodType","JsonMarkdownStructuredOutputParser","RouterOutputParserInput","RouterOutputParser","Y","Promise"],"sources":["../../src/output_parsers/router.d.ts"],"sourcesContent":["import { type InferInteropZodOutput, type InteropZodType } from \"@langchain/core/utils/types\";\nimport { JsonMarkdownStructuredOutputParser } from \"./structured.js\";\n/**\n * Defines the input parameters for the RouterOutputParser class. It can\n * include a default destination and an interpolation depth.\n */\nexport type RouterOutputParserInput = {\n    defaultDestination?: string;\n    interpolationDepth?: number;\n};\n/**\n * A type of output parser that extends the\n * JsonMarkdownStructuredOutputParser. It is used to parse the output of a\n * router in LangChain. The class takes a schema and an optional\n * RouterOutputParserInput object as parameters.\n */\nexport declare class RouterOutputParser<Y extends InteropZodType> extends JsonMarkdownStructuredOutputParser<Y> {\n    defaultDestination: string;\n    constructor(schema: Y, options?: RouterOutputParserInput);\n    /**\n     * Overrides the parse method from JsonMarkdownStructuredOutputParser.\n     * This method takes a string as input, attempts to parse it, and returns\n     * the parsed text. If the destination of the parsed text matches the\n     * defaultDestination, the destination is set to null. If the parsing\n     * fails, an OutputParserException is thrown.\n     * @param text The text to be parsed.\n     * @returns The parsed text as a Promise.\n     */\n    parse(text: string): Promise<InferInteropZodOutput<Y>>;\n}\n//# sourceMappingURL=router.d.ts.map"],"mappings":";;;;;;;AAMA;AAUA;AAAkDC,KAVtCE,uBAAAA,GAUsCF;EAA2DI,kBAAAA,CAAAA,EAAAA,MAAAA;EAErFA,kBAAAA,CAAAA,EAAAA,MAAAA;CAAaF;;;;;AAFuE;;cAAvFC,6BAA6BH,wBAAwBC,mCAAmCG;;sBAErFA,aAAaF;;;;;;;;;;uBAUZG,QAAQN,sBAAsBK"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","names":["InferInteropZodOutput","InteropZodType","JsonMarkdownStructuredOutputParser","RouterOutputParserInput","RouterOutputParser","Y","Promise"],"sources":["../../src/output_parsers/router.d.ts"],"sourcesContent":["import { type InferInteropZodOutput, type InteropZodType } from \"@langchain/core/utils/types\";\nimport { JsonMarkdownStructuredOutputParser } from \"./structured.js\";\n/**\n * Defines the input parameters for the RouterOutputParser class. It can\n * include a default destination and an interpolation depth.\n */\nexport type RouterOutputParserInput = {\n    defaultDestination?: string;\n    interpolationDepth?: number;\n};\n/**\n * A type of output parser that extends the\n * JsonMarkdownStructuredOutputParser. It is used to parse the output of a\n * router in LangChain. The class takes a schema and an optional\n * RouterOutputParserInput object as parameters.\n */\nexport declare class RouterOutputParser<Y extends InteropZodType> extends JsonMarkdownStructuredOutputParser<Y> {\n    defaultDestination: string;\n    constructor(schema: Y, options?: RouterOutputParserInput);\n    /**\n     * Overrides the parse method from JsonMarkdownStructuredOutputParser.\n     * This method takes a string as input, attempts to parse it, and returns\n     * the parsed text. If the destination of the parsed text matches the\n     * defaultDestination, the destination is set to null. If the parsing\n     * fails, an OutputParserException is thrown.\n     * @param text The text to be parsed.\n     * @returns The parsed text as a Promise.\n     */\n    parse(text: string): Promise<InferInteropZodOutput<Y>>;\n}\n//# sourceMappingURL=router.d.ts.map"],"mappings":";;;;;;;AAMA;AAUA;AAAkDC,KAVtCE,uBAAAA,GAUsCF;EAA2DI,kBAAAA,CAAAA,EAAAA,MAAAA;EAErFA,kBAAAA,CAAAA,EAAAA,MAAAA;CAAaF;;;;;AAFuE;;cAAvFC,6BAA6BH,wBAAwBC,mCAAmCG;;sBAErFA,aAAaF;;;;;;;;;;uBAUZG,QAAQN,sBAAsBK"}