@langchain/classic 1.0.4 → 1.0.6-dev-1765431816670

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @langchain/classic
 
+## 1.0.5
+
+### Patch Changes
+
+- [#9416](https://github.com/langchain-ai/langchainjs/pull/9416) [`0fe9beb`](https://github.com/langchain-ai/langchainjs/commit/0fe9bebee6710f719e47f913eec1ec4f638e4de4) Thanks [@hntrl](https://github.com/hntrl)! - fix 'moduleResultion: "node"' compatibility
+
+- [#9463](https://github.com/langchain-ai/langchainjs/pull/9463) [`10fa2af`](https://github.com/langchain-ai/langchainjs/commit/10fa2afec0b81efd3467e61b59ba5c82e1043de5) Thanks [@christian-bromann](https://github.com/christian-bromann)! - fix(core): update p-retry to fix memory leak
+
+- Updated dependencies [[`0fe9beb`](https://github.com/langchain-ai/langchainjs/commit/0fe9bebee6710f719e47f913eec1ec4f638e4de4)]:
+  - @langchain/openai@1.1.3
+  - @langchain/textsplitters@1.0.1
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/_virtual/rolldown_runtime.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
 	for (var name in all) __defProp(target, name, {
 		get: all[name],
@@ -32,7 +29,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 
-exports.__commonJS = __commonJS;
 exports.__export = __export;
 exports.__reExport = __reExport;
 exports.__toESM = __toESM;

package/dist/_virtual/rolldown_runtime.js

@@ -1,13 +1,8 @@
 //#region rolldown:runtime
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
 	for (var name in all) __defProp(target, name, {
 		get: all[name],
@@ -25,10 +20,6 @@ var __copyProps = (to, from, except, desc) => {
 	return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
 
 //#endregion
-export { __commonJS, __export, __reExport, __toESM };
+export { __export, __reExport };

package/dist/agents/agent.d.cts

@@ -15,7 +15,6 @@ import { Serializable } from "@langchain/core/load/serializable";
 /**
  * Record type for arguments passed to output parsers.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type OutputParserArgs = Record<string, any>;
 /**
  * Abstract base class for agents in LangChain. Provides common
@@ -79,32 +78,16 @@ declare abstract class BaseMultiActionAgent extends BaseAgent {
    */
   abstract plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction[] | AgentFinish>;
 }
-// TODO: Remove in the future. Only for backwards compatibility.
-// Allows for the creation of runnables with properties that will
-// be passed to the agent executor constructor.
-declare class AgentRunnableSequence<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {
+declare class AgentRunnableSequence<RunInput = any, RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {
   streamRunnable?: boolean;
   singleAction: boolean;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [RunnableLike<RunInput>, ...RunnableLike[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunnableLike<any, RunOutput>], config: {
+  static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [RunnableLike<RunInput>, ...RunnableLike[], RunnableLike<any, RunOutput>], config: {
     singleAction: boolean;
     streamRunnable?: boolean;
     name?: string;
   }): AgentRunnableSequence<RunInput, Exclude<RunOutput, Error>>;
   static isAgentRunnableSequence(x: Runnable): x is AgentRunnableSequence;
 }
-/**
- * Class representing a single-action agent powered by runnables.
- * Extends the BaseSingleActionAgent class and provides methods for
- * planning agent actions with runnables.
- */
-
 /**
  * Class representing a multi-action agent powered by runnables.
  * Extends the BaseMultiActionAgent class and provides methods for
@@ -112,7 +95,6 @@ RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {
  */
 declare class RunnableMultiActionAgent extends BaseMultiActionAgent {
   lc_namespace: string[];
-  // TODO: Rename input to "intermediate_steps"
   runnable: Runnable<ChainValues & {
     steps: AgentStep[];
   }, AgentAction[] | AgentAction | AgentFinish>;
@@ -228,9 +210,7 @@ declare abstract class Agent extends BaseSingleActionAgent {
    *
    * @returns A PromptTemplate assembled from the given tools and fields.
    * */
-  static createPrompt(_tools: StructuredToolInterface[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _fields?: Record<string, any>): BasePromptTemplate;
+  static createPrompt(_tools: StructuredToolInterface[], _fields?: Record<string, any>): BasePromptTemplate;
   /** Construct an agent from an LLM and a list of tools */
   static fromLLMAndTools(_llm: BaseLanguageModelInterface, _tools: StructuredToolInterface[], _args?: AgentArgs): Agent;
   /**

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

@@ -1 +1 @@
-{"version":3,"file":"agent.d.cts","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":"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"}
+{"version":3,"file":"agent.d.cts","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 */\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;\nexport declare class AgentRunnableSequence<RunInput = any, RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {\n    streamRunnable?: boolean;\n    singleAction: boolean;\n    static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [\n        RunnableLike<RunInput>,\n        ...RunnableLike[],\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    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[], _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//# sourceMappingURL=agent.d.ts.map"],"mappings":";;;;;;;;;;;;;;;;AAcA;AAK8ByB,KALlBF,gBAAAA,GAAmBC,MAKQ,CAAA,MAAA,EAAA,GAAA,CAAA;;;;;AAgBsFrB,uBAhB/FsB,SAAAA,SAAkBd,YAAAA,CAgB6ER;EAA0BI,QAAAA,EAfzIP,uBAeyIO;EAARmB,aAAAA,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAI3GnB,IAAAA,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAqCC,IAAAA,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;EAAsBD;;;EApBnC,UAAA,CAAA,CAAA,EAAA,MAAA;EA2B9BoB;;;EAW+CxB,SAAAA,gBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0BU;;;EAAiBa,qBAAAA,CAAAA,mBAAAA,EAtBzEJ,cAsByEI,EAAAA,MAAAA,EAtBjDlB,SAsBiDkB,EAAAA,EAAAA,OAAAA,EAtB3BhB,WAsB2BgB,EAAAA,gBAAAA,CAAAA,EAtBKvB,eAsBLuB,CAAAA,EAtBuBA,OAsBvBA,CAtB+BnB,WAsB/BmB,CAAAA;EAX5DD;AAAS;AAkBrE;EAWyBjB,gBAAAA,CAAAA,aAAAA,EApCWD,WAoCXC,CAAAA,cAAAA,CAAAA,EAAAA,MAAAA,EApCgDA,SAoChDA,EAAAA,CAAAA,EApC8DkB,OAoC9DlB,CApCsED,WAoCtEC,CAAAA,cAAAA,CAAAA,CAAAA;;;;;;;AAXkCiB,uBAlB7BE,qBAAAA,SAA8BF,SAAAA,CAkBDA;EAAS,gBAAA,CAAA,CAAA,EAAA,MAAA;EAc/CK;;;;;;;;;EAW2BE,SAAAA,IAAAA,CAAAA,KAAAA,EAhCvBxB,SAgCuBwB,EAAAA,EAAAA,MAAAA,EAhCFtB,WAgCEsB,EAAAA,eAAAA,CAAAA,EAhC6B7B,eAgC7B6B,EAAAA,MAAAA,CAAAA,EAhCuDnB,cAgCvDmB,CAAAA,EAhCwEN,OAgCxEM,CAhCgF1B,WAgChF0B,GAhC8FzB,WAgC9FyB,CAAAA;;;;;;;AAXoD,uBAdtEJ,oBAAAA,SAA6BH,SAAAA,CAcyC;EA8C/EW,gBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAEE1B;;;;;;;;;EAQ6CP,SAAAA,IAAAA,CAAAA,KAAAA,EA3D3CK,SA2D2CL,EAAAA,EAAAA,MAAAA,EA3DtBO,WA2DsBP,EAAAA,eAAAA,CAAAA,EA3DSA,eA2DTA,EAAAA,MAAAA,CAAAA,EA3DmCU,cA2DnCV,CAAAA,EA3DoDuB,OA2DpDvB,CA3D4DG,WA2D5DH,EAAAA,GA3D4EI,WA2D5EJ,CAAAA;;AAAmEI,cAxDlHuB,qBAwDkHvB,CAAAA,WAAAA,GAAAA,EAAAA,YAAAA,GAAAA,CAAAA,SAxDnDO,gBAwDmDP,CAxDlCwB,QAwDkCxB,EAxDxByB,SAwDwBzB,CAAAA,CAAAA;EAAxBmB,cAAAA,CAAAA,EAAAA,OAAAA;EAVzDE,YAAAA,EAAAA,OAAAA;EAAoB,OAAA,aAAA,CAAA,WAAA,GAAA,EAAA,YAAA,GAAA,CAAA,CAAA,CAAA,KAAA,EAAA,GAAA,SAAA,CAAA,EAAA,CA1ClEb,YAsD0B,CAtDbgB,QAsDa,CAAA,EAKjBO,GA1DNvB,YA0DMuB,EAAAA,EAzDTvB,YA2FawB,CAAAA,GAAAA,EA3FKP,SA2Fe,CAAA,CAE3BhB,EAAAA,MAAAA,EAAAA;IACIC,YAAAA,EAAAA,OAAAA;IAEKqB,cAAAA,CAAAA,EAAAA,OAAAA;IAWP9B,IAAAA,CAAAA,EAAAA,MAAAA;EAAqBE,CAAAA,CAAAA,EAtG7BoB,qBAsG6BpB,CAtGPqB,QAsGOrB,EAtGGwB,OAsGHxB,CAtGWsB,SAsGXtB,EAtGsBuB,KAsGtBvB,CAAAA,CAAAA;EAA+BP,OAAAA,uBAAAA,CAAAA,CAAAA,EArG9BS,QAqG8BT,CAAAA,EAAAA,CAAAA,IArGd2B,qBAqGc3B;;;;;;;AAiFrBmB,cApJ1Bc,wBAAAA,SAAiCR,oBAAAA,CAoJPN;EAAuBd,YAAAA,EAAAA,MAAAA,EAAAA;EAAqBE,QAAAA,EAlJ7EE,QAkJ6EF,CAlJpEA,WAkJoEA,GAAAA;IAA+BP,KAAAA,EAjJ3GK,SAiJ2GL,EAAAA;EAA0BI,CAAAA,EAhJ7ID,WAgJ6IC,EAAAA,GAhJ7HD,WAgJ6HC,GAhJ/GA,WAgJ+GA,CAAAA;EAARmB,cAAAA,EAAAA,MAAAA;EAI/GL,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EACfnB,cAAAA,EAAAA,OAAAA;EACED,IAAAA,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EACAwC,WAAAA,CAAAA,MAAAA,EAlJQtB,6BAkJRsB;EAARf,IAAAA,CAAAA,KAAAA,EAjJQlB,SAiJRkB,EAAAA,EAAAA,MAAAA,EAjJ6BhB,WAiJ7BgB,EAAAA,eAAAA,CAAAA,EAjJ4DvB,eAiJ5DuB,EAAAA,MAAAA,CAAAA,EAjJsFb,cAiJtFa,CAAAA,EAjJuGA,OAiJvGA,CAjJ+GpB,WAiJ/GoB,EAAAA,GAjJ+HnB,WAiJ/HmB,CAAAA;;AApEyD,cA3E5CW,aAAAA,SAAsBD,wBAAwB,CA2EF;;;;UAtEhDE,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,qCAAqCwB,sBAAsBnB;;+BAE1DH,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/agent.d.ts

@@ -15,7 +15,6 @@ import { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";
 /**
  * Record type for arguments passed to output parsers.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type OutputParserArgs = Record<string, any>;
 /**
  * Abstract base class for agents in LangChain. Provides common
@@ -79,32 +78,16 @@ declare abstract class BaseMultiActionAgent extends BaseAgent {
    */
   abstract plan(steps: AgentStep[], inputs: ChainValues, callbackManager?: CallbackManager, config?: RunnableConfig): Promise<AgentAction[] | AgentFinish>;
 }
-// TODO: Remove in the future. Only for backwards compatibility.
-// Allows for the creation of runnables with properties that will
-// be passed to the agent executor constructor.
-declare class AgentRunnableSequence<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunInput = any,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {
+declare class AgentRunnableSequence<RunInput = any, RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {
   streamRunnable?: boolean;
   singleAction: boolean;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [RunnableLike<RunInput>, ...RunnableLike[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  RunnableLike<any, RunOutput>], config: {
+  static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [RunnableLike<RunInput>, ...RunnableLike[], RunnableLike<any, RunOutput>], config: {
     singleAction: boolean;
     streamRunnable?: boolean;
     name?: string;
   }): AgentRunnableSequence<RunInput, Exclude<RunOutput, Error>>;
   static isAgentRunnableSequence(x: Runnable): x is AgentRunnableSequence;
 }
-/**
- * Class representing a single-action agent powered by runnables.
- * Extends the BaseSingleActionAgent class and provides methods for
- * planning agent actions with runnables.
- */
-
 /**
  * Class representing a multi-action agent powered by runnables.
  * Extends the BaseMultiActionAgent class and provides methods for
@@ -112,7 +95,6 @@ RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {
  */
 declare class RunnableMultiActionAgent extends BaseMultiActionAgent {
   lc_namespace: string[];
-  // TODO: Rename input to "intermediate_steps"
   runnable: Runnable<ChainValues & {
     steps: AgentStep[];
   }, AgentAction[] | AgentAction | AgentFinish>;
@@ -228,9 +210,7 @@ declare abstract class Agent extends BaseSingleActionAgent {
    *
    * @returns A PromptTemplate assembled from the given tools and fields.
    * */
-  static createPrompt(_tools: StructuredToolInterface[],
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _fields?: Record<string, any>): BasePromptTemplate;
+  static createPrompt(_tools: StructuredToolInterface[], _fields?: Record<string, any>): BasePromptTemplate;
   /** Construct an agent from an LLM and a list of tools */
   static fromLLMAndTools(_llm: BaseLanguageModelInterface, _tools: StructuredToolInterface[], _args?: AgentArgs): Agent;
   /**

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

@@ -1 +1 @@
-{"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"}
+{"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 */\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;\nexport declare class AgentRunnableSequence<RunInput = any, RunOutput = any> extends RunnableSequence<RunInput, RunOutput> {\n    streamRunnable?: boolean;\n    singleAction: boolean;\n    static fromRunnables<RunInput = any, RunOutput = any>([first, ...runnables]: [\n        RunnableLike<RunInput>,\n        ...RunnableLike[],\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    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[], _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//# sourceMappingURL=agent.d.ts.map"],"mappings":"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"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;AAWA;AAgBYW,UAhBKD,oBAAAA,CAgBqBF;EAKjBI;EAGPX,MAAAA,CAAAA,EAAAA,MAAAA;EACSU;EAWSV,MAAAA,CAAAA,EAAAA,MAAAA;EAMYM;EAAmBE,oBAAAA,CAAAA,EAAAA,MAAAA;EAOhCN;EAAcU,kBAAAA,CAAAA,EAAAA,MAAAA;EAWdZ;EAAwBS,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AASuEE,KArDlHD,cAAAA,GAAiBP,QAqDiGQ,CArDxFJ,UAqDwFI,EAAAA,cAAAA,CAAAA;;AAhDlF;;;cAAvBA,SAAAA,SAAkBP,KAAAA;;;YAGzBJ;qBACSU;;;;;;;;;;;8BAWSV;;;;;;0CAMYM,mBAAmBE;;;;;;;6BAOhCN,cAAcU;;;;;;;;;;;6BAWdZ,wBAAwBS,uBAAuBR;;;;;;;;;8BAS9CF,mCAAmCC,wBAAwBS,uBAAuBJ,YAAYM"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;AAWA;AAgBYW,UAhBKD,oBAAAA,CAgBqBF;EAKjBI;EAGPX,MAAAA,CAAAA,EAAAA,MAAAA;EACSU;EAWSV,MAAAA,CAAAA,EAAAA,MAAAA;EAMYM;EAAmBE,oBAAAA,CAAAA,EAAAA,MAAAA;EAOhCN;EAAcU,kBAAAA,CAAAA,EAAAA,MAAAA;EAWdZ;EAAwBS,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AASuEE,KArDlHD,cAAAA,GAAiBP,QAqDiGQ,CArDxFJ,UAqDwFI,EAAAA,cAAAA,CAAAA;;AAhDlF;;;cAAvBA,SAAAA,SAAkBP,KAAAA;;;YAGzBJ;qBACSU;;;;;;;;;;;8BAWSV;;;;;;0CAMYM,mBAAmBE;;;;;;;6BAOhCN,cAAcU;;;;;;;;;;;6BAWdZ,wBAAwBS,uBAAuBR;;;;;;;;;8BAS9CF,mCAAmCC,wBAAwBS,uBAAuBJ,YAAYM"}

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

@@ -51,12 +51,12 @@ declare class ChatAgentOutputParser extends AgentActionOutputParser {
    * @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.
    */
   parse(text: string): Promise<{
+    tool?: undefined;
+    toolInput?: undefined;
     returnValues: {
       output: string;
     };
     log: string;
-    tool?: undefined;
-    toolInput?: undefined;
   } | {
     returnValues?: undefined;
     tool: any;

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

@@ -1 +1 @@
-{"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"}
+{"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        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//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqBE,qBAAAA,SAA8BF,uBAAuB;;;;;;;;;;;uBAWjDG"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqBE,qBAAAA,SAA8BF,uBAAuB;;;;;;;;;;;uBAWjDG"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;AAYA;AAeA;AAKqBa,UApBJF,kCAAAA,CAoB2B;EAG9BV;EACSW,aAAAA,CAAAA,EAAAA,MAAAA;EAKSX;EAODE,YAAAA,CAAAA,EAAAA,MAAAA;EAAsBC;EAARU,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAQFN;EAEnCC,YAAAA,CAAAA,EAtCWA,uBAsCXA;;;;;;;AAoBwHF,KAnDpHK,4BAAAA,GAA+BP,QAmDqFE,CAnD5EG,UAmD4EH,EAAAA,cAAAA,CAAAA;;;AA9CtE;;cAArCM,uBAAAA,SAAgCP,KAAAA;;;YAGvCL;qBACSW;;;;;8BAKSX;;;;;;;6BAODE,cAAcW,QAAQV;;;;;;;;yCAQVI;;MAEnCC;;;;;;;;;;6BAUuBR,wBAAwBU,qCAAqCT;;;;;;;;;;8BAU5DF,mCAAmCC,wBAAwBU,qCAAqCJ,YAAYM"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;AAYA;AAeA;AAKqBa,UApBJF,kCAAAA,CAoB2B;EAG9BV;EACSW,aAAAA,CAAAA,EAAAA,MAAAA;EAKSX;EAODE,YAAAA,CAAAA,EAAAA,MAAAA;EAAsBC;EAARU,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAQFN;EAEnCC,YAAAA,CAAAA,EAtCWA,uBAsCXA;;;;;;;AAoBwHF,KAnDpHK,4BAAAA,GAA+BP,QAmDqFE,CAnD5EG,UAmD4EH,EAAAA,cAAAA,CAAAA;;;AA9CtE;;cAArCM,uBAAAA,SAAgCP,KAAAA;;;YAGvCL;qBACSW;;;;;8BAKSX;;;;;;;6BAODE,cAAcW,QAAQV;;;;;;;;yCAQVI;;MAEnCC;;;;;;;;;;6BAUuBR,wBAAwBU,qCAAqCT;;;;;;;;;;8BAU5DF,mCAAmCC,wBAAwBU,qCAAqCJ,YAAYM"}

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

@@ -1 +1 @@
-{"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"}
+{"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//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;;KAKYM,4DAAAA,GAA+DH;;EAA/DG,GAAAA,CAAAA,EAAAA,OAAAA;AASZ,CAAA;;;;;AAAwF;AAqB5EG,cArBSF,mCAAAA,SAA4CH,uBAAAA,CAqBd;EAClCG,YAAAA,EAAAA,MAAAA,EAAAA;EAC2BN,QAAAA,SAAAA;EAAcC,WAAAA,CAAAA,MAAAA,EAAAA;IAAjCG,SAAAA,EAAAA,MAAAA,EAAAA;EAAkB,CAAA;EAStBK;;;;;;EA2BGV,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA/CCQ,OA+CDR,CA/CSC,WA+CTD,GA/CuBE,WA+CvBF,CAAAA;EAA0CS;;;;AA3BiC;;;;KAXvFA,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 +1 @@
-{"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"}
+{"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//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;;KAKYM,4DAAAA,GAA+DH;;EAA/DG,GAAAA,CAAAA,EAAAA,OAAAA;AASZ,CAAA;;;;;AAAwF;AAqB5EG,cArBSF,mCAAAA,SAA4CH,uBAAAA,CAqBd;EAClCG,YAAAA,EAAAA,MAAAA,EAAAA;EAC2BN,QAAAA,SAAAA;EAAcC,WAAAA,CAAAA,MAAAA,EAAAA;IAAjCG,SAAAA,EAAAA,MAAAA,EAAAA;EAAkB,CAAA;EAStBK;;;;;;EA2BGV,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA/CCQ,OA+CDR,CA/CSC,WA+CTD,GA/CuBE,WA+CvBF,CAAAA;EAA0CS;;;;AA3BiC;;;;KAXvFA,uCAAAA;eACKF;uBACQF,mBAAmBJ,cAAcC;;;;;;;;;cASrCQ,8CAAAA,SAAuDN,uBAAAA;;;;;sBAKpDK;;;;;iCAKWH;;;;;;uBAMVE,QAAQP,cAAcC;;;;;;;;;;;sBAWvBF,qCAAqCW,KAAKF,iEAAiEC"}