@langchain/classic 1.0.4 → 1.0.5

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

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","names":["StructuredToolInterface","ToolInterface","BaseLanguageModelInterface","CallbackManager","Callbacks","BasePromptTemplate","AgentAction","AgentFinish","AgentStep","BaseMessage","ChainValues","Serializable","Runnable","RunnableConfig","RunnableSequence","RunnableLike","LLMChain","AgentActionOutputParser","AgentInput","RunnableMultiActionAgentInput","RunnableSingleActionAgentInput","SerializedAgent","StoppingMethod","OutputParserArgs","Record","BaseAgent","Promise","BaseSingleActionAgent","BaseMultiActionAgent","isRunnableAgent","AgentRunnableSequence","RunInput","RunOutput","Error","Exclude","RunnableSingleActionAgent","RunnableMultiActionAgent","RunnableAgent","LLMSingleActionAgentInput","LLMSingleActionAgent","AgentArgs","Agent"],"sources":["../../src/agents/agent.d.ts"],"sourcesContent":["import type { StructuredToolInterface, ToolInterface } from \"@langchain/core/tools\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { CallbackManager, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { Runnable, type RunnableConfig, RunnableSequence, RunnableLike } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { AgentActionOutputParser, AgentInput, RunnableMultiActionAgentInput, RunnableSingleActionAgentInput, SerializedAgent, StoppingMethod } from \"./types.js\";\n/**\n * Record type for arguments passed to output parsers.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type OutputParserArgs = Record<string, any>;\n/**\n * Abstract base class for agents in LangChain. Provides common\n * functionality for agents, such as handling inputs and outputs.\n */\nexport declare abstract class BaseAgent extends Serializable {\n    ToolType: StructuredToolInterface;\n    abstract get inputKeys(): string[];\n    get returnValues(): string[];\n    get allowedTools(): string[] | undefined;\n    /**\n     * Return the string type key uniquely identifying this class of agent.\n     */\n    _agentType(): string;\n    /**\n     * Return the string type key uniquely identifying multi or single action agents.\n     */\n    abstract _agentActionType(): string;\n    /**\n     * Return response when agent has been stopped due to max iterations\n     */\n    returnStoppedResponse(earlyStoppingMethod: StoppingMethod, _steps: AgentStep[], _inputs: ChainValues, _callbackManager?: CallbackManager): Promise<AgentFinish>;\n    /**\n     * Prepare the agent for output, if needed\n     */\n    prepareForOutput(_returnValues: AgentFinish[\"returnValues\"], _steps: AgentStep[]): Promise<AgentFinish[\"returnValues\"]>;\n}\n/**\n * Abstract base class for single action agents in LangChain. Extends the\n * BaseAgent class and provides additional functionality specific to\n * single action agents.\n */\nexport declare abstract class BaseSingleActionAgent extends BaseAgent {\n    _agentActionType(): string;\n    /**\n     * Decide what to do, given some input.\n     *\n     * @param steps - Steps the LLM has taken so far, along with observations from each.\n     * @param inputs - User inputs.\n     * @param callbackManager - Callback manager.\n     *\n     * @returns Action specifying what tool to use.\n     */\n    abstract plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Abstract base class for multi-action agents in LangChain. Extends the\n * BaseAgent class and provides additional functionality specific to\n * multi-action agents.\n */\nexport declare abstract class BaseMultiActionAgent extends BaseAgent {\n    _agentActionType(): string;\n    /**\n     * Decide what to do, given some input.\n     *\n     * @param steps - Steps the LLM has taken so far, along with observations from each.\n     * @param inputs - User inputs.\n     * @param callbackManager - Callback manager.\n     *\n     * @returns Actions specifying what tools to use.\n     */\n    abstract plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction[] | AgentFinish>;\n}\nexport declare function isRunnableAgent(x: BaseAgent): boolean;\n// TODO: Remove in the future. Only for backwards compatibility.\n// Allows for the creation of runnables with properties that will\n// be passed to the agent executor constructor.\nexport declare class AgentRunnableSequence<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunInput = any, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunOutput = any> extends RunnableSequence<RunInput, RunOutput> {\n    streamRunnable?: boolean;\n    singleAction: boolean;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [\n        RunnableLike<RunInput>,\n        ...RunnableLike[],\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        RunnableLike<any, RunOutput>\n    ], config: {\n        singleAction: boolean;\n        streamRunnable?: boolean;\n        name?: string;\n    }): AgentRunnableSequence<RunInput, Exclude<RunOutput, Error>>;\n    static isAgentRunnableSequence(x: Runnable): x is AgentRunnableSequence;\n}\n/**\n * Class representing a single-action agent powered by runnables.\n * Extends the BaseSingleActionAgent class and provides methods for\n * planning agent actions with runnables.\n */\nexport declare class RunnableSingleActionAgent extends BaseSingleActionAgent {\n    lc_namespace: string[];\n    runnable: Runnable<ChainValues & {\n        steps: AgentStep[];\n    }, AgentAction | AgentFinish>;\n    get inputKeys(): string[];\n    /**\n     * Whether to stream from the runnable or not.\n     * If true, the underlying LLM is invoked in a streaming fashion to make it\n     * possible to get access to the individual LLM tokens when using\n     * `streamLog` with the Agent Executor. If false then LLM is invoked in a\n     * non-streaming fashion and individual LLM tokens will not be available\n     * in `streamLog`.\n     *\n     * Note that the runnable should still only stream a single action or\n     * finish chunk.\n     */\n    streamRunnable: boolean;\n    defaultRunName: string;\n    constructor(fields: RunnableSingleActionAgentInput);\n    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Class representing a multi-action agent powered by runnables.\n * Extends the BaseMultiActionAgent class and provides methods for\n * planning agent actions with runnables.\n */\nexport declare class RunnableMultiActionAgent extends BaseMultiActionAgent {\n    lc_namespace: string[];\n    // TODO: Rename input to \"intermediate_steps\"\n    runnable: Runnable<ChainValues & {\n        steps: AgentStep[];\n    }, AgentAction[] | AgentAction | AgentFinish>;\n    defaultRunName: string;\n    stop?: string[];\n    streamRunnable: boolean;\n    get inputKeys(): string[];\n    constructor(fields: RunnableMultiActionAgentInput);\n    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction[] | AgentFinish>;\n}\nexport declare class RunnableAgent extends RunnableMultiActionAgent {\n}\n/**\n * Interface for input data for creating a LLMSingleActionAgent.\n */\nexport interface LLMSingleActionAgentInput {\n    llmChain: LLMChain;\n    outputParser: AgentActionOutputParser;\n    stop?: string[];\n}\n/**\n * Class representing a single action agent using a LLMChain in LangChain.\n * Extends the BaseSingleActionAgent class and provides methods for\n * planning agent actions based on LLMChain outputs.\n * @example\n * ```typescript\n * const customPromptTemplate = new CustomPromptTemplate({\n *   tools: [new Calculator()],\n *   inputVariables: [\"input\", \"agent_scratchpad\"],\n * });\n * const customOutputParser = new CustomOutputParser();\n * const agent = new LLMSingleActionAgent({\n *   llmChain: new LLMChain({\n *     prompt: customPromptTemplate,\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   }),\n *   outputParser: customOutputParser,\n *   stop: [\"\\nObservation\"],\n * });\n * const executor = new AgentExecutor({\n *   agent,\n *   tools: [new Calculator()],\n * });\n * const result = await executor.invoke({\n *   input:\n *     \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\",\n * });\n * ```\n */\nexport declare class LLMSingleActionAgent extends BaseSingleActionAgent {\n    lc_namespace: string[];\n    llmChain: LLMChain;\n    outputParser: AgentActionOutputParser;\n    stop?: string[];\n    constructor(input: LLMSingleActionAgentInput);\n    get inputKeys(): string[];\n    /**\n     * Decide what to do given some input.\n     *\n     * @param steps - Steps the LLM has taken so far, along with observations from each.\n     * @param inputs - User inputs.\n     * @param callbackManager - Callback manager.\n     *\n     * @returns Action specifying what tool to use.\n     */\n    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n}\n/**\n * Interface for arguments used to create an agent in LangChain.\n */\nexport interface AgentArgs {\n    outputParser?: AgentActionOutputParser;\n    callbacks?: Callbacks;\n    /**\n     * @deprecated Use `callbacks` instead.\n     */\n    callbackManager?: CallbackManager;\n}\n/**\n * Class responsible for calling a language model and deciding an action.\n *\n * @remarks This is driven by an LLMChain. The prompt in the LLMChain *must*\n * include a variable called \"agent_scratchpad\" where the agent can put its\n * intermediary work.\n */\nexport declare abstract class Agent extends BaseSingleActionAgent {\n    llmChain: LLMChain;\n    outputParser: AgentActionOutputParser | undefined;\n    private _allowedTools?;\n    get allowedTools(): string[] | undefined;\n    get inputKeys(): string[];\n    constructor(input: AgentInput);\n    /**\n     * Prefix to append the observation with.\n     */\n    abstract observationPrefix(): string;\n    /**\n     * Prefix to append the LLM call with.\n     */\n    abstract llmPrefix(): string;\n    /**\n     * Return the string type key uniquely identifying this class of agent.\n     */\n    abstract _agentType(): string;\n    /**\n     * Get the default output parser for this agent.\n     */\n    static getDefaultOutputParser(_fields?: OutputParserArgs): AgentActionOutputParser;\n    /**\n     * Create a prompt for this class\n     *\n     * @param _tools - List of tools the agent will have access to, used to format the prompt.\n     * @param _fields - Additional fields used to format the prompt.\n     *\n     * @returns A PromptTemplate assembled from the given tools and fields.\n     * */\n    static createPrompt(_tools: StructuredToolInterface[], \n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    _fields?: Record<string, any>): BasePromptTemplate;\n    /** Construct an agent from an LLM and a list of tools */\n    static fromLLMAndTools(_llm: BaseLanguageModelInterface, _tools: StructuredToolInterface[], _args?: AgentArgs): Agent;\n    /**\n     * Validate that appropriate tools are passed in\n     */\n    static validateTools(_tools: StructuredToolInterface[]): void;\n    _stop(): string[];\n    /**\n     * Name of tool to use to terminate the chain.\n     */\n    finishToolName(): string;\n    /**\n     * Construct a scratchpad to let the agent continue its thought process\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string | BaseMessage[]>;\n    private _plan;\n    /**\n     * Decide what to do given some input.\n     *\n     * @param steps - Steps the LLM has taken so far, along with observations from each.\n     * @param inputs - User inputs.\n     * @param callbackManager - Callback manager to use for this call.\n     *\n     * @returns Action specifying what tool to use.\n     */\n    plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentAction | AgentFinish>;\n    /**\n     * Return response when agent has been stopped due to max iterations\n     */\n    returnStoppedResponse(earlyStoppingMethod: StoppingMethod, steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager): Promise<AgentFinish>;\n    /**\n     * Load an agent from a json-like object describing it.\n     */\n    static deserialize(data: SerializedAgent & {\n        llm?: BaseLanguageModelInterface;\n        tools?: ToolInterface[];\n    }): Promise<Agent>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA;AAKA;AAAuC,KAL3BuB,gBAAAA,GAAmBC,MAKQ,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;AAgBsFrB,uBAhB/FsB,SAAAA,SAAkBd,YAAAA,CAgB6ER;EAAe,QAAWI,EAfzIP,uBAeyIO;EAAW,aAAnBmB,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,IAIlHnB,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAW,IAA0BC,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;EAAS;;;EApBtB,UAAA,CAAA,CAAA,EAAA,MAAA;EA2B9BmB;;;EAWI,SAAYjB,gBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW;;;EAAkF,qBAAGH,CAAAA,mBAAAA,EAtB/Fe,cAsB+Ff,EAAAA,MAAAA,EAtBvEC,SAsBuED,EAAAA,EAAAA,OAAAA,EAtBjDG,WAsBiDH,EAAAA,gBAAAA,CAAAA,EAtBjBJ,eAsBiBI,CAAAA,EAtBCmB,OAsBDnB,CAtBSA,WAsBTA,CAAAA;EAAW;;AAXpF;EAkBvCqB,gBAAAA,CAAAA,aAAoB,EAzBdrB,WAyBc,CAAA,cAAA,CAAA,EAAA,MAAA,EAzBuBC,SAyBvB,EAAA,CAAA,EAzBqCkB,OAyBrC,CAzB6CnB,WAyB7C,CAAA,cAAA,CAAA,CAAA;;;;;;;AAW8FA,uBA7BlHoB,qBAAAA,SAA8BF,SAAAA,CA6BoFlB;EAAW,gBAAnCmB,CAAAA,CAAAA,EAAAA,MAAAA;EAAO;AAX3D;AAiBpE;;;;;;;EAUuB,SAEGM,IAAAA,CAAAA,KAAAA,EApCDxB,SAoCCwB,EAAAA,EAAAA,MAAAA,EApCoBtB,WAoCpBsB,EAAAA,eAAAA,CAAAA,EApCmD7B,eAoCnD6B,EAAAA,MAAAA,CAAAA,EApC6EnB,cAoC7EmB,CAAAA,EApC8FN,OAoC9FM,CApCsG1B,WAoCtG0B,GApCoHzB,WAoCpHyB,CAAAA;;;;;;;AAMYpB,uBAnCRgB,oBAAAA,SAA6BH,SAAAA,CAmCrBb;EAAQ,gBAAQkB,CAAAA,CAAAA,EAAAA,MAAAA;EAAqB;AAdlC;AAgDzC;;;;;;;EAKgD,SAFlClB,IAAAA,CAAAA,KAAAA,EA7DWJ,SA6DXI,EAAAA,EAAAA,MAAAA,EA7DgCF,WA6DhCE,EAAAA,eAAAA,CAAAA,EA7D+DT,eA6D/DS,EAAAA,MAAAA,CAAAA,EA7DyFC,cA6DzFD,CAAAA,EA7D0Gc,OA6D1Gd,CA7DkHN,WA6DlHM,EAAAA,GA7DkIL,WA6DlIK,CAAAA;;;;;AAQyGN,cA/DlGwB,qBA+DkGxB;;WAARoB,GAAAA;;AAXrC,YAAA,GAAA,CAAA,SAhDjDZ,gBAgDiD,CAhDhCiB,QAgDgC,EAhDtBC,SAgDsB,CAAA,CAAA;EAarDK,cAAAA,CAAAA,EAAa,OAAA;EAKjBC,YAAAA,EAAAA,OAAAA;EAAyB;EAAA,OAC5BtB,aAAAA,CAAAA,WAAAA,GAAAA,EAAAA,YAAAA,GAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,SAAAA,CAAAA,EAAAA,CA9DND,YA+DUE,CA/DGc,QA+DHd,CAAAA,EAAuB,GA9D9BF,YA8D8B,EAAA;EAgCpBwB;EA5FbxB,YA4FiC,CAAA,GAAA,EA5FfiB,SA4Fe,CAAA,CAAA,EAE3BhB,MAAAA,EAAAA;IACIC,YAAAA,EAAAA,OAAAA;IAEKqB,cAAAA,CAAAA,EAAAA,OAAAA;IAWP9B,IAAAA,CAAAA,EAAAA,MAAAA;EAAS,CAAA,CAAA,EAvGjBsB,qBAuG6BpB,CAvGPqB,QAuGOrB,EAvGGwB,OAuGHxB,CAvGWsB,SAuGXtB,EAvGsBuB,KAuGtBvB,CAAAA,CAAAA;EAAW,OAAoBP,uBAAAA,CAAAA,CAAAA,EAtG9BS,QAsG8BT,CAAAA,EAAAA,CAAAA,IAtGd2B,qBAsGc3B;;;;;AAhBG;AAqBvE;;;;;;;AA0E4GI,cAnJvF6B,wBAAAA,SAAiCR,oBAAAA,CAmJsDrB;EAAW,YAAjCmB,EAAAA,MAAAA,EAAAA;EAAO;EAIhC,QAASlB,EApJxDI,QAoJwDJ,CApJ/CE,WAoJ+CF,GAAAA;IAAqBE,KAAAA,EAnJ5EF,SAmJ4EE,EAAAA;EAAW,CAAA,EAlJ/FJ,WAkJmHH,EAAAA,GAlJnGG,WAkJmGH,GAlJrFI,WAkJqFJ,CAAAA;EAAe,cAAWI,EAAAA,MAAAA;EAAW,IAAnBmB,CAAAA,EAAAA,MAAAA,EAAAA;EAAO,cAItHL,EAAAA,OAAAA;EAAe,IAC9BnB,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA0B,WACxBD,CAAAA,MAAAA,EAnJQkB,6BAmJRlB;EAAa,IACbwC,CAAAA,KAAAA,EAnJAjC,SAmJAiC,EAAAA,EAAAA,MAAAA,EAnJqB/B,WAmJrB+B,EAAAA,eAAAA,CAAAA,EAnJoDtC,eAmJpDsC,EAAAA,MAAAA,CAAAA,EAnJ8E5B,cAmJ9E4B,CAAAA,EAnJ+Ff,OAmJ/Fe,CAnJuGnC,WAmJvGmC,EAAAA,GAnJuHlC,WAmJvHkC,CAAAA;;AAtE4Bd,cA3EvBU,aAAAA,SAAsBD,wBAAwB,CA2EvBT;;;;UAtE3BW,yBAAAA;YACHtB;gBACIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgCGsB,oBAAAA,SAA6BZ,qBAAAA;;YAEpCX;gBACIC;;qBAEKqB;;;;;;;;;;;cAWP9B,qBAAqBE,+BAA+BP,kBAAkBuB,QAAQpB,cAAcC;;;;;UAK3FiC,SAAAA;iBACEvB;cACHb;;;;oBAIMD;;;;;;;;;uBASQsC,KAAAA,SAAcd,qBAAAA;YAC9BX;gBACIC;;;;qBAIKC;;;;;;;;;;;;;;;;0CAgBqBK,mBAAmBN;;;;;;;;;8BAS/BjB;;YAElBwB,sBAAsBnB;;+BAEHH,oCAAoCF,mCAAmCwC,YAAYC;;;;+BAInFzC;;;;;;;;;6BASFQ,cAAckB,iBAAiBjB;;;;;;;;;;;cAW9CD,qBAAqBE,+BAA+BP,kBAAkBuB,QAAQpB,cAAcC;;;;6CAI7De,uBAAuBd,qBAAqBE,+BAA+BP,kBAAkBuB,QAAQnB;;;;2BAIvHc;UACfnB;YACED;MACRyB,QAAQe"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","ToolInterface","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","OutputParserArgs","AgentInput","ChatAgentOutputParser","ChatCreatePromptArgs","ChatAgentInput","ChatAgent","Promise"],"sources":["../../../src/agents/chat/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport type { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { ChatAgentOutputParser } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a chat prompt.\n */\nexport interface ChatCreatePromptArgs {\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    /** Formattable string to use as the instructions template. */\n    formatInstructions?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n}\n/**\n * Type for input data for creating a ChatAgent, extending AgentInput with\n * optional 'outputParser'.\n */\nexport type ChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n */\nexport declare class ChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ChatAgentInput);\n    _agentType(): \"chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all tools have descriptions. Throws an error if a tool\n     * without a description is found.\n     * @param tools Array of Tool instances to validate.\n     * @returns void\n     */\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Returns a default output parser for the ChatAgent.\n     * @param _fields Optional OutputParserArgs to customize the output parser.\n     * @returns ChatAgentOutputParser instance\n     */\n    static getDefaultOutputParser(_fields?: OutputParserArgs): ChatAgentOutputParser;\n    /**\n     * Constructs the agent's scratchpad, which is a string representation of\n     * the agent's previous steps.\n     * @param steps Array of AgentStep instances representing the agent's previous steps.\n     * @returns Promise resolving to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\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.humanMessageTemplate - String to use directly as the human message template\n     * @param args.formatInstructions - Formattable string to use as the instructions template\n     */\n    static createPrompt(tools: ToolInterface[], args?: ChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a ChatAgent instance using a language model, tools, and\n     * optional arguments.\n     * @param llm BaseLanguageModelInterface instance to use in the agent.\n     * @param tools Array of Tool instances to include in the agent.\n     * @param args Optional arguments to customize the agent and prompt.\n     * @returns ChatAgent instance\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ChatCreatePromptArgs & AgentArgs): ChatAgent;\n}\n"],"mappings":";;;;;;;;;;;;;AAWA;AAgBYW,UAhBKD,oBAAAA,CAgBS;EAAA;EAAA,MAAYF,CAAAA,EAAAA,MAAAA;EAAU;EAAX,MAAA,CAAA,EAAA,MAAA;EAKhBI;EAAS,oBAAA,CAAA,EAAA,MAAA;EAAA;EAGH,kBACJD,CAAAA,EAAAA,MAAAA;EAAc;EAWQ,cAMDJ,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AAkBkCL,KA5ClES,cAAAA,GAAiBP,QA4CiDF,CA5CxCM,UA4CwCN,EAAAA,cAAAA,CAAAA;;;;;AASgDU,cAhDzGA,SAAAA,SAAkBP,KAAAA,CAgDuFO;EAAS,OAhDhGP,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAK,YAAA,EAAA,MAAA,EAAA;YAG9BJ;qBACSU;;;;;;;;;;;8BAWSV;;;;;;0CAMYM,mBAAmBE;;;;;;;6BAOhCN,cAAcU;;;;;;;;;;;6BAWdZ,wBAAwBS,uBAAuBR;;;;;;;;;8BAS9CF,mCAAmCC,wBAAwBS,uBAAuBJ,YAAYM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","ToolInterface","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","OutputParserArgs","AgentInput","ChatAgentOutputParser","ChatCreatePromptArgs","ChatAgentInput","ChatAgent","Promise"],"sources":["../../../src/agents/chat/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport type { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { ChatAgentOutputParser } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a chat prompt.\n */\nexport interface ChatCreatePromptArgs {\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    /** Formattable string to use as the instructions template. */\n    formatInstructions?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n}\n/**\n * Type for input data for creating a ChatAgent, extending AgentInput with\n * optional 'outputParser'.\n */\nexport type ChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n */\nexport declare class ChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ChatAgentInput);\n    _agentType(): \"chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all tools have descriptions. Throws an error if a tool\n     * without a description is found.\n     * @param tools Array of Tool instances to validate.\n     * @returns void\n     */\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Returns a default output parser for the ChatAgent.\n     * @param _fields Optional OutputParserArgs to customize the output parser.\n     * @returns ChatAgentOutputParser instance\n     */\n    static getDefaultOutputParser(_fields?: OutputParserArgs): ChatAgentOutputParser;\n    /**\n     * Constructs the agent's scratchpad, which is a string representation of\n     * the agent's previous steps.\n     * @param steps Array of AgentStep instances representing the agent's previous steps.\n     * @returns Promise resolving to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\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.humanMessageTemplate - String to use directly as the human message template\n     * @param args.formatInstructions - Formattable string to use as the instructions template\n     */\n    static createPrompt(tools: ToolInterface[], args?: ChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a ChatAgent instance using a language model, tools, and\n     * optional arguments.\n     * @param llm BaseLanguageModelInterface instance to use in the agent.\n     * @param tools Array of Tool instances to include in the agent.\n     * @param args Optional arguments to customize the agent and prompt.\n     * @returns ChatAgent instance\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ChatCreatePromptArgs & AgentArgs): ChatAgent;\n}\n"],"mappings":";;;;;;;;;;;;;AAWA;AAgBYW,UAhBKD,oBAAAA,CAgBS;EAAA;EAAA,MAAYF,CAAAA,EAAAA,MAAAA;EAAU;EAAX,MAAA,CAAA,EAAA,MAAA;EAKhBI;EAAS,oBAAA,CAAA,EAAA,MAAA;EAAA;EAGH,kBACJD,CAAAA,EAAAA,MAAAA;EAAc;EAWQ,cAMDJ,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AAkBkCL,KA5ClES,cAAAA,GAAiBP,QA4CiDF,CA5CxCM,UA4CwCN,EAAAA,cAAAA,CAAAA;;;;;AASgDU,cAhDzGA,SAAAA,SAAkBP,KAAAA,CAgDuFO;EAAS,OAhDhGP,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAK,YAAA,EAAA,MAAA,EAAA;YAG9BJ;qBACSU;;;;;;;;;;;8BAWSV;;;;;;0CAMYM,mBAAmBE;;;;;;;6BAOhCN,cAAcU;;;;;;;;;;;6BAWdZ,wBAAwBS,uBAAuBR;;;;;;;;;8BAS9CF,mCAAmCC,wBAAwBS,uBAAuBJ,YAAYM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"outputParser.d.cts","names":["AgentActionOutputParser","FINAL_ANSWER_ACTION","ChatAgentOutputParser","Promise"],"sources":["../../../src/agents/chat/outputParser.d.ts"],"sourcesContent":["import { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends the AgentActionOutputParser to parse the output of\n * the ChatAgent in LangChain. It checks if the output text contains the\n * final answer action or a JSON response, and parses it accordingly.\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\n *     \"ai\",\n *     `{PREFIX}\n * {FORMAT_INSTRUCTIONS}\n * {SUFFIX}`,\n *   ],\n *   [\"human\", \"Question: {input}\"],\n * ]);\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: AgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: AgentStep[] }) =>\n *       formatLogToString(i.steps),\n *   },\n *   prompt,\n *   new OpenAI({ temperature: 0 }),\n *   new ChatAgentOutputParser(),\n * ]);\n *\n * const executor = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n *\n * const result = await executor.invoke({\n *   input:\n *     \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\",\n * });\n * ```\n */\nexport declare class ChatAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    /**\n     * Parses the output text from the MRKL chain into an agent action or\n     * agent finish. If the text contains the final answer action or does not\n     * contain an action, it returns an AgentFinish with the output and log.\n     * If the text contains a JSON response, it returns the tool, toolInput,\n     * and log.\n     * @param text The output text from the MRKL chain.\n     * @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and 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: any;\n        toolInput: any;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions used in the output parser for the\n     * ChatAgent class.\n     * @returns The format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;AAuCA;;;;AAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArDE,qBAAAA,SAA8BF,uBAAAA;;;;;;;;;;;uBAW1BG"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"outputParser.d.ts","names":["AgentActionOutputParser","FINAL_ANSWER_ACTION","ChatAgentOutputParser","Promise"],"sources":["../../../src/agents/chat/outputParser.d.ts"],"sourcesContent":["import { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends the AgentActionOutputParser to parse the output of\n * the ChatAgent in LangChain. It checks if the output text contains the\n * final answer action or a JSON response, and parses it accordingly.\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\n *     \"ai\",\n *     `{PREFIX}\n * {FORMAT_INSTRUCTIONS}\n * {SUFFIX}`,\n *   ],\n *   [\"human\", \"Question: {input}\"],\n * ]);\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: AgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: AgentStep[] }) =>\n *       formatLogToString(i.steps),\n *   },\n *   prompt,\n *   new OpenAI({ temperature: 0 }),\n *   new ChatAgentOutputParser(),\n * ]);\n *\n * const executor = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n *\n * const result = await executor.invoke({\n *   input:\n *     \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\",\n * });\n * ```\n */\nexport declare class ChatAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    /**\n     * Parses the output text from the MRKL chain into an agent action or\n     * agent finish. If the text contains the final answer action or does not\n     * contain an action, it returns an AgentFinish with the output and log.\n     * If the text contains a JSON response, it returns the tool, toolInput,\n     * and log.\n     * @param text The output text from the MRKL chain.\n     * @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.\n     */\n    parse(text: string): Promise<{\n        tool?: undefined;\n        toolInput?: undefined;\n        returnValues: {\n            output: string;\n        };\n        log: string;\n    } | {\n        returnValues?: undefined;\n        tool: any;\n        toolInput: any;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions used in the output parser for the\n     * ChatAgent class.\n     * @returns The format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;AAuCA;;;;AAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArDE,qBAAAA,SAA8BF,uBAAAA;;;;;;;;;;;uBAW1BG"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","ToolInterface","ChatPromptTemplate","AgentStep","BaseMessage","Optional","Agent","AgentArgs","OutputParserArgs","AgentActionOutputParser","AgentInput","ChatConversationalCreatePromptArgs","ChatConversationalAgentInput","ChatConversationalAgent","Promise"],"sources":["../../../src/agents/chat_convo/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport type { AgentStep } from \"@langchain/core/agents\";\nimport { type BaseMessage } from \"@langchain/core/messages\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser, AgentInput } from \"../types.js\";\n/**\n * Interface defining the structure of arguments used to create a prompt\n * for the ChatConversationalAgent class.\n */\nexport interface ChatConversationalCreatePromptArgs {\n    /** String to put after the list of tools. */\n    systemMessage?: string;\n    /** String to put before the list of tools. */\n    humanMessage?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** Output parser to use for formatting. */\n    outputParser?: AgentActionOutputParser;\n}\n/**\n * Type that extends the AgentInput interface for the\n * ChatConversationalAgent class, making the outputParser property\n * optional.\n */\nexport type ChatConversationalAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n */\nexport declare class ChatConversationalAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ChatConversationalAgentInput);\n    _agentType(): \"chat-conversational-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Constructs the agent scratchpad based on the agent steps. It returns an\n     * array of base messages representing the thoughts of the agent.\n     * @param steps The agent steps to construct the scratchpad from.\n     * @returns An array of base messages representing the thoughts of the agent.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<BaseMessage[]>;\n    /**\n     * Returns the default output parser for the ChatConversationalAgent\n     * class. It takes optional fields as arguments to customize the output\n     * parser.\n     * @param fields Optional fields to customize the output parser.\n     * @returns The default output parser for the ChatConversationalAgent class.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): AgentActionOutputParser;\n    /**\n     * Create prompt in the style of the ChatConversationAgent.\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.systemMessage - String to put before the list of tools.\n     * @param args.humanMessage - String to put after the list of tools.\n     * @param args.outputParser - Output parser to use for formatting.\n     */\n    static createPrompt(tools: ToolInterface[], args?: ChatConversationalCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates an instance of the ChatConversationalAgent class from a\n     * BaseLanguageModel and a set of tools. It takes optional arguments to\n     * customize the agent.\n     * @param llm The BaseLanguageModel to create the agent from.\n     * @param tools The set of tools to create the agent from.\n     * @param args Optional arguments to customize the agent.\n     * @returns An instance of the ChatConversationalAgent class.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ChatConversationalCreatePromptArgs & AgentArgs): ChatConversationalAgent;\n}\n"],"mappings":";;;;;;;;;;;;;AAYA;AAeA;AAAwC,UAfvBW,kCAAAA,CAeuB;EAAA;EAAsB,aAAnBN,CAAAA,EAAAA,MAAAA;EAAQ;EAK9BQ,YAAAA,CAAAA,EAAAA,MAAAA;EAAuB;EAAA,cAG9BZ,CAAAA,EAAAA,MAAAA,EAAAA;EAAa;EACwB,YAKnBA,CAAAA,EArBbQ,uBAqBaR;;;;;;;AA2BuBU,KAzC3CC,4BAAAA,GAA+BP,QAyCYM,CAzCHD,UAyCGC,EAAAA,cAAAA,CAAAA;;;;;AAUyEJ,cA9C3GM,uBAAAA,SAAgCP,KAAAA,CA8C2EC;EAAS,OAAGM,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,YA9C9GP,EAAAA,MAAAA,EAAAA;EAAK,QAAA,EAG5CL,aAH4C;qBAInCW;;;;;8BAKSX;;;;;;;6BAODE,cAAcW,QAAQV;;;;;;;;yCAQVI;;MAEnCC;;;;;;;;;;6BAUuBR,wBAAwBU,qCAAqCT;;;;;;;;;;8BAU5DF,mCAAmCC,wBAAwBU,qCAAqCJ,YAAYM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","ToolInterface","ChatPromptTemplate","AgentStep","BaseMessage","Optional","Agent","AgentArgs","OutputParserArgs","AgentActionOutputParser","AgentInput","ChatConversationalCreatePromptArgs","ChatConversationalAgentInput","ChatConversationalAgent","Promise"],"sources":["../../../src/agents/chat_convo/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport type { AgentStep } from \"@langchain/core/agents\";\nimport { type BaseMessage } from \"@langchain/core/messages\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser, AgentInput } from \"../types.js\";\n/**\n * Interface defining the structure of arguments used to create a prompt\n * for the ChatConversationalAgent class.\n */\nexport interface ChatConversationalCreatePromptArgs {\n    /** String to put after the list of tools. */\n    systemMessage?: string;\n    /** String to put before the list of tools. */\n    humanMessage?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** Output parser to use for formatting. */\n    outputParser?: AgentActionOutputParser;\n}\n/**\n * Type that extends the AgentInput interface for the\n * ChatConversationalAgent class, making the outputParser property\n * optional.\n */\nexport type ChatConversationalAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n */\nexport declare class ChatConversationalAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ChatConversationalAgentInput);\n    _agentType(): \"chat-conversational-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Constructs the agent scratchpad based on the agent steps. It returns an\n     * array of base messages representing the thoughts of the agent.\n     * @param steps The agent steps to construct the scratchpad from.\n     * @returns An array of base messages representing the thoughts of the agent.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<BaseMessage[]>;\n    /**\n     * Returns the default output parser for the ChatConversationalAgent\n     * class. It takes optional fields as arguments to customize the output\n     * parser.\n     * @param fields Optional fields to customize the output parser.\n     * @returns The default output parser for the ChatConversationalAgent class.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): AgentActionOutputParser;\n    /**\n     * Create prompt in the style of the ChatConversationAgent.\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.systemMessage - String to put before the list of tools.\n     * @param args.humanMessage - String to put after the list of tools.\n     * @param args.outputParser - Output parser to use for formatting.\n     */\n    static createPrompt(tools: ToolInterface[], args?: ChatConversationalCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates an instance of the ChatConversationalAgent class from a\n     * BaseLanguageModel and a set of tools. It takes optional arguments to\n     * customize the agent.\n     * @param llm The BaseLanguageModel to create the agent from.\n     * @param tools The set of tools to create the agent from.\n     * @param args Optional arguments to customize the agent.\n     * @returns An instance of the ChatConversationalAgent class.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ChatConversationalCreatePromptArgs & AgentArgs): ChatConversationalAgent;\n}\n"],"mappings":";;;;;;;;;;;;;AAYA;AAeA;AAAwC,UAfvBW,kCAAAA,CAeuB;EAAA;EAAsB,aAAnBN,CAAAA,EAAAA,MAAAA;EAAQ;EAK9BQ,YAAAA,CAAAA,EAAAA,MAAAA;EAAuB;EAAA,cAG9BZ,CAAAA,EAAAA,MAAAA,EAAAA;EAAa;EACwB,YAKnBA,CAAAA,EArBbQ,uBAqBaR;;;;;;;AA2BuBU,KAzC3CC,4BAAAA,GAA+BP,QAyCYM,CAzCHD,UAyCGC,EAAAA,cAAAA,CAAAA;;;;;AAUyEJ,cA9C3GM,uBAAAA,SAAgCP,KAAAA,CA8C2EC;EAAS,OAAGM,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,YA9C9GP,EAAAA,MAAAA,EAAAA;EAAK,QAAA,EAG5CL,aAH4C;qBAInCW;;;;;8BAKSX;;;;;;;6BAODE,cAAcW,QAAQV;;;;;;;;yCAQVI;;MAEnCC;;;;;;;;;;6BAUuBR,wBAAwBU,qCAAqCT;;;;;;;;;;8BAU5DF,mCAAmCC,wBAAwBU,qCAAqCJ,YAAYM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"outputParser.d.cts","names":["BaseLanguageModelInterface","AgentAction","AgentFinish","FormatInstructionsOptions","AgentActionOutputParser","OutputFixingParser","ChatConversationalAgentOutputParserFormatInstructionsOptions","ChatConversationalAgentOutputParser","Promise","ChatConversationalAgentOutputParserArgs","ChatConversationalAgentOutputParserWithRetries","Omit"],"sources":["../../../src/agents/chat_convo/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { FormatInstructionsOptions } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\nexport type ChatConversationalAgentOutputParserFormatInstructionsOptions = FormatInstructionsOptions & {\n    toolNames: string[];\n    raw?: boolean;\n};\n/**\n * Class that represents an output parser for the ChatConversationalAgent\n * class. It extends the AgentActionOutputParser class and provides\n * methods for parsing the output of the MRKL chain into agent actions.\n */\nexport declare class ChatConversationalAgentOutputParser 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}\nexport type ChatConversationalAgentOutputParserArgs = {\n    baseParser?: ChatConversationalAgentOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n};\n/**\n * Class that represents an output parser with retries for the\n * ChatConversationalAgent class. It extends the AgentActionOutputParser\n * class and provides methods for parsing the output of the MRKL chain\n * into agent actions with retry functionality.\n */\nexport declare class ChatConversationalAgentOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: ChatConversationalAgentOutputParserArgs);\n    /**\n     * Returns the format instructions as a string.\n     * @returns Format instructions as a string.\n     */\n    getFormatInstructions(options: ChatConversationalAgentOutputParserFormatInstructionsOptions): string;\n    /**\n     * Parses the given text into an AgentAction or AgentFinish object.\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     * Static method to create a new\n     * ChatConversationalAgentOutputParserWithRetries from a BaseLanguageModelInterface\n     * and options. If no base parser is provided in the options, a new\n     * ChatConversationalAgentOutputParser is created. An OutputFixingParser\n     * is also created from the BaseLanguageModelInterface and the base parser.\n     * @param llm BaseLanguageModelInterface instance used to create the OutputFixingParser.\n     * @param options Options for creating the ChatConversationalAgentOutputParserWithRetries instance.\n     * @returns A new instance of ChatConversationalAgentOutputParserWithRetries.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<ChatConversationalAgentOutputParserArgs, \"outputFixingParser\">): ChatConversationalAgentOutputParserWithRetries;\n}\n"],"mappings":";;;;;;;KAKYM,4DAAAA,GAA+DH;;EAA/DG,GAAAA,CAAAA,EAAAA,OAAAA;AASZ,CAAA;;;;;;AAAwF,cAAnEC,mCAAAA,SAA4CH,uBAAAA,CAAuB;EAqB5EK,YAAAA,EAAAA,MAAAA,EAAAA;EAAuC,QAAA,SAAA;EAAA,WAClCF,CAAAA,MAAAA,EAAAA;IAC2BN,SAAAA,EAAAA,MAAAA,EAAAA;EAAW,CAAA;EAAc;AAA1B;AAS3C;;;;EAU+F,KAM9DA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EApCRO,OAoCQP,CApCAA,WAoCAA,GApCcC,WAoCdD,CAAAA;EAAW;;;;;;EAWqI,qBA3BrGG,CAAAA,CAAAA,EAAAA,MAAAA;AAAuB;KAXvFK,uCAAAA;eACKF;uBACQF,mBAAmBJ,cAAcC;;;;;;;;;cASrCQ,8CAAAA,SAAuDN,uBAAAA;;;;;sBAKpDK;;;;;iCAKWH;;;;;;uBAMVE,QAAQP,cAAcC;;;;;;;;;;;sBAWvBF,qCAAqCW,KAAKF,iEAAiEC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"outputParser.d.ts","names":["BaseLanguageModelInterface","AgentAction","AgentFinish","FormatInstructionsOptions","AgentActionOutputParser","OutputFixingParser","ChatConversationalAgentOutputParserFormatInstructionsOptions","ChatConversationalAgentOutputParser","Promise","ChatConversationalAgentOutputParserArgs","ChatConversationalAgentOutputParserWithRetries","Omit"],"sources":["../../../src/agents/chat_convo/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { FormatInstructionsOptions } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\nexport type ChatConversationalAgentOutputParserFormatInstructionsOptions = FormatInstructionsOptions & {\n    toolNames: string[];\n    raw?: boolean;\n};\n/**\n * Class that represents an output parser for the ChatConversationalAgent\n * class. It extends the AgentActionOutputParser class and provides\n * methods for parsing the output of the MRKL chain into agent actions.\n */\nexport declare class ChatConversationalAgentOutputParser 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}\nexport type ChatConversationalAgentOutputParserArgs = {\n    baseParser?: ChatConversationalAgentOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n};\n/**\n * Class that represents an output parser with retries for the\n * ChatConversationalAgent class. It extends the AgentActionOutputParser\n * class and provides methods for parsing the output of the MRKL chain\n * into agent actions with retry functionality.\n */\nexport declare class ChatConversationalAgentOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: ChatConversationalAgentOutputParserArgs);\n    /**\n     * Returns the format instructions as a string.\n     * @returns Format instructions as a string.\n     */\n    getFormatInstructions(options: ChatConversationalAgentOutputParserFormatInstructionsOptions): string;\n    /**\n     * Parses the given text into an AgentAction or AgentFinish object.\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     * Static method to create a new\n     * ChatConversationalAgentOutputParserWithRetries from a BaseLanguageModelInterface\n     * and options. If no base parser is provided in the options, a new\n     * ChatConversationalAgentOutputParser is created. An OutputFixingParser\n     * is also created from the BaseLanguageModelInterface and the base parser.\n     * @param llm BaseLanguageModelInterface instance used to create the OutputFixingParser.\n     * @param options Options for creating the ChatConversationalAgentOutputParserWithRetries instance.\n     * @returns A new instance of ChatConversationalAgentOutputParserWithRetries.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<ChatConversationalAgentOutputParserArgs, \"outputFixingParser\">): ChatConversationalAgentOutputParserWithRetries;\n}\n"],"mappings":";;;;;;;KAKYM,4DAAAA,GAA+DH;;EAA/DG,GAAAA,CAAAA,EAAAA,OAAAA;AASZ,CAAA;;;;;;AAAwF,cAAnEC,mCAAAA,SAA4CH,uBAAAA,CAAuB;EAqB5EK,YAAAA,EAAAA,MAAAA,EAAAA;EAAuC,QAAA,SAAA;EAAA,WAClCF,CAAAA,MAAAA,EAAAA;IAC2BN,SAAAA,EAAAA,MAAAA,EAAAA;EAAW,CAAA;EAAc;AAA1B;AAS3C;;;;EAU+F,KAM9DA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EApCRO,OAoCQP,CApCAA,WAoCAA,GApCcC,WAoCdD,CAAAA;EAAW;;;;;;EAWqI,qBA3BrGG,CAAAA,CAAAA,EAAAA,MAAAA;AAAuB;KAXvFK,uCAAAA;eACKF;uBACQF,mBAAmBJ,cAAcC;;;;;;;;;cASrCQ,8CAAAA,SAAuDN,uBAAAA;;;;;sBAKpDK;;;;;iCAKWH;;;;;;uBAMVE,QAAQP,cAAcC;;;;;;;;;;;sBAWvBF,qCAAqCW,KAAKF,iEAAiEC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"executor.d.cts","names":["StructuredToolInterface","ToolInterface","ToolInputParsingException","Tool","Runnable","RunnableConfig","AgentAction","AgentFinish","AgentStep","ChainValues","CallbackManagerForChainRun","Callbacks","OutputParserException","Serializable","SerializedLLMChain","StoppingMethod","BaseMultiActionAgent","BaseSingleActionAgent","BaseChain","ChainInputs","AgentExecutorIteratorInput","AgentExecutor","Record","AgentExecutorIterator","Promise","AsyncGenerator","ExtractToolType","T","AgentExecutorInput","Error","AgentExecutorOutput","ExceptionTool","Partial"],"sources":["../../src/agents/executor.d.ts"],"sourcesContent":["import { type StructuredToolInterface, type ToolInterface, ToolInputParsingException, Tool } from \"@langchain/core/tools\";\nimport { Runnable, type RunnableConfig } from \"@langchain/core/runnables\";\nimport { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { SerializedLLMChain } from \"../chains/serde.js\";\nimport { StoppingMethod } from \"./types.js\";\nimport { BaseMultiActionAgent, BaseSingleActionAgent } from \"./agent.js\";\nimport { BaseChain, ChainInputs } from \"../chains/base.js\";\ninterface AgentExecutorIteratorInput {\n    agentExecutor: AgentExecutor;\n    inputs: Record<string, string>;\n    config?: RunnableConfig;\n    /** @deprecated Use \"config\" */\n    callbacks?: Callbacks;\n    /** @deprecated Use \"config\" */\n    tags?: string[];\n    /** @deprecated Use \"config\" */\n    metadata?: Record<string, unknown>;\n    runName?: string;\n    runManager?: CallbackManagerForChainRun;\n}\nexport declare class AgentExecutorIterator extends Serializable implements AgentExecutorIteratorInput {\n    lc_namespace: string[];\n    agentExecutor: AgentExecutor;\n    inputs: Record<string, string>;\n    config?: RunnableConfig;\n    /** @deprecated Use \"config\" */\n    callbacks?: Callbacks;\n    /** @deprecated Use \"config\" */\n    tags: string[] | undefined;\n    /** @deprecated Use \"config\" */\n    metadata: Record<string, unknown> | undefined;\n    /** @deprecated Use \"config\" */\n    runName: string | undefined;\n    private _finalOutputs;\n    get finalOutputs(): Record<string, unknown> | undefined;\n    /** Intended to be used as a setter method, needs to be async. */\n    setFinalOutputs(value: Record<string, unknown> | undefined): Promise<void>;\n    runManager: CallbackManagerForChainRun | undefined;\n    intermediateSteps: AgentStep[];\n    iterations: number;\n    get nameToToolMap(): Record<string, ToolInterface>;\n    constructor(fields: AgentExecutorIteratorInput);\n    /**\n     * Reset the iterator to its initial state, clearing intermediate steps,\n     * iterations, and the final output.\n     */\n    reset(): void;\n    updateIterations(): void;\n    streamIterator(): AsyncGenerator<Record<string, unknown>, Record<string, unknown>, unknown>;\n    /**\n     * Perform any necessary setup for the first step\n     * of the asynchronous iterator.\n     */\n    onFirstStep(): Promise<void>;\n    /**\n     * Execute the next step in the chain using the\n     * AgentExecutor's _takeNextStep method.\n     */\n    _executeNextStep(runManager?: CallbackManagerForChainRun): Promise<AgentFinish | AgentStep[]>;\n    /**\n     * Process the output of the next step,\n     * handling AgentFinish and tool return cases.\n     */\n    _processNextStepOutput(nextStepOutput: AgentFinish | AgentStep[], runManager?: CallbackManagerForChainRun): Promise<Record<string, string | AgentStep[]>>;\n    _stop(): Promise<Record<string, unknown>>;\n    _callNext(): Promise<Record<string, unknown>>;\n}\ntype ExtractToolType<T> = T extends {\n    ToolType: infer ToolInterface;\n} ? ToolInterface : StructuredToolInterface;\n/**\n * Interface defining the structure of input data for creating an\n * AgentExecutor. It extends ChainInputs and includes additional\n * properties specific to agent execution.\n */\nexport interface AgentExecutorInput extends ChainInputs {\n    agent: BaseSingleActionAgent | BaseMultiActionAgent | Runnable<ChainValues & {\n        steps?: AgentStep[];\n    }, AgentAction[] | AgentAction | AgentFinish>;\n    tools: ExtractToolType<this[\"agent\"]>[];\n    returnIntermediateSteps?: boolean;\n    maxIterations?: number;\n    earlyStoppingMethod?: StoppingMethod;\n    handleParsingErrors?: boolean | string | ((e: OutputParserException | ToolInputParsingException) => string);\n    handleToolRuntimeErrors?: (e: Error) => string;\n}\n// TODO: Type properly with { intermediateSteps?: AgentStep[] };\nexport type AgentExecutorOutput = ChainValues;\n/**\n * Tool that just returns the query.\n * Used for exception tracking.\n */\nexport declare class ExceptionTool extends Tool {\n    name: string;\n    description: string;\n    _call(query: string): Promise<string>;\n}\n/**\n * A chain managing an agent using tools.\n * @augments BaseChain\n * @example\n * ```typescript\n *\n * const executor = AgentExecutor.fromAgentAndTools({\n *   agent: async () => loadAgentFromLangchainHub(),\n *   tools: [new SerpAPI(), new Calculator()],\n *   returnIntermediateSteps: true,\n * });\n *\n * const result = await executor.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n *\n * ```\n */\nexport declare class AgentExecutor extends BaseChain<ChainValues, AgentExecutorOutput> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    agent: BaseSingleActionAgent | BaseMultiActionAgent;\n    tools: this[\"agent\"][\"ToolType\"][];\n    returnIntermediateSteps: boolean;\n    maxIterations?: number;\n    earlyStoppingMethod: StoppingMethod;\n    // TODO: Update BaseChain implementation on breaking change to include this\n    returnOnlyOutputs: boolean;\n    /**\n     * How to handle errors raised by the agent's output parser.\n      Defaults to `False`, which raises the error.\n  \n      If `true`, the error will be sent back to the LLM as an observation.\n      If a string, the string itself will be sent to the LLM as an observation.\n      If a callable function, the function will be called with the exception\n      as an argument, and the result of that function will be passed to the agent\n      as an observation.\n     */\n    handleParsingErrors: boolean | string | ((e: OutputParserException | ToolInputParsingException) => string);\n    handleToolRuntimeErrors?: (e: Error) => string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(input: AgentExecutorInput);\n    /** Create from agent and a list of tools. */\n    static fromAgentAndTools(fields: AgentExecutorInput): AgentExecutor;\n    get shouldContinueGetter(): (iterations: number) => boolean;\n    /**\n     * Method that checks if the agent execution should continue based on the\n     * number of iterations.\n     * @param iterations The current number of iterations.\n     * @returns A boolean indicating whether the agent execution should continue.\n     */\n    private shouldContinue;\n    /** @ignore */\n    _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<AgentExecutorOutput>;\n    _takeNextStep(nameToolMap: Record<string, ToolInterface>, inputs: ChainValues, intermediateSteps: AgentStep[], runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<AgentFinish | AgentStep[]>;\n    _return(output: AgentFinish, intermediateSteps: AgentStep[], runManager?: CallbackManagerForChainRun): Promise<AgentExecutorOutput>;\n    _getToolReturn(nextStepOutput: AgentStep): Promise<AgentFinish | null>;\n    _returnStoppedResponse(earlyStoppingMethod: StoppingMethod): AgentFinish;\n    _streamIterator(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    inputs: Record<string, any>, options?: Partial<RunnableConfig>): AsyncGenerator<ChainValues>;\n    _chainType(): \"agent_executor\";\n    serialize(): SerializedLLMChain;\n}\nexport {};\n"],"mappings":";;;;;;;;;;;;;;KAuEK0B,eAuF0CF,CAAAA,CAAAA,CAAAA,GAvFrBG,CAuFqBH,SAAAA;EAAO,QACNT,EAAAA,KAAAA,cAAAA;CAAc,GAtF1Dd,aAsF6DM,GAtF7CP,uBAsF6CO;;;;;;AAKhDO,UArFAc,kBAAAA,SAA2BT,WAqF3BL,CAAAA;EAAkB,KA7CQI,EAvChCD,qBAuCgCC,GAvCRF,oBAuCQE,GAvCed,QAuCfc,CAvCwBT,WAuCxBS,GAAAA;IAAS,KAAA,CAAA,EAtCpCV,SAsCoC,EAAA;KArC7CF,gBAAgBA,cAAcC;SAC1BmB;;;wBAGeX;gDACwBH,wBAAwBV;gCACxC2B;;;KAGtBC,mBAAAA,GAAsBrB;;;;;;;;;;;;;;;;;;;;;;;;cA4BbY,aAAAA,SAAsBH,UAAUT,aAAaqB;;;SAGvDb,wBAAwBD;;;;uBAIVD;;;;;;;;;;;;+CAawBH,wBAAwBV;gCACvC2B;;;qBAGXD;;mCAEcA,qBAAqBP;;;;;;;;;;gBAUxCZ,0BAA0BC,qCAAqCL,iBAAiBmB,QAAQM;6BAC3ER,eAAerB,wBAAwBQ,gCAAgCD,0BAA0BE,qCAAqCL,iBAAiBmB,QAAQjB,cAAcC;kBACxLD,gCAAgCC,0BAA0BE,6BAA6Bc,QAAQM;iCAChFtB,YAAYgB,QAAQjB;8CACPQ,iBAAiBR;;;UAGrDe,+BAA+BU,QAAQ3B,kBAAkBoB,eAAehB;;eAEnEK"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"executor.d.ts","names":["StructuredToolInterface","ToolInterface","ToolInputParsingException","Tool","Runnable","RunnableConfig","AgentAction","AgentFinish","AgentStep","ChainValues","CallbackManagerForChainRun","Callbacks","OutputParserException","Serializable","SerializedLLMChain","StoppingMethod","BaseMultiActionAgent","BaseSingleActionAgent","BaseChain","ChainInputs","AgentExecutorIteratorInput","AgentExecutor","Record","AgentExecutorIterator","Promise","AsyncGenerator","ExtractToolType","T","AgentExecutorInput","Error","AgentExecutorOutput","ExceptionTool","Partial"],"sources":["../../src/agents/executor.d.ts"],"sourcesContent":["import { type StructuredToolInterface, type ToolInterface, ToolInputParsingException, Tool } from \"@langchain/core/tools\";\nimport { Runnable, type RunnableConfig } from \"@langchain/core/runnables\";\nimport { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { CallbackManagerForChainRun, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { SerializedLLMChain } from \"../chains/serde.js\";\nimport { StoppingMethod } from \"./types.js\";\nimport { BaseMultiActionAgent, BaseSingleActionAgent } from \"./agent.js\";\nimport { BaseChain, ChainInputs } from \"../chains/base.js\";\ninterface AgentExecutorIteratorInput {\n    agentExecutor: AgentExecutor;\n    inputs: Record<string, string>;\n    config?: RunnableConfig;\n    /** @deprecated Use \"config\" */\n    callbacks?: Callbacks;\n    /** @deprecated Use \"config\" */\n    tags?: string[];\n    /** @deprecated Use \"config\" */\n    metadata?: Record<string, unknown>;\n    runName?: string;\n    runManager?: CallbackManagerForChainRun;\n}\nexport declare class AgentExecutorIterator extends Serializable implements AgentExecutorIteratorInput {\n    lc_namespace: string[];\n    agentExecutor: AgentExecutor;\n    inputs: Record<string, string>;\n    config?: RunnableConfig;\n    /** @deprecated Use \"config\" */\n    callbacks?: Callbacks;\n    /** @deprecated Use \"config\" */\n    tags: string[] | undefined;\n    /** @deprecated Use \"config\" */\n    metadata: Record<string, unknown> | undefined;\n    /** @deprecated Use \"config\" */\n    runName: string | undefined;\n    private _finalOutputs;\n    get finalOutputs(): Record<string, unknown> | undefined;\n    /** Intended to be used as a setter method, needs to be async. */\n    setFinalOutputs(value: Record<string, unknown> | undefined): Promise<void>;\n    runManager: CallbackManagerForChainRun | undefined;\n    intermediateSteps: AgentStep[];\n    iterations: number;\n    get nameToToolMap(): Record<string, ToolInterface>;\n    constructor(fields: AgentExecutorIteratorInput);\n    /**\n     * Reset the iterator to its initial state, clearing intermediate steps,\n     * iterations, and the final output.\n     */\n    reset(): void;\n    updateIterations(): void;\n    streamIterator(): AsyncGenerator<Record<string, unknown>, Record<string, unknown>, unknown>;\n    /**\n     * Perform any necessary setup for the first step\n     * of the asynchronous iterator.\n     */\n    onFirstStep(): Promise<void>;\n    /**\n     * Execute the next step in the chain using the\n     * AgentExecutor's _takeNextStep method.\n     */\n    _executeNextStep(runManager?: CallbackManagerForChainRun): Promise<AgentFinish | AgentStep[]>;\n    /**\n     * Process the output of the next step,\n     * handling AgentFinish and tool return cases.\n     */\n    _processNextStepOutput(nextStepOutput: AgentFinish | AgentStep[], runManager?: CallbackManagerForChainRun): Promise<Record<string, string | AgentStep[]>>;\n    _stop(): Promise<Record<string, unknown>>;\n    _callNext(): Promise<Record<string, unknown>>;\n}\ntype ExtractToolType<T> = T extends {\n    ToolType: infer ToolInterface;\n} ? ToolInterface : StructuredToolInterface;\n/**\n * Interface defining the structure of input data for creating an\n * AgentExecutor. It extends ChainInputs and includes additional\n * properties specific to agent execution.\n */\nexport interface AgentExecutorInput extends ChainInputs {\n    agent: BaseSingleActionAgent | BaseMultiActionAgent | Runnable<ChainValues & {\n        steps?: AgentStep[];\n    }, AgentAction[] | AgentAction | AgentFinish>;\n    tools: ExtractToolType<this[\"agent\"]>[];\n    returnIntermediateSteps?: boolean;\n    maxIterations?: number;\n    earlyStoppingMethod?: StoppingMethod;\n    handleParsingErrors?: boolean | string | ((e: OutputParserException | ToolInputParsingException) => string);\n    handleToolRuntimeErrors?: (e: Error) => string;\n}\n// TODO: Type properly with { intermediateSteps?: AgentStep[] };\nexport type AgentExecutorOutput = ChainValues;\n/**\n * Tool that just returns the query.\n * Used for exception tracking.\n */\nexport declare class ExceptionTool extends Tool {\n    name: string;\n    description: string;\n    _call(query: string): Promise<string>;\n}\n/**\n * A chain managing an agent using tools.\n * @augments BaseChain\n * @example\n * ```typescript\n *\n * const executor = AgentExecutor.fromAgentAndTools({\n *   agent: async () => loadAgentFromLangchainHub(),\n *   tools: [new SerpAPI(), new Calculator()],\n *   returnIntermediateSteps: true,\n * });\n *\n * const result = await executor.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n *\n * ```\n */\nexport declare class AgentExecutor extends BaseChain<ChainValues, AgentExecutorOutput> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    agent: BaseSingleActionAgent | BaseMultiActionAgent;\n    tools: this[\"agent\"][\"ToolType\"][];\n    returnIntermediateSteps: boolean;\n    maxIterations?: number;\n    earlyStoppingMethod: StoppingMethod;\n    // TODO: Update BaseChain implementation on breaking change to include this\n    returnOnlyOutputs: boolean;\n    /**\n     * How to handle errors raised by the agent's output parser.\n      Defaults to `False`, which raises the error.\n  \n      If `true`, the error will be sent back to the LLM as an observation.\n      If a string, the string itself will be sent to the LLM as an observation.\n      If a callable function, the function will be called with the exception\n      as an argument, and the result of that function will be passed to the agent\n      as an observation.\n     */\n    handleParsingErrors: boolean | string | ((e: OutputParserException | ToolInputParsingException) => string);\n    handleToolRuntimeErrors?: (e: Error) => string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(input: AgentExecutorInput);\n    /** Create from agent and a list of tools. */\n    static fromAgentAndTools(fields: AgentExecutorInput): AgentExecutor;\n    get shouldContinueGetter(): (iterations: number) => boolean;\n    /**\n     * Method that checks if the agent execution should continue based on the\n     * number of iterations.\n     * @param iterations The current number of iterations.\n     * @returns A boolean indicating whether the agent execution should continue.\n     */\n    private shouldContinue;\n    /** @ignore */\n    _call(inputs: ChainValues, runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<AgentExecutorOutput>;\n    _takeNextStep(nameToolMap: Record<string, ToolInterface>, inputs: ChainValues, intermediateSteps: AgentStep[], runManager?: CallbackManagerForChainRun, config?: RunnableConfig): Promise<AgentFinish | AgentStep[]>;\n    _return(output: AgentFinish, intermediateSteps: AgentStep[], runManager?: CallbackManagerForChainRun): Promise<AgentExecutorOutput>;\n    _getToolReturn(nextStepOutput: AgentStep): Promise<AgentFinish | null>;\n    _returnStoppedResponse(earlyStoppingMethod: StoppingMethod): AgentFinish;\n    _streamIterator(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    inputs: Record<string, any>, options?: Partial<RunnableConfig>): AsyncGenerator<ChainValues>;\n    _chainType(): \"agent_executor\";\n    serialize(): SerializedLLMChain;\n}\nexport {};\n"],"mappings":";;;;;;;;;;;;;;KAuEK0B,eAuF0CF,CAAAA,CAAAA,CAAAA,GAvFrBG,CAuFqBH,SAAAA;EAAO,QACNT,EAAAA,KAAAA,cAAAA;CAAc,GAtF1Dd,aAsF6DM,GAtF7CP,uBAsF6CO;;;;;;AAKhDO,UArFAc,kBAAAA,SAA2BT,WAqF3BL,CAAAA;EAAkB,KA7CQI,EAvChCD,qBAuCgCC,GAvCRF,oBAuCQE,GAvCed,QAuCfc,CAvCwBT,WAuCxBS,GAAAA;IAAS,KAAA,CAAA,EAtCpCV,SAsCoC,EAAA;KArC7CF,gBAAgBA,cAAcC;SAC1BmB;;;wBAGeX;gDACwBH,wBAAwBV;gCACxC2B;;;KAGtBC,mBAAAA,GAAsBrB;;;;;;;;;;;;;;;;;;;;;;;;cA4BbY,aAAAA,SAAsBH,UAAUT,aAAaqB;;;SAGvDb,wBAAwBD;;;;uBAIVD;;;;;;;;;;;;+CAawBH,wBAAwBV;gCACvC2B;;;qBAGXD;;mCAEcA,qBAAqBP;;;;;;;;;;gBAUxCZ,0BAA0BC,qCAAqCL,iBAAiBmB,QAAQM;6BAC3ER,eAAerB,wBAAwBQ,gCAAgCD,0BAA0BE,qCAAqCL,iBAAiBmB,QAAQjB,cAAcC;kBACxLD,gCAAgCC,0BAA0BE,6BAA6Bc,QAAQM;iCAChFtB,YAAYgB,QAAQjB;8CACPQ,iBAAiBR;;;UAGrDe,+BAA+BU,QAAQ3B,kBAAkBoB,eAAehB;;eAEnEK"}

package/dist/agents/format_scratchpad/log.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.d.cts","names":["AgentStep","formatLogToString"],"sources":["../../../src/agents/format_scratchpad/log.d.ts"],"sourcesContent":["import { AgentStep } from \"@langchain/core/agents\";\n/**\n * Construct the scratchpad that lets the agent continue its thought process.\n * @param intermediateSteps\n * @param observationPrefix\n * @param llmPrefix\n * @returns a string with the formatted observations and agent logs\n */\nexport declare function formatLogToString(intermediateSteps: AgentStep[], observationPrefix?: string, llmPrefix?: string): string;\n"],"mappings":";;;;;;AAQA;;;;;iBAAwBC,iBAAAA,oBAAqCD"}

package/dist/agents/format_scratchpad/log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.d.ts","names":["AgentStep","formatLogToString"],"sources":["../../../src/agents/format_scratchpad/log.d.ts"],"sourcesContent":["import { AgentStep } from \"@langchain/core/agents\";\n/**\n * Construct the scratchpad that lets the agent continue its thought process.\n * @param intermediateSteps\n * @param observationPrefix\n * @param llmPrefix\n * @returns a string with the formatted observations and agent logs\n */\nexport declare function formatLogToString(intermediateSteps: AgentStep[], observationPrefix?: string, llmPrefix?: string): string;\n"],"mappings":";;;;;;AAQA;;;;;iBAAwBC,iBAAAA,oBAAqCD"}

package/dist/agents/format_scratchpad/log_to_message.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log_to_message.d.cts","names":["AgentStep","BaseMessage","formatLogToMessage"],"sources":["../../../src/agents/format_scratchpad/log_to_message.d.ts"],"sourcesContent":["import type { AgentStep } from \"@langchain/core/agents\";\nimport { type BaseMessage } from \"@langchain/core/messages\";\nexport declare function formatLogToMessage(intermediateSteps: AgentStep[], templateToolResponse?: string): BaseMessage[];\n"],"mappings":";;;;iBAEwBE,kBAAAA,oBAAsCF,6CAA6CC"}

package/dist/agents/format_scratchpad/log_to_message.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log_to_message.d.ts","names":["AgentStep","BaseMessage","formatLogToMessage"],"sources":["../../../src/agents/format_scratchpad/log_to_message.d.ts"],"sourcesContent":["import type { AgentStep } from \"@langchain/core/agents\";\nimport { type BaseMessage } from \"@langchain/core/messages\";\nexport declare function formatLogToMessage(intermediateSteps: AgentStep[], templateToolResponse?: string): BaseMessage[];\n"],"mappings":";;;;iBAEwBE,kBAAAA,oBAAsCF,6CAA6CC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"openai_functions.d.cts","names":["BaseMessage","AgentStep","formatForOpenAIFunctions","formatToOpenAIFunctionMessages"],"sources":["../../../src/agents/format_scratchpad/openai_functions.d.ts"],"sourcesContent":["import { type BaseMessage } from \"@langchain/core/messages\";\nimport type { AgentStep } from \"@langchain/core/agents\";\n/**\n * Format a list of AgentSteps into a list of BaseMessage instances for\n * agents that use OpenAI's API. Helpful for passing in previous agent\n * step context into new iterations.\n *\n * @param steps A list of AgentSteps to format.\n * @returns A list of BaseMessages.\n */\nexport declare function formatForOpenAIFunctions(steps: AgentStep[]): BaseMessage[];\n/**\n * Format a list of AgentSteps into a list of BaseMessage instances for\n * agents that use OpenAI's API. Helpful for passing in previous agent\n * step context into new iterations.\n *\n * @param steps A list of AgentSteps to format.\n * @returns A list of BaseMessages.\n */\nexport declare function formatToOpenAIFunctionMessages(steps: AgentStep[]): BaseMessage[];\n"],"mappings":";;;;;;;AAUA;;;;AAAiF;AASjF;AAAsD,iBAT9BE,wBAAAA,CAS8B,KAAA,EATED,SASF,EAAA,CAAA,EATgBD,WAShB,EAAA;;;AAAiC;;;;;;iBAA/DG,8BAAAA,QAAsCF,cAAcD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"openai_functions.d.ts","names":["BaseMessage","AgentStep","formatForOpenAIFunctions","formatToOpenAIFunctionMessages"],"sources":["../../../src/agents/format_scratchpad/openai_functions.d.ts"],"sourcesContent":["import { type BaseMessage } from \"@langchain/core/messages\";\nimport type { AgentStep } from \"@langchain/core/agents\";\n/**\n * Format a list of AgentSteps into a list of BaseMessage instances for\n * agents that use OpenAI's API. Helpful for passing in previous agent\n * step context into new iterations.\n *\n * @param steps A list of AgentSteps to format.\n * @returns A list of BaseMessages.\n */\nexport declare function formatForOpenAIFunctions(steps: AgentStep[]): BaseMessage[];\n/**\n * Format a list of AgentSteps into a list of BaseMessage instances for\n * agents that use OpenAI's API. Helpful for passing in previous agent\n * step context into new iterations.\n *\n * @param steps A list of AgentSteps to format.\n * @returns A list of BaseMessages.\n */\nexport declare function formatToOpenAIFunctionMessages(steps: AgentStep[]): BaseMessage[];\n"],"mappings":";;;;;;;AAUA;;;;AAAiF;AASjF;AAAsD,iBAT9BE,wBAAAA,CAS8B,KAAA,EATED,SASF,EAAA,CAAA,EATgBD,WAShB,EAAA;;;AAAiC;;;;;;iBAA/DG,8BAAAA,QAAsCF,cAAcD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"tool_calling.d.cts","names":["BaseMessage","ToolMessage","ToolsAgentStep","_createToolMessage","formatToToolMessages"],"sources":["../../../src/agents/format_scratchpad/tool_calling.d.ts"],"sourcesContent":["import { BaseMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { ToolsAgentStep } from \"../tool_calling/output_parser.js\";\n/**\n * Convert agent action and observation into a function message.\n * @param agentAction - The tool invocation request from the agent\n * @param observation - The result of the tool invocation\n * @returns FunctionMessage that corresponds to the original tool invocation\n */\nexport declare function _createToolMessage(step: ToolsAgentStep): ToolMessage;\nexport declare function formatToToolMessages(steps: ToolsAgentStep[]): BaseMessage[];\n"],"mappings":";;;;;iBASwBI,oBAAAA,QAA4BF,mBAAmBF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"tool_calling.d.ts","names":["BaseMessage","ToolMessage","ToolsAgentStep","_createToolMessage","formatToToolMessages"],"sources":["../../../src/agents/format_scratchpad/tool_calling.d.ts"],"sourcesContent":["import { BaseMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { ToolsAgentStep } from \"../tool_calling/output_parser.js\";\n/**\n * Convert agent action and observation into a function message.\n * @param agentAction - The tool invocation request from the agent\n * @param observation - The result of the tool invocation\n * @returns FunctionMessage that corresponds to the original tool invocation\n */\nexport declare function _createToolMessage(step: ToolsAgentStep): ToolMessage;\nexport declare function formatToToolMessages(steps: ToolsAgentStep[]): BaseMessage[];\n"],"mappings":";;;;;iBASwBI,oBAAAA,QAA4BF,mBAAmBF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"xml.d.cts","names":["AgentStep","formatXml"],"sources":["../../../src/agents/format_scratchpad/xml.d.ts"],"sourcesContent":["import { AgentStep } from \"@langchain/core/agents\";\nexport declare function formatXml(intermediateSteps: AgentStep[]): string;\n"],"mappings":";;;iBACwBC,SAAAA,oBAA6BD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"xml.d.ts","names":["AgentStep","formatXml"],"sources":["../../../src/agents/format_scratchpad/xml.d.ts"],"sourcesContent":["import { AgentStep } from \"@langchain/core/agents\";\nexport declare function formatXml(intermediateSteps: AgentStep[]): string;\n"],"mappings":";;;iBACwBC,SAAAA,oBAA6BD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"initialize.d.cts","names":["_langchain_core_language_models_base0","BaseLanguageModelInterface","StructuredToolInterface","ToolInterface","CallbackManager","ChatAgent","ChatConversationalAgent","StructuredChatAgent","AgentExecutor","AgentExecutorInput","ZeroShotAgent","OpenAIAgent","XMLAgent","AgentType","initializeAgentExecutor","_________langchain_core_dist_tools_types_js0","StringInputToolSchema","BaseLanguageModelCallOptions","Promise","InitializeAgentExecutorOptions","fromLLMAndTools","Parameters","Omit","InitializeAgentExecutorOptionsStructured","initializeAgentExecutorWithOptions"],"sources":["../../src/agents/initialize.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface, ToolInterface } from \"@langchain/core/tools\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { ChatAgent } from \"./chat/index.js\";\nimport { ChatConversationalAgent } from \"./chat_convo/index.js\";\nimport { StructuredChatAgent } from \"./structured_chat/index.js\";\nimport { AgentExecutor, AgentExecutorInput } from \"./executor.js\";\nimport { ZeroShotAgent } from \"./mrkl/index.js\";\nimport { OpenAIAgent } from \"./openai_functions/index.js\";\nimport { XMLAgent } from \"./xml/index.js\";\n/**\n * Represents the type of an agent in LangChain. It can be\n * \"zero-shot-react-description\", \"chat-zero-shot-react-description\", or\n * \"chat-conversational-react-description\".\n */\ntype AgentType = \"zero-shot-react-description\" | \"chat-zero-shot-react-description\" | \"chat-conversational-react-description\";\nexport declare const initializeAgentExecutor: (tools: ToolInterface<import(\"../../../langchain-core/dist/tools/types.js\").StringInputToolSchema, any, any>[], llm: BaseLanguageModelInterface<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, _agentType?: AgentType | undefined, _verbose?: boolean | undefined, _callbackManager?: CallbackManager | undefined) => Promise<AgentExecutor>;\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptions = ({\n    agentType: \"zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ZeroShotAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ChatAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-conversational-react-description\";\n    agentArgs?: Parameters<typeof ChatConversationalAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"xml\";\n    agentArgs?: Parameters<typeof XMLAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptionsStructured = ({\n    agentType: \"structured-chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof StructuredChatAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"openai-functions\";\n    agentArgs?: Parameters<typeof OpenAIAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * Initialize an agent executor with options.\n * @param tools Array of tools to use in the agent\n * @param llm LLM or ChatModel to use in the agent\n * @param options Options for the agent, including agentType, agentArgs, and other options for AgentExecutor.fromAgentAndTools\n * @returns AgentExecutor\n */\nexport declare function initializeAgentExecutorWithOptions(tools: StructuredToolInterface[], llm: BaseLanguageModelInterface, options: InitializeAgentExecutorOptionsStructured): Promise<AgentExecutor>;\nexport declare function initializeAgentExecutorWithOptions(tools: ToolInterface[], llm: BaseLanguageModelInterface, options?: InitializeAgentExecutorOptions): Promise<AgentExecutor>;\nexport {};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAS0C;AAO1C,KADKa,SAAAA,GACgBC,6BAAyY,GAAA,kCAAA,GAAA,uCAAA;AAAA,cAAzYA,uBAAyY,EAAA,CAAA,KAAA,EAAxWX,aAAwW,CAAA,qBAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,EAAA,GAAA,EAA3PF,0BAA2P,CAAA,GAAA,EAA3VD,qCAAAA,CAA+KiB,4BAAAA,CAA4K,EAAA,UAAA,CAAA,EAAhIJ,SAAgI,GAAA,SAAA,EAAA,QAAA,CAAA,EAAA,OAAA,GAAA,SAAA,EAAA,gBAAA,CAAA,EAAtDT,eAAsD,GAAA,SAAA,EAAA,GAAtBc,OAAsB,CAAdV,aAAc,CAAA;;;;AAA3PP,KAIvJkB,8BAAAA,GAJuJlB,CAAAA;EAA0B,SAAiGY,EAAAA,6BAAAA;EAAS,SAAiET,CAAAA,EAMxViB,UANwVjB,CAAAA,OAMtUM,aAAAA,CAAcU,eANwThB,CAAAA,CAAAA,CAAAA,CAAAA;EAAe,MAAyBI,CAAAA,EAAAA,KAAAA;CAAa,GAQzZc,IARoYJ,CAQ/XT,kBAR+XS,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAO,SAAA,EAAA,kCAAA;EAInYC,SAAAA,CAAAA,EAMIE,UANJF,CAAAA,OAMsBd,SAAAA,CAAUe,eANF,CAAA,CAAA,CAAA,CAAA;EAAA,MAAA,CAAA,EAAA,KAAA;CAAA,GAQtCE,IAN8BZ,CAMzBD,kBANuCW,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAe,SAA/CC,EAAAA,uCAAAA;EAAU,SAEjBZ,CAAAA,EAMOY,UANPZ,CAAAA,OAMyBH,uBAAAA,CAAwBc,eANjDX,CAAAA,CAAAA,CAAAA,CAAAA;CAAkB,GAOvBa,IAPAA,CAOKb,kBAPLa,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAI,SAE0BjB,EAAAA,KAAUe;EAAe,SAA3CC,CAAAA,EAOAA,UAPAA,CAAAA,OAOkBT,QAAAA,CAASQ,eAP3BC,CAAAA,CAAAA,CAAAA,CAAAA;CAAU,GAQtBC,IANKb,CAMAA,kBANAA,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA;;;;AAGAA,KAOGc,wCAAAA,GAPHd,CAAAA;EAAkB,SAAvBa,EAAAA,6CAAAA;EAAI,SAE0BV,CAAAA,EAOlBS,UAP2BD,CAAAA,OAOTb,mBAAAA,CAAoBa,eAPXA,CAAAA,CAAAA,CAAAA,CAAAA;CAAe,GAQtDE,IARYD,CAQPZ,kBAROY,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAU,SACjBZ,EAAAA,kBAAAA;EAAkB,SAAvBa,CAAAA,EASYD,UATZC,CAAAA,OAS8BX,WAAAA,CAAYS,eAT1CE,CAAAA,CAAAA,CAAAA,CAAAA;AAAI,CAAA,GAUJA,IAVI,CAUCb,kBAVD,EAAA,OAAA,GAAA,OAAA,CAAA,CAAA;AAIR;;;;;;;AAKgBY,iBASQG,kCAAAA,CATRH,KAAAA,EASkDnB,uBATlDmB,EAAAA,EAAAA,GAAAA,EASkFpB,0BATlFoB,EAAAA,OAAAA,EASuHE,wCATvHF,CAAAA,EASkKH,OATlKG,CAS0Kb,aAT1Ka,CAAAA;AACPZ,iBASee,kCAAAA,CATff,KAAAA,EASyDN,aATzDM,EAAAA,EAAAA,GAAAA,EAS+ER,0BAT/EQ,EAAAA,OAAAA,CAAAA,EASqHU,8BATrHV,CAAAA,EASsJS,OATtJT,CAS8JD,aAT9JC,CAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"initialize.d.ts","names":["_langchain_core_language_models_base0","BaseLanguageModelInterface","StructuredToolInterface","ToolInterface","CallbackManager","ChatAgent","ChatConversationalAgent","StructuredChatAgent","AgentExecutor","AgentExecutorInput","ZeroShotAgent","OpenAIAgent","XMLAgent","AgentType","initializeAgentExecutor","_________langchain_core_dist_tools_types_js0","StringInputToolSchema","BaseLanguageModelCallOptions","Promise","InitializeAgentExecutorOptions","fromLLMAndTools","Parameters","Omit","InitializeAgentExecutorOptionsStructured","initializeAgentExecutorWithOptions"],"sources":["../../src/agents/initialize.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface, ToolInterface } from \"@langchain/core/tools\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { ChatAgent } from \"./chat/index.js\";\nimport { ChatConversationalAgent } from \"./chat_convo/index.js\";\nimport { StructuredChatAgent } from \"./structured_chat/index.js\";\nimport { AgentExecutor, AgentExecutorInput } from \"./executor.js\";\nimport { ZeroShotAgent } from \"./mrkl/index.js\";\nimport { OpenAIAgent } from \"./openai_functions/index.js\";\nimport { XMLAgent } from \"./xml/index.js\";\n/**\n * Represents the type of an agent in LangChain. It can be\n * \"zero-shot-react-description\", \"chat-zero-shot-react-description\", or\n * \"chat-conversational-react-description\".\n */\ntype AgentType = \"zero-shot-react-description\" | \"chat-zero-shot-react-description\" | \"chat-conversational-react-description\";\nexport declare const initializeAgentExecutor: (tools: ToolInterface<import(\"../../../langchain-core/dist/tools/types.js\").StringInputToolSchema, any, any>[], llm: BaseLanguageModelInterface<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, _agentType?: AgentType | undefined, _verbose?: boolean | undefined, _callbackManager?: CallbackManager | undefined) => Promise<AgentExecutor>;\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptions = ({\n    agentType: \"zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ZeroShotAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ChatAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-conversational-react-description\";\n    agentArgs?: Parameters<typeof ChatConversationalAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"xml\";\n    agentArgs?: Parameters<typeof XMLAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptionsStructured = ({\n    agentType: \"structured-chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof StructuredChatAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"openai-functions\";\n    agentArgs?: Parameters<typeof OpenAIAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * Initialize an agent executor with options.\n * @param tools Array of tools to use in the agent\n * @param llm LLM or ChatModel to use in the agent\n * @param options Options for the agent, including agentType, agentArgs, and other options for AgentExecutor.fromAgentAndTools\n * @returns AgentExecutor\n */\nexport declare function initializeAgentExecutorWithOptions(tools: StructuredToolInterface[], llm: BaseLanguageModelInterface, options: InitializeAgentExecutorOptionsStructured): Promise<AgentExecutor>;\nexport declare function initializeAgentExecutorWithOptions(tools: ToolInterface[], llm: BaseLanguageModelInterface, options?: InitializeAgentExecutorOptions): Promise<AgentExecutor>;\nexport {};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAS0C;AAO1C,KADKa,SAAAA,GACgBC,6BAAyY,GAAA,kCAAA,GAAA,uCAAA;AAAA,cAAzYA,uBAAyY,EAAA,CAAA,KAAA,EAAxWX,aAAwW,CAAA,qBAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,EAAA,GAAA,EAA3PF,0BAA2P,CAAA,GAAA,EAA3VD,qCAAAA,CAA+KiB,4BAAAA,CAA4K,EAAA,UAAA,CAAA,EAAhIJ,SAAgI,GAAA,SAAA,EAAA,QAAA,CAAA,EAAA,OAAA,GAAA,SAAA,EAAA,gBAAA,CAAA,EAAtDT,eAAsD,GAAA,SAAA,EAAA,GAAtBc,OAAsB,CAAdV,aAAc,CAAA;;;;AAA3PP,KAIvJkB,8BAAAA,GAJuJlB,CAAAA;EAA0B,SAAiGY,EAAAA,6BAAAA;EAAS,SAAiET,CAAAA,EAMxViB,UANwVjB,CAAAA,OAMtUM,aAAAA,CAAcU,eANwThB,CAAAA,CAAAA,CAAAA,CAAAA;EAAe,MAAyBI,CAAAA,EAAAA,KAAAA;CAAa,GAQzZc,IARoYJ,CAQ/XT,kBAR+XS,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAO,SAAA,EAAA,kCAAA;EAInYC,SAAAA,CAAAA,EAMIE,UANJF,CAAAA,OAMsBd,SAAAA,CAAUe,eANF,CAAA,CAAA,CAAA,CAAA;EAAA,MAAA,CAAA,EAAA,KAAA;CAAA,GAQtCE,IAN8BZ,CAMzBD,kBANuCW,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAe,SAA/CC,EAAAA,uCAAAA;EAAU,SAEjBZ,CAAAA,EAMOY,UANPZ,CAAAA,OAMyBH,uBAAAA,CAAwBc,eANjDX,CAAAA,CAAAA,CAAAA,CAAAA;CAAkB,GAOvBa,IAPAA,CAOKb,kBAPLa,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAI,SAE0BjB,EAAAA,KAAUe;EAAe,SAA3CC,CAAAA,EAOAA,UAPAA,CAAAA,OAOkBT,QAAAA,CAASQ,eAP3BC,CAAAA,CAAAA,CAAAA,CAAAA;CAAU,GAQtBC,IANKb,CAMAA,kBANAA,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA;;;;AAGAA,KAOGc,wCAAAA,GAPHd,CAAAA;EAAkB,SAAvBa,EAAAA,6CAAAA;EAAI,SAE0BV,CAAAA,EAOlBS,UAP2BD,CAAAA,OAOTb,mBAAAA,CAAoBa,eAPXA,CAAAA,CAAAA,CAAAA,CAAAA;CAAe,GAQtDE,IARYD,CAQPZ,kBAROY,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAU,SACjBZ,EAAAA,kBAAAA;EAAkB,SAAvBa,CAAAA,EASYD,UATZC,CAAAA,OAS8BX,WAAAA,CAAYS,eAT1CE,CAAAA,CAAAA,CAAAA,CAAAA;AAAI,CAAA,GAUJA,IAVI,CAUCb,kBAVD,EAAA,OAAA,GAAA,OAAA,CAAA,CAAA;AAIR;;;;;;;AAKgBY,iBASQG,kCAAAA,CATRH,KAAAA,EASkDnB,uBATlDmB,EAAAA,EAAAA,GAAAA,EASkFpB,0BATlFoB,EAAAA,OAAAA,EASuHE,wCATvHF,CAAAA,EASkKH,OATlKG,CAS0Kb,aAT1Ka,CAAAA;AACPZ,iBASee,kCAAAA,CATff,KAAAA,EASyDN,aATzDM,EAAAA,EAAAA,GAAAA,EAS+ER,0BAT/EQ,EAAAA,OAAAA,CAAAA,EASqHU,8BATrHV,CAAAA,EASsJS,OATtJT,CAS8JD,aAT9JC,CAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"load.d.cts","names":["_________langchain_core_dist_tools_types_js0","BaseLanguageModelInterface","ToolInterface","Agent","loadAgent","_langchain_core_language_models_base0","BaseLanguageModelCallOptions","StringInputToolSchema","Promise"],"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: (uri: string, llmAndTools?: {\n    llm?: BaseLanguageModelInterface<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n    tools?: ToolInterface<import(\"../../../langchain-core/dist/tools/types.js\").StringInputToolSchema, any, any>[] | undefined;\n} | undefined) => Promise<Agent>;\n"],"mappings":";;;;;;;cAGqBI;QACXH,gCAEsBI,qCAAAA,CAFyDC,4BAAAA;UAC7EJ,cADwB,qBAAA;kBAElBM,QAAQL"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"load.d.ts","names":["_________langchain_core_dist_tools_types_js0","BaseLanguageModelInterface","ToolInterface","Agent","loadAgent","_langchain_core_language_models_base0","BaseLanguageModelCallOptions","StringInputToolSchema","Promise"],"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: (uri: string, llmAndTools?: {\n    llm?: BaseLanguageModelInterface<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions> | undefined;\n    tools?: ToolInterface<import(\"../../../langchain-core/dist/tools/types.js\").StringInputToolSchema, any, any>[] | undefined;\n} | undefined) => Promise<Agent>;\n"],"mappings":";;;;;;;cAGqBI;QACXH,gCAEsBI,qCAAAA,CAFyDC,4BAAAA;UAC7EJ,cADwB,qBAAA;kBAElBM,QAAQL"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;;;AAUA;AAYYW,UAZKD,wBAAAA,CAYa;EAAA;EAAA,MAAYH,CAAAA,EAAAA,MAAAA;EAAU;EAAX,MAAA,CAAA,EAAA,MAAA;EA0BpBK;EAAa,cAAA,CAAA,EAAA,MAAA,EAAA;;;;;;AA6BHX,KAvDnBU,kBAAAA,GAAqBR,QAuDFF,CAvDWM,UAuDXN,EAAAA,cAAAA,CAAAA;;;;;;;;;;;;;;AA7BiB;;;;;;;;;;;;cAA3BW,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;;;AAUA;AAYYW,UAZKD,wBAAAA,CAYa;EAAA;EAAA,MAAYH,CAAAA,EAAAA,MAAAA;EAAU;EAAX,MAAA,CAAA,EAAA,MAAA;EA0BpBK;EAAa,cAAA,CAAA,EAAA,MAAA,EAAA;;;;;;AA6BHX,KAvDnBU,kBAAAA,GAAqBR,QAuDFF,CAvDWM,UAuDXN,EAAAA,cAAAA,CAAAA;;;;;;;;;;;;;;AA7BiB;;;;;;;;;;;;cAA3BW,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.map

@@ -1 +0,0 @@
-{"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        tool: string;\n        toolInput: string;\n        log: string;\n        returnValues?: undefined;\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"],"mappings":";;;;;;AAOA;;;AAUyBI,cAVJD,yBAAAA,SAAkCF,uBAAAA,CAU9BG;EAAO,YAVuBH,EAAAA,MAAAA,EAAAA;EAAuB,cAAA,EAAA,MAAA;uBAGrDD;;;;;;;uBAOAI"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;AAOA;;;AAUyBI,cAVJD,yBAAAA,SAAkCF,uBAAAA,CAU9BG;EAAO,YAVuBH,EAAAA,MAAAA,EAAAA;EAAuB,cAAA,EAAA,MAAA;uBAGrDD;;;;;;;uBAOAI"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;;;;;;AAeA;;AACWE,UADMiB,gBAAAA,SAAyBH,UAC/Bd,CAAAA;EAAuB,KADQc,EAC/Bd,uBAD+Bc,EAAAA;AAAU;AAOpD;AASA;;;AAQkBC,UAjBDG,2BAAAA,CAiBCH;EAAgC,MACtBE,CAAAA,EAAAA,MAAAA;EAAgB,aAArBG,CAAAA,EAhBHd,aAgBGc;;;;;;;AAgBiHR,cAzBnHO,WAAAA,SAAoBR,KAAAA,CAyB+FC;EAAS,OAAdS,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,YAA2BF,EAAAA,MAAAA,EAAAA;EAAW,UAM9If,CAAAA,CAAAA,EAAAA,kBAAAA;EAAS,iBAAsBC,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,SAA5BiB,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,KAS9BlB,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAS,KAAfmB,EAjCLvB,uBAiCKuB,EAAAA;EAAK,YAAqBhB,EAhCxBQ,gCAgCwBR;EAAW,WAAoBG,CAAAA,KAAAA,EA/BlDU,IA+BkDV,CA/B7CO,gBA+B6CP,EAAAA,cAAAA,CAAAA;EAAe;;;;AAxC1C;AA6C9C;;EAA4C,OAMrBX,YAAAA,CAAAA,MAAAA,EAlCSC,uBAkCTD,EAAAA,EAAAA,MAAAA,CAAAA,EAlC6CmB,2BAkC7CnB,CAAAA,EAlC2EU,kBAkC3EV;EAAuB;;;AAIhB;AA+D9B;;;EAAwD,OAAE4B,eAAAA,CAAAA,GAAAA,EA7F1B7B,0BA6F0B6B,EAAAA,KAAAA,EA7FS3B,uBA6FT2B,EAAAA,EAAAA,IAAAA,CAAAA,EA7F2CT,2BA6F3CS,GA7FyEN,IA6FzEM,CA7F8Ef,SA6F9Ee,EAAAA,WAAAA,CAAAA,CAAAA,EA7FwGR,WA6FxGQ;EAAK;;;;;EAEjD,mBAAGxB,CAAAA,KAAAA,EAzFcC,SAyFdD,EAAAA,CAAAA,EAzF4BmB,OAyF5BnB,CAAAA,MAAAA,GAzF6CE,WAyF7CF,EAAAA,CAAAA;EAAW;;AAFyG;;;;;;cA9ErHoB,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;;;;;;AAeA;;AACWE,UADMiB,gBAAAA,SAAyBH,UAC/Bd,CAAAA;EAAuB,KADQc,EAC/Bd,uBAD+Bc,EAAAA;AAAU;AAOpD;AASA;;;AAQkBC,UAjBDG,2BAAAA,CAiBCH;EAAgC,MACtBE,CAAAA,EAAAA,MAAAA;EAAgB,aAArBG,CAAAA,EAhBHd,aAgBGc;;;;;;;AAgBiHR,cAzBnHO,WAAAA,SAAoBR,KAAAA,CAyB+FC;EAAS,OAAdS,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,YAA2BF,EAAAA,MAAAA,EAAAA;EAAW,UAM9If,CAAAA,CAAAA,EAAAA,kBAAAA;EAAS,iBAAsBC,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,SAA5BiB,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,KAS9BlB,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAS,KAAfmB,EAjCLvB,uBAiCKuB,EAAAA;EAAK,YAAqBhB,EAhCxBQ,gCAgCwBR;EAAW,WAAoBG,CAAAA,KAAAA,EA/BlDU,IA+BkDV,CA/B7CO,gBA+B6CP,EAAAA,cAAAA,CAAAA;EAAe;;;;AAxC1C;AA6C9C;;EAA4C,OAMrBX,YAAAA,CAAAA,MAAAA,EAlCSC,uBAkCTD,EAAAA,EAAAA,MAAAA,CAAAA,EAlC6CmB,2BAkC7CnB,CAAAA,EAlC2EU,kBAkC3EV;EAAuB;;;AAIhB;AA+D9B;;;EAAwD,OAAE4B,eAAAA,CAAAA,GAAAA,EA7F1B7B,0BA6F0B6B,EAAAA,KAAAA,EA7FS3B,uBA6FT2B,EAAAA,EAAAA,IAAAA,CAAAA,EA7F2CT,2BA6F3CS,GA7FyEN,IA6FzEM,CA7F8Ef,SA6F9Ee,EAAAA,WAAAA,CAAAA,CAAAA,EA7FwGR,WA6FxGQ;EAAK;;;;;EAEjD,mBAAGxB,CAAAA,KAAAA,EAzFcC,SAyFdD,EAAAA,CAAAA,EAzF4BmB,OAyF5BnB,CAAAA,MAAAA,GAzF6CE,WAyF7CF,EAAAA,CAAAA;EAAW;;AAFyG;;;;;;cA9ErHoB,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;AAOA;AAAgC,KAApBK,oBAAAA,GAAuBL,WAAH,GAAA;EAAA,UAAGA,CAAAA,EAClBE,WADkBF,EAAAA;CAAW;AAClB;AAkC5B;;;;;;;;;;;;;AAAqF;;;;;;;;;;;;;;;;;;cAAhEM,gCAAAA,SAAyCF,uBAAAA;;;uBAGrCG,QAAQP,cAAcC;2BAClBE,mBAAmBI,QAAQN,cAAcI;;;;;;;0BAO1CH,cAAcG,uBAAuBJ"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;AAOA;AAAgC,KAApBK,oBAAAA,GAAuBL,WAAH,GAAA;EAAA,UAAGA,CAAAA,EAClBE,WADkBF,EAAAA;CAAW;AAClB;AAkC5B;;;;;;;;;;;;;AAAqF;;;;;;;;;;;;;;;;;;cAAhEM,gCAAAA,SAAyCF,uBAAAA;;;uBAGrCG,QAAQP,cAAcC;2BAClBE,mBAAmBI,QAAQN,cAAcI;;;;;;;0BAO1CH,cAAcG,uBAAuBJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","___index_js0","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[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n         | 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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>>;\n"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAMlB,GAMXT,EANFC,aAMED,CANYE,wBAMZF,GAAAA;IAA4BK,KAAAA,CAAAA,EALvBL,uBAKuBK,EAAAA,GALKD,YAAAA,CAAaM,kBAKlBL;IAE3BF;IAAAA,EAAkB,GAAA,EAAA;EA+DNQ,CAAAA,CAAAA;EAAsB;EAAA,KAAGC,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAG;EAAO,MAAEE,EA/DjDX,kBA+DiDW;EAAM;;;;EAE/B,cAAA,CAAA,EAAA,OAAA;CAAoC;;AAFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGH,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAc,WAAA,GACW,WAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","___index_js1","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[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n         | 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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>>;\n"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAMlB,GAMXT,EANFC,aAMED,CANYE,wBAMZF,GAAAA;IAA4BK,KAAAA,CAAAA,EALvBL,uBAKuBK,EAAAA,GALKD,YAAAA,CAAaM,kBAKlBL;IAE3BF;IAAAA,EAAkB,GAAA,EAAA;EA+DNQ,CAAAA,CAAAA;EAAsB;EAAA,KAAGC,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAG;EAAO,MAAEE,EA/DjDX,kBA+DiDW;EAAM;;;;EAE/B,cAAA,CAAA,EAAA,OAAA;CAAoC;;AAFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGH,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAc,WAAA,GACW,WAAA"}

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

@@ -1 +0,0 @@
-{"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"],"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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;AAmCA;;;;;;;;;;;;;AAAsF;;;;;;;;;;;;;;;cAAjEO,4BAAAA,SAAqCH,4BAAAA;;;uBAGjCI,QAAQR,gBAAgBC;2BACpBE,mBAAmBK,QAAQP,cAAcI;;;;;;;0BAO1CH,cAAcG,qBAAqBJ"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","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"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAAA;EAAA,GAEzBH,EAAAA,0BAAAA;EAA0B;EAEX,KAKZD,EALDD,aAKCC,EAAAA;EAAkB;AAkD9B;;;EAA8C,MAAEO,EAlDpCP,kBAkDoCO;EAAK;;;;EACjC,cAAAG,CAAAA,EAAAA,OAAAA;CAC2B;;;AAFkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFL,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","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"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAAA;EAAA,GAEzBH,EAAAA,0BAAAA;EAA0B;EAEX,KAKZD,EALDD,aAKCC,EAAAA;EAAkB;AAkD9B;;;EAA8C,MAAEO,EAlDpCP,kBAkDoCO;EAAK;;;;EACjC,cAAAG,CAAAA,EAAAA,OAAAA;CAC2B;;;AAFkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFL,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;AAyCA;;;;;;AAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5DG,4BAAAA,SAAqCD,uBAAAA;;;;;;;;;;;;uBAYjCE,QAAQJ,cAAcC"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;AAyCA;;;;;;AAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5DG,4BAAAA,SAAqCD,uBAAAA;;;;;;;;;;;;uBAYjCE,QAAQJ,cAAcC"}

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

@@ -1 +0,0 @@
-{"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_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"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAAoC,UAhBnBc,8BAAAA,CAgBmB;EAAA;EAAsB,MAAnBP,CAAAA,EAAAA,MAAAA;EAAQ;EAK1BS,MAAAA,CAAAA,EAAAA,MAAAA;EAAmB;EAAA,oBAGjBD,CAAAA,EAAAA,MAAAA;EAAwB;EAUQ,cAOZJ,CAAAA,EAAAA,MAAAA,EAAAA;EAAgB;EAEd,aAQdL,CAAAA,EAzCXF,yBAyCWE,EAAAA;;;;;;AA2BCL,KA9DpBc,wBAAAA,GAA2BR,QA8DPN,CA9DgBW,UA8DhBX,EAAAA,cAAAA,CAAAA;;;;;AAzDiBO,cAA5BQ,mBAAAA,SAA4BR,KAAAA,CAAAA;EAAK,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EA8D1CU,YAAAA,EAAAA,MAAAA,EAAAA;EAA+B,WAAA,CAAA,KAAA,EA3DpBH,wBA2DoB;EAAA,UAElCd,CAAAA,CAAAA,EAAAA,6CAAAA;EAA0B,iBAEvBD,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,SAAGE,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,KAKxCC,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkB;AA+D9B;;;;EAA8D,OAAEmB,aAAAA,CAAAA,KAAAA,EAzHhCtB,uBAyHgCsB,EAAAA,CAAAA,EAAAA,IAAAA;EAAM;;;;;;EAAmF,OAA7BL,sBAAAA,CAAAA,OAAAA,EAlHjFN,gBAkHiFM,GAAAA;IAAO,SAAA,EAAA,MAAA,EAAA;MAhH3HJ;;;;;;;;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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAAoC,UAhBnBc,8BAAAA,CAgBmB;EAAA;EAAsB,MAAnBP,CAAAA,EAAAA,MAAAA;EAAQ;EAK1BS,MAAAA,CAAAA,EAAAA,MAAAA;EAAmB;EAAA,oBAGjBD,CAAAA,EAAAA,MAAAA;EAAwB;EAUQ,cAOZJ,CAAAA,EAAAA,MAAAA,EAAAA;EAAgB;EAEd,aAQdL,CAAAA,EAzCXF,yBAyCWE,EAAAA;;;;;;AA2BCL,KA9DpBc,wBAAAA,GAA2BR,QA8DPN,CA9DgBW,UA8DhBX,EAAAA,cAAAA,CAAAA;;;;;AAzDiBO,cAA5BQ,mBAAAA,SAA4BR,KAAAA,CAAAA;EAAK,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EA8D1CU,YAAAA,EAAAA,MAAAA,EAAAA;EAA+B,WAAA,CAAA,KAAA,EA3DpBH,wBA2DoB;EAAA,UAElCd,CAAAA,CAAAA,EAAAA,6CAAAA;EAA0B,iBAEvBD,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,SAAGE,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,KAKxCC,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkB;AA+D9B;;;;EAA8D,OAAEmB,aAAAA,CAAAA,KAAAA,EAzHhCtB,uBAyHgCsB,EAAAA,CAAAA,EAAAA,IAAAA;EAAM;;;;;;EAAmF,OAA7BL,sBAAAA,CAAAA,OAAAA,EAlHjFN,gBAkHiFM,GAAAA;IAAO,SAAA,EAAA,MAAA,EAAA;MAhH3HJ;;;;;;;;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"}