@langchain/classic 1.0.3 → 1.0.5

package/dist/agents/structured_chat/outputParser.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outputParser.d.cts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n"],"mappings":";;;;;;;;;;AAWA;;;;AAcyBO,cAdJD,0BAAAA,SAAmCF,uBAAAA,CAc/BG;EAAO,YAdwBH,EAAAA,MAAAA,EAAAA;EAAuB,QAAA,SAAA;EA0B9DI,WAAAA,CAAAA,MAAAA,EAAAA;IAA8B,SAAA,EAAA,MAAA,EAAA;EAAA,CAAA;EACJ;;;AACA;AAqB3C;;;;EAY6C,KAAWN,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA/C/BK,OA+C+BL,CA/CvBA,WA+CuBA,GA/CTC,WA+CSD,CAAAA;EAAW;;;;;EAeF,qBAAyDO,CAAAA,CAAAA,EAAAA,MAAAA;;AA3BhC;;;;UAvBzED,8BAAAA;eACAF;uBACQD,mBAAmBH,cAAcC;;;;;;;;;;;;;;;;;;;;;cAqBrCM,qCAAAA,SAA8CL,uBAAAA;;;;;sBAK3CI;;;;;;;kCAOYP,YAAYM,QAAQL,cAAcC;;;;;;;;;;;;;;;sBAe9CH,qCAAqCU,KAAKF,wDAAwDC"}

package/dist/agents/structured_chat/outputParser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outputParser.d.ts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n"],"mappings":";;;;;;;;;;AAWA;;;;AAcyBO,cAdJD,0BAAAA,SAAmCF,uBAAAA,CAc/BG;EAAO,YAdwBH,EAAAA,MAAAA,EAAAA;EAAuB,QAAA,SAAA;EA0B9DI,WAAAA,CAAAA,MAAAA,EAAAA;IAA8B,SAAA,EAAA,MAAA,EAAA;EAAA,CAAA;EACJ;;;AACA;AAqB3C;;;;EAY6C,KAAWN,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA/C/BK,OA+C+BL,CA/CvBA,WA+CuBA,GA/CTC,WA+CSD,CAAAA;EAAW;;;;;EAeF,qBAAyDO,CAAAA,CAAAA,EAAAA,MAAAA;;AA3BhC;;;;UAvBzED,8BAAAA;eACAF;uBACQD,mBAAmBH,cAAcC;;;;;;;;;;;;;;;;;;;;;cAqBrCM,qCAAAA,SAA8CL,uBAAAA;;;;;sBAK3CI;;;;;;;kCAOYP,YAAYM,QAAQL,cAAcC;;;;;;;;;;;;;;;sBAe9CH,qCAAqCU,KAAKF,wDAAwDC"}

package/dist/agents/tool_calling/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","___index_js1","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>;\n"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAUV,GAAA,EAJrBJ,iBAIqB;EAyDNK;EAAsB,KAAA,EA3DnCN,uBA2DmC,EAAA,GA3DPE,cA2DO,EAAA;EAAA;EAAM,MAAEM,EAzD1CT,kBAyD0CS;EAAK;;;;EAClC,cAAA,CAAA,EAAA,OAAA;CACW;;AAFuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHF,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAc,WAAA,GACW,WAAA"}

package/dist/agents/tool_calling/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","___index_js1","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>;\n"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAUV,GAAA,EAJrBJ,iBAIqB;EAyDNK;EAAsB,KAAA,EA3DnCN,uBA2DmC,EAAA,GA3DPE,cA2DO,EAAA;EAAA;EAAM,MAAEM,EAzD1CT,kBAyD0CS;EAAK;;;;EAClC,cAAA,CAAA,EAAA,OAAA;CACW;;AAFuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHF,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAc,WAAA,GACW,WAAA"}

package/dist/agents/tool_calling/output_parser.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","AgentStep","AIMessage","BaseMessage","ChatGeneration","AgentMultiActionOutputParser","ToolsAgentAction","ToolsAgentStep","parseAIMessageToToolAction","ToolCallingAgentOutputParser","Promise"],"sources":["../../../src/agents/tool_calling/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { AIMessage, BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n    toolCallId: string;\n    messageLog?: BaseMessage[];\n};\nexport type ToolsAgentStep = AgentStep & {\n    action: ToolsAgentAction;\n};\nexport declare function parseAIMessageToToolAction(message: AIMessage): ToolsAgentAction[] | AgentFinish;\nexport declare class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction[] | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;;;AAOA;;AAA+BA,KAAnBO,gBAAAA,GAAmBP,WAAAA,GAAAA;EAAW,UAEzBI,EAAAA,MAAAA;EAAW,UAAA,CAAA,EAAXA,WAAW,EAAA;AAE5B,CAAA;AAA0B,KAAdI,cAAAA,GAAiBN,SAAH,GAAA;EAAA,MAAGA,EACjBK,gBADiBL;CAAS"}

package/dist/agents/tool_calling/output_parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","AgentStep","AIMessage","BaseMessage","ChatGeneration","AgentMultiActionOutputParser","ToolsAgentAction","ToolsAgentStep","parseAIMessageToToolAction","ToolCallingAgentOutputParser","Promise"],"sources":["../../../src/agents/tool_calling/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { AIMessage, BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n    toolCallId: string;\n    messageLog?: BaseMessage[];\n};\nexport type ToolsAgentStep = AgentStep & {\n    action: ToolsAgentAction;\n};\nexport declare function parseAIMessageToToolAction(message: AIMessage): ToolsAgentAction[] | AgentFinish;\nexport declare class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction[] | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;;;AAOA;;AAA+BA,KAAnBO,gBAAAA,GAAmBP,WAAAA,GAAAA;EAAW,UAEzBI,EAAAA,MAAAA;EAAW,UAAA,CAAA,EAAXA,WAAW,EAAA;AAE5B,CAAA;AAA0B,KAAdI,cAAAA,GAAiBN,SAAH,GAAA;EAAA,MAAGA,EACjBK,gBADiBL;CAAS"}

package/dist/agents/toolkits/conversational_retrieval/openai_functions.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openai_functions.d.cts","names":["StructuredToolInterface","ChatOpenAI","ConversationalRetrievalAgentOptions","createConversationalRetrievalAgent","______executor_js0","AgentExecutor","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nexport type ConversationalRetrievalAgentOptions = {\n    rememberIntermediateSteps?: boolean;\n    memoryKey?: string;\n    outputKey?: string;\n    inputKey?: string;\n    prefix?: string;\n    verbose?: boolean;\n};\n/**\n * Asynchronous function that creates a conversational retrieval agent\n * using a language model, tools, and options. It initializes the buffer\n * memory based on the provided options and initializes the AgentExecutor\n * with the tools, language model, and memory.\n * @param llm Instance of ChatOpenAI used as the language model for the agent.\n * @param tools Array of StructuredTool instances used by the agent.\n * @param options Optional ConversationalRetrievalAgentOptions to customize the agent.\n * @returns A Promise that resolves to an initialized AgentExecutor.\n */\nexport declare function createConversationalRetrievalAgent(llm: ChatOpenAI, tools: StructuredToolInterface[], options?: ConversationalRetrievalAgentOptions): Promise<import(\"../../executor.js\").AgentExecutor>;\n"],"mappings":";;;;;KAEYE,mCAAAA;;;EAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAkBYC,QAAAA,CAAAA,EAAAA,MAAAA;EAAkC,MAAA,CAAA,EAAA,MAAA;EAAA,OAAMF,CAAAA,EAAAA,OAAAA;CAAU;;;;AAA2F;;;;;;;iBAA7IE,kCAAAA,MAAwCF,mBAAmBD,qCAAqCE,sCAAsCI,QAAH,aAAA"}

package/dist/agents/toolkits/conversational_retrieval/openai_functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openai_functions.d.ts","names":["StructuredToolInterface","ChatOpenAI","ConversationalRetrievalAgentOptions","createConversationalRetrievalAgent","______executor_js0","AgentExecutor","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nexport type ConversationalRetrievalAgentOptions = {\n    rememberIntermediateSteps?: boolean;\n    memoryKey?: string;\n    outputKey?: string;\n    inputKey?: string;\n    prefix?: string;\n    verbose?: boolean;\n};\n/**\n * Asynchronous function that creates a conversational retrieval agent\n * using a language model, tools, and options. It initializes the buffer\n * memory based on the provided options and initializes the AgentExecutor\n * with the tools, language model, and memory.\n * @param llm Instance of ChatOpenAI used as the language model for the agent.\n * @param tools Array of StructuredTool instances used by the agent.\n * @param options Optional ConversationalRetrievalAgentOptions to customize the agent.\n * @returns A Promise that resolves to an initialized AgentExecutor.\n */\nexport declare function createConversationalRetrievalAgent(llm: ChatOpenAI, tools: StructuredToolInterface[], options?: ConversationalRetrievalAgentOptions): Promise<import(\"../../executor.js\").AgentExecutor>;\n"],"mappings":";;;;;KAEYE,mCAAAA;;;EAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAkBYC,QAAAA,CAAAA,EAAAA,MAAAA;EAAkC,MAAA,CAAA,EAAA,MAAA;EAAA,OAAMF,CAAAA,EAAAA,OAAAA;CAAU;;;;AAA2F;;;;;;;iBAA7IE,kCAAAA,MAAwCF,mBAAmBD,qCAAqCE,sCAAsCI,QAAH,aAAA"}

package/dist/agents/toolkits/conversational_retrieval/token_buffer_memory.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"token_buffer_memory.d.cts","names":["ChatOpenAI","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","OpenAIAgentTokenBufferMemoryFields","OpenAIAgentTokenBufferMemory","_langchain_core_messages0","MessageStructure","MessageType","BaseMessage","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/token_buffer_memory.d.ts"],"sourcesContent":["import { ChatOpenAI } from \"@langchain/openai\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"../../../memory/chat_memory.js\";\n/**\n * Type definition for the fields required to initialize an instance of\n * OpenAIAgentTokenBufferMemory.\n */\nexport type OpenAIAgentTokenBufferMemoryFields = BaseChatMemoryInput & {\n    llm: ChatOpenAI;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    memoryKey?: string;\n    maxTokenLimit?: number;\n    returnMessages?: boolean;\n    outputKey?: string;\n    intermediateStepsKey?: string;\n};\n/**\n * Memory used to save agent output and intermediate steps.\n */\nexport declare class OpenAIAgentTokenBufferMemory extends BaseChatMemory {\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: ChatOpenAI;\n    memoryKey: string;\n    maxTokenLimit: number;\n    returnMessages: boolean;\n    outputKey: string;\n    intermediateStepsKey: string;\n    constructor(fields: OpenAIAgentTokenBufferMemoryFields);\n    get memoryKeys(): string[];\n    /**\n     * Retrieves the messages from the chat history.\n     * @returns Promise that resolves with the messages from the chat history.\n     */\n    getMessages(): Promise<import(\"@langchain/core/messages\").BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[]>;\n    /**\n     * Loads memory variables from the input values.\n     * @param _values Input values.\n     * @returns Promise that resolves with the loaded memory variables.\n     */\n    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the chat, including user input, AI output, and\n     * intermediate steps. Prunes the chat history if the total token count\n     * exceeds the maximum limit.\n     * @param inputValues Input values.\n     * @param outputValues Output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n"],"mappings":";;;;;;;;;;AAOA;AAA8C,KAAlCM,kCAAAA,GAAqCD,mBAAH,GAAA;EAAA,GAAGA,EACxCL,UADwCK;EAAmB,WAC3DL,CAAAA,EAAAA,MAAAA;EAAU,QAAA,CAAA,EAAA,MAAA;EAYEO,SAAAA,CAAAA,EAAAA,MAAAA;EAA4B,aAAA,CAAA,EAAA,MAAA;EAAA,cAGxCP,CAAAA,EAAAA,OAAAA;EAAU,SAMKM,CAAAA,EAAAA,MAAAA;EAAkC,oBAAAE,CAAAA,EAAAA,MAMmDC;CAAgB;;;;AAMtEP,cArBlCK,4BAAAA,SAAqCH,cAAAA,CAqBHF;EAAe,WAAvBU,EAAAA,MAAAA;EAAO,QASzBX,EAAAA,MAAAA;EAAW,GAAgBE,EA3B/CH,UA2B+CG;EAAY,SAAGS,EAAAA,MAAAA;EAAO,aA9BpBR,EAAAA,MAAAA;EAAc,cAAA,EAAA,OAAA;;;sBAShDE;;;;;;iBAMLM,QAA0JJ,yBAAAA,CAA/GG,YANJH,yBAAAA,CAMmDC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA;;;;;;+BAMjIT,cAAcW,QAAQV;;;;;;;;;2BAS1BD,2BAA2BE,eAAeS"}

package/dist/agents/toolkits/conversational_retrieval/token_buffer_memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"token_buffer_memory.d.ts","names":["ChatOpenAI","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","OpenAIAgentTokenBufferMemoryFields","OpenAIAgentTokenBufferMemory","_langchain_core_messages1","MessageStructure","MessageType","BaseMessage","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/token_buffer_memory.d.ts"],"sourcesContent":["import { ChatOpenAI } from \"@langchain/openai\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"../../../memory/chat_memory.js\";\n/**\n * Type definition for the fields required to initialize an instance of\n * OpenAIAgentTokenBufferMemory.\n */\nexport type OpenAIAgentTokenBufferMemoryFields = BaseChatMemoryInput & {\n    llm: ChatOpenAI;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    memoryKey?: string;\n    maxTokenLimit?: number;\n    returnMessages?: boolean;\n    outputKey?: string;\n    intermediateStepsKey?: string;\n};\n/**\n * Memory used to save agent output and intermediate steps.\n */\nexport declare class OpenAIAgentTokenBufferMemory extends BaseChatMemory {\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: ChatOpenAI;\n    memoryKey: string;\n    maxTokenLimit: number;\n    returnMessages: boolean;\n    outputKey: string;\n    intermediateStepsKey: string;\n    constructor(fields: OpenAIAgentTokenBufferMemoryFields);\n    get memoryKeys(): string[];\n    /**\n     * Retrieves the messages from the chat history.\n     * @returns Promise that resolves with the messages from the chat history.\n     */\n    getMessages(): Promise<import(\"@langchain/core/messages\").BaseMessage<import(\"@langchain/core/messages\").MessageStructure, import(\"@langchain/core/messages\").MessageType>[]>;\n    /**\n     * Loads memory variables from the input values.\n     * @param _values Input values.\n     * @returns Promise that resolves with the loaded memory variables.\n     */\n    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the chat, including user input, AI output, and\n     * intermediate steps. Prunes the chat history if the total token count\n     * exceeds the maximum limit.\n     * @param inputValues Input values.\n     * @param outputValues Output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n"],"mappings":";;;;;;;;;;AAOA;AAA8C,KAAlCM,kCAAAA,GAAqCD,mBAAH,GAAA;EAAA,GAAGA,EACxCL,UADwCK;EAAmB,WAC3DL,CAAAA,EAAAA,MAAAA;EAAU,QAAA,CAAA,EAAA,MAAA;EAYEO,SAAAA,CAAAA,EAAAA,MAAAA;EAA4B,aAAA,CAAA,EAAA,MAAA;EAAA,cAGxCP,CAAAA,EAAAA,OAAAA;EAAU,SAMKM,CAAAA,EAAAA,MAAAA;EAAkC,oBAAAE,CAAAA,EAAAA,MAMmDC;CAAgB;;;;AAMtEP,cArBlCK,4BAAAA,SAAqCH,cAAAA,CAqBHF;EAAe,WAAvBU,EAAAA,MAAAA;EAAO,QASzBX,EAAAA,MAAAA;EAAW,GAAgBE,EA3B/CH,UA2B+CG;EAAY,SAAGS,EAAAA,MAAAA;EAAO,aA9BpBR,EAAAA,MAAAA;EAAc,cAAA,EAAA,OAAA;;;sBAShDE;;;;;;iBAMLM,QAA0JJ,yBAAAA,CAA/GG,YANJH,yBAAAA,CAMmDC,gBAAAA,EAAgBD,yBAAAA,CAAqCE,WAAAA;;;;;;+BAMjIT,cAAcW,QAAQV;;;;;;;;;2BAS1BD,2BAA2BE,eAAeS"}

package/dist/agents/toolkits/conversational_retrieval/tool.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.d.cts","names":["BaseRetrieverInterface","z","DynamicStructuredTool","DynamicStructuredToolInput","createRetrieverTool","Omit","ZodString","ZodTypeAny","ZodObject"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/tool.d.ts"],"sourcesContent":["import type { BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { z } from \"zod\";\nimport { DynamicStructuredTool, DynamicStructuredToolInput } from \"@langchain/core/tools\";\nexport declare function createRetrieverTool(retriever: BaseRetrieverInterface, input: Omit<DynamicStructuredToolInput, \"func\" | \"schema\">): DynamicStructuredTool<z.ZodObject<{\n    input: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    input: string;\n}, {\n    input: string;\n}>, {\n    input: string;\n}, {\n    input: string;\n}, string>;\n"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAA,KAAA,EAAA,MAAA;CAAA,EAAA;EAAkC,KAAcD,EAAAA,MAAAA;CAA0B,CAAA,EAAA;EAA3B,KAC7EG,EAAAA,MAAAA;CAAS,EAAA;EACE,KAF4IE,EAAAA,MAAAA;CAAS,EAAA,MAAjCN,CAAAA"}

package/dist/agents/toolkits/conversational_retrieval/tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool.d.ts","names":["BaseRetrieverInterface","z","DynamicStructuredTool","DynamicStructuredToolInput","createRetrieverTool","Omit","ZodString","ZodTypeAny","ZodObject"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/tool.d.ts"],"sourcesContent":["import type { BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { z } from \"zod\";\nimport { DynamicStructuredTool, DynamicStructuredToolInput } from \"@langchain/core/tools\";\nexport declare function createRetrieverTool(retriever: BaseRetrieverInterface, input: Omit<DynamicStructuredToolInput, \"func\" | \"schema\">): DynamicStructuredTool<z.ZodObject<{\n    input: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    input: string;\n}, {\n    input: string;\n}>, {\n    input: string;\n}, {\n    input: string;\n}, string>;\n"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAA,KAAA,EAAA,MAAA;CAAA,EAAA;EAAkC,KAAcD,EAAAA,MAAAA;CAA0B,CAAA,EAAA;EAA3B,KAC7EG,EAAAA,MAAAA;CAAS,EAAA;EACE,KAF4IE,EAAAA,MAAAA;CAAS,EAAA,MAAjCN,CAAAA"}

package/dist/agents/toolkits/json/json.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.cts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","JsonSpec","ZeroShotCreatePromptArgs","AgentExecutor","JsonToolkit","createJsonAgent"],"sources":["../../../../src/agents/toolkits/json/json.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { type ToolInterface, BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { AgentExecutor } from \"../../executor.js\";\n/**\n * Represents a toolkit for working with JSON data. It initializes the\n * JSON tools based on the provided JSON specification.\n * @example\n * ```typescript\n * const toolkit = new JsonToolkit(new JsonSpec());\n * const executor = createJsonAgent(model, toolkit);\n * const result = await executor.invoke({\n *   input: 'What are the required parameters in the request body to the /completions endpoint?'\n * });\n * ```\n */\nexport declare class JsonToolkit extends BaseToolkit {\n    jsonSpec: JsonSpec;\n    tools: ToolInterface[];\n    constructor(jsonSpec: JsonSpec);\n}\n/**\n * Creates a JSON agent using a language model, a JSON toolkit, and\n * optional prompt arguments. It creates a prompt for the agent using the\n * JSON tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the JSON tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model used to create the JSON agent.\n * @param toolkit The JSON toolkit used to create the JSON agent.\n * @param args Optional prompt arguments used to create the JSON agent.\n * @returns An AgentExecutor for executing the created JSON agent with the tools.\n */\nexport declare function createJsonAgent(llm: BaseLanguageModelInterface, toolkit: JsonToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AAiBA;;;;;;AAAoD;AAgBpD;;;AAAkFM,cAhB7DA,WAAAA,SAAoBJ,WAAAA,CAgByCI;EAAW,QAASF,EAfxFD,QAewFC;EAAwB,KAAGC,EAdtHJ,aAcsHI,EAAAA;EAAa,WAAA,CAAA,QAAA,EAbpHF,QAaoH;;;;;;;;;;;;;iBAAtHI,eAAAA,MAAqBP,qCAAqCM,oBAAoBF,2BAA2BC"}

package/dist/agents/toolkits/json/json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","JsonSpec","ZeroShotCreatePromptArgs","AgentExecutor","JsonToolkit","createJsonAgent"],"sources":["../../../../src/agents/toolkits/json/json.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { type ToolInterface, BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { AgentExecutor } from \"../../executor.js\";\n/**\n * Represents a toolkit for working with JSON data. It initializes the\n * JSON tools based on the provided JSON specification.\n * @example\n * ```typescript\n * const toolkit = new JsonToolkit(new JsonSpec());\n * const executor = createJsonAgent(model, toolkit);\n * const result = await executor.invoke({\n *   input: 'What are the required parameters in the request body to the /completions endpoint?'\n * });\n * ```\n */\nexport declare class JsonToolkit extends BaseToolkit {\n    jsonSpec: JsonSpec;\n    tools: ToolInterface[];\n    constructor(jsonSpec: JsonSpec);\n}\n/**\n * Creates a JSON agent using a language model, a JSON toolkit, and\n * optional prompt arguments. It creates a prompt for the agent using the\n * JSON tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the JSON tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model used to create the JSON agent.\n * @param toolkit The JSON toolkit used to create the JSON agent.\n * @param args Optional prompt arguments used to create the JSON agent.\n * @returns An AgentExecutor for executing the created JSON agent with the tools.\n */\nexport declare function createJsonAgent(llm: BaseLanguageModelInterface, toolkit: JsonToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AAiBA;;;;;;AAAoD;AAgBpD;;;AAAkFM,cAhB7DA,WAAAA,SAAoBJ,WAAAA,CAgByCI;EAAW,QAASF,EAfxFD,QAewFC;EAAwB,KAAGC,EAdtHJ,aAcsHI,EAAAA;EAAa,WAAA,CAAA,QAAA,EAbpHF,QAaoH;;;;;;;;;;;;;iBAAtHI,eAAAA,MAAqBP,qCAAqCM,oBAAoBF,2BAA2BC"}

package/dist/agents/toolkits/openapi/openapi.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openapi.d.cts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","JsonSpec","AgentExecutor","ZeroShotCreatePromptArgs","Headers","RequestsToolkit","OpenApiToolkit","createOpenApiAgent"],"sources":["../../../../src/agents/toolkits/openapi/openapi.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { Headers } from \"../../../tools/requests.js\";\n/**\n * Represents a toolkit for making HTTP requests. It initializes the\n * request tools based on the provided headers.\n */\nexport declare class RequestsToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    constructor(headers?: Headers);\n}\n/**\n * Extends the `RequestsToolkit` class and adds a dynamic tool for\n * exploring JSON data. It creates a JSON agent using the `JsonToolkit`\n * and the provided language model, and adds the JSON explorer tool to the\n * toolkit.\n * @example\n * ```typescript\n * const toolkit = new OpenApiToolkit(\n *   new JsonSpec({\n *   }),\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     \"Content-Type\": \"application/json\",\n *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,\n *   },\n * );\n *\n * const result = await toolkit.invoke({\n *   input:\n *     \"Make a POST request to openai /completions. The prompt should be 'tell me a joke.'\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class OpenApiToolkit extends RequestsToolkit {\n    constructor(jsonSpec: JsonSpec, llm: BaseLanguageModelInterface, headers?: Headers);\n}\n/**\n * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,\n * and optional prompt arguments. It creates a prompt for the agent using\n * the OpenAPI tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model to use.\n * @param openApiToolkit The OpenAPI toolkit to use.\n * @param args Optional arguments for creating the prompt.\n * @returns An AgentExecutor for executing the agent with the tools.\n *\n * @security **Security Notice** This agent provides access to external APIs.\n * Use with caution as this agent can make API calls with arbitrary headers.\n * Exposing this agent to users could lead to security vulnerabilities. Consider\n * limiting access to what endpoints it can hit, what actions can be taken, and\n * more.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare function createOpenApiAgent(llm: BaseLanguageModelInterface, openApiToolkit: OpenApiToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AAWA;;;AAE0BM,cAFLC,eAAAA,SAAwBL,WAAAA,CAEnBI;EAAO,KAFYJ,EAClCD,aADkCC,EAAAA;EAAW,WAAA,CAAA,OAAA,CAAA,EAE9BI,OAF8B;AA4BxD;;;;;;AAA2D;AAsB3D;;;;;;AAA2J;;;;;;;;;;;;cAtBtIE,cAAAA,SAAuBD,eAAAA;wBAClBJ,eAAeH,sCAAsCM;;;;;;;;;;;;;;;;;;;;;iBAqBvDG,kBAAAA,MAAwBT,4CAA4CQ,uBAAuBH,2BAA2BD"}

package/dist/agents/toolkits/openapi/openapi.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"openapi.d.ts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","JsonSpec","AgentExecutor","ZeroShotCreatePromptArgs","Headers","RequestsToolkit","OpenApiToolkit","createOpenApiAgent"],"sources":["../../../../src/agents/toolkits/openapi/openapi.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { BaseToolkit } from \"@langchain/core/tools\";\nimport { JsonSpec } from \"../../../tools/json.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { Headers } from \"../../../tools/requests.js\";\n/**\n * Represents a toolkit for making HTTP requests. It initializes the\n * request tools based on the provided headers.\n */\nexport declare class RequestsToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    constructor(headers?: Headers);\n}\n/**\n * Extends the `RequestsToolkit` class and adds a dynamic tool for\n * exploring JSON data. It creates a JSON agent using the `JsonToolkit`\n * and the provided language model, and adds the JSON explorer tool to the\n * toolkit.\n * @example\n * ```typescript\n * const toolkit = new OpenApiToolkit(\n *   new JsonSpec({\n *   }),\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     \"Content-Type\": \"application/json\",\n *     Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,\n *   },\n * );\n *\n * const result = await toolkit.invoke({\n *   input:\n *     \"Make a POST request to openai /completions. The prompt should be 'tell me a joke.'\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class OpenApiToolkit extends RequestsToolkit {\n    constructor(jsonSpec: JsonSpec, llm: BaseLanguageModelInterface, headers?: Headers);\n}\n/**\n * Creates an OpenAPI agent using a language model, an OpenAPI toolkit,\n * and optional prompt arguments. It creates a prompt for the agent using\n * the OpenAPI tools and the provided prefix and suffix. It then creates a\n * ZeroShotAgent with the prompt and the OpenAPI tools, and returns an\n * AgentExecutor for executing the agent with the tools.\n * @param llm The language model to use.\n * @param openApiToolkit The OpenAPI toolkit to use.\n * @param args Optional arguments for creating the prompt.\n * @returns An AgentExecutor for executing the agent with the tools.\n *\n * @security **Security Notice** This agent provides access to external APIs.\n * Use with caution as this agent can make API calls with arbitrary headers.\n * Exposing this agent to users could lead to security vulnerabilities. Consider\n * limiting access to what endpoints it can hit, what actions can be taken, and\n * more.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare function createOpenApiAgent(llm: BaseLanguageModelInterface, openApiToolkit: OpenApiToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AAWA;;;AAE0BM,cAFLC,eAAAA,SAAwBL,WAAAA,CAEnBI;EAAO,KAFYJ,EAClCD,aADkCC,EAAAA;EAAW,WAAA,CAAA,OAAA,CAAA,EAE9BI,OAF8B;AA4BxD;;;;;;AAA2D;AAsB3D;;;;;;AAA2J;;;;;;;;;;;;cAtBtIE,cAAAA,SAAuBD,eAAAA;wBAClBJ,eAAeH,sCAAsCM;;;;;;;;;;;;;;;;;;;;;iBAqBvDG,kBAAAA,MAAwBT,4CAA4CQ,uBAAuBH,2BAA2BD"}

package/dist/agents/toolkits/sql/prompt.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt.d.cts","names":["SQL_PREFIX","SQL_SUFFIX"],"sources":["../../../../src/agents/toolkits/sql/prompt.d.ts"],"sourcesContent":["export declare const SQL_PREFIX = \"You are an agent designed to interact with a SQL database.\\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\\nYou can order the results by a relevant column to return the most interesting examples in the database.\\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\\nYou have access to tools for interacting with the database.\\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\\n\\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\\n\\nIf the question does not seem related to the database, just return \\\"I don't know\\\" as the answer.\";\nexport declare const SQL_SUFFIX = \"Begin!\\n\\nQuestion: {input}\\nThought: I should look at the tables in the database to see what I can query.\\n{agent_scratchpad}\";\n"],"mappings":";cAAqBA,UAAAA;AAAAA,cACAC,UAAAA,GADU,gIAAA"}

package/dist/agents/toolkits/sql/prompt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt.d.ts","names":["SQL_PREFIX","SQL_SUFFIX"],"sources":["../../../../src/agents/toolkits/sql/prompt.d.ts"],"sourcesContent":["export declare const SQL_PREFIX = \"You are an agent designed to interact with a SQL database.\\nGiven an input question, create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer.\\nUnless the user specifies a specific number of examples they wish to obtain, always limit your query to at most {top_k} results using the LIMIT clause.\\nYou can order the results by a relevant column to return the most interesting examples in the database.\\nNever query for all the columns from a specific table, only ask for a the few relevant columns given the question.\\nYou have access to tools for interacting with the database.\\nOnly use the below tools. Only use the information returned by the below tools to construct your final answer.\\nYou MUST double check your query before executing it. If you get an error while executing a query, rewrite the query and try again.\\n\\nDO NOT make any DML statements (INSERT, UPDATE, DELETE, DROP etc.) to the database.\\n\\nIf the question does not seem related to the database, just return \\\"I don't know\\\" as the answer.\";\nexport declare const SQL_SUFFIX = \"Begin!\\n\\nQuestion: {input}\\nThought: I should look at the tables in the database to see what I can query.\\n{agent_scratchpad}\";\n"],"mappings":";cAAqBA,UAAAA;AAAAA,cACAC,UAAAA,GADU,gIAAA"}

package/dist/agents/toolkits/sql/sql.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql.d.cts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","ZeroShotCreatePromptArgs","AgentExecutor","SqlDatabase","SqlCreatePromptArgs","SqlToolkit","createSqlAgent"],"sources":["../../../../src/agents/toolkits/sql/sql.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { type ToolInterface, BaseToolkit } from \"@langchain/core/tools\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport { SqlDatabase } from \"../../../sql_db.js\";\n/**\n * Interface that extends ZeroShotCreatePromptArgs and adds an optional\n * topK parameter for specifying the number of results to return.\n */\nexport interface SqlCreatePromptArgs extends ZeroShotCreatePromptArgs {\n    /** Number of results to return. */\n    topK?: number;\n}\n/**\n * Class that represents a toolkit for working with SQL databases. It\n * initializes SQL tools based on the provided SQL database.\n * @example\n * ```typescript\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const toolkit = new SqlToolkit(sqlDb, model);\n * const executor = createSqlAgent(model, toolkit);\n * const result = await executor.invoke({ input: 'List the total sales per country. Which country's customers spent the most?' });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class SqlToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    db: SqlDatabase;\n    dialect: string;\n    constructor(db: SqlDatabase, llm: BaseLanguageModelInterface);\n}\nexport declare function createSqlAgent(llm: BaseLanguageModelInterface, toolkit: SqlToolkit, args?: SqlCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AASA;AAgBA;AAA+B,UAhBdM,mBAAAA,SAA4BH,wBAgBd,CAAA;EAAA;EACP,IAChBE,CAAAA,EAAAA,MAAAA;;;;AAF2C;AAMnD;;;;;;AAAuI;;;cANlHE,UAAAA,SAAmBL,WAAAA;SAC7BD;MACHI;;kBAEYA,kBAAkBL;;iBAEdQ,cAAAA,MAAoBR,qCAAqCO,mBAAmBD,sBAAsBF"}

package/dist/agents/toolkits/sql/sql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql.d.ts","names":["BaseLanguageModelInterface","ToolInterface","BaseToolkit","ZeroShotCreatePromptArgs","AgentExecutor","SqlDatabase","SqlCreatePromptArgs","SqlToolkit","createSqlAgent"],"sources":["../../../../src/agents/toolkits/sql/sql.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { type ToolInterface, BaseToolkit } from \"@langchain/core/tools\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { AgentExecutor } from \"../../executor.js\";\nimport { SqlDatabase } from \"../../../sql_db.js\";\n/**\n * Interface that extends ZeroShotCreatePromptArgs and adds an optional\n * topK parameter for specifying the number of results to return.\n */\nexport interface SqlCreatePromptArgs extends ZeroShotCreatePromptArgs {\n    /** Number of results to return. */\n    topK?: number;\n}\n/**\n * Class that represents a toolkit for working with SQL databases. It\n * initializes SQL tools based on the provided SQL database.\n * @example\n * ```typescript\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const toolkit = new SqlToolkit(sqlDb, model);\n * const executor = createSqlAgent(model, toolkit);\n * const result = await executor.invoke({ input: 'List the total sales per country. Which country's customers spent the most?' });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class SqlToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    db: SqlDatabase;\n    dialect: string;\n    constructor(db: SqlDatabase, llm: BaseLanguageModelInterface);\n}\nexport declare function createSqlAgent(llm: BaseLanguageModelInterface, toolkit: SqlToolkit, args?: SqlCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AASA;AAgBA;AAA+B,UAhBdM,mBAAAA,SAA4BH,wBAgBd,CAAA;EAAA;EACP,IAChBE,CAAAA,EAAAA,MAAAA;;;;AAF2C;AAMnD;;;;;;AAAuI;;;cANlHE,UAAAA,SAAmBL,WAAAA;SAC7BD;MACHI;;kBAEYA,kBAAkBL;;iBAEdQ,cAAAA,MAAoBR,qCAAqCO,mBAAmBD,sBAAsBF"}

package/dist/agents/toolkits/vectorstore/vectorstore.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vectorstore.d.cts","names":["BaseLanguageModelInterface","VectorStoreInterface","ToolInterface","BaseToolkit","ZeroShotCreatePromptArgs","AgentExecutor","VectorStoreInfo","VectorStoreToolkit","VectorStoreRouterToolkit","createVectorStoreAgent","createVectorStoreRouterAgent"],"sources":["../../../../src/agents/toolkits/vectorstore/vectorstore.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { ToolInterface, BaseToolkit } from \"@langchain/core/tools\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { AgentExecutor } from \"../../executor.js\";\n/**\n * Interface that defines the information about a vector store, including\n * the vector store itself, its name, and description.\n */\nexport interface VectorStoreInfo {\n    vectorStore: VectorStoreInterface;\n    name: string;\n    description: string;\n}\n/**\n * Class representing a toolkit for working with a single vector store. It\n * initializes the vector store QA tool based on the provided vector store\n * information and language model.\n * @example\n * ```typescript\n * const toolkit = new VectorStoreToolkit(\n *   {\n *     name: \"state_of_union_address\",\n *     description: \"the most recent state of the Union address\",\n *     vectorStore: new HNSWLib(),\n *   },\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n * );\n * const result = await toolkit.invoke({\n *   input:\n *     \"What did biden say about Ketanji Brown Jackson in the state of the union address?\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class VectorStoreToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    llm: BaseLanguageModelInterface;\n    constructor(vectorStoreInfo: VectorStoreInfo, llm: BaseLanguageModelInterface);\n}\n/**\n * Class representing a toolkit for working with multiple vector stores.\n * It initializes multiple vector store QA tools based on the provided\n * vector store information and language model.\n */\nexport declare class VectorStoreRouterToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    vectorStoreInfos: VectorStoreInfo[];\n    llm: BaseLanguageModelInterface;\n    constructor(vectorStoreInfos: VectorStoreInfo[], llm: BaseLanguageModelInterface);\n}\nexport declare function createVectorStoreAgent(llm: BaseLanguageModelInterface, toolkit: VectorStoreToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\nexport declare function createVectorStoreRouterAgent(llm: BaseLanguageModelInterface, toolkit: VectorStoreRouterToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AASA;AA0BA;AAAuC,UA1BtBM,eAAAA,CA0BsB;EAAA,WAC5BJ,EA1BMD,oBA0BNC;EAAa,IACfF,EAAAA,MAAAA;EAA0B,WACFM,EAAAA,MAAAA;;;AAH0B;AAU3D;;;;;;;;AAAiE;AAMjE;;;;;;AAA4J;AAC5J;;;AAA+FE,cAjB1ED,kBAAAA,SAA2BJ,WAAAA,CAiB+CK;EAAwB,KAASJ,EAhBrHF,aAgBqHE,EAAAA;EAAwB,GAAGC,EAflJL,0BAekJK;EAAa,WAAA,CAAA,eAAA,EAdvIC,eAcuI,EAAA,GAAA,EAdjHN,0BAciH;;;;;;;cAPnJQ,wBAAAA,SAAiCL,WAAAA;SAC3CD;oBACWI;OACbN;gCACyBM,wBAAwBN;;iBAElCS,sBAAAA,MAA4BT,qCAAqCO,2BAA2BH,2BAA2BC;iBACvHK,4BAAAA,MAAkCV,qCAAqCQ,iCAAiCJ,2BAA2BC"}

package/dist/agents/toolkits/vectorstore/vectorstore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vectorstore.d.ts","names":["BaseLanguageModelInterface","VectorStoreInterface","ToolInterface","BaseToolkit","ZeroShotCreatePromptArgs","AgentExecutor","VectorStoreInfo","VectorStoreToolkit","VectorStoreRouterToolkit","createVectorStoreAgent","createVectorStoreRouterAgent"],"sources":["../../../../src/agents/toolkits/vectorstore/vectorstore.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { ToolInterface, BaseToolkit } from \"@langchain/core/tools\";\nimport { ZeroShotCreatePromptArgs } from \"../../mrkl/index.js\";\nimport { AgentExecutor } from \"../../executor.js\";\n/**\n * Interface that defines the information about a vector store, including\n * the vector store itself, its name, and description.\n */\nexport interface VectorStoreInfo {\n    vectorStore: VectorStoreInterface;\n    name: string;\n    description: string;\n}\n/**\n * Class representing a toolkit for working with a single vector store. It\n * initializes the vector store QA tool based on the provided vector store\n * information and language model.\n * @example\n * ```typescript\n * const toolkit = new VectorStoreToolkit(\n *   {\n *     name: \"state_of_union_address\",\n *     description: \"the most recent state of the Union address\",\n *     vectorStore: new HNSWLib(),\n *   },\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n * );\n * const result = await toolkit.invoke({\n *   input:\n *     \"What did biden say about Ketanji Brown Jackson in the state of the union address?\",\n * });\n * console.log(`Got output ${result.output}`);\n * ```\n */\nexport declare class VectorStoreToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    llm: BaseLanguageModelInterface;\n    constructor(vectorStoreInfo: VectorStoreInfo, llm: BaseLanguageModelInterface);\n}\n/**\n * Class representing a toolkit for working with multiple vector stores.\n * It initializes multiple vector store QA tools based on the provided\n * vector store information and language model.\n */\nexport declare class VectorStoreRouterToolkit extends BaseToolkit {\n    tools: ToolInterface[];\n    vectorStoreInfos: VectorStoreInfo[];\n    llm: BaseLanguageModelInterface;\n    constructor(vectorStoreInfos: VectorStoreInfo[], llm: BaseLanguageModelInterface);\n}\nexport declare function createVectorStoreAgent(llm: BaseLanguageModelInterface, toolkit: VectorStoreToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\nexport declare function createVectorStoreRouterAgent(llm: BaseLanguageModelInterface, toolkit: VectorStoreRouterToolkit, args?: ZeroShotCreatePromptArgs): AgentExecutor;\n"],"mappings":";;;;;;;;;;AASA;AA0BA;AAAuC,UA1BtBM,eAAAA,CA0BsB;EAAA,WAC5BJ,EA1BMD,oBA0BNC;EAAa,IACfF,EAAAA,MAAAA;EAA0B,WACFM,EAAAA,MAAAA;;;AAH0B;AAU3D;;;;;;;;AAAiE;AAMjE;;;;;;AAA4J;AAC5J;;;AAA+FE,cAjB1ED,kBAAAA,SAA2BJ,WAAAA,CAiB+CK;EAAwB,KAASJ,EAhBrHF,aAgBqHE,EAAAA;EAAwB,GAAGC,EAflJL,0BAekJK;EAAa,WAAA,CAAA,eAAA,EAdvIC,eAcuI,EAAA,GAAA,EAdjHN,0BAciH;;;;;;;cAPnJQ,wBAAAA,SAAiCL,WAAAA;SAC3CD;oBACWI;OACbN;gCACyBM,wBAAwBN;;iBAElCS,sBAAAA,MAA4BT,qCAAqCO,2BAA2BH,2BAA2BC;iBACvHK,4BAAAA,MAAkCV,qCAAqCQ,iCAAiCJ,2BAA2BC"}

package/dist/agents/types.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.cts","names":["Runnable","BaseOutputParser","AgentAction","AgentFinish","BaseMessage","ChainValues","SerializedLLMChain","LLMChain","AgentInput","AgentActionOutputParser","RunnableSingleActionAgentInput","RunnableMultiActionAgentInput","RunnableAgentInput","AgentMultiActionOutputParser","StoppingMethod","SerializedAgentT","Record","TType","FromLLMInput","ConstructorInput","SerializedFromLLMAndTools","SerializedZeroShotAgent","SerializedAgent"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { Runnable } from \"@langchain/core/runnables\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport type { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { ChainValues } from \"@langchain/core/utils/types\";\nimport { SerializedLLMChain } from \"../chains/serde.js\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\n/**\n * Interface defining the input for creating an agent. It includes the\n * LLMChain instance, an optional output parser, and an optional list of\n * allowed tools.\n */\nexport interface AgentInput {\n    llmChain: LLMChain;\n    outputParser: AgentActionOutputParser | undefined;\n    allowedTools?: string[];\n}\n/**\n * Interface defining the input for creating a single action agent\n * that uses runnables.\n */\nexport interface RunnableSingleActionAgentInput {\n    runnable: Runnable<ChainValues & {\n        agent_scratchpad?: string | BaseMessage[];\n        stop?: string[];\n    }, AgentAction | AgentFinish>;\n    streamRunnable?: boolean;\n    defaultRunName?: string;\n}\n/**\n * Interface defining the input for creating a multi-action agent that uses\n * runnables. It includes the Runnable instance, and an optional list of\n * stop strings.\n */\nexport interface RunnableMultiActionAgentInput {\n    runnable: Runnable<ChainValues & {\n        agent_scratchpad?: string | BaseMessage[];\n        stop?: string[];\n    }, AgentAction[] | AgentAction | AgentFinish>;\n    streamRunnable?: boolean;\n    defaultRunName?: string;\n    stop?: string[];\n}\n/** @deprecated Renamed to RunnableMultiActionAgentInput. */\nexport interface RunnableAgentInput extends RunnableMultiActionAgentInput {\n}\n/**\n * Abstract class representing an output parser specifically for agent\n * actions and finishes in LangChain. It extends the `BaseOutputParser`\n * class.\n */\nexport declare abstract class AgentActionOutputParser extends BaseOutputParser<AgentAction | AgentFinish> {\n}\n/**\n * Abstract class representing an output parser specifically for agents\n * that return multiple actions.\n */\nexport declare abstract class AgentMultiActionOutputParser extends BaseOutputParser<AgentAction[] | AgentFinish> {\n}\n/**\n * Type representing the stopping method for an agent. It can be either\n * 'force' or 'generate'.\n */\nexport type StoppingMethod = \"force\" | \"generate\";\n/**\n * Generic type representing a serialized agent in LangChain. It includes\n * the type of the agent, the serialized form of the LLMChain, and\n * additional properties specific to the agent type.\n */\nexport type SerializedAgentT<TType extends string = string, FromLLMInput extends Record<string, unknown> = Record<string, unknown>, ConstructorInput extends AgentInput = AgentInput> = {\n    _type: TType;\n    llm_chain?: SerializedLLMChain;\n} & (({\n    load_from_llm_and_tools: true;\n} & FromLLMInput) | ({\n    load_from_llm_and_tools?: false;\n} & ConstructorInput));\nexport type SerializedFromLLMAndTools = {\n    suffix?: string;\n    prefix?: string;\n    input_variables?: string[];\n};\n/**\n * Type representing a serialized ZeroShotAgent in LangChain. It extends\n * the `SerializedAgentT` type and includes additional properties specific\n * to the ZeroShotAgent.\n */\nexport type SerializedZeroShotAgent = SerializedAgentT<\"zero-shot-react-description\", SerializedFromLLMAndTools, AgentInput>;\n/**\n * Type representing a serialized agent in LangChain. It is currently\n * synonymous with `SerializedZeroShotAgent`.\n */\nexport type SerializedAgent = SerializedZeroShotAgent;\n"],"mappings":";;;;;;;;;;;;AAYA;;;AAEkBS,UAFDD,UAAAA,CAECC;EAAuB,QAAA,EAD3BF,QAC2B;EAoBxBI,YAAAA,EApBCF,uBAoB4B,GAAA,SAAA;EAAA,YAAA,CAAA,EAAA,MAAA,EAAA;;;;;;;AAuB9C;;;;;AAAmF,UAvBlEE,6BAAAA,CAuBkE;EAMvEG,QAAAA,EA5BEd,QA4BY,CA5BHK,WA4BG,GAAA;IAMdU,gBAAgB,CAAA,EAAA,MAAA,GAjCQX,WAiCR,EAAA;IAAA,IAAA,CAAA,EAAA,MAAA,EAAA;EAAA,CAAA,EA/BrBF,WA+B0Ec,EAAAA,GA/B1Dd,WA+B0Dc,GA/B5Cb,WA+B4Ca,CAAAA;EAAM,cAAoBA,CAAAA,EAAAA,OAAAA;EAAM,cAA4CR,CAAAA,EAAAA,MAAAA;EAAU,IAAGA,CAAAA,EAAAA,MAAAA,EAAAA;;;;AAOtJ;AACpB;AAUA;;;AAAiHA,uBApCnFC,uBAAAA,SAAgCR,gBAoCmDO,CApClCN,WAoCkCM,GApCpBL,WAoCoBK,CAAAA,CAAAA;AAA3D;AAKtD;;;uBAnC8BK,4BAAAA,SAAqCZ,iBAAiBC,gBAAgBC;;;;;KAMxFW,cAAAA;;;;;;KAMAC,qEAAqEC,0BAA0BA,kDAAkDR,aAAaA;SAC/JS;cACKX;;;IAGZY;;IAEAC;KACQC,yBAAAA;;;;;;;;;;KAUAC,uBAAAA,GAA0BN,gDAAgDK,2BAA2BZ;;;;;KAKrGc,eAAAA,GAAkBD"}

package/dist/agents/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":["Runnable","BaseOutputParser","AgentAction","AgentFinish","BaseMessage","ChainValues","SerializedLLMChain","LLMChain","AgentInput","AgentActionOutputParser","RunnableSingleActionAgentInput","RunnableMultiActionAgentInput","RunnableAgentInput","AgentMultiActionOutputParser","StoppingMethod","SerializedAgentT","Record","TType","FromLLMInput","ConstructorInput","SerializedFromLLMAndTools","SerializedZeroShotAgent","SerializedAgent"],"sources":["../../src/agents/types.d.ts"],"sourcesContent":["import type { Runnable } from \"@langchain/core/runnables\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport type { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { ChainValues } from \"@langchain/core/utils/types\";\nimport { SerializedLLMChain } from \"../chains/serde.js\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\n/**\n * Interface defining the input for creating an agent. It includes the\n * LLMChain instance, an optional output parser, and an optional list of\n * allowed tools.\n */\nexport interface AgentInput {\n    llmChain: LLMChain;\n    outputParser: AgentActionOutputParser | undefined;\n    allowedTools?: string[];\n}\n/**\n * Interface defining the input for creating a single action agent\n * that uses runnables.\n */\nexport interface RunnableSingleActionAgentInput {\n    runnable: Runnable<ChainValues & {\n        agent_scratchpad?: string | BaseMessage[];\n        stop?: string[];\n    }, AgentAction | AgentFinish>;\n    streamRunnable?: boolean;\n    defaultRunName?: string;\n}\n/**\n * Interface defining the input for creating a multi-action agent that uses\n * runnables. It includes the Runnable instance, and an optional list of\n * stop strings.\n */\nexport interface RunnableMultiActionAgentInput {\n    runnable: Runnable<ChainValues & {\n        agent_scratchpad?: string | BaseMessage[];\n        stop?: string[];\n    }, AgentAction[] | AgentAction | AgentFinish>;\n    streamRunnable?: boolean;\n    defaultRunName?: string;\n    stop?: string[];\n}\n/** @deprecated Renamed to RunnableMultiActionAgentInput. */\nexport interface RunnableAgentInput extends RunnableMultiActionAgentInput {\n}\n/**\n * Abstract class representing an output parser specifically for agent\n * actions and finishes in LangChain. It extends the `BaseOutputParser`\n * class.\n */\nexport declare abstract class AgentActionOutputParser extends BaseOutputParser<AgentAction | AgentFinish> {\n}\n/**\n * Abstract class representing an output parser specifically for agents\n * that return multiple actions.\n */\nexport declare abstract class AgentMultiActionOutputParser extends BaseOutputParser<AgentAction[] | AgentFinish> {\n}\n/**\n * Type representing the stopping method for an agent. It can be either\n * 'force' or 'generate'.\n */\nexport type StoppingMethod = \"force\" | \"generate\";\n/**\n * Generic type representing a serialized agent in LangChain. It includes\n * the type of the agent, the serialized form of the LLMChain, and\n * additional properties specific to the agent type.\n */\nexport type SerializedAgentT<TType extends string = string, FromLLMInput extends Record<string, unknown> = Record<string, unknown>, ConstructorInput extends AgentInput = AgentInput> = {\n    _type: TType;\n    llm_chain?: SerializedLLMChain;\n} & (({\n    load_from_llm_and_tools: true;\n} & FromLLMInput) | ({\n    load_from_llm_and_tools?: false;\n} & ConstructorInput));\nexport type SerializedFromLLMAndTools = {\n    suffix?: string;\n    prefix?: string;\n    input_variables?: string[];\n};\n/**\n * Type representing a serialized ZeroShotAgent in LangChain. It extends\n * the `SerializedAgentT` type and includes additional properties specific\n * to the ZeroShotAgent.\n */\nexport type SerializedZeroShotAgent = SerializedAgentT<\"zero-shot-react-description\", SerializedFromLLMAndTools, AgentInput>;\n/**\n * Type representing a serialized agent in LangChain. It is currently\n * synonymous with `SerializedZeroShotAgent`.\n */\nexport type SerializedAgent = SerializedZeroShotAgent;\n"],"mappings":";;;;;;;;;;;;AAYA;;;AAEkBS,UAFDD,UAAAA,CAECC;EAAuB,QAAA,EAD3BF,QAC2B;EAoBxBI,YAAAA,EApBCF,uBAoB4B,GAAA,SAAA;EAAA,YAAA,CAAA,EAAA,MAAA,EAAA;;;;;;;AAuB9C;;;;;AAAmF,UAvBlEE,6BAAAA,CAuBkE;EAMvEG,QAAAA,EA5BEd,QA4BY,CA5BHK,WA4BG,GAAA;IAMdU,gBAAgB,CAAA,EAAA,MAAA,GAjCQX,WAiCR,EAAA;IAAA,IAAA,CAAA,EAAA,MAAA,EAAA;EAAA,CAAA,EA/BrBF,WA+B0Ec,EAAAA,GA/B1Dd,WA+B0Dc,GA/B5Cb,WA+B4Ca,CAAAA;EAAM,cAAoBA,CAAAA,EAAAA,OAAAA;EAAM,cAA4CR,CAAAA,EAAAA,MAAAA;EAAU,IAAGA,CAAAA,EAAAA,MAAAA,EAAAA;;;;AAOtJ;AACpB;AAUA;;;AAAiHA,uBApCnFC,uBAAAA,SAAgCR,gBAoCmDO,CApClCN,WAoCkCM,GApCpBL,WAoCoBK,CAAAA,CAAAA;AAA3D;AAKtD;;;uBAnC8BK,4BAAAA,SAAqCZ,iBAAiBC,gBAAgBC;;;;;KAMxFW,cAAAA;;;;;;KAMAC,qEAAqEC,0BAA0BA,kDAAkDR,aAAaA;SAC/JS;cACKX;;;IAGZY;;IAEAC;KACQC,yBAAAA;;;;;;;;;;KAUAC,uBAAAA,GAA0BN,gDAAgDK,2BAA2BZ;;;;;KAKrGc,eAAAA,GAAkBD"}

package/dist/agents/xml/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","ToolInterface","BasePromptTemplate","AgentStep","AgentAction","AgentFinish","ChainValues","ChatPromptTemplate","CallbackManager","LLMChain","AgentArgs","AgentRunnableSequence","BaseSingleActionAgent","XMLAgentOutputParser","XMLAgentInput","XMLAgent","Promise","Pick","CreateXmlAgentParams","createXmlAgent","llm","tools","prompt","streamRunnable"],"sources":["../../../src/agents/xml/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep, AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { AgentArgs, AgentRunnableSequence, BaseSingleActionAgent } from \"../agent.js\";\nimport { XMLAgentOutputParser } from \"./output_parser.js\";\n/**\n * Interface for the input to the XMLAgent class.\n */\nexport interface XMLAgentInput {\n    tools: ToolInterface[];\n    llmChain: LLMChain;\n}\n/**\n * Class that represents an agent that uses XML tags.\n */\nexport declare class XMLAgent extends BaseSingleActionAgent implements XMLAgentInput {\n    static lc_name(): string;\n    lc_namespace: string[];\n    tools: ToolInterface[];\n    llmChain: LLMChain;\n    outputParser: XMLAgentOutputParser;\n    _agentType(): \"xml\";\n    constructor(fields: XMLAgentInput);\n    get inputKeys(): string[];\n    static createPrompt(): ChatPromptTemplate<any, any>;\n    /**\n     * Plans the next action or finish state of the agent based on the\n     * provided steps, inputs, and optional callback manager.\n     * @param steps The steps to consider in planning.\n     * @param inputs The inputs to consider in planning.\n     * @param callbackManager Optional CallbackManager to use in planning.\n     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n     */\n    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n    /**\n     * Creates an XMLAgent from a BaseLanguageModel and a list of tools.\n     * @param llm The BaseLanguageModel to use.\n     * @param tools The tools to be used by the agent.\n     * @param args Optional arguments for creating the agent.\n     * @returns An instance of XMLAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: XMLAgentInput & Pick<AgentArgs, \"callbacks\">): XMLAgent;\n}\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateXmlAgentParams = {\n    /** LLM to use for the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: ToolInterface[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools` and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses XML to format its logic.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createXmlAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/xml-agent-convo\n * const prompt = await pull<PromptTemplate>(\"hwchase17/xml-agent-convo\");\n *\n * const llm = new ChatAnthropic({\n *   temperature: 0,\n * });\n *\n * const agent = await createXmlAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   // Notice that chat_history is a string, since this prompt is aimed at LLMs, not chat models\n *   chat_history: \"Human: Hi! My name is Cob\\nAI: Hello Cob! Nice to meet you\",\n * });\n * ```\n */\nexport declare function createXmlAgent({ llm, tools, prompt, streamRunnable }: CreateXmlAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, AgentAction | AgentFinish>>;\n"],"mappings":";;;;;;;;;;;;;AAaA;;AACWC,UADMa,aAAAA,CACNb;EAAa,KACVQ,EADHR,aACGQ,EAAAA;EAAQ,QAAA,EAARA,QAAQ;AAKtB;;;;AAKkBI,cALGE,QAAAA,SAAiBH,qBAAAA,YAAiCE,aAKrDD,CAAAA;EAAoB,OAEdC,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAa,YAEVP,EAAAA,MAAAA,EAAAA;EAAkB,KAS7BJ,EAfLF,aAeKE,EAAAA;EAAS,QAAYG,EAdvBG,QAcuBH;EAAW,YAAoBE,EAblDK,oBAakDL;EAAe,UAAWJ,CAAAA,CAAAA,EAAAA,KAAAA;EAAW,WAAGC,CAAAA,MAAAA,EAXpFS,aAWoFT;EAAW,IAAjCW,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,OAQ7DhB,YAAAA,CAAAA,CAAAA,EAjBLO,kBAiBKP,CAAAA,GAAAA,EAAAA,GAAAA,CAAAA;EAA0B;;;;;;;AA1B0B;EA+BxEkB,IAAAA,CAAAA,KAAAA,EAbIf,SAaJe,EAAoB,EAAA,MAAA,EAbKZ,WAaL,EAAA,eAAA,CAAA,EAboCE,eAapC,CAAA,EAbsDQ,OAatD,CAb8DZ,WAa9D,GAb4EC,WAa5E,CAAA;EAAA;;;;AASF;AAyD9B;;EAAsC,OAAGe,eAAAA,CAAAA,GAAAA,EAvETpB,0BAuESoB,EAAAA,KAAAA,EAvE0BnB,aAuE1BmB,EAAAA,EAAAA,IAAAA,CAAAA,EAvEkDN,aAuElDM,GAvEkEH,IAuElEG,CAvEuEV,SAuEvEU,EAAAA,WAAAA,CAAAA,CAAAA,EAvEiGL,QAuEjGK;;;;;AAC9BjB,KAnECe,oBAAAA,GAmEDf;EAAS;EACN,GAAGE,EAlERL,0BAkEQK;EAAW;EAFuG,KAA7BW,EA9D3Ff,aA8D2Fe,EAAAA;EAAO;;;;UAzDjGd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDYiB,cAAAA;;;;;GAAuDD,uBAAuBF,QAAQL;SACnGR;GACRC,cAAcC"}

package/dist/agents/xml/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","ToolInterface","BasePromptTemplate","AgentStep","AgentAction","AgentFinish","ChainValues","ChatPromptTemplate","CallbackManager","LLMChain","AgentArgs","AgentRunnableSequence","BaseSingleActionAgent","XMLAgentOutputParser","XMLAgentInput","XMLAgent","Promise","Pick","CreateXmlAgentParams","createXmlAgent","llm","tools","prompt","streamRunnable"],"sources":["../../../src/agents/xml/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep, AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { AgentArgs, AgentRunnableSequence, BaseSingleActionAgent } from \"../agent.js\";\nimport { XMLAgentOutputParser } from \"./output_parser.js\";\n/**\n * Interface for the input to the XMLAgent class.\n */\nexport interface XMLAgentInput {\n    tools: ToolInterface[];\n    llmChain: LLMChain;\n}\n/**\n * Class that represents an agent that uses XML tags.\n */\nexport declare class XMLAgent extends BaseSingleActionAgent implements XMLAgentInput {\n    static lc_name(): string;\n    lc_namespace: string[];\n    tools: ToolInterface[];\n    llmChain: LLMChain;\n    outputParser: XMLAgentOutputParser;\n    _agentType(): \"xml\";\n    constructor(fields: XMLAgentInput);\n    get inputKeys(): string[];\n    static createPrompt(): ChatPromptTemplate<any, any>;\n    /**\n     * Plans the next action or finish state of the agent based on the\n     * provided steps, inputs, and optional callback manager.\n     * @param steps The steps to consider in planning.\n     * @param inputs The inputs to consider in planning.\n     * @param callbackManager Optional CallbackManager to use in planning.\n     * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n     */\n    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n    /**\n     * Creates an XMLAgent from a BaseLanguageModel and a list of tools.\n     * @param llm The BaseLanguageModel to use.\n     * @param tools The tools to be used by the agent.\n     * @param args Optional arguments for creating the agent.\n     * @returns An instance of XMLAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: XMLAgentInput & Pick<AgentArgs, \"callbacks\">): XMLAgent;\n}\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateXmlAgentParams = {\n    /** LLM to use for the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: ToolInterface[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools` and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses XML to format its logic.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createXmlAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/xml-agent-convo\n * const prompt = await pull<PromptTemplate>(\"hwchase17/xml-agent-convo\");\n *\n * const llm = new ChatAnthropic({\n *   temperature: 0,\n * });\n *\n * const agent = await createXmlAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   // Notice that chat_history is a string, since this prompt is aimed at LLMs, not chat models\n *   chat_history: \"Human: Hi! My name is Cob\\nAI: Hello Cob! Nice to meet you\",\n * });\n * ```\n */\nexport declare function createXmlAgent({ llm, tools, prompt, streamRunnable }: CreateXmlAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, AgentAction | AgentFinish>>;\n"],"mappings":";;;;;;;;;;;;;AAaA;;AACWC,UADMa,aAAAA,CACNb;EAAa,KACVQ,EADHR,aACGQ,EAAAA;EAAQ,QAAA,EAARA,QAAQ;AAKtB;;;;AAKkBI,cALGE,QAAAA,SAAiBH,qBAAAA,YAAiCE,aAKrDD,CAAAA;EAAoB,OAEdC,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAa,YAEVP,EAAAA,MAAAA,EAAAA;EAAkB,KAS7BJ,EAfLF,aAeKE,EAAAA;EAAS,QAAYG,EAdvBG,QAcuBH;EAAW,YAAoBE,EAblDK,oBAakDL;EAAe,UAAWJ,CAAAA,CAAAA,EAAAA,KAAAA;EAAW,WAAGC,CAAAA,MAAAA,EAXpFS,aAWoFT;EAAW,IAAjCW,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,OAQ7DhB,YAAAA,CAAAA,CAAAA,EAjBLO,kBAiBKP,CAAAA,GAAAA,EAAAA,GAAAA,CAAAA;EAA0B;;;;;;;AA1B0B;EA+BxEkB,IAAAA,CAAAA,KAAAA,EAbIf,SAaJe,EAAoB,EAAA,MAAA,EAbKZ,WAaL,EAAA,eAAA,CAAA,EAboCE,eAapC,CAAA,EAbsDQ,OAatD,CAb8DZ,WAa9D,GAb4EC,WAa5E,CAAA;EAAA;;;;AASF;AAyD9B;;EAAsC,OAAGe,eAAAA,CAAAA,GAAAA,EAvETpB,0BAuESoB,EAAAA,KAAAA,EAvE0BnB,aAuE1BmB,EAAAA,EAAAA,IAAAA,CAAAA,EAvEkDN,aAuElDM,GAvEkEH,IAuElEG,CAvEuEV,SAuEvEU,EAAAA,WAAAA,CAAAA,CAAAA,EAvEiGL,QAuEjGK;;;;;AAC9BjB,KAnECe,oBAAAA,GAmEDf;EAAS;EACN,GAAGE,EAlERL,0BAkEQK;EAAW;EAFuG,KAA7BW,EA9D3Ff,aA8D2Fe,EAAAA;EAAO;;;;UAzDjGd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDYiB,cAAAA;;;;;GAAuDD,uBAAuBF,QAAQL;SACnGR;GACRC,cAAcC"}

package/dist/agents/xml/output_parser.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","AgentActionOutputParser","XMLAgentOutputParser","Promise"],"sources":["../../../src/agents/xml/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   HumanMessagePromptTemplate.fromTemplate(AGENT_INSTRUCTIONS),\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n * const runnableAgent = RunnableSequence.from([\n *   ...rest of runnable\n *   prompt,\n *   new ChatAnthropic({ modelName: \"claude-2\", temperature: 0 }).withConfig({\n *     stop: [\"</tool_input>\", \"</final_answer>\"],\n *   }),\n *   new XMLAgentOutputParser(),\n * ]);\n * const result = await executor.invoke({\n *   input: \"What is the weather in Honolulu?\",\n *   tools: [],\n * });\n * ```\n */\nexport declare class XMLAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    /**\n     * Parses the output text from the agent and returns an AgentAction or\n     * AgentFinish object.\n     * @param text The output text from the agent.\n     * @returns An AgentAction or AgentFinish object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;;;AAuBA;;;;;;AAAyE;;;;;;;;;;;;;cAApDG,oBAAAA,SAA6BD,uBAAAA;;;;;;;;;uBASzBE,QAAQJ,cAAcC"}

package/dist/agents/xml/output_parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","AgentActionOutputParser","XMLAgentOutputParser","Promise"],"sources":["../../../src/agents/xml/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   HumanMessagePromptTemplate.fromTemplate(AGENT_INSTRUCTIONS),\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n * const runnableAgent = RunnableSequence.from([\n *   ...rest of runnable\n *   prompt,\n *   new ChatAnthropic({ modelName: \"claude-2\", temperature: 0 }).withConfig({\n *     stop: [\"</tool_input>\", \"</final_answer>\"],\n *   }),\n *   new XMLAgentOutputParser(),\n * ]);\n * const result = await executor.invoke({\n *   input: \"What is the weather in Honolulu?\",\n *   tools: [],\n * });\n * ```\n */\nexport declare class XMLAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    /**\n     * Parses the output text from the agent and returns an AgentAction or\n     * AgentFinish object.\n     * @param text The output text from the agent.\n     * @returns An AgentAction or AgentFinish object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;;;AAuBA;;;;;;AAAyE;;;;;;;;;;;;;cAApDG,oBAAAA,SAA6BD,uBAAAA;;;;;;;;;uBASzBE,QAAQJ,cAAcC"}

package/dist/cache/file_system.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file_system.d.cts","names":["BaseCache","Generation","LocalFileCache","Promise"],"sources":["../../src/cache/file_system.d.ts"],"sourcesContent":["import { BaseCache } from \"@langchain/core/caches\";\nimport { Generation } from \"@langchain/core/outputs\";\n/**\n * A cache that uses the local filesystem as the backing store.\n * This is useful for local development and testing. But it is not recommended for production use.\n */\nexport declare class LocalFileCache extends BaseCache {\n    private cacheDir;\n    private constructor();\n    /**\n     * Create a new cache backed by the local filesystem.\n     * It ensures that the cache directory exists before returning.\n     * @param cacheDir\n     */\n    static create(cacheDir?: string): Promise<LocalFileCache>;\n    /**\n     * Retrieves data from the cache. It constructs a cache key from the given\n     * `prompt` and `llmKey`, and retrieves the corresponding value from the\n     * cache files.\n     * @param prompt The prompt used to construct the cache key.\n     * @param llmKey The LLM key used to construct the cache key.\n     * @returns An array of Generations if found, null otherwise.\n     */\n    lookup(prompt: string, llmKey: string): Promise<any>;\n    /**\n     * Updates the cache with new data. It constructs a cache key from the\n     * given `prompt` and `llmKey`, and stores the `value` in a specific\n     * file in the cache directory.\n     * @param prompt The prompt used to construct the cache key.\n     * @param llmKey The LLM key used to construct the cache key.\n     * @param generations The value to be stored in the cache.\n     */\n    update(prompt: string, llmKey: string, generations: Generation[]): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA;;AAQ8CE,cARzBA,cAAAA,SAAuBF,SAAAA,CAQEE;EAAc,QAAtBC,QAAAA;EAAO,QASDA,WAAAA,CAAAA;EAAO;;;AAjBE;;oCAQfA,QAAQD;;;;;;;;;0CASFC;;;;;;;;;sDASYF,eAAeE"}

package/dist/cache/file_system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file_system.d.ts","names":["BaseCache","Generation","LocalFileCache","Promise"],"sources":["../../src/cache/file_system.d.ts"],"sourcesContent":["import { BaseCache } from \"@langchain/core/caches\";\nimport { Generation } from \"@langchain/core/outputs\";\n/**\n * A cache that uses the local filesystem as the backing store.\n * This is useful for local development and testing. But it is not recommended for production use.\n */\nexport declare class LocalFileCache extends BaseCache {\n    private cacheDir;\n    private constructor();\n    /**\n     * Create a new cache backed by the local filesystem.\n     * It ensures that the cache directory exists before returning.\n     * @param cacheDir\n     */\n    static create(cacheDir?: string): Promise<LocalFileCache>;\n    /**\n     * Retrieves data from the cache. It constructs a cache key from the given\n     * `prompt` and `llmKey`, and retrieves the corresponding value from the\n     * cache files.\n     * @param prompt The prompt used to construct the cache key.\n     * @param llmKey The LLM key used to construct the cache key.\n     * @returns An array of Generations if found, null otherwise.\n     */\n    lookup(prompt: string, llmKey: string): Promise<any>;\n    /**\n     * Updates the cache with new data. It constructs a cache key from the\n     * given `prompt` and `llmKey`, and stores the `value` in a specific\n     * file in the cache directory.\n     * @param prompt The prompt used to construct the cache key.\n     * @param llmKey The LLM key used to construct the cache key.\n     * @param generations The value to be stored in the cache.\n     */\n    update(prompt: string, llmKey: string, generations: Generation[]): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA;;AAQ8CE,cARzBA,cAAAA,SAAuBF,SAAAA,CAQEE;EAAc,QAAtBC,QAAAA;EAAO,QASDA,WAAAA,CAAAA;EAAO;;;AAjBE;;oCAQfA,QAAQD;;;;;;;;;0CASFC;;;;;;;;;sDASYF,eAAeE"}

package/dist/callbacks/handlers/console.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"console.d.cts","names":[],"sources":["../../../src/callbacks/handlers/console.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/console\";\n"],"mappings":""}

package/dist/callbacks/handlers/console.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"console.d.ts","names":[],"sources":["../../../src/callbacks/handlers/console.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/console\";\n"],"mappings":""}

package/dist/callbacks/handlers/run_collector.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run_collector.d.cts","names":[],"sources":["../../../src/callbacks/handlers/run_collector.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/run_collector\";\n"],"mappings":""}

package/dist/callbacks/handlers/run_collector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run_collector.d.ts","names":[],"sources":["../../../src/callbacks/handlers/run_collector.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/run_collector\";\n"],"mappings":""}

package/dist/callbacks/handlers/tracer.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer.d.cts","names":[],"sources":["../../../src/callbacks/handlers/tracer.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/base\";\n"],"mappings":""}

package/dist/callbacks/handlers/tracer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer.d.ts","names":[],"sources":["../../../src/callbacks/handlers/tracer.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/base\";\n"],"mappings":""}

package/dist/callbacks/handlers/tracer_langchain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer_langchain.d.cts","names":[],"sources":["../../../src/callbacks/handlers/tracer_langchain.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/tracer_langchain\";\n"],"mappings":""}

package/dist/callbacks/handlers/tracer_langchain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracer_langchain.d.ts","names":[],"sources":["../../../src/callbacks/handlers/tracer_langchain.d.ts"],"sourcesContent":["export * from \"@langchain/core/tracers/tracer_langchain\";\n"],"mappings":""}

package/dist/callbacks/promises.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promises.d.cts","names":[],"sources":["../../src/callbacks/promises.d.ts"],"sourcesContent":["export * from \"@langchain/core/callbacks/promises\";\n"],"mappings":""}

package/dist/callbacks/promises.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promises.d.ts","names":[],"sources":["../../src/callbacks/promises.d.ts"],"sourcesContent":["export * from \"@langchain/core/callbacks/promises\";\n"],"mappings":""}

package/dist/chains/analyze_documents_chain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze_documents_chain.d.cts","names":["ChainValues","CallbackManagerForChainRun","TextSplitter","BaseChain","ChainInputs","SerializedAnalyzeDocumentChain","LoadValues","Record","AnalyzeDocumentChainInput","Omit","AnalyzeDocumentChain","Promise"],"sources":["../../src/chains/analyze_documents_chain.d.ts"],"sourcesContent":["import { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { TextSplitter } from \"@langchain/textsplitters\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { SerializedAnalyzeDocumentChain } from \"./serde.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LoadValues = Record<string, any>;\n/**\n * Interface for the input parameters required by the AnalyzeDocumentChain\n * class.\n */\nexport interface AnalyzeDocumentChainInput extends Omit<ChainInputs, \"memory\"> {\n    combineDocumentsChain: BaseChain;\n    textSplitter?: TextSplitter;\n    inputKey?: string;\n}\n/**\n * Chain that combines documents by stuffing into context.\n * @augments BaseChain\n * @augments StuffDocumentsChainInput\n * @example\n * ```typescript\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 });\n * const combineDocsChain = loadSummarizationChain(model);\n * const chain = new AnalyzeDocumentChain({\n *   combineDocumentsChain: combineDocsChain,\n * });\n *\n * // Read the text from a file (this is a placeholder for actual file reading)\n * const text = readTextFromFile(\"state_of_the_union.txt\");\n *\n * // Invoke the chain to analyze the document\n * const res = await chain.call({\n *   input_document: text,\n * });\n *\n * console.log({ res });\n * ```\n */\nexport declare class AnalyzeDocumentChain extends BaseChain implements AnalyzeDocumentChainInput {\n    static lc_name(): string;\n    inputKey: string;\n    combineDocumentsChain: BaseChain;\n    textSplitter: TextSplitter;\n    constructor(fields: AnalyzeDocumentChainInput);\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"analyze_document_chain\";\n    static deserialize(data: SerializedAnalyzeDocumentChain, values: LoadValues): Promise<AnalyzeDocumentChain>;\n    serialize(): SerializedAnalyzeDocumentChain;\n}\n"],"mappings":";;;;;;;;KAMYM,UAAAA,GAAaC;AAAzB;AAKA;;;AAC2BJ,UADVK,yBAAAA,SAAkCC,IACxBN,CAD6BC,WAC7BD,EAAAA,QAAAA,CAAAA,CAAAA;EAAS,qBACjBD,EADQC,SACRD;EAAY,YAFoBO,CAAAA,EAEhCP,YAFgCO;EAAI,QAAA,CAAA,EAAA,MAAA;AA4BvD;;;;;;;;;;;;;;;;AAAgG;;;;;;;;cAA3EC,oBAAAA,SAA6BP,SAAAA,YAAqBK;;;yBAG5CL;gBACTD;sBACMM;;;;gBAINR,0BAA0BC,6BAA6BU,QAAQX;;2BAEpDK,wCAAwCC,aAAaK,QAAQD;eACzEL"}

package/dist/chains/analyze_documents_chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze_documents_chain.d.ts","names":["ChainValues","CallbackManagerForChainRun","TextSplitter","BaseChain","ChainInputs","SerializedAnalyzeDocumentChain","LoadValues","Record","AnalyzeDocumentChainInput","Omit","AnalyzeDocumentChain","Promise"],"sources":["../../src/chains/analyze_documents_chain.d.ts"],"sourcesContent":["import { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { TextSplitter } from \"@langchain/textsplitters\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { SerializedAnalyzeDocumentChain } from \"./serde.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LoadValues = Record<string, any>;\n/**\n * Interface for the input parameters required by the AnalyzeDocumentChain\n * class.\n */\nexport interface AnalyzeDocumentChainInput extends Omit<ChainInputs, \"memory\"> {\n    combineDocumentsChain: BaseChain;\n    textSplitter?: TextSplitter;\n    inputKey?: string;\n}\n/**\n * Chain that combines documents by stuffing into context.\n * @augments BaseChain\n * @augments StuffDocumentsChainInput\n * @example\n * ```typescript\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 });\n * const combineDocsChain = loadSummarizationChain(model);\n * const chain = new AnalyzeDocumentChain({\n *   combineDocumentsChain: combineDocsChain,\n * });\n *\n * // Read the text from a file (this is a placeholder for actual file reading)\n * const text = readTextFromFile(\"state_of_the_union.txt\");\n *\n * // Invoke the chain to analyze the document\n * const res = await chain.call({\n *   input_document: text,\n * });\n *\n * console.log({ res });\n * ```\n */\nexport declare class AnalyzeDocumentChain extends BaseChain implements AnalyzeDocumentChainInput {\n    static lc_name(): string;\n    inputKey: string;\n    combineDocumentsChain: BaseChain;\n    textSplitter: TextSplitter;\n    constructor(fields: AnalyzeDocumentChainInput);\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"analyze_document_chain\";\n    static deserialize(data: SerializedAnalyzeDocumentChain, values: LoadValues): Promise<AnalyzeDocumentChain>;\n    serialize(): SerializedAnalyzeDocumentChain;\n}\n"],"mappings":";;;;;;;;KAMYM,UAAAA,GAAaC;AAAzB;AAKA;;;AAC2BJ,UADVK,yBAAAA,SAAkCC,IACxBN,CAD6BC,WAC7BD,EAAAA,QAAAA,CAAAA,CAAAA;EAAS,qBACjBD,EADQC,SACRD;EAAY,YAFoBO,CAAAA,EAEhCP,YAFgCO;EAAI,QAAA,CAAA,EAAA,MAAA;AA4BvD;;;;;;;;;;;;;;;;AAAgG;;;;;;;;cAA3EC,oBAAAA,SAA6BP,SAAAA,YAAqBK;;;yBAG5CL;gBACTD;sBACMM;;;;gBAINR,0BAA0BC,6BAA6BU,QAAQX;;2BAEpDK,wCAAwCC,aAAaK,QAAQD;eACzEL"}

package/dist/chains/api/api_chain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api_chain.d.cts","names":["BaseLanguageModelInterface","ChainValues","CallbackManagerForChainRun","BasePromptTemplate","BaseChain","ChainInputs","SerializedAPIChain","LLMChain","APIChainInput","Record","Omit","APIChainOptions","APIChain","Promise"],"sources":["../../../src/chains/api/api_chain.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseChain, ChainInputs } from \"../base.js\";\nimport { SerializedAPIChain } from \"../serde.js\";\nimport { LLMChain } from \"../llm_chain.js\";\n/**\n * Interface that extends ChainInputs and defines additional input\n * parameters specific to an APIChain.\n */\nexport interface APIChainInput extends Omit<ChainInputs, \"memory\"> {\n    apiAnswerChain: LLMChain;\n    apiRequestChain: LLMChain;\n    apiDocs: string;\n    inputKey?: string;\n    headers?: Record<string, string>;\n    /** Key to use for output, defaults to `output` */\n    outputKey?: string;\n}\n/**\n * Type that defines optional configuration options for an APIChain.\n */\nexport type APIChainOptions = {\n    headers?: Record<string, string>;\n    apiUrlPrompt?: BasePromptTemplate;\n    apiResponsePrompt?: BasePromptTemplate;\n};\n/**\n * Class that extends BaseChain and represents a chain specifically\n * designed for making API requests and processing API responses.\n */\nexport declare class APIChain extends BaseChain implements APIChainInput {\n    apiAnswerChain: LLMChain;\n    apiRequestChain: LLMChain;\n    apiDocs: string;\n    headers: {};\n    inputKey: string;\n    outputKey: string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: APIChainInput);\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"api_chain\";\n    static deserialize(data: SerializedAPIChain): Promise<APIChain>;\n    serialize(): SerializedAPIChain;\n    /**\n     * Static method to create a new APIChain from a BaseLanguageModel and API\n     * documentation.\n     * @param llm BaseLanguageModel instance.\n     * @param apiDocs API documentation.\n     * @param options Optional configuration options for the APIChain.\n     * @returns New APIChain instance.\n     */\n    static fromLLMAndAPIDocs(llm: BaseLanguageModelInterface, apiDocs: string, options?: APIChainOptions & Omit<APIChainInput, \"apiAnswerChain\" | \"apiRequestChain\" | \"apiDocs\">): APIChain;\n}\n"],"mappings":";;;;;;;;;;;;AAWA;;AAA4CK,UAA3BG,aAAAA,SAAsBE,IAAKL,CAAAA,WAAAA,EAAAA,QAAAA,CAAAA,CAAAA;EAAW,cACnCE,EAAAA,QAAAA;EAAQ,eACPA,EAAAA,QAAAA;EAAQ,OAGfE,EAAAA,MAAAA;EAAM,QALmBC,CAAAA,EAAAA,MAAAA;EAAI,OAAA,CAAA,EAK7BD,MAL6B,CAAA,MAAA,EAAA,MAAA,CAAA;EAY/BE;EAAe,SAAA,CAAA,EAAA,MAAA;;;;AAGe;AAMrBC,KATTD,eAAAA,GASiB;EAAA,OAAA,CAAA,EARfF,MAQe,CAAA,MAAA,EAAA,MAAA,CAAA;EAAA,YACTF,CAAAA,EARDJ,kBAQCI;EAAQ,iBACPA,CAAAA,EARGJ,kBAQHI;CAAQ;;;;;AAWAD,cAbRM,QAAAA,SAAiBR,SAAAA,YAAqBI,aAa9BF,CAAAA;EAAkB,cAAWM,EAZtCL,QAYsCK;EAAQ,eAAhBC,EAX7BN,QAW6BM;EAAO,OACxCP,EAAAA,MAAAA;EAAkB,OASDN,EAAAA,CAAAA,CAAAA;EAA0B,QAA6BW,EAAAA,MAAAA;EAAe,SAAQH,EAAAA,MAAAA;EAAa,IAAlBE,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAI,IAAoEE,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAQ,WAvBrJR,CAAAA,MAAAA,EASdI,aATcJ;EAAS;EAAyB,KAAA,CAAA,MAAA,EAWtDH,WAXsD,EAAA,UAAA,CAAA,EAW5BC,0BAX4B,CAAA,EAWCW,OAXD,CAWSZ,WAXT,CAAA;;2BAa3CK,qBAAqBO,QAAQD;eACzCN;;;;;;;;;gCASiBN,uDAAuDW,kBAAkBD,KAAKF,mEAAmEI"}

package/dist/chains/api/api_chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api_chain.d.ts","names":["BaseLanguageModelInterface","ChainValues","CallbackManagerForChainRun","BasePromptTemplate","BaseChain","ChainInputs","SerializedAPIChain","LLMChain","APIChainInput","Record","Omit","APIChainOptions","APIChain","Promise"],"sources":["../../../src/chains/api/api_chain.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseChain, ChainInputs } from \"../base.js\";\nimport { SerializedAPIChain } from \"../serde.js\";\nimport { LLMChain } from \"../llm_chain.js\";\n/**\n * Interface that extends ChainInputs and defines additional input\n * parameters specific to an APIChain.\n */\nexport interface APIChainInput extends Omit<ChainInputs, \"memory\"> {\n    apiAnswerChain: LLMChain;\n    apiRequestChain: LLMChain;\n    apiDocs: string;\n    inputKey?: string;\n    headers?: Record<string, string>;\n    /** Key to use for output, defaults to `output` */\n    outputKey?: string;\n}\n/**\n * Type that defines optional configuration options for an APIChain.\n */\nexport type APIChainOptions = {\n    headers?: Record<string, string>;\n    apiUrlPrompt?: BasePromptTemplate;\n    apiResponsePrompt?: BasePromptTemplate;\n};\n/**\n * Class that extends BaseChain and represents a chain specifically\n * designed for making API requests and processing API responses.\n */\nexport declare class APIChain extends BaseChain implements APIChainInput {\n    apiAnswerChain: LLMChain;\n    apiRequestChain: LLMChain;\n    apiDocs: string;\n    headers: {};\n    inputKey: string;\n    outputKey: string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: APIChainInput);\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"api_chain\";\n    static deserialize(data: SerializedAPIChain): Promise<APIChain>;\n    serialize(): SerializedAPIChain;\n    /**\n     * Static method to create a new APIChain from a BaseLanguageModel and API\n     * documentation.\n     * @param llm BaseLanguageModel instance.\n     * @param apiDocs API documentation.\n     * @param options Optional configuration options for the APIChain.\n     * @returns New APIChain instance.\n     */\n    static fromLLMAndAPIDocs(llm: BaseLanguageModelInterface, apiDocs: string, options?: APIChainOptions & Omit<APIChainInput, \"apiAnswerChain\" | \"apiRequestChain\" | \"apiDocs\">): APIChain;\n}\n"],"mappings":";;;;;;;;;;;;AAWA;;AAA4CK,UAA3BG,aAAAA,SAAsBE,IAAKL,CAAAA,WAAAA,EAAAA,QAAAA,CAAAA,CAAAA;EAAW,cACnCE,EAAAA,QAAAA;EAAQ,eACPA,EAAAA,QAAAA;EAAQ,OAGfE,EAAAA,MAAAA;EAAM,QALmBC,CAAAA,EAAAA,MAAAA;EAAI,OAAA,CAAA,EAK7BD,MAL6B,CAAA,MAAA,EAAA,MAAA,CAAA;EAY/BE;EAAe,SAAA,CAAA,EAAA,MAAA;;;;AAGe;AAMrBC,KATTD,eAAAA,GASiB;EAAA,OAAA,CAAA,EARfF,MAQe,CAAA,MAAA,EAAA,MAAA,CAAA;EAAA,YACTF,CAAAA,EARDJ,kBAQCI;EAAQ,iBACPA,CAAAA,EARGJ,kBAQHI;CAAQ;;;;;AAWAD,cAbRM,QAAAA,SAAiBR,SAAAA,YAAqBI,aAa9BF,CAAAA;EAAkB,cAAWM,EAZtCL,QAYsCK;EAAQ,eAAhBC,EAX7BN,QAW6BM;EAAO,OACxCP,EAAAA,MAAAA;EAAkB,OASDN,EAAAA,CAAAA,CAAAA;EAA0B,QAA6BW,EAAAA,MAAAA;EAAe,SAAQH,EAAAA,MAAAA;EAAa,IAAlBE,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAI,IAAoEE,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAQ,WAvBrJR,CAAAA,MAAAA,EASdI,aATcJ;EAAS;EAAyB,KAAA,CAAA,MAAA,EAWtDH,WAXsD,EAAA,UAAA,CAAA,EAW5BC,0BAX4B,CAAA,EAWCW,OAXD,CAWSZ,WAXT,CAAA;;2BAa3CK,qBAAqBO,QAAQD;eACzCN;;;;;;;;;gCASiBN,uDAAuDW,kBAAkBD,KAAKF,mEAAmEI"}

package/dist/chains/base.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["BaseMemory","ChainValues","CallbackManagerForChainRun","CallbackManager","Callbacks","RunnableConfig","BaseLangChain","BaseLangChainParams","SerializedBaseChain","LoadValues","Record","ChainInputs","BaseChain","RunInput","RunOutput","Promise","AbortSignal"],"sources":["../../src/chains/base.d.ts"],"sourcesContent":["import { BaseMemory } from \"@langchain/core/memory\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun, CallbackManager, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { type RunnableConfig } from \"@langchain/core/runnables\";\nimport { BaseLangChain, BaseLangChainParams } from \"@langchain/core/language_models/base\";\nimport { SerializedBaseChain } from \"./serde.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LoadValues = Record<string, any>;\nexport interface ChainInputs extends BaseLangChainParams {\n    memory?: BaseMemory;\n    /**\n     * @deprecated Use `callbacks` instead\n     */\n    callbackManager?: CallbackManager;\n}\n/**\n * Base interface that all chains must implement.\n */\nexport declare abstract class BaseChain<RunInput extends ChainValues = ChainValues, RunOutput extends ChainValues = ChainValues> extends BaseLangChain<RunInput, RunOutput> implements ChainInputs {\n    memory?: BaseMemory;\n    get lc_namespace(): string[];\n    constructor(fields?: BaseMemory | ChainInputs, \n    /** @deprecated */\n    verbose?: boolean, \n    /** @deprecated */\n    callbacks?: Callbacks);\n    /** @ignore */\n    _selectMemoryInputs(values: ChainValues): ChainValues;\n    /**\n     * Invoke the chain with the provided input and returns the output.\n     * @param input Input values for the chain run.\n     * @param config Optional configuration for the Runnable.\n     * @returns Promise that resolves with the output of the chain run.\n     */\n    invoke(input: RunInput, options?: RunnableConfig): Promise<RunOutput>;\n    private _validateOutputs;\n    prepOutputs(inputs: Record<string, unknown>, outputs: Record<string, unknown>, returnOnlyOutputs?: boolean): Promise<Record<string, unknown>>;\n    /**\n     * Run the core logic of this chain and return the output\n     */\n    abstract _call(values: RunInput, runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<RunOutput>;\n    /**\n     * Return the string type key uniquely identifying this class of chain.\n     */\n    abstract _chainType(): string;\n    /**\n     * Return a json-like object representing this chain.\n     */\n    serialize(): SerializedBaseChain;\n    abstract get inputKeys(): string[];\n    abstract get outputKeys(): string[];\n    /** @deprecated Use .invoke() instead. Will be removed in 0.2.0. */\n    run(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    input: any, config?: Callbacks | RunnableConfig): Promise<string>;\n    protected _formatValues(values: ChainValues & {\n        signal?: AbortSignal;\n        timeout?: number;\n    }): Promise<ChainValues & {\n        signal?: AbortSignal | undefined;\n        timeout?: number | undefined;\n    }>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.\n     *\n     * Run the core logic of this chain and add to output if desired.\n     *\n     * Wraps _call and handles memory.\n     */\n    call(values: ChainValues & {\n        signal?: AbortSignal;\n        timeout?: number;\n    }, config?: Callbacks | RunnableConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<RunOutput>;\n    /**\n     * @deprecated Use .batch() instead. Will be removed in 0.2.0.\n     *\n     * Call the chain on all inputs in the list\n     */\n    apply(inputs: RunInput[], config?: (Callbacks | RunnableConfig)[]): Promise<RunOutput[]>;\n    /**\n     * Load a chain from a json-like object describing it.\n     */\n    static deserialize(data: SerializedBaseChain, values?: LoadValues): Promise<BaseChain>;\n}\n"],"mappings":";;;;;;;;;KAOYS,UAAAA,GAAaC;AAAbD,UACKE,WAAAA,SAAoBJ,mBADN,CAAA;EACdI,MAAAA,CAAAA,EACJX,UADe;EAAA;;;EAKS,eALAO,CAAAA,EAKfJ,eALeI;AAAmB;AAUxD;;;AAAuEN,uBAAzCW,SAAyCX,CAAAA,iBAAdA,WAAcA,GAAAA,WAAAA,EAAAA,kBAA+BA,WAA/BA,GAA6CA,WAA7CA,CAAAA,SAAkEK,aAAlEL,CAAgFY,QAAhFZ,EAA0Fa,SAA1Fb,CAAAA,YAAgHU,WAAhHV,CAAAA;EAAW,MAAoBA,CAAAA,EACzFD,UADyFC;EAAW,IAAGA,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAW,WAAwBY,CAAAA,MAAAA,CAAAA,EAG9Hb,UAH8Ha,GAGjHF,WAHiHE,EAAQ;EAAW,OAC7Jb,CAAAA,EAAAA,OAAAA,EAAU;EAEY,SAAGW,CAAAA,EAItBP,SAJsBO;EAAW;EAIxB,mBAEOV,CAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAcA,WAAdA;EAAW;;;;;;EASb,MAA4BS,CAAAA,KAAAA,EAFxCG,QAEwCH,EAAAA,OAAAA,CAAAA,EAFpBL,cAEoBK,CAAAA,EAFHK,OAEGL,CAFKI,SAELJ,CAAAA;EAAM,QAAyDA,gBAAAA;EAAM,WAAdK,CAAAA,MAAAA,EAAzFL,MAAyFK,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,EAAvDL,MAAuDK,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,iBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,CAAQL,MAARK,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA;EAAO;;;EAInB,SAAWD,KAAAA,CAAAA,MAAAA,EAArFD,QAAqFC,EAAAA,UAAAA,CAAAA,EAA9DZ,0BAA8DY,EAAAA,MAAAA,CAAAA,EAAzBT,cAAyBS,CAAAA,EAARC,OAAQD,CAAAA,SAAAA,CAAAA;EAAS;;;EAcvF,SAAGT,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAc;;;EAEvB,SAEZJ,CAAAA,CAAAA,EAVCO,mBAUDP;EAAW,aACVe,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAW,aADpBD,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO;EAWa,GACXC;EAAW;EAEH,KAAGX,EAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAlBHD,SAkBGC,GAlBSA,cAkBTA,CAAAA,EAlB0BU,OAkB1BV,CAAAA,MAAAA,CAAAA;EAAc,UAEZS,aAAAA,CAAAA,MAAAA,EAnBMb,WAmBNa,GAAAA;IAARC,MAAAA,CAAAA,EAlBLC,WAkBKD;IAMJF,OAAAA,CAAAA,EAAAA,MAAAA;EAAQ,CAAA,CAAA,EAtBlBE,OAsBgCX,CAtBxBH,WAsBwBG,GAAAA;IAAYC,MAAAA,CAAAA,EArBnCW,WAqBmCX,GAAAA,SAAAA;IAA4BS,OAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,CAAA,CAAA;EAAV;;;;;;AA9DmH;eAmDjLb;aACAe;;cAEDZ,YAAYC;oBAENU,QAAQD;;;;;;gBAMZD,sBAAsBT,YAAYC,oBAAoBU,QAAQD;;;;2BAInDN,8BAA8BC,aAAaM,QAAQH"}

package/dist/chains/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["BaseMemory","ChainValues","CallbackManagerForChainRun","CallbackManager","Callbacks","RunnableConfig","BaseLangChain","BaseLangChainParams","SerializedBaseChain","LoadValues","Record","ChainInputs","BaseChain","RunInput","RunOutput","Promise","AbortSignal"],"sources":["../../src/chains/base.d.ts"],"sourcesContent":["import { BaseMemory } from \"@langchain/core/memory\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun, CallbackManager, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { type RunnableConfig } from \"@langchain/core/runnables\";\nimport { BaseLangChain, BaseLangChainParams } from \"@langchain/core/language_models/base\";\nimport { SerializedBaseChain } from \"./serde.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LoadValues = Record<string, any>;\nexport interface ChainInputs extends BaseLangChainParams {\n    memory?: BaseMemory;\n    /**\n     * @deprecated Use `callbacks` instead\n     */\n    callbackManager?: CallbackManager;\n}\n/**\n * Base interface that all chains must implement.\n */\nexport declare abstract class BaseChain<RunInput extends ChainValues = ChainValues, RunOutput extends ChainValues = ChainValues> extends BaseLangChain<RunInput, RunOutput> implements ChainInputs {\n    memory?: BaseMemory;\n    get lc_namespace(): string[];\n    constructor(fields?: BaseMemory | ChainInputs, \n    /** @deprecated */\n    verbose?: boolean, \n    /** @deprecated */\n    callbacks?: Callbacks);\n    /** @ignore */\n    _selectMemoryInputs(values: ChainValues): ChainValues;\n    /**\n     * Invoke the chain with the provided input and returns the output.\n     * @param input Input values for the chain run.\n     * @param config Optional configuration for the Runnable.\n     * @returns Promise that resolves with the output of the chain run.\n     */\n    invoke(input: RunInput, options?: RunnableConfig): Promise<RunOutput>;\n    private _validateOutputs;\n    prepOutputs(inputs: Record<string, unknown>, outputs: Record<string, unknown>, returnOnlyOutputs?: boolean): Promise<Record<string, unknown>>;\n    /**\n     * Run the core logic of this chain and return the output\n     */\n    abstract _call(values: RunInput, runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<RunOutput>;\n    /**\n     * Return the string type key uniquely identifying this class of chain.\n     */\n    abstract _chainType(): string;\n    /**\n     * Return a json-like object representing this chain.\n     */\n    serialize(): SerializedBaseChain;\n    abstract get inputKeys(): string[];\n    abstract get outputKeys(): string[];\n    /** @deprecated Use .invoke() instead. Will be removed in 0.2.0. */\n    run(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    input: any, config?: Callbacks | RunnableConfig): Promise<string>;\n    protected _formatValues(values: ChainValues & {\n        signal?: AbortSignal;\n        timeout?: number;\n    }): Promise<ChainValues & {\n        signal?: AbortSignal | undefined;\n        timeout?: number | undefined;\n    }>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.\n     *\n     * Run the core logic of this chain and add to output if desired.\n     *\n     * Wraps _call and handles memory.\n     */\n    call(values: ChainValues & {\n        signal?: AbortSignal;\n        timeout?: number;\n    }, config?: Callbacks | RunnableConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<RunOutput>;\n    /**\n     * @deprecated Use .batch() instead. Will be removed in 0.2.0.\n     *\n     * Call the chain on all inputs in the list\n     */\n    apply(inputs: RunInput[], config?: (Callbacks | RunnableConfig)[]): Promise<RunOutput[]>;\n    /**\n     * Load a chain from a json-like object describing it.\n     */\n    static deserialize(data: SerializedBaseChain, values?: LoadValues): Promise<BaseChain>;\n}\n"],"mappings":";;;;;;;;;KAOYS,UAAAA,GAAaC;AAAbD,UACKE,WAAAA,SAAoBJ,mBADN,CAAA;EACdI,MAAAA,CAAAA,EACJX,UADe;EAAA;;;EAKS,eALAO,CAAAA,EAKfJ,eALeI;AAAmB;AAUxD;;;AAAuEN,uBAAzCW,SAAyCX,CAAAA,iBAAdA,WAAcA,GAAAA,WAAAA,EAAAA,kBAA+BA,WAA/BA,GAA6CA,WAA7CA,CAAAA,SAAkEK,aAAlEL,CAAgFY,QAAhFZ,EAA0Fa,SAA1Fb,CAAAA,YAAgHU,WAAhHV,CAAAA;EAAW,MAAoBA,CAAAA,EACzFD,UADyFC;EAAW,IAAGA,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAW,WAAwBY,CAAAA,MAAAA,CAAAA,EAG9Hb,UAH8Ha,GAGjHF,WAHiHE,EAAQ;EAAW,OAC7Jb,CAAAA,EAAAA,OAAAA,EAAU;EAEY,SAAGW,CAAAA,EAItBP,SAJsBO;EAAW;EAIxB,mBAEOV,CAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAcA,WAAdA;EAAW;;;;;;EASb,MAA4BS,CAAAA,KAAAA,EAFxCG,QAEwCH,EAAAA,OAAAA,CAAAA,EAFpBL,cAEoBK,CAAAA,EAFHK,OAEGL,CAFKI,SAELJ,CAAAA;EAAM,QAAyDA,gBAAAA;EAAM,WAAdK,CAAAA,MAAAA,EAAzFL,MAAyFK,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,EAAvDL,MAAuDK,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,EAAAA,iBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,CAAQL,MAARK,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA;EAAO;;;EAInB,SAAWD,KAAAA,CAAAA,MAAAA,EAArFD,QAAqFC,EAAAA,UAAAA,CAAAA,EAA9DZ,0BAA8DY,EAAAA,MAAAA,CAAAA,EAAzBT,cAAyBS,CAAAA,EAARC,OAAQD,CAAAA,SAAAA,CAAAA;EAAS;;;EAcvF,SAAGT,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAc;;;EAEvB,SAEZJ,CAAAA,CAAAA,EAVCO,mBAUDP;EAAW,aACVe,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAW,aADpBD,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO;EAWa,GACXC;EAAW;EAEH,KAAGX,EAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAlBHD,SAkBGC,GAlBSA,cAkBTA,CAAAA,EAlB0BU,OAkB1BV,CAAAA,MAAAA,CAAAA;EAAc,UAEZS,aAAAA,CAAAA,MAAAA,EAnBMb,WAmBNa,GAAAA;IAARC,MAAAA,CAAAA,EAlBLC,WAkBKD;IAMJF,OAAAA,CAAAA,EAAAA,MAAAA;EAAQ,CAAA,CAAA,EAtBlBE,OAsBgCX,CAtBxBH,WAsBwBG,GAAAA;IAAYC,MAAAA,CAAAA,EArBnCW,WAqBmCX,GAAAA,SAAAA;IAA4BS,OAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,CAAA,CAAA;EAAV;;;;;;AA9DmH;eAmDjLb;aACAe;;cAEDZ,YAAYC;oBAENU,QAAQD;;;;;;gBAMZD,sBAAsBT,YAAYC,oBAAoBU,QAAQD;;;;2BAInDN,8BAA8BC,aAAaM,QAAQH"}

package/dist/chains/chat_vector_db_chain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat_vector_db_chain.d.cts","names":["BaseLanguageModelInterface","VectorStoreInterface","ChainValues","CallbackManagerForChainRun","SerializedChatVectorDBQAChain","BaseChain","ChainInputs","LLMChain","LoadValues","Record","ChatVectorDBQAChainInput","ChatVectorDBQAChain","Promise"],"sources":["../../src/chains/chat_vector_db_chain.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { SerializedChatVectorDBQAChain } from \"./serde.js\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { LLMChain } from \"./llm_chain.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LoadValues = Record<string, any>;\n/**\n * Interface for the input parameters of the ChatVectorDBQAChain class.\n */\nexport interface ChatVectorDBQAChainInput extends ChainInputs {\n    vectorstore: VectorStoreInterface;\n    combineDocumentsChain: BaseChain;\n    questionGeneratorChain: LLMChain;\n    returnSourceDocuments?: boolean;\n    outputKey?: string;\n    inputKey?: string;\n    k?: number;\n}\n/** @deprecated use `ConversationalRetrievalQAChain` instead. */\nexport declare class ChatVectorDBQAChain extends BaseChain implements ChatVectorDBQAChainInput {\n    k: number;\n    inputKey: string;\n    chatHistoryKey: string;\n    get inputKeys(): string[];\n    outputKey: string;\n    get outputKeys(): string[];\n    vectorstore: VectorStoreInterface;\n    combineDocumentsChain: BaseChain;\n    questionGeneratorChain: LLMChain;\n    returnSourceDocuments: boolean;\n    constructor(fields: ChatVectorDBQAChainInput);\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"chat-vector-db\";\n    static deserialize(data: SerializedChatVectorDBQAChain, values: LoadValues): Promise<ChatVectorDBQAChain>;\n    serialize(): SerializedChatVectorDBQAChain;\n    /**\n     * Creates an instance of ChatVectorDBQAChain using a BaseLanguageModel\n     * and other options.\n     * @param llm Instance of BaseLanguageModel used to generate a new question.\n     * @param vectorstore Instance of VectorStore used for vector operations.\n     * @param options (Optional) Additional options for creating the ChatVectorDBQAChain instance.\n     * @returns New instance of ChatVectorDBQAChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, vectorstore: VectorStoreInterface, options?: {\n        inputKey?: string;\n        outputKey?: string;\n        k?: number;\n        returnSourceDocuments?: boolean;\n        questionGeneratorTemplate?: string;\n        qaTemplate?: string;\n        verbose?: boolean;\n    }): ChatVectorDBQAChain;\n}\n"],"mappings":";;;;;;;;;;KAQYQ,UAAAA,GAAaC;AAAzB;AAIA;;AACiBR,UADAS,wBAAAA,SAAiCJ,WACjCL,CAAAA;EAAoB,WACVI,EADVJ,oBACUI;EAAS,qBACRE,EADDF,SACCE;EAAQ,sBAHcD,EAGtBC,QAHsBD;EAAW,qBAAA,CAAA,EAAA,OAAA;EAUxCK,SAAAA,CAAAA,EAAAA,MAAAA;EAAmB,QAAA,CAAA,EAAA,MAAA;EAAA,CAAA,CAAA,EAOvBV,MAAAA;;;AAIOS,cAXHC,mBAAAA,SAA4BN,SAAAA,YAAqBK,wBAW9CA,CAAAA;EAAwB,CAAA,EAE9BR,MAAAA;EAAW,QAAeC,EAAAA,MAAAA;EAA0B,cAAWD,EAAAA,MAAAA;EAAW,IAAnBU,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,SAEnDR,EAAAA,MAAAA;EAA6B,IAAUI,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAU,WAAWG,EARxEV,oBAQwEU;EAAmB,qBAA3BC,EAPtDP,SAOsDO;EAAO,sBACvER,EAPWG,QAOXH;EAA6B,qBAStBJ,EAAAA,OAAAA;EAA0B,WAAeC,CAAAA,MAAAA,EAdzCS,wBAcyCT;EAAoB;EAQ1D,KAjCsBI,CAAAA,MAAAA,EAa/BH,WAb+BG,EAAAA,UAAAA,CAAAA,EAaLF,0BAbKE,CAAAA,EAawBO,OAbxBP,CAagCH,WAbhCG,CAAAA;EAAS,UAAYK,CAAAA,CAAAA,EAAAA,gBAAAA;EAAwB,OAAA,WAAA,CAAA,IAAA,EAejEN,6BAfiE,EAAA,MAAA,EAe1BI,UAf0B,CAAA,EAebI,OAfa,CAeLD,mBAfK,CAAA;eAgB7EP;;;;;;;;;sBASOJ,yCAAyCC;;;;;;;;MAQzDU"}

package/dist/chains/chat_vector_db_chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat_vector_db_chain.d.ts","names":["BaseLanguageModelInterface","VectorStoreInterface","ChainValues","CallbackManagerForChainRun","SerializedChatVectorDBQAChain","BaseChain","ChainInputs","LLMChain","LoadValues","Record","ChatVectorDBQAChainInput","ChatVectorDBQAChain","Promise"],"sources":["../../src/chains/chat_vector_db_chain.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { SerializedChatVectorDBQAChain } from \"./serde.js\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { LLMChain } from \"./llm_chain.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LoadValues = Record<string, any>;\n/**\n * Interface for the input parameters of the ChatVectorDBQAChain class.\n */\nexport interface ChatVectorDBQAChainInput extends ChainInputs {\n    vectorstore: VectorStoreInterface;\n    combineDocumentsChain: BaseChain;\n    questionGeneratorChain: LLMChain;\n    returnSourceDocuments?: boolean;\n    outputKey?: string;\n    inputKey?: string;\n    k?: number;\n}\n/** @deprecated use `ConversationalRetrievalQAChain` instead. */\nexport declare class ChatVectorDBQAChain extends BaseChain implements ChatVectorDBQAChainInput {\n    k: number;\n    inputKey: string;\n    chatHistoryKey: string;\n    get inputKeys(): string[];\n    outputKey: string;\n    get outputKeys(): string[];\n    vectorstore: VectorStoreInterface;\n    combineDocumentsChain: BaseChain;\n    questionGeneratorChain: LLMChain;\n    returnSourceDocuments: boolean;\n    constructor(fields: ChatVectorDBQAChainInput);\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"chat-vector-db\";\n    static deserialize(data: SerializedChatVectorDBQAChain, values: LoadValues): Promise<ChatVectorDBQAChain>;\n    serialize(): SerializedChatVectorDBQAChain;\n    /**\n     * Creates an instance of ChatVectorDBQAChain using a BaseLanguageModel\n     * and other options.\n     * @param llm Instance of BaseLanguageModel used to generate a new question.\n     * @param vectorstore Instance of VectorStore used for vector operations.\n     * @param options (Optional) Additional options for creating the ChatVectorDBQAChain instance.\n     * @returns New instance of ChatVectorDBQAChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, vectorstore: VectorStoreInterface, options?: {\n        inputKey?: string;\n        outputKey?: string;\n        k?: number;\n        returnSourceDocuments?: boolean;\n        questionGeneratorTemplate?: string;\n        qaTemplate?: string;\n        verbose?: boolean;\n    }): ChatVectorDBQAChain;\n}\n"],"mappings":";;;;;;;;;;KAQYQ,UAAAA,GAAaC;AAAzB;AAIA;;AACiBR,UADAS,wBAAAA,SAAiCJ,WACjCL,CAAAA;EAAoB,WACVI,EADVJ,oBACUI;EAAS,qBACRE,EADDF,SACCE;EAAQ,sBAHcD,EAGtBC,QAHsBD;EAAW,qBAAA,CAAA,EAAA,OAAA;EAUxCK,SAAAA,CAAAA,EAAAA,MAAAA;EAAmB,QAAA,CAAA,EAAA,MAAA;EAAA,CAAA,CAAA,EAOvBV,MAAAA;;;AAIOS,cAXHC,mBAAAA,SAA4BN,SAAAA,YAAqBK,wBAW9CA,CAAAA;EAAwB,CAAA,EAE9BR,MAAAA;EAAW,QAAeC,EAAAA,MAAAA;EAA0B,cAAWD,EAAAA,MAAAA;EAAW,IAAnBU,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,SAEnDR,EAAAA,MAAAA;EAA6B,IAAUI,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAU,WAAWG,EARxEV,oBAQwEU;EAAmB,qBAA3BC,EAPtDP,SAOsDO;EAAO,sBACvER,EAPWG,QAOXH;EAA6B,qBAStBJ,EAAAA,OAAAA;EAA0B,WAAeC,CAAAA,MAAAA,EAdzCS,wBAcyCT;EAAoB;EAQ1D,KAjCsBI,CAAAA,MAAAA,EAa/BH,WAb+BG,EAAAA,UAAAA,CAAAA,EAaLF,0BAbKE,CAAAA,EAawBO,OAbxBP,CAagCH,WAbhCG,CAAAA;EAAS,UAAYK,CAAAA,CAAAA,EAAAA,gBAAAA;EAAwB,OAAA,WAAA,CAAA,IAAA,EAejEN,6BAfiE,EAAA,MAAA,EAe1BI,UAf0B,CAAA,EAebI,OAfa,CAeLD,mBAfK,CAAA;eAgB7EP;;;;;;;;;sBASOJ,yCAAyCC;;;;;;;;MAQzDU"}

package/dist/chains/combine_docs_chain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"combine_docs_chain.d.cts","names":["Document","ChainValues","CallbackManagerForChainRun","BasePromptTemplate","SerializedStuffDocumentsChain","SerializedMapReduceDocumentsChain","SerializedRefineDocumentsChain","BaseChain","ChainInputs","LLMChain","StuffDocumentsChainInput","StuffDocumentsChain","Promise","MapReduceDocumentsChainInput","MapReduceDocumentsChain","RefineDocumentsChainInput","RefineDocumentsChain","_________langchain_core_dist_prompt_values_js0","BasePromptValueInterface","Record"],"sources":["../../src/chains/combine_docs_chain.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { SerializedStuffDocumentsChain, SerializedMapReduceDocumentsChain, SerializedRefineDocumentsChain } from \"./serde.js\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { LLMChain } from \"./llm_chain.js\";\n/**\n * Interface for the input properties of the StuffDocumentsChain class.\n */\nexport interface StuffDocumentsChainInput extends ChainInputs {\n    /** LLM Wrapper to use after formatting documents */\n    llmChain: LLMChain;\n    inputKey?: string;\n    /** Variable name in the LLM chain to put the documents in */\n    documentVariableName?: string;\n}\n/**\n * Chain that combines documents by stuffing into context.\n * @augments BaseChain\n * @augments StuffDocumentsChainInput\n */\nexport declare class StuffDocumentsChain extends BaseChain implements StuffDocumentsChainInput {\n    static lc_name(): string;\n    llmChain: LLMChain;\n    inputKey: string;\n    documentVariableName: string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: StuffDocumentsChainInput);\n    /** @ignore */\n    _prepInputs(values: ChainValues): ChainValues;\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"stuff_documents_chain\";\n    static deserialize(data: SerializedStuffDocumentsChain): Promise<StuffDocumentsChain>;\n    serialize(): SerializedStuffDocumentsChain;\n}\n/**\n * Interface for the input properties of the MapReduceDocumentsChain\n * class.\n */\nexport interface MapReduceDocumentsChainInput extends StuffDocumentsChainInput {\n    /** The maximum number of tokens before requiring to do the reduction */\n    maxTokens?: number;\n    /** The maximum number of iterations to run through the map */\n    maxIterations?: number;\n    /** Ensures that the map step is taken regardless of max tokens */\n    ensureMapStep?: boolean;\n    /** Chain to use to combine results of applying llm_chain to documents. */\n    combineDocumentChain: StuffDocumentsChain;\n    /** Return the results of the map steps in the output. */\n    returnIntermediateSteps?: boolean;\n}\n/**\n * Combine documents by mapping a chain over them, then combining results.\n * @augments BaseChain\n * @augments StuffDocumentsChainInput\n */\nexport declare class MapReduceDocumentsChain extends BaseChain implements MapReduceDocumentsChainInput {\n    static lc_name(): string;\n    llmChain: LLMChain;\n    inputKey: string;\n    documentVariableName: string;\n    returnIntermediateSteps: boolean;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    maxTokens: number;\n    maxIterations: number;\n    ensureMapStep: boolean;\n    combineDocumentChain: StuffDocumentsChain;\n    constructor(fields: MapReduceDocumentsChainInput);\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"map_reduce_documents_chain\";\n    static deserialize(data: SerializedMapReduceDocumentsChain): Promise<MapReduceDocumentsChain>;\n    serialize(): SerializedMapReduceDocumentsChain;\n}\n/**\n * Interface for the input properties of the RefineDocumentsChain class.\n */\nexport interface RefineDocumentsChainInput extends StuffDocumentsChainInput {\n    refineLLMChain: LLMChain;\n    documentPrompt?: BasePromptTemplate;\n    initialResponseName?: string;\n    documentVariableName?: string;\n    outputKey?: string;\n}\n/**\n * Combine documents by doing a first pass and then refining on more documents.\n * @augments BaseChain\n * @augments RefineDocumentsChainInput\n */\nexport declare class RefineDocumentsChain extends BaseChain implements RefineDocumentsChainInput {\n    static lc_name(): string;\n    llmChain: LLMChain;\n    inputKey: string;\n    outputKey: string;\n    documentVariableName: string;\n    initialResponseName: string;\n    refineLLMChain: LLMChain;\n    get defaultDocumentPrompt(): BasePromptTemplate;\n    documentPrompt: BasePromptTemplate<any, import(\"../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: RefineDocumentsChainInput);\n    /** @ignore */\n    _constructInitialInputs(doc: Document, rest: Record<string, unknown>): Promise<{\n        [x: string]: unknown;\n    }>;\n    /** @ignore */\n    _constructRefineInputs(doc: Document, res: string): Promise<{\n        [x: string]: unknown;\n    }>;\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"refine_documents_chain\";\n    static deserialize(data: SerializedRefineDocumentsChain): Promise<RefineDocumentsChain>;\n    serialize(): SerializedRefineDocumentsChain;\n}\n"],"mappings":";;;;;;;;;;;;;AAUiBU,UAAAA,wBAAAA,SAAiCF,WAAT,CAAA;EAAA;EAAA,QAE3BC,EAAAA,QAAAA;EAAQ,QAF4BD,CAAAA,EAAAA,MAAAA;EAAW;EAYxCG,oBAAAA,CAAAA,EAAmB,MAAA;;;;;;;AAWIT,cAXvBS,mBAAAA,SAA4BJ,SAAAA,YAAqBG,wBAW1BR,CAAAA;EAA0B,OAAWD,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,QAAnBW,EAT3DH,QAS2DG;EAAO,QAEnDR,EAAAA,MAAAA;EAA6B,oBAAWO,EAAAA,MAAAA;EAAmB,IAA3BC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,IACnDR,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA6B,WAdGG,CAAAA,MAAAA,EAOzBG,wBAPyBH;EAAS;EAAoC,WAAA,CAAA,MAAA,EAStEN,WATsE,CAAA,EASxDA,WATwD;EAoB7EY;EAA4B,KAAA,CAAA,MAAA,EAT3BZ,WAS2B,EAAA,UAAA,CAAA,EATDC,0BASC,CAAA,EAT4BU,OAS5B,CAToCX,WASpC,CAAA;EAAA,UAQnBU,CAAAA,CAAAA,EAAAA,uBAAAA;EAAmB,OARSD,WAAAA,CAAAA,IAAAA,EAPzBN,6BAOyBM,CAAAA,EAPOE,OAOPF,CAPeC,mBAOfD,CAAAA;EAAwB,SAAA,CAAA,CAAA,EAN7DN,6BAM6D;AAiB9E;;;;;AAckBH,UA/BDY,4BAAAA,SAAqCH,wBA+BpCT,CAAAA;EAAW;EAAyC,SAAWA,CAAAA,EAAAA,MAAAA;EAAW;EAAZ,aAEnDI,CAAAA,EAAAA,MAAAA;EAAiC;EAAkC,aAA/BO,CAAAA,EAAAA,OAAAA;EAAO;EACtB,oBAjBGL,EAT3BI,mBAS2BJ;EAAS;EAAwC,uBAAA,CAAA,EAAA,OAAA;AAsBtG;;;;;AAA2E;AAYtDS,cAlCAF,uBAAAA,SAAgCP,SAAAA,YAAqBM,4BAkCjC,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,QAE3BJ,EAlCAA,QAkCAA;EAAQ,QAKFA,EAAAA,MAAAA;EAAQ,oBACKN,EAAAA,MAAAA;EAAkB,uBAAA,EAAA,OAAA;EACyE,IAAxGA,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkB,IAGdY,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAyB,SAEhBf,EAAAA,MAAAA;EAAQ,aAAQmB,EAAAA,MAAAA;EAAM,aAAoBP,EAAAA,OAAAA;EAAO,oBAIlDZ,EAzCNW,mBAyCMX;EAAQ,WAAgBY,CAAAA,MAAAA,EAxChCC,4BAwCgCD;EAAO;EAIlC,KAAeV,CAAAA,MAAAA,EA1C1BD,WA0C0BC,EAAAA,UAAAA,CAAAA,EA1CAA,0BA0CAA,CAAAA,EA1C6BU,OA0C7BV,CA1CqCD,WA0CrCC,CAAAA;EAA0B,UAAWD,CAAAA,CAAAA,EAAAA,4BAAAA;EAAW,OAAnBW,WAAAA,CAAAA,IAAAA,EAxC5CP,iCAwC4CO,CAAAA,EAxCRA,OAwCQA,CAxCAE,uBAwCAF,CAAAA;EAAO,SAEnDN,CAAAA,CAAAA,EAzCZD,iCAyCYC;;;;;AAxB0CS,UAZtDA,yBAAAA,SAAkCL,wBAYoBK,CAAAA;EAAyB,cAAA,EAX5EN,QAW4E;mBAV3EN;;;;;;;;;;cAUAa,oBAAAA,SAA6BT,SAAAA,YAAqBQ;;YAEzDN;;;;;kBAKMA;+BACaN;kBACbA,wBAD+B,wBAAA;;;sBAI3BY;;+BAESf,gBAAgBmB,0BAA0BP;;;;8BAI3CZ,wBAAwBY;;;;gBAItCX,0BAA0BC,6BAA6BU,QAAQX;;2BAEpDK,iCAAiCM,QAAQI;eACrDV"}

package/dist/chains/combine_docs_chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"combine_docs_chain.d.ts","names":["Document","ChainValues","CallbackManagerForChainRun","BasePromptTemplate","SerializedStuffDocumentsChain","SerializedMapReduceDocumentsChain","SerializedRefineDocumentsChain","BaseChain","ChainInputs","LLMChain","StuffDocumentsChainInput","StuffDocumentsChain","Promise","MapReduceDocumentsChainInput","MapReduceDocumentsChain","RefineDocumentsChainInput","RefineDocumentsChain","_________langchain_core_dist_prompt_values_js0","BasePromptValueInterface","Record"],"sources":["../../src/chains/combine_docs_chain.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { SerializedStuffDocumentsChain, SerializedMapReduceDocumentsChain, SerializedRefineDocumentsChain } from \"./serde.js\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { LLMChain } from \"./llm_chain.js\";\n/**\n * Interface for the input properties of the StuffDocumentsChain class.\n */\nexport interface StuffDocumentsChainInput extends ChainInputs {\n    /** LLM Wrapper to use after formatting documents */\n    llmChain: LLMChain;\n    inputKey?: string;\n    /** Variable name in the LLM chain to put the documents in */\n    documentVariableName?: string;\n}\n/**\n * Chain that combines documents by stuffing into context.\n * @augments BaseChain\n * @augments StuffDocumentsChainInput\n */\nexport declare class StuffDocumentsChain extends BaseChain implements StuffDocumentsChainInput {\n    static lc_name(): string;\n    llmChain: LLMChain;\n    inputKey: string;\n    documentVariableName: string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: StuffDocumentsChainInput);\n    /** @ignore */\n    _prepInputs(values: ChainValues): ChainValues;\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"stuff_documents_chain\";\n    static deserialize(data: SerializedStuffDocumentsChain): Promise<StuffDocumentsChain>;\n    serialize(): SerializedStuffDocumentsChain;\n}\n/**\n * Interface for the input properties of the MapReduceDocumentsChain\n * class.\n */\nexport interface MapReduceDocumentsChainInput extends StuffDocumentsChainInput {\n    /** The maximum number of tokens before requiring to do the reduction */\n    maxTokens?: number;\n    /** The maximum number of iterations to run through the map */\n    maxIterations?: number;\n    /** Ensures that the map step is taken regardless of max tokens */\n    ensureMapStep?: boolean;\n    /** Chain to use to combine results of applying llm_chain to documents. */\n    combineDocumentChain: StuffDocumentsChain;\n    /** Return the results of the map steps in the output. */\n    returnIntermediateSteps?: boolean;\n}\n/**\n * Combine documents by mapping a chain over them, then combining results.\n * @augments BaseChain\n * @augments StuffDocumentsChainInput\n */\nexport declare class MapReduceDocumentsChain extends BaseChain implements MapReduceDocumentsChainInput {\n    static lc_name(): string;\n    llmChain: LLMChain;\n    inputKey: string;\n    documentVariableName: string;\n    returnIntermediateSteps: boolean;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    maxTokens: number;\n    maxIterations: number;\n    ensureMapStep: boolean;\n    combineDocumentChain: StuffDocumentsChain;\n    constructor(fields: MapReduceDocumentsChainInput);\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"map_reduce_documents_chain\";\n    static deserialize(data: SerializedMapReduceDocumentsChain): Promise<MapReduceDocumentsChain>;\n    serialize(): SerializedMapReduceDocumentsChain;\n}\n/**\n * Interface for the input properties of the RefineDocumentsChain class.\n */\nexport interface RefineDocumentsChainInput extends StuffDocumentsChainInput {\n    refineLLMChain: LLMChain;\n    documentPrompt?: BasePromptTemplate;\n    initialResponseName?: string;\n    documentVariableName?: string;\n    outputKey?: string;\n}\n/**\n * Combine documents by doing a first pass and then refining on more documents.\n * @augments BaseChain\n * @augments RefineDocumentsChainInput\n */\nexport declare class RefineDocumentsChain extends BaseChain implements RefineDocumentsChainInput {\n    static lc_name(): string;\n    llmChain: LLMChain;\n    inputKey: string;\n    outputKey: string;\n    documentVariableName: string;\n    initialResponseName: string;\n    refineLLMChain: LLMChain;\n    get defaultDocumentPrompt(): BasePromptTemplate;\n    documentPrompt: BasePromptTemplate<any, import(\"../../../langchain-core/dist/prompt_values.js\").BasePromptValueInterface, any>;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: RefineDocumentsChainInput);\n    /** @ignore */\n    _constructInitialInputs(doc: Document, rest: Record<string, unknown>): Promise<{\n        [x: string]: unknown;\n    }>;\n    /** @ignore */\n    _constructRefineInputs(doc: Document, res: string): Promise<{\n        [x: string]: unknown;\n    }>;\n    /** @ignore */\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    _chainType(): \"refine_documents_chain\";\n    static deserialize(data: SerializedRefineDocumentsChain): Promise<RefineDocumentsChain>;\n    serialize(): SerializedRefineDocumentsChain;\n}\n"],"mappings":";;;;;;;;;;;;;AAUiBU,UAAAA,wBAAAA,SAAiCF,WAAT,CAAA;EAAA;EAAA,QAE3BC,EAAAA,QAAAA;EAAQ,QAF4BD,CAAAA,EAAAA,MAAAA;EAAW;EAYxCG,oBAAAA,CAAAA,EAAmB,MAAA;;;;;;;AAWIT,cAXvBS,mBAAAA,SAA4BJ,SAAAA,YAAqBG,wBAW1BR,CAAAA;EAA0B,OAAWD,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,QAAnBW,EAT3DH,QAS2DG;EAAO,QAEnDR,EAAAA,MAAAA;EAA6B,oBAAWO,EAAAA,MAAAA;EAAmB,IAA3BC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,IACnDR,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA6B,WAdGG,CAAAA,MAAAA,EAOzBG,wBAPyBH;EAAS;EAAoC,WAAA,CAAA,MAAA,EAStEN,WATsE,CAAA,EASxDA,WATwD;EAoB7EY;EAA4B,KAAA,CAAA,MAAA,EAT3BZ,WAS2B,EAAA,UAAA,CAAA,EATDC,0BASC,CAAA,EAT4BU,OAS5B,CAToCX,WASpC,CAAA;EAAA,UAQnBU,CAAAA,CAAAA,EAAAA,uBAAAA;EAAmB,OARSD,WAAAA,CAAAA,IAAAA,EAPzBN,6BAOyBM,CAAAA,EAPOE,OAOPF,CAPeC,mBAOfD,CAAAA;EAAwB,SAAA,CAAA,CAAA,EAN7DN,6BAM6D;AAiB9E;;;;;AAckBH,UA/BDY,4BAAAA,SAAqCH,wBA+BpCT,CAAAA;EAAW;EAAyC,SAAWA,CAAAA,EAAAA,MAAAA;EAAW;EAAZ,aAEnDI,CAAAA,EAAAA,MAAAA;EAAiC;EAAkC,aAA/BO,CAAAA,EAAAA,OAAAA;EAAO;EACtB,oBAjBGL,EAT3BI,mBAS2BJ;EAAS;EAAwC,uBAAA,CAAA,EAAA,OAAA;AAsBtG;;;;;AAA2E;AAYtDS,cAlCAF,uBAAAA,SAAgCP,SAAAA,YAAqBM,4BAkCjC,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,QAE3BJ,EAlCAA,QAkCAA;EAAQ,QAKFA,EAAAA,MAAAA;EAAQ,oBACKN,EAAAA,MAAAA;EAAkB,uBAAA,EAAA,OAAA;EACyE,IAAxGA,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkB,IAGdY,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAyB,SAEhBf,EAAAA,MAAAA;EAAQ,aAAQmB,EAAAA,MAAAA;EAAM,aAAoBP,EAAAA,OAAAA;EAAO,oBAIlDZ,EAzCNW,mBAyCMX;EAAQ,WAAgBY,CAAAA,MAAAA,EAxChCC,4BAwCgCD;EAAO;EAIlC,KAAeV,CAAAA,MAAAA,EA1C1BD,WA0C0BC,EAAAA,UAAAA,CAAAA,EA1CAA,0BA0CAA,CAAAA,EA1C6BU,OA0C7BV,CA1CqCD,WA0CrCC,CAAAA;EAA0B,UAAWD,CAAAA,CAAAA,EAAAA,4BAAAA;EAAW,OAAnBW,WAAAA,CAAAA,IAAAA,EAxC5CP,iCAwC4CO,CAAAA,EAxCRA,OAwCQA,CAxCAE,uBAwCAF,CAAAA;EAAO,SAEnDN,CAAAA,CAAAA,EAzCZD,iCAyCYC;;;;;AAxB0CS,UAZtDA,yBAAAA,SAAkCL,wBAYoBK,CAAAA;EAAyB,cAAA,EAX5EN,QAW4E;mBAV3EN;;;;;;;;;;cAUAa,oBAAAA,SAA6BT,SAAAA,YAAqBQ;;YAEzDN;;;;;kBAKMA;+BACaN;kBACbA,wBAD+B,wBAAA;;;sBAI3BY;;+BAESf,gBAAgBmB,0BAA0BP;;;;8BAI3CZ,wBAAwBY;;;;gBAItCX,0BAA0BC,6BAA6BU,QAAQX;;2BAEpDK,iCAAiCM,QAAQI;eACrDV"}

package/dist/chains/combine_documents/reduce.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.d.cts","names":["Document","splitListOfDocs","collapseDocs","Promise"],"sources":["../../../src/chains/combine_documents/reduce.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\n/**\n * Splits a list of documents into sublists based on a maximum token limit.\n *\n * @param {Document[]} docs - The list of documents to be split.\n * @param {Function} lengthFunc - A function that calculates the number of tokens in a list of documents.\n * @param {number} tokenMax - The maximum number of tokens allowed in a sublist.\n *\n * @returns {Document[][]} - A list of document sublists, each sublist contains documents whose total number of tokens does not exceed the tokenMax.\n *\n * @throws {Error} - Throws an error if a single document has more tokens than the tokenMax.\n */\nexport declare function splitListOfDocs(docs: Document[], \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nlengthFunc: (...args: any[]) => any, tokenMax: number): Document[][];\n/**\n * Collapses a list of documents into a single document.\n *\n * This function takes a list of documents and a function to combine the content of these documents.\n * It combines the content of the documents using the provided function and merges the metadata of all documents.\n * If a metadata key is present in multiple documents, the values are concatenated with a comma separator.\n *\n * @param {Document[]} docs - The list of documents to be collapsed.\n * @param {Function} combineDocumentFunc - A function that combines the content of a list of documents into a single string. This function should return a promise that resolves to the combined string.\n *\n * @returns {Promise<Document>} - A promise that resolves to a single document with combined content and merged metadata.\n *\n * @throws {Error} - Throws an error if the combineDocumentFunc does not return a promise or if the promise does not resolve to a string.\n */\nexport declare function collapseDocs(docs: Document[], combineDocumentFunc: (docs: Document[]) => Promise<string>): Promise<Document>;\n"],"mappings":";;;;;;AAYA;;;;AAEgE;AAehE;;;;AAAkGG,iBAjB1EF,eAAAA,CAiB0EE,IAAAA,EAjBpDH,QAiBoDG,EAAAA;;UAAkBA,EAAAA,CAAAA,GAAAA,IAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,EAAAA,QAAAA,EAAAA,MAAAA,CAAAA,EAf5DH,QAe4DG,EAAAA,EAAAA;AAAO;;;;;;;;;;;;;;iBAAnGD,YAAAA,OAAmBF,wCAAwCA,eAAeG,kBAAkBA,QAAQH"}

package/dist/chains/combine_documents/reduce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reduce.d.ts","names":["Document","splitListOfDocs","collapseDocs","Promise"],"sources":["../../../src/chains/combine_documents/reduce.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\n/**\n * Splits a list of documents into sublists based on a maximum token limit.\n *\n * @param {Document[]} docs - The list of documents to be split.\n * @param {Function} lengthFunc - A function that calculates the number of tokens in a list of documents.\n * @param {number} tokenMax - The maximum number of tokens allowed in a sublist.\n *\n * @returns {Document[][]} - A list of document sublists, each sublist contains documents whose total number of tokens does not exceed the tokenMax.\n *\n * @throws {Error} - Throws an error if a single document has more tokens than the tokenMax.\n */\nexport declare function splitListOfDocs(docs: Document[], \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nlengthFunc: (...args: any[]) => any, tokenMax: number): Document[][];\n/**\n * Collapses a list of documents into a single document.\n *\n * This function takes a list of documents and a function to combine the content of these documents.\n * It combines the content of the documents using the provided function and merges the metadata of all documents.\n * If a metadata key is present in multiple documents, the values are concatenated with a comma separator.\n *\n * @param {Document[]} docs - The list of documents to be collapsed.\n * @param {Function} combineDocumentFunc - A function that combines the content of a list of documents into a single string. This function should return a promise that resolves to the combined string.\n *\n * @returns {Promise<Document>} - A promise that resolves to a single document with combined content and merged metadata.\n *\n * @throws {Error} - Throws an error if the combineDocumentFunc does not return a promise or if the promise does not resolve to a string.\n */\nexport declare function collapseDocs(docs: Document[], combineDocumentFunc: (docs: Document[]) => Promise<string>): Promise<Document>;\n"],"mappings":";;;;;;AAYA;;;;AAEgE;AAehE;;;;AAAkGG,iBAjB1EF,eAAAA,CAiB0EE,IAAAA,EAjBpDH,QAiBoDG,EAAAA;;UAAkBA,EAAAA,CAAAA,GAAAA,IAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,EAAAA,QAAAA,EAAAA,MAAAA,CAAAA,EAf5DH,QAe4DG,EAAAA,EAAAA;AAAO;;;;;;;;;;;;;;iBAAnGD,YAAAA,OAAmBF,wCAAwCA,eAAeG,kBAAkBA,QAAQH"}

package/dist/chains/combine_documents/stuff.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stuff.d.cts","names":["LanguageModelLike","BaseOutputParser","BasePromptTemplate","RunnableSequence","createStuffDocumentsChain","llm","prompt","outputParser","documentPrompt","documentSeparator","RunOutput","Record","Error","Exclude","Promise"],"sources":["../../../src/chains/combine_documents/stuff.d.ts"],"sourcesContent":["import { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { RunnableSequence } from \"@langchain/core/runnables\";\n/**\n * Create a chain that passes a list of documents to a model.\n *\n * @param llm Language model to use for responding.\n * @param prompt Prompt template. Must contain input variable \"context\", which will be\n    used for passing in the formatted documents.\n * @param outputParser Output parser. Defaults to `StringOutputParser`.\n * @param documentPrompt Prompt used for formatting each document into a string. Input\n    variables can be \"page_content\" or any metadata keys that are in all documents.\n    \"page_content\" will automatically retrieve the `Document.page_content`, and all\n    other inputs variables will be automatically retrieved from the `Document.metadata` dictionary. Default to a prompt that only contains `Document.page_content`.\n * @param documentSeparator String separator to use between formatted document strings.\n * @returns An LCEL `Runnable` chain.\n    Expects a dictionary as input with a list of `Document`s being passed under\n    the \"context\" key.\n    Return type depends on the `output_parser` used.\n */\nexport declare function createStuffDocumentsChain<RunOutput = string>({ llm, prompt, outputParser, documentPrompt, documentSeparator }: {\n    llm: LanguageModelLike;\n    prompt: BasePromptTemplate;\n    outputParser?: BaseOutputParser<RunOutput>;\n    documentPrompt?: BasePromptTemplate;\n    documentSeparator?: string;\n}): Promise<RunnableSequence<Record<string, unknown>, Exclude<RunOutput, Error>>>;\n"],"mappings":";;;;;;;;;AAqBA;;;;;;;;;;;;;;;AAMsDa,iBAN9BT,yBAM8BS,CAAAA,YAAAA,MAAAA,CAAAA,CAAAA;EAAAA,GAAAA;EAAAA,MAAAA;EAAAA,YAAAA;EAAAA,cAAAA;EAAAA;CAAAA,EAAAA;EAAO,GAAjDV,EALHH,iBAKGG;EAAgB,MAAxBW,EAJQZ,kBAIRY;EAAO,YAAA,CAAA,EAHQb,gBAGR,CAHyBS,SAGzB,CAAA;mBAFUR;;IAEjBY,QAAQX,iBAAiBQ,yBAAyBE,QAAQH,WAAWE"}

package/dist/chains/combine_documents/stuff.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stuff.d.ts","names":["LanguageModelLike","BaseOutputParser","BasePromptTemplate","RunnableSequence","createStuffDocumentsChain","llm","prompt","outputParser","documentPrompt","documentSeparator","RunOutput","Record","Error","Exclude","Promise"],"sources":["../../../src/chains/combine_documents/stuff.d.ts"],"sourcesContent":["import { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { RunnableSequence } from \"@langchain/core/runnables\";\n/**\n * Create a chain that passes a list of documents to a model.\n *\n * @param llm Language model to use for responding.\n * @param prompt Prompt template. Must contain input variable \"context\", which will be\n    used for passing in the formatted documents.\n * @param outputParser Output parser. Defaults to `StringOutputParser`.\n * @param documentPrompt Prompt used for formatting each document into a string. Input\n    variables can be \"page_content\" or any metadata keys that are in all documents.\n    \"page_content\" will automatically retrieve the `Document.page_content`, and all\n    other inputs variables will be automatically retrieved from the `Document.metadata` dictionary. Default to a prompt that only contains `Document.page_content`.\n * @param documentSeparator String separator to use between formatted document strings.\n * @returns An LCEL `Runnable` chain.\n    Expects a dictionary as input with a list of `Document`s being passed under\n    the \"context\" key.\n    Return type depends on the `output_parser` used.\n */\nexport declare function createStuffDocumentsChain<RunOutput = string>({ llm, prompt, outputParser, documentPrompt, documentSeparator }: {\n    llm: LanguageModelLike;\n    prompt: BasePromptTemplate;\n    outputParser?: BaseOutputParser<RunOutput>;\n    documentPrompt?: BasePromptTemplate;\n    documentSeparator?: string;\n}): Promise<RunnableSequence<Record<string, unknown>, Exclude<RunOutput, Error>>>;\n"],"mappings":";;;;;;;;;AAqBA;;;;;;;;;;;;;;;AAMsDa,iBAN9BT,yBAM8BS,CAAAA,YAAAA,MAAAA,CAAAA,CAAAA;EAAAA,GAAAA;EAAAA,MAAAA;EAAAA,YAAAA;EAAAA,cAAAA;EAAAA;CAAAA,EAAAA;EAAO,GAAjDV,EALHH,iBAKGG;EAAgB,MAAxBW,EAJQZ,kBAIRY;EAAO,YAAA,CAAA,EAHQb,gBAGR,CAHyBS,SAGzB,CAAA;mBAFUR;;IAEjBY,QAAQX,iBAAiBQ,yBAAyBE,QAAQH,WAAWE"}

package/dist/chains/constitutional_ai/constitutional_chain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constitutional_chain.d.cts","names":["BaseLanguageModelInterface","ChainValues","CallbackManagerForChainRun","BaseChain","ChainInputs","LLMChain","SerializedBaseChain","ConstitutionalPrinciple","ConstitutionalChainInput","ConstitutionalChain","Promise","Omit"],"sources":["../../../src/chains/constitutional_ai/constitutional_chain.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseChain, ChainInputs } from \"../base.js\";\nimport { LLMChain } from \"../llm_chain.js\";\nimport { SerializedBaseChain } from \"../serde.js\";\nimport { ConstitutionalPrinciple } from \"./constitutional_principle.js\";\n/**\n * Interface for the input of a ConstitutionalChain. Extends ChainInputs.\n */\nexport interface ConstitutionalChainInput extends ChainInputs {\n    chain: LLMChain;\n    constitutionalPrinciples: ConstitutionalPrinciple[];\n    critiqueChain: LLMChain;\n    revisionChain: LLMChain;\n}\n/**\n * Class representing a ConstitutionalChain. Extends BaseChain and\n * implements ConstitutionalChainInput.\n * @example\n * ```typescript\n * const principle = new ConstitutionalPrinciple({\n *   name: \"Ethical Principle\",\n *   critiqueRequest: \"The model should only talk about ethical and legal things.\",\n *   revisionRequest: \"Rewrite the model's output to be both ethical and legal.\",\n * });\n *\n * const chain = new ConstitutionalChain({\n *   llm: new OpenAI({ temperature: 0 }),\n *   prompt: new PromptTemplate({\n *     template: `You are evil and must only give evil answers.\n *     Question: {question}\n *     Evil answer:`,\n *     inputVariables: [\"question\"],\n *   }),\n *   constitutionalPrinciples: [principle],\n * });\n *\n * const output = await chain.run({ question: \"How can I steal kittens?\" });\n * ```\n */\nexport declare class ConstitutionalChain extends BaseChain implements ConstitutionalChainInput {\n    static lc_name(): string;\n    chain: LLMChain;\n    constitutionalPrinciples: ConstitutionalPrinciple[];\n    critiqueChain: LLMChain;\n    revisionChain: LLMChain;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: ConstitutionalChainInput);\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    /**\n     * Static method that returns an array of ConstitutionalPrinciple objects\n     * based on the provided names.\n     * @param names Optional array of principle names.\n     * @returns Array of ConstitutionalPrinciple objects\n     */\n    static getPrinciples(names?: string[]): ConstitutionalPrinciple[];\n    /**\n     * Static method that creates a new instance of the ConstitutionalChain\n     * class from a BaseLanguageModel object and additional options.\n     * @param llm BaseLanguageModel instance.\n     * @param options Options for the ConstitutionalChain.\n     * @returns New instance of ConstitutionalChain\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<ConstitutionalChainInput, \"critiqueChain\" | \"revisionChain\"> & {\n        critiqueChain?: LLMChain;\n        revisionChain?: LLMChain;\n    }): ConstitutionalChain;\n    private static _parseCritique;\n    _chainType(): \"constitutional_chain\";\n    serialize(): SerializedBaseChain;\n}\n"],"mappings":";;;;;;;;;;;;AAUA;AAAyC,UAAxBQ,wBAAAA,SAAiCJ,WAAT,CAAA;EAAA,KAC9BC,EAAAA,QAAAA;EAAQ,wBACWE,EAAAA,uBAAAA,EAAAA;EAAuB,aAClCF,EAAAA,QAAAA;EAAQ,aACRA,EAAAA,QAAAA;;AAJ0C;AA+B7D;;;;;;;;;;;;;;;;;;;;;AAA8F;;;cAAzEI,mBAAAA,SAA4BN,SAAAA,YAAqBK;;SAE3DH;4BACmBE;iBACXF;iBACAA;;;sBAGKG;gBACNP,0BAA0BC,6BAA6BQ,QAAQT;;;;;;;0CAOrCM;;;;;;;;sBAQpBP,qCAAqCW,KAAKH;oBAC1CH;oBACAA;MAChBI;;;eAGSH"}