@langchain/classic 1.0.5 → 1.0.6-dev-1765432861398

package/dist/agents/load.d.cts

@@ -1,14 +1,6 @@
-import { Agent } from "./agent.cjs";
-import { StringInputToolSchema } from "../langchain-core/dist/tools/types.cjs";
-import * as _langchain_core_language_models_base0 from "@langchain/core/language_models/base";
-import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import { ToolInterface } from "@langchain/core/tools";
-
 //#region src/agents/load.d.ts
-declare const loadAgent: (uri: string, llmAndTools?: {
-  llm?: BaseLanguageModelInterface<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions> | undefined;
-  tools?: ToolInterface<StringInputToolSchema, any, any>[] | undefined;
-} | undefined) => Promise<Agent>;
+
+declare const loadAgent: any;
 //#endregion
 export { loadAgent };
 //# sourceMappingURL=load.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.cts","names":["BaseLanguageModelInterface","ToolInterface","Agent","loadAgent"],"sources":["../../src/agents/load.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { Agent } from \"./agent.js\";\nexport declare const loadAgent: any;\n//# sourceMappingURL=load.d.ts.map"],"mappings":";;cAGqBG"}

package/dist/agents/load.d.ts

@@ -1,14 +1,6 @@
-import { Agent } from "./agent.js";
-import { StringInputToolSchema } from "../libs/langchain-core/dist/tools/types.js";
-import { ToolInterface } from "@langchain/core/tools";
-import * as _langchain_core_language_models_base0 from "@langchain/core/language_models/base";
-import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-
 //#region src/agents/load.d.ts
-declare const loadAgent: (uri: string, llmAndTools?: {
-  llm?: BaseLanguageModelInterface<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions> | undefined;
-  tools?: ToolInterface<StringInputToolSchema, any, any>[] | undefined;
-} | undefined) => Promise<Agent>;
+
+declare const loadAgent: any;
 //#endregion
 export { loadAgent };
 //# sourceMappingURL=load.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","names":["BaseLanguageModelInterface","ToolInterface","Agent","loadAgent"],"sources":["../../src/agents/load.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { Agent } from \"./agent.js\";\nexport declare const loadAgent: any;\n//# sourceMappingURL=load.d.ts.map"],"mappings":";;cAGqBG"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","ToolInterface","PromptTemplate","Optional","Agent","AgentArgs","OutputParserArgs","AgentInput","SerializedZeroShotAgent","ZeroShotAgentOutputParser","ZeroShotCreatePromptArgs","ZeroShotAgentInput","ZeroShotAgent","Promise"],"sources":["../../../src/agents/mrkl/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput, SerializedZeroShotAgent } from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n}\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport declare class ZeroShotAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ZeroShotAgentInput);\n    _agentType(): \"zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    /**\n     * Returns the default output parser for the ZeroShotAgent.\n     * @param fields Optional arguments for the output parser.\n     * @returns An instance of ZeroShotAgentOutputParser.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs): ZeroShotAgentOutputParser;\n    /**\n     * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n     * does not have a description.\n     * @param tools List of tools to validate.\n     */\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Create prompt in the style of the zero shot agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables - List of input variables the final prompt will expect.\n     */\n    static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs): PromptTemplate<any, any>;\n    /**\n     * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n     * @param llm The Large Language Model to use.\n     * @param tools The tools for the agent to use.\n     * @param args Optional arguments for creating the agent.\n     * @returns A new instance of ZeroShotAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ZeroShotCreatePromptArgs & AgentArgs): ZeroShotAgent;\n    static deserialize(data: SerializedZeroShotAgent & {\n        llm?: BaseLanguageModelInterface;\n        tools?: ToolInterface[];\n    }): Promise<ZeroShotAgent>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;AAUA;AAYYW,UAZKD,wBAAAA,CAYyBH;EA0BrBK;EAGPX,MAAAA,CAAAA,EAAAA,MAAAA;EACSU;EASoBL,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBG;EAM9BR,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AAkB2DS,KA/D/EC,kBAAAA,GAAqBR,QA+D0DO,CA/DjDH,UA+DiDG,EAAAA,cAAAA,CAAAA;;;;;;;;;AArC3C;;;;;;;;;;;;;;;;;cAA3BE,aAAAA,SAAsBR,KAAAA;;;YAG7BH;qBACSU;;;;;;;;;yCASoBL,mBAAmBG;;;;;;8BAM9BR;;;;;;;;;;6BAUDA,wBAAwBS,2BAA2BR;;;;;;;;8BAQlDF,mCAAmCC,wBAAwBS,2BAA2BL,YAAYO;2BACrGJ;UACfR;YACEC;MACRY,QAAQD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","ToolInterface","PromptTemplate","Optional","Agent","AgentArgs","OutputParserArgs","AgentInput","SerializedZeroShotAgent","ZeroShotAgentOutputParser","ZeroShotCreatePromptArgs","ZeroShotAgentInput","ZeroShotAgent","Promise"],"sources":["../../../src/agents/mrkl/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput, SerializedZeroShotAgent } from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n}\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport declare class ZeroShotAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ZeroShotAgentInput);\n    _agentType(): \"zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    /**\n     * Returns the default output parser for the ZeroShotAgent.\n     * @param fields Optional arguments for the output parser.\n     * @returns An instance of ZeroShotAgentOutputParser.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs): ZeroShotAgentOutputParser;\n    /**\n     * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n     * does not have a description.\n     * @param tools List of tools to validate.\n     */\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Create prompt in the style of the zero shot agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables - List of input variables the final prompt will expect.\n     */\n    static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs): PromptTemplate<any, any>;\n    /**\n     * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n     * @param llm The Large Language Model to use.\n     * @param tools The tools for the agent to use.\n     * @param args Optional arguments for creating the agent.\n     * @returns A new instance of ZeroShotAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ZeroShotCreatePromptArgs & AgentArgs): ZeroShotAgent;\n    static deserialize(data: SerializedZeroShotAgent & {\n        llm?: BaseLanguageModelInterface;\n        tools?: ToolInterface[];\n    }): Promise<ZeroShotAgent>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;AAUA;AAYYW,UAZKD,wBAAAA,CAYyBH;EA0BrBK;EAGPX,MAAAA,CAAAA,EAAAA,MAAAA;EACSU;EASoBL,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBG;EAM9BR,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AAkB2DS,KA/D/EC,kBAAAA,GAAqBR,QA+D0DO,CA/DjDH,UA+DiDG,EAAAA,cAAAA,CAAAA;;;;;;;;;AArC3C;;;;;;;;;;;;;;;;;cAA3BE,aAAAA,SAAsBR,KAAAA;;;YAG7BH;qBACSU;;;;;;;;;yCASoBL,mBAAmBG;;;;;;8BAM9BR;;;;;;;;;;6BAUDA,wBAAwBS,2BAA2BR;;;;;;;;8BAQlDF,mCAAmCC,wBAAwBS,2BAA2BL,YAAYO;2BACrGJ;UACfR;YACEC;MACRY,QAAQD"}

package/dist/agents/mrkl/outputParser.d.cts

@@ -25,10 +25,10 @@ declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {
     tool?: undefined;
     toolInput?: undefined;
   } | {
+    returnValues?: undefined;
     tool: string;
     toolInput: string;
     log: string;
-    returnValues?: undefined;
   }>;
   /**
    * Returns the format instructions for parsing the output of an agent

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

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.d.cts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        returnValues?: undefined;\n        tool: string;\n        toolInput: string;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}

package/dist/agents/mrkl/outputParser.d.ts

@@ -25,10 +25,10 @@ declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {
     tool?: undefined;
     toolInput?: undefined;
   } | {
+    returnValues?: undefined;
     tool: string;
     toolInput: string;
     log: string;
-    returnValues?: undefined;
   }>;
   /**
    * Returns the format instructions for parsing the output of an agent

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

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.d.ts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        returnValues?: undefined;\n        tool: string;\n        toolInput: string;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","BaseFunctionCallOptions","StructuredToolInterface","BaseChatModel","AgentAction","AgentFinish","AgentStep","BaseMessage","SystemMessage","ChainValues","ChatPromptTemplate","BasePromptTemplate","CallbackManager","Agent","AgentArgs","AgentRunnableSequence","AgentInput","OpenAIFunctionsAgentOutputParser","_formatIntermediateSteps","OpenAIAgentInput","OpenAIAgentCreatePromptArgs","OpenAIAgent","Omit","Pick","Promise","Array","CreateOpenAIFunctionsAgentParams","createOpenAIFunctionsAgent","llm","tools","prompt","streamRunnable"],"sources":["../../../src/agents/openai_functions/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface, BaseFunctionCallOptions } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatPromptTemplate, BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { OpenAIFunctionsAgentOutputParser } from \"../openai/output_parser.js\";\nexport declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n    tools: StructuredToolInterface[];\n}\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n    prefix?: string;\n    systemMessage?: SystemMessage;\n}\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport declare class OpenAIAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    _agentType(): \"openai-functions\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    tools: StructuredToolInterface[];\n    outputParser: OpenAIFunctionsAgentOutputParser;\n    constructor(input: Omit<OpenAIAgentInput, \"outputParser\">);\n    /**\n     * Creates a prompt for the OpenAIAgent using the provided tools and\n     * fields.\n     * @param _tools The tools to be used in the prompt.\n     * @param fields Optional fields for creating the prompt.\n     * @returns A BasePromptTemplate object representing the created prompt.\n     */\n    static createPrompt(_tools: StructuredToolInterface[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;\n    /**\n     * Creates an OpenAIAgent 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 OpenAIAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">): OpenAIAgent;\n    /**\n     * Constructs a scratch pad from a list of agent steps.\n     * @param steps The steps to include in the scratch pad.\n     * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;\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: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI function 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: BaseChatModel<BaseFunctionCallOptions>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[];\n    /** The prompt to use, must have an input key for `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 OpenAI-style function calling.\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, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\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/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\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 *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIFunctionsAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, AgentAction | AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAeA;AAOA;AASqBqB,UAhBJF,gBAAAA,SAAyBH,UAgBV,CAAA;EAOrBd,KAAAA,EAtBAA,uBAsBAA,EAAAA;;;;;;AAUuFS,UA1BjFS,2BAAAA,CA0BiFT;EAQlEX,MAAAA,CAAAA,EAAAA,MAAAA;EAAmCE,aAAAA,CAAAA,EAhC/CM,aAgC+CN;;;;;;;AAMtBsB,cA/BxBH,WAAAA,SAAoBR,KAAAA,CA+BIW;EASvBlB,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAANmB,YAAAA,EAAAA,MAAAA,EAAAA;EAA0BhB,UAAAA,CAAAA,CAAAA,EAAAA,kBAAAA;EAA+BG,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0BR,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAcC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAtBmB,KAAAA,EAjChFtB,uBAiCgFsB,EAAAA;EAxClDX,YAAAA,EAQvBI,gCARuBJ;EAAK,WAAA,CAAA,KAAA,EASvBS,IATuB,CASlBH,gBATkB,EAAA,cAAA,CAAA;EA6ClCO;;;;;AAUkB;AA+D9B;EAAqDE,OAAAA,YAAAA,CAAAA,MAAAA,EArGrB1B,uBAqGqB0B,EAAAA,EAAAA,MAAAA,CAAAA,EArGeR,2BAqGfQ,CAAAA,EArG6CjB,kBAqG7CiB;EAAKC;;;;;;;EAA4Ed,OAAAA,eAAAA,CAAAA,GAAAA,EA7FtGf,0BA6FsGe,EAAAA,KAAAA,EA7FnEb,uBA6FmEa,EAAAA,EAAAA,IAAAA,CAAAA,EA7FjCK,2BA6FiCL,GA7FHQ,IA6FGR,CA7FED,SA6FFC,EAAAA,WAAAA,CAAAA,CAAAA,EA7F4BM,WA6F5BN;EAARS;AAAO;;;;6BAvFtGlB,cAAckB,iBAAiBjB;;;;;;;;;cAS9CkB,MAAMnB,oBAAoBG,+BAA+BG,kBAAkBY,QAAQpB,cAAcC;;;;;KAKrGqB,gCAAAA;;;;;;OAMHvB,cAAcF;;SAEZC;;UAECQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYiB,0BAAAA;;;;;GAAmED,mCAAmCF,QAAQT;SAC3HT;GACRF,cAAcC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","BaseFunctionCallOptions","StructuredToolInterface","BaseChatModel","AgentAction","AgentFinish","AgentStep","BaseMessage","SystemMessage","ChainValues","ChatPromptTemplate","BasePromptTemplate","CallbackManager","Agent","AgentArgs","AgentRunnableSequence","AgentInput","OpenAIFunctionsAgentOutputParser","_formatIntermediateSteps","OpenAIAgentInput","OpenAIAgentCreatePromptArgs","OpenAIAgent","Omit","Pick","Promise","Array","CreateOpenAIFunctionsAgentParams","createOpenAIFunctionsAgent","llm","tools","prompt","streamRunnable"],"sources":["../../../src/agents/openai_functions/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface, BaseFunctionCallOptions } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport type { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { BaseMessage, SystemMessage } from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatPromptTemplate, BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { OpenAIFunctionsAgentOutputParser } from \"../openai/output_parser.js\";\nexport declare function _formatIntermediateSteps(intermediateSteps: AgentStep[]): BaseMessage[];\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n    tools: StructuredToolInterface[];\n}\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n    prefix?: string;\n    systemMessage?: SystemMessage;\n}\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport declare class OpenAIAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    _agentType(): \"openai-functions\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    tools: StructuredToolInterface[];\n    outputParser: OpenAIFunctionsAgentOutputParser;\n    constructor(input: Omit<OpenAIAgentInput, \"outputParser\">);\n    /**\n     * Creates a prompt for the OpenAIAgent using the provided tools and\n     * fields.\n     * @param _tools The tools to be used in the prompt.\n     * @param fields Optional fields for creating the prompt.\n     * @returns A BasePromptTemplate object representing the created prompt.\n     */\n    static createPrompt(_tools: StructuredToolInterface[], fields?: OpenAIAgentCreatePromptArgs): BasePromptTemplate;\n    /**\n     * Creates an OpenAIAgent 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 OpenAIAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">): OpenAIAgent;\n    /**\n     * Constructs a scratch pad from a list of agent steps.\n     * @param steps The steps to include in the scratch pad.\n     * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;\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: Array<AgentStep>, inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI function 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: BaseChatModel<BaseFunctionCallOptions>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[];\n    /** The prompt to use, must have an input key for `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 OpenAI-style function calling.\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, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\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/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\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 *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIFunctionsAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, AgentAction | AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;;;;AAeA;AAOiBoB,UAPAD,gBAAAA,SAAyBH,UAStBR,CAAAA;EAOCa,KAAAA,EAfVnB,uBAeqB,EAAA;;;;;;AAiBoCkB,UA1BnDA,2BAAAA,CA0BmDA;EAA8BT,MAAAA,CAAAA,EAAAA,MAAAA;EAQlEX,aAAAA,CAAAA,EAhCZQ,aAgCYR;;;;;;;AAM8BO,cA/BzCc,WAAAA,SAAoBR,KAAAA,CA+BqBN;EAAjBiB,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EASvBlB,YAAAA,EAAAA,MAAAA,EAAAA;EAANmB,UAAAA,CAAAA,CAAAA,EAAAA,kBAAAA;EAA0BhB,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA+BG,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0BR,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAcC,KAAAA,EAjCtGH,uBAiCsGG,EAAAA;EAAtBmB,YAAAA,EAhCzEP,gCAgCyEO;EAxClDX,WAAAA,CAAAA,KAAAA,EASlBS,IATkBT,CASbM,gBATaN,EAAAA,cAAAA,CAAAA;EAAK;AA6C9C;;;;;AAU8B;EA+DNc,OAAAA,YAAAA,CAAAA,MAAAA,EArGQzB,uBAqGkB,EAAA,EAAA,MAAA,CAAA,EArGkBkB,2BAqGlB,CAAA,EArGgDT,kBAqGhD;EAAGiB;;;;;;;EAEpCvB,OAAAA,eAAAA,CAAAA,GAAAA,EA/FeL,0BA+FfK,EAAAA,KAAAA,EA/FkDH,uBA+FlDG,EAAAA,EAAAA,IAAAA,CAAAA,EA/FoFe,2BA+FpFf,GA/FkHkB,IA+FlHlB,CA/FuHS,SA+FvHT,EAAAA,WAAAA,CAAAA,CAAAA,EA/FiJgB,WA+FjJhB;EAFqHU;;AAAD;;;6BAvFtGT,cAAckB,iBAAiBjB;;;;;;;;;cAS9CkB,MAAMnB,oBAAoBG,+BAA+BG,kBAAkBY,QAAQpB,cAAcC;;;;;KAKrGqB,gCAAAA;;;;;;OAMHvB,cAAcF;;SAEZC;;UAECQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYiB,0BAAAA;;;;;GAAmED,mCAAmCF,QAAQT;SAC3HT;GACRF,cAAcC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","BaseMessage","ChatGeneration","AgentActionOutputParser","FunctionsAgentAction","OpenAIFunctionsAgentOutputParser","Promise"],"sources":["../../../src/agents/openai_functions/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n    messageLog?: BaseMessage[];\n};\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;\n    /**\n     * Parses the output message into a FunctionsAgentAction or AgentFinish\n     * object.\n     * @param message The BaseMessage to parse.\n     * @returns A FunctionsAgentAction or AgentFinish object.\n     */\n    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAmCqBM,KAnCTD,oBAAAA,GAAuBL,WAmCkB,GAAA;EAGpBA,UAAAA,CAAAA,EArChBE,WAqCgBF,EAAAA;CAAcC;;;;;;;;;;AAHsC;;;;;;;;;;;;;;;;;;;;;;;cAAhEK,gCAAAA,SAAyCF,uBAAAA;;;uBAGrCG,QAAQP,cAAcC;2BAClBE,mBAAmBI,QAAQN,cAAcI;;;;;;;0BAO1CH,cAAcG,uBAAuBJ"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","BaseMessage","ChatGeneration","AgentActionOutputParser","FunctionsAgentAction","OpenAIFunctionsAgentOutputParser","Promise"],"sources":["../../../src/agents/openai_functions/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type FunctionsAgentAction = AgentAction & {\n    messageLog?: BaseMessage[];\n};\n/**\n * @example\n * ```typescript\n *\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const modelWithFunctions = new ChatOpenAI({\n *   model: \"gpt-4\",\n *   temperature: 0,\n * }).bindTools(tools);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i) => i.input,\n *     agent_scratchpad: (i) => formatAgentSteps(i.steps),\n *   },\n *   prompt,\n *   modelWithFunctions,\n *   new OpenAIFunctionsAgentOutputParser(),\n * ]);\n *\n * const result = await runnableAgent.invoke({\n *   input: \"What is the weather in New York?\",\n *   steps: agentSteps,\n * });\n *\n * ```\n */\nexport declare class OpenAIFunctionsAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | FunctionsAgentAction>;\n    /**\n     * Parses the output message into a FunctionsAgentAction or AgentFinish\n     * object.\n     * @param message The BaseMessage to parse.\n     * @returns A FunctionsAgentAction or AgentFinish object.\n     */\n    parseAIMessage(message: BaseMessage): FunctionsAgentAction | AgentFinish;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAmCqBM,KAnCTD,oBAAAA,GAAuBL,WAmCkB,GAAA;EAGpBA,UAAAA,CAAAA,EArChBE,WAqCgBF,EAAAA;CAAcC;;;;;;;;;;AAHsC;;;;;;;;;;;;;;;;;;;;;;;cAAhEK,gCAAAA,SAAyCF,uBAAAA;;;uBAGrCG,QAAQP,cAAcC;2BAClBE,mBAAmBI,QAAQN,cAAcI;;;;;;;0BAO1CH,cAAcG,uBAAuBJ"}

package/dist/agents/openai_tools/index.d.cts

@@ -1,7 +1,7 @@
 import { ToolsAgentStep } from "../tool_calling/output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
 import { OpenAIToolsAgentOutputParser } from "./output_parser.cjs";
-import { AgentAction, AgentFinish } from "../index.cjs";
+import * as _langchain_core_agents1 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -19,9 +19,7 @@ type CreateOpenAIToolsAgentParams = {
    * a different model that adds in equivalent support.
    */
   llm: BaseChatModel<BaseChatModelCallOptions & {
-    tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    | any[];
+    tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
   }>;
   /** Tools this agent has access to. */
   tools: StructuredToolInterface[] | ToolDefinition[];
@@ -96,7 +94,7 @@ declare function createOpenAIToolsAgent({
   streamRunnable
 }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, AgentFinish | AgentAction[]>>;
+}, _langchain_core_agents1.AgentFinish | _langchain_core_agents1.AgentAction[]>>;
 //#endregion
 export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\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: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\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 OpenAI-style tool calling.\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, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\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/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\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 *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

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

@@ -1,12 +1,12 @@
 import { ToolsAgentStep } from "../tool_calling/output_parser.js";
 import { AgentRunnableSequence } from "../agent.js";
 import { OpenAIToolsAgentOutputParser } from "./output_parser.js";
-import { AgentAction, AgentFinish } from "../index.js";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { OpenAIClient } from "@langchain/openai";
 import { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 
 //#region src/agents/openai_tools/index.d.ts
 /**
@@ -19,9 +19,7 @@ type CreateOpenAIToolsAgentParams = {
    * a different model that adds in equivalent support.
    */
   llm: BaseChatModel<BaseChatModelCallOptions & {
-    tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    | any[];
+    tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
   }>;
   /** Tools this agent has access to. */
   tools: StructuredToolInterface[] | ToolDefinition[];
@@ -96,7 +94,7 @@ declare function createOpenAIToolsAgent({
   streamRunnable
 }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, AgentFinish | AgentAction[]>>;
+}, _langchain_core_agents0.AgentFinish | _langchain_core_agents0.AgentAction[]>>;
 //#endregion
 export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\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: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\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 OpenAI-style tool calling.\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, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\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/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\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 *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","BaseMessage","ChatGeneration","AgentMultiActionOutputParser","ToolsAgentAction","ToolsAgentStep","OpenAIToolsAgentOutputParser","Promise"],"sources":["../../../src/agents/openai_tools/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\nimport { ToolsAgentAction, ToolsAgentStep } from \"../tool_calling/output_parser.js\";\nexport type { ToolsAgentAction, ToolsAgentStep };\n/**\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>\n *       formatToOpenAIToolMessages(i.steps),\n *   },\n *   prompt,\n *   new ChatOpenAI({\n *     model: \"gpt-3.5-turbo-1106\",\n *     temperature: 0,\n *   }).bindTools(tools),\n *   new OpenAIToolsAgentOutputParser(),\n * ]).withConfig({ runName: \"OpenAIToolsAgent\" });\n *\n * const result = await runnableAgent.invoke({\n *   input:\n *     \"What is the sum of the current temperature in San Francisco, New York, and Tokyo?\",\n * });\n * ```\n */\nexport declare class OpenAIToolsAgentOutputParser 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    /**\n     * Parses the output message into a ToolsAgentAction[] or AgentFinish\n     * object.\n     * @param message The BaseMessage to parse.\n     * @returns A ToolsAgentAction[] or AgentFinish object.\n     */\n    parseAIMessage(message: BaseMessage): ToolsAgentAction[] | AgentFinish;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAmCA;;;;;;;;;;;;AAAsF;;;;;;;;;;;;;;;;cAAjEO,4BAAAA,SAAqCH,4BAAAA;;;uBAGjCI,QAAQR,gBAAgBC;2BACpBE,mBAAmBK,QAAQP,cAAcI;;;;;;;0BAO1CH,cAAcG,qBAAqBJ"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","BaseMessage","ChatGeneration","AgentMultiActionOutputParser","ToolsAgentAction","ToolsAgentStep","OpenAIToolsAgentOutputParser","Promise"],"sources":["../../../src/agents/openai_tools/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\nimport { ToolsAgentAction, ToolsAgentStep } from \"../tool_calling/output_parser.js\";\nexport type { ToolsAgentAction, ToolsAgentStep };\n/**\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>\n *       formatToOpenAIToolMessages(i.steps),\n *   },\n *   prompt,\n *   new ChatOpenAI({\n *     model: \"gpt-3.5-turbo-1106\",\n *     temperature: 0,\n *   }).bindTools(tools),\n *   new OpenAIToolsAgentOutputParser(),\n * ]).withConfig({ runName: \"OpenAIToolsAgent\" });\n *\n * const result = await runnableAgent.invoke({\n *   input:\n *     \"What is the sum of the current temperature in San Francisco, New York, and Tokyo?\",\n * });\n * ```\n */\nexport declare class OpenAIToolsAgentOutputParser 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    /**\n     * Parses the output message into a ToolsAgentAction[] or AgentFinish\n     * object.\n     * @param message The BaseMessage to parse.\n     * @returns A ToolsAgentAction[] or AgentFinish object.\n     */\n    parseAIMessage(message: BaseMessage): ToolsAgentAction[] | AgentFinish;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAmCA;;;;;;;;;;;;AAAsF;;;;;;;;;;;;;;;;cAAjEO,4BAAAA,SAAqCH,4BAAAA;;;uBAGjCI,QAAQR,gBAAgBC;2BACpBE,mBAAmBK,QAAQP,cAAcI;;;;;;;0BAO1CH,cAAcG,qBAAqBJ"}

package/dist/agents/react/index.d.cts

@@ -1,5 +1,5 @@
 import { AgentRunnableSequence } from "../agent.cjs";
-import * as _langchain_core_agents0 from "@langchain/core/agents";
+import * as _langchain_core_agents5 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
@@ -75,7 +75,7 @@ declare function createReactAgent({
   streamRunnable
 }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
+}, _langchain_core_agents5.AgentAction | _langchain_core_agents5.AgentFinish>>;
 //#endregion
 export { CreateReactAgentParams, createReactAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","AgentAction","AgentFinish","Promise"],"sources":["../../../src/agents/react/index.d.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\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`, `tool_names`, 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 ReAct prompting.\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, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\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/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\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 */\nexport declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAEzBH;EAEEF,GAAAA,EAFFE,0BAEEF;EAKCC;EAAkB,KAAA,EALnBD,aAKmB,EAAA;EAkDNM;;;;EAAuCI,MAAAA,EAlDnDT,kBAkDmDS;EAAkBL;;;;EAAiCD,cAAAA,CAAAA,EAAAA,OAAAA;CAARU;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFR,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -2,7 +2,7 @@ import { AgentRunnableSequence } from "../agent.js";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { ToolInterface } from "@langchain/core/tools";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import * as _langchain_core_agents0 from "@langchain/core/agents";
+import * as _langchain_core_agents5 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 
 //#region src/agents/react/index.d.ts
@@ -75,7 +75,7 @@ declare function createReactAgent({
   streamRunnable
 }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
+}, _langchain_core_agents5.AgentAction | _langchain_core_agents5.AgentFinish>>;
 //#endregion
 export { CreateReactAgentParams, createReactAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","AgentAction","AgentFinish","Promise"],"sources":["../../../src/agents/react/index.d.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\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`, `tool_names`, 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 ReAct prompting.\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, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\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/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\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 */\nexport declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAEzBH;EAEEF,GAAAA,EAFFE,0BAEEF;EAKCC;EAAkB,KAAA,EALnBD,aAKmB,EAAA;EAkDNM;;;;EAAuCI,MAAAA,EAlDnDT,kBAkDmDS;EAAkBL;;;;EAAiCD,cAAAA,CAAAA,EAAAA,OAAAA;CAARU;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFR,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","AgentActionOutputParser","ReActSingleInputOutputParser","Promise"],"sources":["../../../src/agents/react/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * Parses ReAct-style LLM calls that have a single tool input.\n *\n * Expects output to be in one of two formats.\n *\n * If the output signals that an action should be taken,\n * should be in the below format. This will result in an AgentAction\n * being returned.\n *\n * ```\n * Thought: agent thought here\n * Action: search\n * Action Input: what is the temperature in SF?\n * ```\n *\n * If the output signals that a final answer should be given,\n * should be in the below format. This will result in an AgentFinish\n * being returned.\n *\n * ```\n * Thought: agent thought here\n * Final Answer: The temperature is 100 degrees\n * ```\n * @example\n * ```typescript\n *\n * const runnableAgent = RunnableSequence.from([\n *   ...rest of runnable\n *   new ReActSingleInputOutputParser({ toolNames: [\"SerpAPI\", \"Calculator\"] }),\n * ]);\n * const agent = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n * const result = await agent.invoke({\n *   input: \"whats the weather in pomfret?\",\n * });\n * ```\n */\nexport declare class ReActSingleInputOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text into an AgentAction or AgentFinish object. If an\n     * output fixing parser is defined, uses it to parse the text.\n     * @param text Text to parse.\n     * @returns Promise that resolves to an AgentAction or AgentFinish object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions as a string. If the 'raw' option is\n     * true, returns the raw FORMAT_INSTRUCTIONS.\n     * @param options Options for getting the format instructions.\n     * @returns Format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;AAyCA;;;;;AAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5DG,4BAAAA,SAAqCD,uBAAAA;;;;;;;;;;;;uBAYjCE,QAAQJ,cAAcC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","AgentActionOutputParser","ReActSingleInputOutputParser","Promise"],"sources":["../../../src/agents/react/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\n/**\n * Parses ReAct-style LLM calls that have a single tool input.\n *\n * Expects output to be in one of two formats.\n *\n * If the output signals that an action should be taken,\n * should be in the below format. This will result in an AgentAction\n * being returned.\n *\n * ```\n * Thought: agent thought here\n * Action: search\n * Action Input: what is the temperature in SF?\n * ```\n *\n * If the output signals that a final answer should be given,\n * should be in the below format. This will result in an AgentFinish\n * being returned.\n *\n * ```\n * Thought: agent thought here\n * Final Answer: The temperature is 100 degrees\n * ```\n * @example\n * ```typescript\n *\n * const runnableAgent = RunnableSequence.from([\n *   ...rest of runnable\n *   new ReActSingleInputOutputParser({ toolNames: [\"SerpAPI\", \"Calculator\"] }),\n * ]);\n * const agent = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n * const result = await agent.invoke({\n *   input: \"whats the weather in pomfret?\",\n * });\n * ```\n */\nexport declare class ReActSingleInputOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text into an AgentAction or AgentFinish object. If an\n     * output fixing parser is defined, uses it to parse the text.\n     * @param text Text to parse.\n     * @returns Promise that resolves to an AgentAction or AgentFinish object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions as a string. If the 'raw' option is\n     * true, returns the raw FORMAT_INSTRUCTIONS.\n     * @param options Options for getting the format instructions.\n     * @returns Format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;AAyCA;;;;;AAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5DG,4BAAAA,SAAqCD,uBAAAA;;;;;;;;;;;;uBAYjCE,QAAQJ,cAAcC"}

package/dist/agents/structured_chat/index.d.cts

@@ -2,7 +2,7 @@ import { AgentInput } from "../types.cjs";
 import { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from "../agent.cjs";
 import { Optional } from "../../types/type-utils.cjs";
 import { StructuredChatOutputParserWithRetries } from "./outputParser.cjs";
-import * as _langchain_core_agents1 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 import { BaseMessagePromptTemplate, BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface, ToolDefinition } from "@langchain/core/language_models/base";
@@ -176,7 +176,7 @@ declare function createStructuredChatAgent({
   streamRunnable
 }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents1.AgentAction | _langchain_core_agents1.AgentFinish>>;
+}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
 //#endregion
 export { CreateStructuredChatAgentParams, StructuredChatAgent, StructuredChatAgentInput, StructuredChatCreatePromptArgs, createStructuredChatAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseLanguageModelInterface","ToolDefinition","BasePromptTemplate","BaseMessagePromptTemplate","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","AgentRunnableSequence","OutputParserArgs","AgentInput","StructuredChatOutputParserWithRetries","StructuredChatCreatePromptArgs","StructuredChatAgentInput","StructuredChatAgent","Promise","CreateStructuredChatAgentParams","createStructuredChatAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","AgentAction","AgentFinish"],"sources":["../../../src/agents/structured_chat/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { type BaseLanguageModelInterface, type ToolDefinition } from \"@langchain/core/language_models/base\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessagePromptTemplate, ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** String to use directly as the human message template. */\n    humanMessageTemplate?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** List of historical prompts from memory.  */\n    memoryPrompts?: BaseMessagePromptTemplate[];\n}\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport declare class StructuredChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    constructor(input: StructuredChatAgentInput);\n    _agentType(): \"structured-chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all provided tools have a description. Throws an error\n     * if any tool lacks a description.\n     * @param tools Array of StructuredTool instances to validate.\n     */\n    static validateTools(tools: StructuredToolInterface[]): void;\n    /**\n     * Returns a default output parser for the StructuredChatAgent. If an LLM\n     * is provided, it creates an output parser with retry logic from the LLM.\n     * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n     * @returns An instance of StructuredChatOutputParserWithRetries.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): StructuredChatOutputParserWithRetries;\n    /**\n     * Constructs the agent's scratchpad from a list of steps. If the agent's\n     * scratchpad is not empty, it prepends a message indicating that the\n     * agent has not seen any previous work.\n     * @param steps Array of AgentStep instances to construct the scratchpad from.\n     * @returns A Promise that resolves to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\n    /**\n     * Creates a string representation of the schemas of the provided tools.\n     * @param tools Array of StructuredTool instances to create the schemas string from.\n     * @returns A string representing the schemas of the provided tools.\n     */\n    static createToolSchemasString(tools: StructuredToolInterface[]): string;\n    /**\n     * Create prompt in the style of the agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables List of input variables the final prompt will expect.\n     * @param args.memoryPrompts List of historical prompts from memory.\n     */\n    static createPrompt(tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a StructuredChatAgent from an LLM and a list of tools.\n     * Validates the tools, creates a prompt, and sets up an LLM chain for the\n     * agent.\n     * @param llm BaseLanguageModel instance to create the agent from.\n     * @param tools Array of StructuredTool instances to create the agent from.\n     * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n     * @returns A new instance of StructuredChatAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;\n}\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n    /** LLM to use as the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: (StructuredToolInterface | ToolDefinition)[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, 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 aimed at supporting tools with multiple inputs.\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, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\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/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\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 *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAKqBgB,UArBJF,8BAAAA,CAqBuB;EAGjBC;EAUSf,MAAAA,CAAAA,EAAAA,MAAAA;EAOWW;EAEnCE,MAAAA,CAAAA,EAAAA,MAAAA;EAQuBP;EAAcW,oBAAAA,CAAAA,EAAAA,MAAAA;EAMHjB;EAWXA,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkCc;EAAiCT,aAAAA,CAAAA,EA1D9ED,yBA0D8EC,EAAAA;;;;;;AA/CjDG,KALrCO,wBAAAA,GAA2BR,QAKUC,CALDI,UAKCJ,EAAAA,cAAAA,CAAAA;AAAK;AA8DtD;;;AAIsCN,cAlEjBc,mBAAAA,SAA4BR,KAAAA,CAkEXN;EAK1BC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,EAAA,MAAA,EAAA;EA+DNgB,WAAAA,CAAAA,KAAAA,EAnIDJ,wBAmI0B;EAAGK,UAAAA,CAAAA,CAAAA,EAAAA,6CAAAA;EAAKC,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAOC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkBL;;;;;EAAkCD,OAAAA,aAAAA,CAAAA,KAAAA,EAzH5FjB,uBAyH4FiB,EAAAA,CAAAA,EAAAA,IAAAA;EAAO;;;;;;yCAlHxFN;;MAEnCE;;;;;;;;6BAQuBP,cAAcW;;;;;;wCAMHjB;;;;;;;;;;;6BAWXA,kCAAkCc,iCAAiCT;;;;;;;;;;8BAUlEJ,mCAAmCD,kCAAkCc,iCAAiCL,YAAYO;;;;;KAKtIE,+BAAAA;;OAEHjB;;UAEGD,0BAA0BE;;;;;UAK1BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYgB,yBAAAA;;;;;GAAkED,kCAAkCD,QAAQP;SACzHJ;GAASkB,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseLanguageModelInterface","ToolDefinition","BasePromptTemplate","BaseMessagePromptTemplate","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","AgentRunnableSequence","OutputParserArgs","AgentInput","StructuredChatOutputParserWithRetries","StructuredChatCreatePromptArgs","StructuredChatAgentInput","StructuredChatAgent","Promise","CreateStructuredChatAgentParams","createStructuredChatAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentAction","AgentFinish"],"sources":["../../../src/agents/structured_chat/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { type BaseLanguageModelInterface, type ToolDefinition } from \"@langchain/core/language_models/base\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessagePromptTemplate, ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** String to use directly as the human message template. */\n    humanMessageTemplate?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** List of historical prompts from memory.  */\n    memoryPrompts?: BaseMessagePromptTemplate[];\n}\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport declare class StructuredChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    constructor(input: StructuredChatAgentInput);\n    _agentType(): \"structured-chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all provided tools have a description. Throws an error\n     * if any tool lacks a description.\n     * @param tools Array of StructuredTool instances to validate.\n     */\n    static validateTools(tools: StructuredToolInterface[]): void;\n    /**\n     * Returns a default output parser for the StructuredChatAgent. If an LLM\n     * is provided, it creates an output parser with retry logic from the LLM.\n     * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n     * @returns An instance of StructuredChatOutputParserWithRetries.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): StructuredChatOutputParserWithRetries;\n    /**\n     * Constructs the agent's scratchpad from a list of steps. If the agent's\n     * scratchpad is not empty, it prepends a message indicating that the\n     * agent has not seen any previous work.\n     * @param steps Array of AgentStep instances to construct the scratchpad from.\n     * @returns A Promise that resolves to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\n    /**\n     * Creates a string representation of the schemas of the provided tools.\n     * @param tools Array of StructuredTool instances to create the schemas string from.\n     * @returns A string representing the schemas of the provided tools.\n     */\n    static createToolSchemasString(tools: StructuredToolInterface[]): string;\n    /**\n     * Create prompt in the style of the agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables List of input variables the final prompt will expect.\n     * @param args.memoryPrompts List of historical prompts from memory.\n     */\n    static createPrompt(tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a StructuredChatAgent from an LLM and a list of tools.\n     * Validates the tools, creates a prompt, and sets up an LLM chain for the\n     * agent.\n     * @param llm BaseLanguageModel instance to create the agent from.\n     * @param tools Array of StructuredTool instances to create the agent from.\n     * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n     * @returns A new instance of StructuredChatAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;\n}\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n    /** LLM to use as the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: (StructuredToolInterface | ToolDefinition)[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, 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 aimed at supporting tools with multiple inputs.\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, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\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/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\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 *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAKqBgB,UArBJF,8BAAAA,CAqBuB;EAGjBC;EAUSf,MAAAA,CAAAA,EAAAA,MAAAA;EAOWW;EAEnCE,MAAAA,CAAAA,EAAAA,MAAAA;EAQuBP;EAAcW,oBAAAA,CAAAA,EAAAA,MAAAA;EAMHjB;EAWXA,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkCc;EAAiCT,aAAAA,CAAAA,EA1D9ED,yBA0D8EC,EAAAA;;;;;;AA/CjDG,KALrCO,wBAAAA,GAA2BR,QAKUC,CALDI,UAKCJ,EAAAA,cAAAA,CAAAA;AAAK;AA8DtD;;;AAIsCN,cAlEjBc,mBAAAA,SAA4BR,KAAAA,CAkEXN;EAK1BC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,EAAA,MAAA,EAAA;EA+DNgB,WAAAA,CAAAA,KAAAA,EAnIDJ,wBAmI0B;EAAGK,UAAAA,CAAAA,CAAAA,EAAAA,6CAAAA;EAAKC,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAOC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkBL;;;;;EAAkCD,OAAAA,aAAAA,CAAAA,KAAAA,EAzH5FjB,uBAyH4FiB,EAAAA,CAAAA,EAAAA,IAAAA;EAAO;;;;;;yCAlHxFN;;MAEnCE;;;;;;;;6BAQuBP,cAAcW;;;;;;wCAMHjB;;;;;;;;;;;6BAWXA,kCAAkCc,iCAAiCT;;;;;;;;;;8BAUlEJ,mCAAmCD,kCAAkCc,iCAAiCL,YAAYO;;;;;KAKtIE,+BAAAA;;OAEHjB;;UAEGD,0BAA0BE;;;;;UAK1BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYgB,yBAAAA;;;;;GAAkED,kCAAkCD,QAAQP;SACzHJ;GAASkB,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.d.cts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n//# 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/structured_chat/outputParser.d.ts.map

@@ -0,0 +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//# 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

@@ -0,0 +1 @@
+{"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_agents3 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_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","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/output_parser.d.cts.map

@@ -0,0 +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//# 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.map

@@ -0,0 +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//# 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

@@ -0,0 +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//# 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

@@ -0,0 +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//# 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

@@ -1,5 +1,5 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "../../../memory/chat_memory.cjs";
-import * as _langchain_core_messages1 from "@langchain/core/messages";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
 import { ChatOpenAI } from "@langchain/openai";
 
@@ -37,7 +37,7 @@ declare class OpenAIAgentTokenBufferMemory extends BaseChatMemory {
    * Retrieves the messages from the chat history.
    * @returns Promise that resolves with the messages from the chat history.
    */
-  getMessages(): Promise<_langchain_core_messages1.BaseMessage<_langchain_core_messages1.MessageStructure, _langchain_core_messages1.MessageType>[]>;
+  getMessages(): Promise<_langchain_core_messages0.BaseMessage<_langchain_core_messages0.MessageStructure, _langchain_core_messages0.MessageType>[]>;
   /**
    * Loads memory variables from the input values.
    * @param _values Input values.