@langchain/classic 1.0.0-alpha.1

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

@@ -0,0 +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"}

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

@@ -0,0 +1,88 @@
+import { AgentInput } from "../types.js";
+import { Agent, AgentArgs, OutputParserArgs } from "../agent.js";
+import { Optional } from "../../types/type-utils.js";
+import { ChatAgentOutputParser } from "./outputParser.js";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { ToolInterface } from "@langchain/core/tools";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { AgentStep } from "@langchain/core/agents";
+
+//#region src/agents/chat/index.d.ts
+
+/**
+ * Interface for arguments used to create a chat prompt.
+ */
+interface ChatCreatePromptArgs {
+  /** String to put after the list of tools. */
+  suffix?: string;
+  /** String to put before the list of tools. */
+  prefix?: string;
+  /** String to use directly as the human message template. */
+  humanMessageTemplate?: string;
+  /** Formattable string to use as the instructions template. */
+  formatInstructions?: string;
+  /** List of input variables the final prompt will expect. */
+  inputVariables?: string[];
+}
+/**
+ * Type for input data for creating a ChatAgent, extending AgentInput with
+ * optional 'outputParser'.
+ */
+type ChatAgentInput = Optional<AgentInput, "outputParser">;
+/**
+ * Agent for the MRKL chain.
+ * @augments Agent
+ */
+declare class ChatAgent extends Agent {
+  static lc_name(): string;
+  lc_namespace: string[];
+  ToolType: ToolInterface;
+  constructor(input: ChatAgentInput);
+  _agentType(): "chat-zero-shot-react-description";
+  observationPrefix(): string;
+  llmPrefix(): string;
+  _stop(): string[];
+  /**
+   * Validates that all tools have descriptions. Throws an error if a tool
+   * without a description is found.
+   * @param tools Array of Tool instances to validate.
+   * @returns void
+   */
+  static validateTools(tools: ToolInterface[]): void;
+  /**
+   * Returns a default output parser for the ChatAgent.
+   * @param _fields Optional OutputParserArgs to customize the output parser.
+   * @returns ChatAgentOutputParser instance
+   */
+  static getDefaultOutputParser(_fields?: OutputParserArgs): ChatAgentOutputParser;
+  /**
+   * Constructs the agent's scratchpad, which is a string representation of
+   * the agent's previous steps.
+   * @param steps Array of AgentStep instances representing the agent's previous steps.
+   * @returns Promise resolving to a string representing the agent's scratchpad.
+   */
+  constructScratchPad(steps: AgentStep[]): Promise<string>;
+  /**
+   * Create prompt in the style of the zero shot agent.
+   *
+   * @param tools - List of tools the agent will have access to, used to format the prompt.
+   * @param args - Arguments to create the prompt with.
+   * @param args.suffix - String to put after the list of tools.
+   * @param args.prefix - String to put before the list of tools.
+   * @param args.humanMessageTemplate - String to use directly as the human message template
+   * @param args.formatInstructions - Formattable string to use as the instructions template
+   */
+  static createPrompt(tools: ToolInterface[], args?: ChatCreatePromptArgs): ChatPromptTemplate<any, any>;
+  /**
+   * Creates a ChatAgent instance using a language model, tools, and
+   * optional arguments.
+   * @param llm BaseLanguageModelInterface instance to use in the agent.
+   * @param tools Array of Tool instances to include in the agent.
+   * @param args Optional arguments to customize the agent and prompt.
+   * @returns ChatAgent instance
+   */
+  static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ChatCreatePromptArgs & AgentArgs): ChatAgent;
+}
+//#endregion
+export { ChatAgent, ChatAgentInput, ChatCreatePromptArgs };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/agents/chat/index.js

@@ -0,0 +1,122 @@
+import { Agent } from "../agent.js";
+import { LLMChain } from "../../chains/llm_chain.js";
+import { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from "./prompt.js";
+import { ChatAgentOutputParser } from "./outputParser.js";
+import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate } from "@langchain/core/prompts";
+
+//#region src/agents/chat/index.ts
+const DEFAULT_HUMAN_MESSAGE_TEMPLATE = "{input}\n\n{agent_scratchpad}";
+/**
+* Agent for the MRKL chain.
+* @augments Agent
+*/
+var ChatAgent = class ChatAgent extends Agent {
+	static lc_name() {
+		return "ChatAgent";
+	}
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"chat"
+	];
+	constructor(input) {
+		const outputParser = input?.outputParser ?? ChatAgent.getDefaultOutputParser();
+		super({
+			...input,
+			outputParser
+		});
+	}
+	_agentType() {
+		return "chat-zero-shot-react-description";
+	}
+	observationPrefix() {
+		return "Observation: ";
+	}
+	llmPrefix() {
+		return "Thought:";
+	}
+	_stop() {
+		return ["Observation:"];
+	}
+	/**
+	* Validates that all tools have descriptions. Throws an error if a tool
+	* without a description is found.
+	* @param tools Array of Tool instances to validate.
+	* @returns void
+	*/
+	static validateTools(tools) {
+		const descriptionlessTool = tools.find((tool) => !tool.description);
+		if (descriptionlessTool) {
+			const msg = `Got a tool ${descriptionlessTool.name} without a description. This agent requires descriptions for all tools.`;
+			throw new Error(msg);
+		}
+	}
+	/**
+	* Returns a default output parser for the ChatAgent.
+	* @param _fields Optional OutputParserArgs to customize the output parser.
+	* @returns ChatAgentOutputParser instance
+	*/
+	static getDefaultOutputParser(_fields) {
+		return new ChatAgentOutputParser();
+	}
+	/**
+	* Constructs the agent's scratchpad, which is a string representation of
+	* the agent's previous steps.
+	* @param steps Array of AgentStep instances representing the agent's previous steps.
+	* @returns Promise resolving to a string representing the agent's scratchpad.
+	*/
+	async constructScratchPad(steps) {
+		const agentScratchpad = await super.constructScratchPad(steps);
+		if (agentScratchpad) return `This was your previous work (but I haven't seen any of it! I only see what you return as final answer):\n${agentScratchpad}`;
+		return agentScratchpad;
+	}
+	/**
+	* Create prompt in the style of the zero shot agent.
+	*
+	* @param tools - List of tools the agent will have access to, used to format the prompt.
+	* @param args - Arguments to create the prompt with.
+	* @param args.suffix - String to put after the list of tools.
+	* @param args.prefix - String to put before the list of tools.
+	* @param args.humanMessageTemplate - String to use directly as the human message template
+	* @param args.formatInstructions - Formattable string to use as the instructions template
+	*/
+	static createPrompt(tools, args) {
+		const { prefix = PREFIX, suffix = SUFFIX, humanMessageTemplate = DEFAULT_HUMAN_MESSAGE_TEMPLATE, formatInstructions = FORMAT_INSTRUCTIONS } = args ?? {};
+		const toolStrings = tools.map((tool) => `${tool.name}: ${tool.description}`).join("\n");
+		const template = [
+			prefix,
+			toolStrings,
+			formatInstructions,
+			suffix
+		].join("\n\n");
+		const messages = [SystemMessagePromptTemplate.fromTemplate(template), HumanMessagePromptTemplate.fromTemplate(humanMessageTemplate)];
+		return ChatPromptTemplate.fromMessages(messages);
+	}
+	/**
+	* Creates a ChatAgent instance using a language model, tools, and
+	* optional arguments.
+	* @param llm BaseLanguageModelInterface instance to use in the agent.
+	* @param tools Array of Tool instances to include in the agent.
+	* @param args Optional arguments to customize the agent and prompt.
+	* @returns ChatAgent instance
+	*/
+	static fromLLMAndTools(llm, tools, args) {
+		ChatAgent.validateTools(tools);
+		const prompt = ChatAgent.createPrompt(tools, args);
+		const chain = new LLMChain({
+			prompt,
+			llm,
+			callbacks: args?.callbacks ?? args?.callbackManager
+		});
+		const outputParser = args?.outputParser ?? ChatAgent.getDefaultOutputParser();
+		return new ChatAgent({
+			llmChain: chain,
+			outputParser,
+			allowedTools: tools.map((t) => t.name)
+		});
+	}
+};
+
+//#endregion
+export { ChatAgent };
+//# sourceMappingURL=index.js.map

package/dist/agents/chat/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["input: ChatAgentInput","tools: ToolInterface[]","_fields?: OutputParserArgs","steps: AgentStep[]","args?: ChatCreatePromptArgs","llm: BaseLanguageModelInterface","args?: ChatCreatePromptArgs & AgentArgs"],"sources":["../../../src/agents/chat/index.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { ToolInterface } from \"@langchain/core/tools\";\nimport {\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\nimport type { AgentStep } from \"@langchain/core/agents\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { ChatAgentOutputParser } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\n\nconst DEFAULT_HUMAN_MESSAGE_TEMPLATE = \"{input}\\n\\n{agent_scratchpad}\";\n\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/**\n * Type for input data for creating a ChatAgent, extending AgentInput with\n * optional 'outputParser'.\n */\nexport type ChatAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n */\nexport class ChatAgent extends Agent {\n  static lc_name() {\n    return \"ChatAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"chat\"];\n\n  declare ToolType: ToolInterface;\n\n  constructor(input: ChatAgentInput) {\n    const outputParser =\n      input?.outputParser ?? ChatAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"chat-zero-shot-react-description\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  _stop(): string[] {\n    return [\"Observation:\"];\n  }\n\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[]) {\n    const descriptionlessTool = tools.find((tool) => !tool.description);\n    if (descriptionlessTool) {\n      const msg =\n        `Got a tool ${descriptionlessTool.name} without a description.` +\n        ` This agent requires descriptions for all tools.`;\n      throw new Error(msg);\n    }\n  }\n\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) {\n    return new ChatAgentOutputParser();\n  }\n\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  async constructScratchPad(steps: AgentStep[]): Promise<string> {\n    const agentScratchpad = await super.constructScratchPad(steps);\n    if (agentScratchpad) {\n      return `This was your previous work (but I haven't seen any of it! I only see what you return as final answer):\\n${agentScratchpad}`;\n    }\n    return agentScratchpad;\n  }\n\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) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      humanMessageTemplate = DEFAULT_HUMAN_MESSAGE_TEMPLATE,\n      formatInstructions = FORMAT_INSTRUCTIONS,\n    } = args ?? {};\n    const toolStrings = tools\n      .map((tool) => `${tool.name}: ${tool.description}`)\n      .join(\"\\n\");\n    const template = [prefix, toolStrings, formatInstructions, suffix].join(\n      \"\\n\\n\"\n    );\n    const messages = [\n      SystemMessagePromptTemplate.fromTemplate(template),\n      HumanMessagePromptTemplate.fromTemplate(humanMessageTemplate),\n    ];\n    return ChatPromptTemplate.fromMessages(messages);\n  }\n\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(\n    llm: BaseLanguageModelInterface,\n    tools: ToolInterface[],\n    args?: ChatCreatePromptArgs & AgentArgs\n  ) {\n    ChatAgent.validateTools(tools);\n    const prompt = ChatAgent.createPrompt(tools, args);\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks ?? args?.callbackManager,\n    });\n    const outputParser =\n      args?.outputParser ?? ChatAgent.getDefaultOutputParser();\n\n    return new ChatAgent({\n      llmChain: chain,\n      outputParser,\n      allowedTools: tools.map((t) => t.name),\n    });\n  }\n}\n"],"mappings":";;;;;;;AAeA,MAAM,iCAAiC;;;;;AA4BvC,IAAa,YAAb,MAAa,kBAAkB,MAAM;CACnC,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAU;CAAO;CAI9C,YAAYA,OAAuB;EACjC,MAAM,eACJ,OAAO,gBAAgB,UAAU,wBAAwB;EAC3D,MAAM;GAAE,GAAG;GAAO;EAAc,EAAC;CAClC;CAED,aAAa;AACX,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO;CACR;CAED,YAAY;AACV,SAAO;CACR;CAED,QAAkB;AAChB,SAAO,CAAC,cAAe;CACxB;;;;;;;CAQD,OAAO,cAAcC,OAAwB;EAC3C,MAAM,sBAAsB,MAAM,KAAK,CAAC,SAAS,CAAC,KAAK,YAAY;AACnE,MAAI,qBAAqB;GACvB,MAAM,MACJ,CAAC,WAAW,EAAE,oBAAoB,KAAK,uEAAuB,CACZ;AACpD,SAAM,IAAI,MAAM;EACjB;CACF;;;;;;CAOD,OAAO,uBAAuBC,SAA4B;AACxD,SAAO,IAAI;CACZ;;;;;;;CAQD,MAAM,oBAAoBC,OAAqC;EAC7D,MAAM,kBAAkB,MAAM,MAAM,oBAAoB,MAAM;AAC9D,MAAI,gBACF,QAAO,CAAC,yGAAyG,EAAE,iBAAiB;AAEtI,SAAO;CACR;;;;;;;;;;;CAYD,OAAO,aAAaF,OAAwBG,MAA6B;EACvE,MAAM,EACJ,SAAS,QACT,SAAS,QACT,uBAAuB,gCACvB,qBAAqB,qBACtB,GAAG,QAAQ,CAAE;EACd,MAAM,cAAc,MACjB,IAAI,CAAC,SAAS,GAAG,KAAK,KAAK,EAAE,EAAE,KAAK,aAAa,CAAC,CAClD,KAAK,KAAK;EACb,MAAM,WAAW;GAAC;GAAQ;GAAa;GAAoB;EAAO,EAAC,KACjE,OACD;EACD,MAAM,WAAW,CACf,4BAA4B,aAAa,SAAS,EAClD,2BAA2B,aAAa,qBAAqB,AAC9D;AACD,SAAO,mBAAmB,aAAa,SAAS;CACjD;;;;;;;;;CAUD,OAAO,gBACLC,KACAJ,OACAK,MACA;EACA,UAAU,cAAc,MAAM;EAC9B,MAAM,SAAS,UAAU,aAAa,OAAO,KAAK;EAClD,MAAM,QAAQ,IAAI,SAAS;GACzB;GACA;GACA,WAAW,MAAM,aAAa,MAAM;EACrC;EACD,MAAM,eACJ,MAAM,gBAAgB,UAAU,wBAAwB;AAE1D,SAAO,IAAI,UAAU;GACnB,UAAU;GACV;GACA,cAAc,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK;EACvC;CACF;AACF"}

package/dist/agents/chat/outputParser.cjs

@@ -0,0 +1,93 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_types = require('../types.cjs');
+const require_prompt = require('./prompt.cjs');
+const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+
+//#region src/agents/chat/outputParser.ts
+const FINAL_ANSWER_ACTION = "Final Answer:";
+/**
+* A class that extends the AgentActionOutputParser to parse the output of
+* the ChatAgent in LangChain. It checks if the output text contains the
+* final answer action or a JSON response, and parses it accordingly.
+* @example
+* ```typescript
+* const prompt = ChatPromptTemplate.fromMessages([
+*   [
+*     "ai",
+*     `{PREFIX}
+* {FORMAT_INSTRUCTIONS}
+* {SUFFIX}`,
+*   ],
+*   ["human", "Question: {input}"],
+* ]);
+* const runnableAgent = RunnableSequence.from([
+*   {
+*     input: (i: { input: string; steps: AgentStep[] }) => i.input,
+*     agent_scratchpad: (i: { input: string; steps: AgentStep[] }) =>
+*       formatLogToString(i.steps),
+*   },
+*   prompt,
+*   new OpenAI({ temperature: 0 }),
+*   new ChatAgentOutputParser(),
+* ]);
+*
+* const executor = AgentExecutor.fromAgentAndTools({
+*   agent: runnableAgent,
+*   tools: [new SerpAPI(), new Calculator()],
+* });
+*
+* const result = await executor.invoke({
+*   input:
+*     "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?",
+* });
+* ```
+*/
+var ChatAgentOutputParser = class extends require_types.AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"chat"
+	];
+	/**
+	* Parses the output text from the MRKL chain into an agent action or
+	* agent finish. If the text contains the final answer action or does not
+	* contain an action, it returns an AgentFinish with the output and log.
+	* If the text contains a JSON response, it returns the tool, toolInput,
+	* and log.
+	* @param text The output text from the MRKL chain.
+	* @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.
+	*/
+	async parse(text) {
+		if (text.includes(FINAL_ANSWER_ACTION) || !text.includes(`"action":`)) {
+			const parts = text.split(FINAL_ANSWER_ACTION);
+			const output = parts[parts.length - 1].trim();
+			return {
+				returnValues: { output },
+				log: text
+			};
+		}
+		const action = text.includes("```") ? text.trim().split(/```(?:json)?/)[1] : text.trim();
+		try {
+			const response = JSON.parse(action.trim());
+			return {
+				tool: response.action,
+				toolInput: response.action_input,
+				log: text
+			};
+		} catch {
+			throw new __langchain_core_output_parsers.OutputParserException(`Unable to parse JSON response from chat agent.\n\n${text}`);
+		}
+	}
+	/**
+	* Returns the format instructions used in the output parser for the
+	* ChatAgent class.
+	* @returns The format instructions as a string.
+	*/
+	getFormatInstructions() {
+		return require_prompt.FORMAT_INSTRUCTIONS;
+	}
+};
+
+//#endregion
+exports.ChatAgentOutputParser = ChatAgentOutputParser;
+//# sourceMappingURL=outputParser.cjs.map

package/dist/agents/chat/outputParser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.cjs","names":["AgentActionOutputParser","text: string","OutputParserException","FORMAT_INSTRUCTIONS"],"sources":["../../../src/agents/chat/outputParser.ts"],"sourcesContent":["import type { AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nexport 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 class ChatAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"chat\"];\n\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  async parse(text: string) {\n    if (text.includes(FINAL_ANSWER_ACTION) || !text.includes(`\"action\":`)) {\n      const parts = text.split(FINAL_ANSWER_ACTION);\n      const output = parts[parts.length - 1].trim();\n      return { returnValues: { output }, log: text } satisfies AgentFinish;\n    }\n\n    const action = text.includes(\"```\")\n      ? text.trim().split(/```(?:json)?/)[1]\n      : text.trim();\n    try {\n      const response = JSON.parse(action.trim());\n      return {\n        tool: response.action,\n        toolInput: response.action_input,\n        log: text,\n      };\n    } catch {\n      throw new OutputParserException(\n        `Unable to parse JSON response from chat agent.\\n\\n${text}`\n      );\n    }\n  }\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    return FORMAT_INSTRUCTIONS;\n  }\n}\n"],"mappings":";;;;;;AAKA,MAAa,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnC,IAAa,wBAAb,cAA2CA,sCAAwB;CACjE,eAAe;EAAC;EAAa;EAAU;CAAO;;;;;;;;;;CAW9C,MAAM,MAAMC,MAAc;AACxB,MAAI,KAAK,SAAS,oBAAoB,IAAI,CAAC,KAAK,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE;GACrE,MAAM,QAAQ,KAAK,MAAM,oBAAoB;GAC7C,MAAM,SAAS,MAAM,MAAM,SAAS,GAAG,MAAM;AAC7C,UAAO;IAAE,cAAc,EAAE,OAAQ;IAAE,KAAK;GAAM;EAC/C;EAED,MAAM,SAAS,KAAK,SAAS,MAAM,GAC/B,KAAK,MAAM,CAAC,MAAM,eAAe,CAAC,KAClC,KAAK,MAAM;AACf,MAAI;GACF,MAAM,WAAW,KAAK,MAAM,OAAO,MAAM,CAAC;AAC1C,UAAO;IACL,MAAM,SAAS;IACf,WAAW,SAAS;IACpB,KAAK;GACN;EACF,QAAO;AACN,SAAM,IAAIC,sDACR,CAAC,kDAAkD,EAAE,MAAM;EAE9D;CACF;;;;;;CAOD,wBAAgC;AAC9B,SAAOC;CACR;AACF"}

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

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

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

@@ -0,0 +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"}

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

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

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

@@ -0,0 +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        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        returnValues?: undefined;\n        tool: any;\n        toolInput: any;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions used in the output parser for the\n     * ChatAgent class.\n     * @returns The format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n"],"mappings":";;;;;AAuCA;;;;AAA0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArDE,qBAAAA,SAA8BF,uBAAAA;;;;;;;;;;;uBAW1BG"}

package/dist/agents/chat/outputParser.js

@@ -0,0 +1,92 @@
+import { AgentActionOutputParser } from "../types.js";
+import { FORMAT_INSTRUCTIONS } from "./prompt.js";
+import { OutputParserException } from "@langchain/core/output_parsers";
+
+//#region src/agents/chat/outputParser.ts
+const FINAL_ANSWER_ACTION = "Final Answer:";
+/**
+* A class that extends the AgentActionOutputParser to parse the output of
+* the ChatAgent in LangChain. It checks if the output text contains the
+* final answer action or a JSON response, and parses it accordingly.
+* @example
+* ```typescript
+* const prompt = ChatPromptTemplate.fromMessages([
+*   [
+*     "ai",
+*     `{PREFIX}
+* {FORMAT_INSTRUCTIONS}
+* {SUFFIX}`,
+*   ],
+*   ["human", "Question: {input}"],
+* ]);
+* const runnableAgent = RunnableSequence.from([
+*   {
+*     input: (i: { input: string; steps: AgentStep[] }) => i.input,
+*     agent_scratchpad: (i: { input: string; steps: AgentStep[] }) =>
+*       formatLogToString(i.steps),
+*   },
+*   prompt,
+*   new OpenAI({ temperature: 0 }),
+*   new ChatAgentOutputParser(),
+* ]);
+*
+* const executor = AgentExecutor.fromAgentAndTools({
+*   agent: runnableAgent,
+*   tools: [new SerpAPI(), new Calculator()],
+* });
+*
+* const result = await executor.invoke({
+*   input:
+*     "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?",
+* });
+* ```
+*/
+var ChatAgentOutputParser = class extends AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"chat"
+	];
+	/**
+	* Parses the output text from the MRKL chain into an agent action or
+	* agent finish. If the text contains the final answer action or does not
+	* contain an action, it returns an AgentFinish with the output and log.
+	* If the text contains a JSON response, it returns the tool, toolInput,
+	* and log.
+	* @param text The output text from the MRKL chain.
+	* @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.
+	*/
+	async parse(text) {
+		if (text.includes(FINAL_ANSWER_ACTION) || !text.includes(`"action":`)) {
+			const parts = text.split(FINAL_ANSWER_ACTION);
+			const output = parts[parts.length - 1].trim();
+			return {
+				returnValues: { output },
+				log: text
+			};
+		}
+		const action = text.includes("```") ? text.trim().split(/```(?:json)?/)[1] : text.trim();
+		try {
+			const response = JSON.parse(action.trim());
+			return {
+				tool: response.action,
+				toolInput: response.action_input,
+				log: text
+			};
+		} catch {
+			throw new OutputParserException(`Unable to parse JSON response from chat agent.\n\n${text}`);
+		}
+	}
+	/**
+	* Returns the format instructions used in the output parser for the
+	* ChatAgent class.
+	* @returns The format instructions as a string.
+	*/
+	getFormatInstructions() {
+		return FORMAT_INSTRUCTIONS;
+	}
+};
+
+//#endregion
+export { ChatAgentOutputParser };
+//# sourceMappingURL=outputParser.js.map

package/dist/agents/chat/outputParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputParser.js","names":["text: string"],"sources":["../../../src/agents/chat/outputParser.ts"],"sourcesContent":["import type { AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nexport 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 class ChatAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"chat\"];\n\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  async parse(text: string) {\n    if (text.includes(FINAL_ANSWER_ACTION) || !text.includes(`\"action\":`)) {\n      const parts = text.split(FINAL_ANSWER_ACTION);\n      const output = parts[parts.length - 1].trim();\n      return { returnValues: { output }, log: text } satisfies AgentFinish;\n    }\n\n    const action = text.includes(\"```\")\n      ? text.trim().split(/```(?:json)?/)[1]\n      : text.trim();\n    try {\n      const response = JSON.parse(action.trim());\n      return {\n        tool: response.action,\n        toolInput: response.action_input,\n        log: text,\n      };\n    } catch {\n      throw new OutputParserException(\n        `Unable to parse JSON response from chat agent.\\n\\n${text}`\n      );\n    }\n  }\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    return FORMAT_INSTRUCTIONS;\n  }\n}\n"],"mappings":";;;;;AAKA,MAAa,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnC,IAAa,wBAAb,cAA2C,wBAAwB;CACjE,eAAe;EAAC;EAAa;EAAU;CAAO;;;;;;;;;;CAW9C,MAAM,MAAMA,MAAc;AACxB,MAAI,KAAK,SAAS,oBAAoB,IAAI,CAAC,KAAK,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE;GACrE,MAAM,QAAQ,KAAK,MAAM,oBAAoB;GAC7C,MAAM,SAAS,MAAM,MAAM,SAAS,GAAG,MAAM;AAC7C,UAAO;IAAE,cAAc,EAAE,OAAQ;IAAE,KAAK;GAAM;EAC/C;EAED,MAAM,SAAS,KAAK,SAAS,MAAM,GAC/B,KAAK,MAAM,CAAC,MAAM,eAAe,CAAC,KAClC,KAAK,MAAM;AACf,MAAI;GACF,MAAM,WAAW,KAAK,MAAM,OAAO,MAAM,CAAC;AAC1C,UAAO;IACL,MAAM,SAAS;IACf,WAAW,SAAS;IACpB,KAAK;GACN;EACF,QAAO;AACN,SAAM,IAAI,sBACR,CAAC,kDAAkD,EAAE,MAAM;EAE9D;CACF;;;;;;CAOD,wBAAgC;AAC9B,SAAO;CACR;AACF"}

package/dist/agents/chat/prompt.cjs

@@ -0,0 +1,33 @@
+
+//#region src/agents/chat/prompt.ts
+const PREFIX = `Answer the following questions as best you can. You have access to the following tools:`;
+const FORMAT_INSTRUCTIONS = `The way you use the tools is by specifying a json blob, denoted below by $JSON_BLOB
+Specifically, this $JSON_BLOB should have a "action" key (with the name of the tool to use) and a "action_input" key (with the input to the tool going here). 
+The $JSON_BLOB should only contain a SINGLE action, do NOT return a list of multiple actions. Here is an example of a valid $JSON_BLOB:
+
+\`\`\`
+{{
+  "action": "calculator",
+  "action_input": "1 + 2"
+}}
+\`\`\`
+
+ALWAYS use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: 
+\`\`\`
+$JSON_BLOB
+\`\`\`
+Observation: the result of the action
+... (this Thought/Action/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question`;
+const SUFFIX = `Begin! Reminder to always use the exact characters \`Final Answer\` when responding.`;
+
+//#endregion
+exports.FORMAT_INSTRUCTIONS = FORMAT_INSTRUCTIONS;
+exports.PREFIX = PREFIX;
+exports.SUFFIX = SUFFIX;
+//# sourceMappingURL=prompt.cjs.map