@langchain/classic 1.0.4 → 1.0.6-dev-1765431816670

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;;;;;AAWA;;;;AAAwDI,cAAnCE,0BAAAA,SAAmCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;EA0B9DI,QAAAA,SAAAA;EACAF,WAAAA,CAAAA,MAAAA,EAAAA;IAC2BJ,SAAAA,EAAAA,MAAAA,EAAAA;EAAcC,CAAAA;EAAjCE;AAAkB;AAqB3C;;;;;;EA2BwBL,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9DCO,OA8DDP,CA9DSE,WA8DTF,GA9DuBG,WA8DvBH,CAAAA;EAA0CQ;;;;AA3BwB;;;;;;;UAvBzEA,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

@@ -1,6 +1,6 @@
 import { ToolsAgentStep } from "./output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
-import { AgentAction, AgentFinish } from "../index.cjs";
+import * as _langchain_core_agents3 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -83,7 +83,7 @@ declare function createToolCallingAgent({
   streamRunnable
 }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, AgentFinish | AgentAction[]>;
+}, _langchain_core_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","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(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

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

@@ -1,9 +1,9 @@
 import { ToolsAgentStep } from "./output_parser.js";
 import { AgentRunnableSequence } from "../agent.js";
-import { AgentAction, AgentFinish } from "../index.js";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 
 //#region src/agents/tool_calling/index.d.ts
 /**
@@ -83,7 +83,7 @@ declare function createToolCallingAgent({
   streamRunnable
 }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, AgentFinish | AgentAction[]>;
+}, _langchain_core_agents0.AgentFinish | _langchain_core_agents0.AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","___index_js0","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"}
+{"version":3,"file":"index.d.ts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","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(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;AAOA;AAIA;KAJYO,gBAAAA,GAAmBP;;eAEdI;;KAELI,cAAAA,GAAiBN;UACjBK"}

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

@@ -1,3 +1,4 @@
+import "../types.js";
 import { ChatGeneration } from "@langchain/core/outputs";
 import { AIMessage, BaseMessage } from "@langchain/core/messages";
 import { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAIYQ,KAJAD,gBAAAA,GAAmBP,WAIFE,GACjBK;;eAHKH;;KAELI,cAAAA,GAAiBN;UACjBK"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;KAEYE,mCAAAA;;;EAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAkBYC,QAAAA,CAAAA,EAAAA,MAAAA;EAAwCF,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBD,OAAAA,CAAAA,EAAAA,OAAAA;CAAqCE;;;AAA6C;;;;;;;;iBAA7IC,kCAAAA,MAAwCF,mBAAmBD,qCAAqCE,sCAAsCI"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;KAEYE,mCAAAA;;;EAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAkBYC,QAAAA,CAAAA,EAAAA,MAAAA;EAAwCF,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBD,OAAAA,CAAAA,EAAAA,OAAAA;CAAqCE;;;AAA6C;;;;;;;;iBAA7IC,kCAAAA,MAAwCF,mBAAmBD,qCAAqCE,sCAAsCI"}

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

@@ -1 +1 @@
-{"version":3,"file":"token_buffer_memory.d.cts","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"}
+{"version":3,"file":"token_buffer_memory.d.cts","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//# sourceMappingURL=token_buffer_memory.d.ts.map"],"mappings":";;;;;;;;;;AAOA;AAaqBO,KAbTD,kCAAAA,GAAqCD,mBAaA,GAAA;EAGxCL,GAAAA,EAfAA,UAeAA;EAMeM,WAAAA,CAAAA,EAAAA,MAAAA;EAAkCE,QAAAA,CAAAA,EAAAA,MAAAA;EAMmEA,SAAAA,CAAAA,EAAAA,MAAAA;EAAgDA,aAAAA,CAAAA,EAAAA,MAAAA;EAA1JI,cAAAA,CAAAA,EAAAA,OAAAA;EAMcX,SAAAA,CAAAA,EAAAA,MAAAA;EAAsBC,oBAAAA,CAAAA,EAAAA,MAAAA;CAARU;;;;AArBWR,cAArCG,4BAAAA,SAAqCH,cAAAA,CAAAA;EAAc,WAAA,EAAA,MAAA;;OAG/DJ;;;;;;sBAMeM;;;;;;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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=token_buffer_memory.d.ts.map"],"mappings":";;;;;;;;;;AAOA;AAaqBO,KAbTD,kCAAAA,GAAqCD,mBAaA,GAAA;EAGxCL,GAAAA,EAfAA,UAeAA;EAMeM,WAAAA,CAAAA,EAAAA,MAAAA;EAAkCE,QAAAA,CAAAA,EAAAA,MAAAA;EAMmEA,SAAAA,CAAAA,EAAAA,MAAAA;EAAgDA,aAAAA,CAAAA,EAAAA,MAAAA;EAA1JI,cAAAA,CAAAA,EAAAA,OAAAA;EAMcX,SAAAA,CAAAA,EAAAA,MAAAA;EAAsBC,oBAAAA,CAAAA,EAAAA,MAAAA;CAARU;;;;AArBWR,cAArCG,4BAAAA,SAAqCH,cAAAA,CAAAA;EAAc,WAAA,EAAA,MAAA;;OAG/DJ;;;;;;sBAMeM;;;;;;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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=tool.d.ts.map"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAYJ,KAAAA,EAAAA,MAAAA;CAAoCG,EAAAA;EAALE,KAAAA,EAAAA,MAAAA;CAC3EJ,CAAAA,EAAEK;EACCC,KAAAA,EAAAA,MAAAA;CAFoJN,EAAEO;EAAxBN,KAAAA,EAAAA,MAAAA;AAAqB,CAAA,EAAA,MAAA,CAAA"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=tool.d.ts.map"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAYJ,KAAAA,EAAAA,MAAAA;CAAoCG,EAAAA;EAALE,KAAAA,EAAAA,MAAAA;CAC3EJ,CAAAA,EAAEK;EACCC,KAAAA,EAAAA,MAAAA;CAFoJN,EAAEO;EAAxBN,KAAAA,EAAAA,MAAAA;AAAqB,CAAA,EAAA,MAAA,CAAA"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;;AAiBA;;;;;AAAoD;AAgBpD;;;;AAAiIK,cAhB5GC,WAAAA,SAAoBJ,WAAAA,CAgBwFG;EAAa,QAAA,EAfhIF,QAegI;SAdnIF;wBACeE;;;;;;;;;;;;;iBAaFI,eAAAA,MAAqBP,qCAAqCM,oBAAoBF,2BAA2BC"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;;AAiBA;;;;;AAAoD;AAgBpD;;;;AAAiIK,cAhB5GC,WAAAA,SAAoBJ,WAAAA,CAgBwFG;EAAa,QAAA,EAfhIF,QAegI;SAdnIF;wBACeE;;;;;;;;;;;;;iBAaFI,eAAAA,MAAqBP,qCAAqCM,oBAAoBF,2BAA2BC"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=openapi.d.ts.map"],"mappings":";;;;;;;;;;AAWA;;;AAA6CE,cAAxBK,eAAAA,SAAwBL,WAAAA,CAAAA;EAAW,KAAA,EAC7CD,aAD6C,EAAA;EA4BnCO,WAAAA,CAAAA,OAAc,CAAA,EA1BTF,OA0BS;;;;;AAAwB;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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=openapi.d.ts.map"],"mappings":";;;;;;;;;;AAWA;;;AAA6CE,cAAxBK,eAAAA,SAAwBL,WAAAA,CAAAA;EAAW,KAAA,EAC7CD,aAD6C,EAAA;EA4BnCO,WAAAA,CAAAA,OAAc,CAAA,EA1BTF,OA0BS;;;;;AAAwB;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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=prompt.d.ts.map"],"mappings":";cAAqBA,UAAAA;AAAAA,cACAC,UAAAA,GADU,gIAAA"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=prompt.d.ts.map"],"mappings":";cAAqBA,UAAAA;AAAAA,cACAC,UAAAA,GADU,gIAAA"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=sql.d.ts.map"],"mappings":";;;;;;;;;;AASA;AAgBA;AACWC,UAjBMK,mBAAAA,SAA4BH,wBAiBlCF,CAAAA;EACHI;EAEYA,IAAAA,CAAAA,EAAAA,MAAAA;;;AAJ+B;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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=sql.d.ts.map"],"mappings":";;;;;;;;;;AASA;AAgBA;AACWC,UAjBMK,mBAAAA,SAA4BH,wBAiBlCF,CAAAA;EACHI;EAEYA,IAAAA,CAAAA,EAAAA,MAAAA;;;AAJ+B;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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=vectorstore.d.ts.map"],"mappings":";;;;;;;;;;AASA;AA0BA;AACWE,UA3BMI,eAAAA,CA2BNJ;EACFF,WAAAA,EA3BQC,oBA2BRD;EACwBM,IAAAA,EAAAA,MAAAA;EAAsBN,WAAAA,EAAAA,MAAAA;;AAHI;AAU3D;;;;;;;AAAiE;AAMjE;;;;;AAA4J;AAC5J;;;;;AAAwK;cAjBnJO,kBAAAA,SAA2BJ,WAAAA;SACrCD;OACFF;+BACwBM,sBAAsBN;;;;;;;cAOlCQ,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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=vectorstore.d.ts.map"],"mappings":";;;;;;;;;;AASA;AA0BA;AACWE,UA3BMI,eAAAA,CA2BNJ;EACFF,WAAAA,EA3BQC,oBA2BRD;EACwBM,IAAAA,EAAAA,MAAAA;EAAsBN,WAAAA,EAAAA,MAAAA;;AAHI;AAU3D;;;;;;;AAAiE;AAMjE;;;;;AAA4J;AAC5J;;;;;AAAwK;cAjBnJO,kBAAAA,SAA2BJ,WAAAA;SACrCD;OACFF;+BACwBM,sBAAsBN;;;;;;;cAOlCQ,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

@@ -18,11 +18,6 @@ interface AgentInput {
   outputParser: AgentActionOutputParser | undefined;
   allowedTools?: string[];
 }
-/**
- * Interface defining the input for creating a single action agent
- * that uses runnables.
- */
-
 /**
  * Interface defining the input for creating a multi-action agent that uses
  * runnables. It includes the Runnable instance, and an optional list of
@@ -37,8 +32,6 @@ interface RunnableMultiActionAgentInput {
   defaultRunName?: string;
   stop?: string[];
 }
-/** @deprecated Renamed to RunnableMultiActionAgentInput. */
-
 /**
  * Abstract class representing an output parser specifically for agent
  * actions and finishes in LangChain. It extends the `BaseOutputParser`

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"types.d.cts","names":["Runnable","BaseOutputParser","AgentAction","AgentFinish","BaseMessage","ChainValues","SerializedLLMChain","LLMChain","AgentInput","AgentActionOutputParser","RunnableSingleActionAgentInput","RunnableMultiActionAgentInput","RunnableAgentInput","AgentMultiActionOutputParser","StoppingMethod","SerializedAgentT","TType","FromLLMInput","ConstructorInput","Record","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//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;AAYA;AAsBA;;AAEoCI,UAxBnBI,UAAAA,CAwBmBJ;EAE7BF,QAAAA,EAzBOK,QAyBPL;EAAgBA,YAAAA,EAxBLO,uBAwBKP,GAAAA,SAAAA;EAAcC,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;AA+BrC;;;;;AACWa,UApCML,6BAAAA,CAoCNK;EACKV,QAAAA,EApCFN,QAoCEM,CApCOD,WAoCPC,GAAAA;IAGZW,gBAAAA,CAAAA,EAAAA,MAAAA,GAtCgCb,WAsChCa,EAAAA;IAEAC,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgB,CAAA,EAtCbhB,WAsCa,EAAA,GAtCGA,WAsCH,GAtCiBC,WAsCjB,CAAA;EACRiB,cAAAA,CAAAA,EAAAA,OAAAA;EAUAC,cAAAA,CAAAA,EAAAA,MAAAA;EAA0ED,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;;uBApCxDX,uBAAAA,SAAgCR,iBAAiBC,cAAcC;;;;;uBAM/DU,4BAAAA,SAAqCZ,iBAAiBC,gBAAgBC;;;;;KAMxFW,cAAAA;;;;;;KAMAC,qEAAqEI,0BAA0BA,kDAAkDX,aAAaA;SAC/JQ;cACKV;;;IAGZW;;IAEAC;KACQE,yBAAAA;;;;;;;;;;KAUAC,uBAAAA,GAA0BN,gDAAgDK,2BAA2BZ;;;;;KAKrGc,eAAAA,GAAkBD"}

package/dist/agents/types.d.ts

@@ -18,11 +18,6 @@ interface AgentInput {
   outputParser: AgentActionOutputParser | undefined;
   allowedTools?: string[];
 }
-/**
- * Interface defining the input for creating a single action agent
- * that uses runnables.
- */
-
 /**
  * Interface defining the input for creating a multi-action agent that uses
  * runnables. It includes the Runnable instance, and an optional list of
@@ -37,8 +32,6 @@ interface RunnableMultiActionAgentInput {
   defaultRunName?: string;
   stop?: string[];
 }
-/** @deprecated Renamed to RunnableMultiActionAgentInput. */
-
 /**
  * Abstract class representing an output parser specifically for agent
  * actions and finishes in LangChain. It extends the `BaseOutputParser`

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"types.d.ts","names":["Runnable","BaseOutputParser","AgentAction","AgentFinish","BaseMessage","ChainValues","SerializedLLMChain","LLMChain","AgentInput","AgentActionOutputParser","RunnableSingleActionAgentInput","RunnableMultiActionAgentInput","RunnableAgentInput","AgentMultiActionOutputParser","StoppingMethod","SerializedAgentT","TType","FromLLMInput","ConstructorInput","Record","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//# sourceMappingURL=types.d.ts.map"],"mappings":";;;;;;;;;;;;AAYA;AAsBA;;AAEoCI,UAxBnBI,UAAAA,CAwBmBJ;EAE7BF,QAAAA,EAzBOK,QAyBPL;EAAgBA,YAAAA,EAxBLO,uBAwBKP,GAAAA,SAAAA;EAAcC,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;AA+BrC;;;;;AACWa,UApCML,6BAAAA,CAoCNK;EACKV,QAAAA,EApCFN,QAoCEM,CApCOD,WAoCPC,GAAAA;IAGZW,gBAAAA,CAAAA,EAAAA,MAAAA,GAtCgCb,WAsChCa,EAAAA;IAEAC,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgB,CAAA,EAtCbhB,WAsCa,EAAA,GAtCGA,WAsCH,GAtCiBC,WAsCjB,CAAA;EACRiB,cAAAA,CAAAA,EAAAA,OAAAA;EAUAC,cAAAA,CAAAA,EAAAA,MAAAA;EAA0ED,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;;uBApCxDX,uBAAAA,SAAgCR,iBAAiBC,cAAcC;;;;;uBAM/DU,4BAAAA,SAAqCZ,iBAAiBC,gBAAgBC;;;;;KAMxFW,cAAAA;;;;;;KAMAC,qEAAqEI,0BAA0BA,kDAAkDX,aAAaA;SAC/JQ;cACKV;;;IAGZW;;IAEAC;KACQE,yBAAAA;;;;;;;;;;KAUAC,uBAAAA,GAA0BN,gDAAgDK,2BAA2BZ;;;;;KAKrGc,eAAAA,GAAkBD"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;AAaA;AAOA;AAGWC,UAVMa,aAAAA,CAUNb;EACGQ,KAAAA,EAVHR,aAUGQ,EAAAA;EACII,QAAAA,EAVJJ,QAUII;;;;;AAakDL,cAlB/CO,QAAAA,SAAiBH,qBAAAA,YAAiCE,aAkBHN,CAAAA;EAA0BJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAcC,YAAAA,EAAAA,MAAAA,EAAAA;EAAtBW,KAAAA,EAf3Ef,aAe2Ee,EAAAA;EAQtDhB,QAAAA,EAtBlBS,QAsBkBT;EAAmCC,YAAAA,EArBjDY,oBAqBiDZ;EAAwBa,UAAAA,CAAAA,CAAAA,EAAAA,KAAAA;EAAqBJ,WAAAA,CAAAA,MAAAA,EAnBxFI,aAmBwFJ;EAALO,IAAAA,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA+BF,OAAAA,YAAAA,CAAAA,CAAAA,EAjB/GR,kBAiB+GQ,CAAAA,GAAAA,EAAAA,GAAAA,CAAAA;EA1BpGH;;AAA8C;AA+BpF;;;;AAS8B;EAyDNO,IAAAA,CAAAA,KAAAA,EA/ERhB,SA+EsB,EAAA,EAAA,MAAA,EA/EDG,WA+EC,EAAA,eAAA,CAAA,EA/E8BE,eA+E9B,CAAA,EA/EgDQ,OA+EhD,CA/EwDZ,WA+ExD,GA/EsEC,WA+EtE,CAAA;EAAGe;;;;;;;EAExBf,OAAAA,eAAAA,CAAAA,GAAAA,EAzEeL,0BAyEfK,EAAAA,KAAAA,EAzEkDJ,aAyElDI,EAAAA,EAAAA,IAAAA,CAAAA,EAzE0ES,aAyE1ET,GAzE0FY,IAyE1FZ,CAzE+FK,SAyE/FL,EAAAA,WAAAA,CAAAA,CAAAA,EAzEyHU,QAyEzHV;;;AAF4F;;KAlEjGa,oBAAAA;;OAEHlB;;SAEEC;;;;;UAKCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyDYiB,cAAAA;;;;;GAAuDD,uBAAuBF,QAAQL;SACnGR;GACRC,cAAcC"}