@langchain/classic 1.0.0-alpha.1

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

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

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

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

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

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

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

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

package/dist/agents/react/output_parser.js

@@ -0,0 +1,105 @@
+import { __export } from "../../_virtual/rolldown_runtime.js";
+import { AgentActionOutputParser } from "../types.js";
+import { FORMAT_INSTRUCTIONS } from "./prompt.js";
+import { renderTemplate } from "@langchain/core/prompts";
+import { OutputParserException } from "@langchain/core/output_parsers";
+
+//#region src/agents/react/output_parser.ts
+var output_parser_exports = {};
+__export(output_parser_exports, { ReActSingleInputOutputParser: () => ReActSingleInputOutputParser });
+const FINAL_ANSWER_ACTION = "Final Answer:";
+const FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "Parsing LLM output produced both a final answer and a parse-able action:";
+/**
+* Parses ReAct-style LLM calls that have a single tool input.
+*
+* Expects output to be in one of two formats.
+*
+* If the output signals that an action should be taken,
+* should be in the below format. This will result in an AgentAction
+* being returned.
+*
+* ```
+* Thought: agent thought here
+* Action: search
+* Action Input: what is the temperature in SF?
+* ```
+*
+* If the output signals that a final answer should be given,
+* should be in the below format. This will result in an AgentFinish
+* being returned.
+*
+* ```
+* Thought: agent thought here
+* Final Answer: The temperature is 100 degrees
+* ```
+* @example
+* ```typescript
+*
+* const runnableAgent = RunnableSequence.from([
+*   ...rest of runnable
+*   new ReActSingleInputOutputParser({ toolNames: ["SerpAPI", "Calculator"] }),
+* ]);
+* const agent = AgentExecutor.fromAgentAndTools({
+*   agent: runnableAgent,
+*   tools: [new SerpAPI(), new Calculator()],
+* });
+* const result = await agent.invoke({
+*   input: "whats the weather in pomfret?",
+* });
+* ```
+*/
+var ReActSingleInputOutputParser = class extends AgentActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"react"
+	];
+	toolNames;
+	constructor(fields) {
+		super(...arguments);
+		this.toolNames = fields.toolNames;
+	}
+	/**
+	* Parses the given text into an AgentAction or AgentFinish object. If an
+	* output fixing parser is defined, uses it to parse the text.
+	* @param text Text to parse.
+	* @returns Promise that resolves to an AgentAction or AgentFinish object.
+	*/
+	async parse(text) {
+		const includesAnswer = text.includes(FINAL_ANSWER_ACTION);
+		const regex = /Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)/;
+		const actionMatch = text.match(regex);
+		if (actionMatch) {
+			if (includesAnswer) throw new OutputParserException(`${FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: ${text}`);
+			const action = actionMatch[1];
+			const actionInput = actionMatch[2];
+			const toolInput = actionInput.trim().replace(/^"|"$/g, "");
+			return {
+				tool: action,
+				toolInput,
+				log: text
+			};
+		}
+		if (includesAnswer) {
+			const finalAnswerText = text.split(FINAL_ANSWER_ACTION)[1].trim();
+			return {
+				returnValues: { output: finalAnswerText },
+				log: text
+			};
+		}
+		throw new OutputParserException(`Could not parse LLM output: ${text}`);
+	}
+	/**
+	* Returns the format instructions as a string. If the 'raw' option is
+	* true, returns the raw FORMAT_INSTRUCTIONS.
+	* @param options Options for getting the format instructions.
+	* @returns Format instructions as a string.
+	*/
+	getFormatInstructions() {
+		return renderTemplate(FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+	}
+};
+
+//#endregion
+export { ReActSingleInputOutputParser, output_parser_exports };
+//# sourceMappingURL=output_parser.js.map

package/dist/agents/react/output_parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.js","names":["fields: { toolNames: string[] }","text: string"],"sources":["../../../src/agents/react/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nconst FINAL_ANSWER_ACTION = \"Final Answer:\";\nconst FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE =\n  \"Parsing LLM output produced both a final answer and a parse-able action:\";\n\n/**\n * Parses ReAct-style LLM calls that have a single tool input.\n *\n * Expects output to be in one of two formats.\n *\n * If the output signals that an action should be taken,\n * should be in the below format. This will result in an AgentAction\n * being returned.\n *\n * ```\n * Thought: agent thought here\n * Action: search\n * Action Input: what is the temperature in SF?\n * ```\n *\n * If the output signals that a final answer should be given,\n * should be in the below format. This will result in an AgentFinish\n * being returned.\n *\n * ```\n * Thought: agent thought here\n * Final Answer: The temperature is 100 degrees\n * ```\n * @example\n * ```typescript\n *\n * const runnableAgent = RunnableSequence.from([\n *   ...rest of runnable\n *   new ReActSingleInputOutputParser({ toolNames: [\"SerpAPI\", \"Calculator\"] }),\n * ]);\n * const agent = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n * const result = await agent.invoke({\n *   input: \"whats the weather in pomfret?\",\n * });\n * ```\n */\nexport class ReActSingleInputOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"react\"];\n\n  private toolNames: string[];\n\n  constructor(fields: { toolNames: string[] }) {\n    super(...arguments);\n    this.toolNames = fields.toolNames;\n  }\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  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    const includesAnswer = text.includes(FINAL_ANSWER_ACTION);\n    const regex =\n      /Action\\s*\\d*\\s*:[\\s]*(.*?)[\\s]*Action\\s*\\d*\\s*Input\\s*\\d*\\s*:[\\s]*(.*)/;\n    const actionMatch = text.match(regex);\n    if (actionMatch) {\n      if (includesAnswer) {\n        throw new OutputParserException(\n          `${FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: ${text}`\n        );\n      }\n\n      const action = actionMatch[1];\n      const actionInput = actionMatch[2];\n      const toolInput = actionInput.trim().replace(/^\"|\"$/g, \"\");\n\n      return {\n        tool: action,\n        toolInput,\n        log: text,\n      };\n    }\n\n    if (includesAnswer) {\n      const finalAnswerText = text.split(FINAL_ANSWER_ACTION)[1].trim();\n      return {\n        returnValues: {\n          output: finalAnswerText,\n        },\n        log: text,\n      };\n    }\n\n    throw new OutputParserException(`Could not parse LLM output: ${text}`);\n  }\n\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    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n"],"mappings":";;;;;;;;;AAMA,MAAM,sBAAsB;AAC5B,MAAM,iDACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCF,IAAa,+BAAb,cAAkD,wBAAwB;CACxE,eAAe;EAAC;EAAa;EAAU;CAAQ;CAE/C,AAAQ;CAER,YAAYA,QAAiC;EAC3C,MAAM,GAAG,UAAU;EACnB,KAAK,YAAY,OAAO;CACzB;;;;;;;CAQD,MAAM,MAAMC,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,oBAAoB;EACzD,MAAM,QACJ;EACF,MAAM,cAAc,KAAK,MAAM,MAAM;AACrC,MAAI,aAAa;AACf,OAAI,eACF,OAAM,IAAI,sBACR,GAAG,+CAA+C,EAAE,EAAE,MAAM;GAIhE,MAAM,SAAS,YAAY;GAC3B,MAAM,cAAc,YAAY;GAChC,MAAM,YAAY,YAAY,MAAM,CAAC,QAAQ,UAAU,GAAG;AAE1D,UAAO;IACL,MAAM;IACN;IACA,KAAK;GACN;EACF;AAED,MAAI,gBAAgB;GAClB,MAAM,kBAAkB,KAAK,MAAM,oBAAoB,CAAC,GAAG,MAAM;AACjE,UAAO;IACL,cAAc,EACZ,QAAQ,gBACT;IACD,KAAK;GACN;EACF;AAED,QAAM,IAAI,sBAAsB,CAAC,4BAA4B,EAAE,MAAM;CACtE;;;;;;;CAQD,wBAAgC;AAC9B,SAAO,eAAe,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,CACtC,EAAC;CACH;AACF"}

package/dist/agents/react/prompt.cjs

@@ -0,0 +1,16 @@
+
+//#region src/agents/react/prompt.ts
+const FORMAT_INSTRUCTIONS = `Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question`;
+
+//#endregion
+exports.FORMAT_INSTRUCTIONS = FORMAT_INSTRUCTIONS;
+//# sourceMappingURL=prompt.cjs.map

package/dist/agents/react/prompt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/react/prompt.ts"],"sourcesContent":["export const FORMAT_INSTRUCTIONS = `Use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question`;\n"],"mappings":";;AAAA,MAAa,sBAAsB,CAAC;;;;;;;;;6DASyB,CAAC"}

package/dist/agents/react/prompt.js

@@ -0,0 +1,15 @@
+//#region src/agents/react/prompt.ts
+const FORMAT_INSTRUCTIONS = `Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question`;
+
+//#endregion
+export { FORMAT_INSTRUCTIONS };
+//# sourceMappingURL=prompt.js.map

package/dist/agents/react/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/react/prompt.ts"],"sourcesContent":["export const FORMAT_INSTRUCTIONS = `Use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question`;\n"],"mappings":";AAAA,MAAa,sBAAsB,CAAC;;;;;;;;;6DASyB,CAAC"}

package/dist/agents/structured_chat/index.cjs

@@ -0,0 +1,243 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_agent = require('../agent.cjs');
+const require_llm_chain = require('../../chains/llm_chain.cjs');
+const require_prompt = require('./prompt.cjs');
+const require_outputParser = require('./outputParser.cjs');
+const require_tools_render = require('../../tools/render.cjs');
+const require_agents_format_scratchpad_log = require('../format_scratchpad/log.cjs');
+const __langchain_core_prompts = require_rolldown_runtime.__toESM(require("@langchain/core/prompts"));
+const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
+const __langchain_core_language_models_base = require_rolldown_runtime.__toESM(require("@langchain/core/language_models/base"));
+const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM(require("@langchain/core/utils/function_calling"));
+const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
+const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
+
+//#region src/agents/structured_chat/index.ts
+/**
+* Agent that interoperates with Structured Tools using React logic.
+* @augments Agent
+*/
+var StructuredChatAgent = class StructuredChatAgent extends require_agent.Agent {
+	static lc_name() {
+		return "StructuredChatAgent";
+	}
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"structured_chat"
+	];
+	constructor(input) {
+		const outputParser = input?.outputParser ?? StructuredChatAgent.getDefaultOutputParser();
+		super({
+			...input,
+			outputParser
+		});
+	}
+	_agentType() {
+		return "structured-chat-zero-shot-react-description";
+	}
+	observationPrefix() {
+		return "Observation: ";
+	}
+	llmPrefix() {
+		return "Thought:";
+	}
+	_stop() {
+		return ["Observation:"];
+	}
+	/**
+	* Validates that all provided tools have a description. Throws an error
+	* if any tool lacks a description.
+	* @param tools Array of StructuredTool instances to validate.
+	*/
+	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 StructuredChatAgent. If an LLM
+	* is provided, it creates an output parser with retry logic from the LLM.
+	* @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.
+	* @returns An instance of StructuredChatOutputParserWithRetries.
+	*/
+	static getDefaultOutputParser(fields) {
+		if (fields?.llm) return require_outputParser.StructuredChatOutputParserWithRetries.fromLLM(fields.llm, { toolNames: fields.toolNames });
+		return new require_outputParser.StructuredChatOutputParserWithRetries({ toolNames: fields?.toolNames });
+	}
+	/**
+	* Constructs the agent's scratchpad from a list of steps. If the agent's
+	* scratchpad is not empty, it prepends a message indicating that the
+	* agent has not seen any previous work.
+	* @param steps Array of AgentStep instances to construct the scratchpad from.
+	* @returns A Promise that resolves 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;
+	}
+	/**
+	* Creates a string representation of the schemas of the provided tools.
+	* @param tools Array of StructuredTool instances to create the schemas string from.
+	* @returns A string representing the schemas of the provided tools.
+	*/
+	static createToolSchemasString(tools) {
+		return tools.map((tool) => {
+			const jsonSchema = (0, __langchain_core_utils_types.isInteropZodSchema)(tool.schema) ? (0, __langchain_core_utils_json_schema.toJsonSchema)(tool.schema) : tool.schema;
+			return `${tool.name}: ${tool.description}, args: ${JSON.stringify(jsonSchema?.properties)}`;
+		}).join("\n");
+	}
+	/**
+	* Create prompt in the style of the 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.inputVariables List of input variables the final prompt will expect.
+	* @param args.memoryPrompts List of historical prompts from memory.
+	*/
+	static createPrompt(tools, args) {
+		const { prefix = require_prompt.PREFIX, suffix = require_prompt.SUFFIX, inputVariables = ["input", "agent_scratchpad"], humanMessageTemplate = "{input}\n\n{agent_scratchpad}", memoryPrompts = [] } = args ?? {};
+		const template = [
+			prefix,
+			require_prompt.FORMAT_INSTRUCTIONS,
+			suffix
+		].join("\n\n");
+		const messages = [
+			new __langchain_core_prompts.SystemMessagePromptTemplate(new __langchain_core_prompts.PromptTemplate({
+				template,
+				inputVariables,
+				partialVariables: {
+					tool_schemas: StructuredChatAgent.createToolSchemasString(tools),
+					tool_names: tools.map((tool) => tool.name).join(", ")
+				}
+			})),
+			...memoryPrompts,
+			new __langchain_core_prompts.HumanMessagePromptTemplate(new __langchain_core_prompts.PromptTemplate({
+				template: humanMessageTemplate,
+				inputVariables
+			}))
+		];
+		return __langchain_core_prompts.ChatPromptTemplate.fromMessages(messages);
+	}
+	/**
+	* Creates a StructuredChatAgent from an LLM and a list of tools.
+	* Validates the tools, creates a prompt, and sets up an LLM chain for the
+	* agent.
+	* @param llm BaseLanguageModel instance to create the agent from.
+	* @param tools Array of StructuredTool instances to create the agent from.
+	* @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.
+	* @returns A new instance of StructuredChatAgent.
+	*/
+	static fromLLMAndTools(llm, tools, args) {
+		StructuredChatAgent.validateTools(tools);
+		const prompt = StructuredChatAgent.createPrompt(tools, args);
+		const outputParser = args?.outputParser ?? StructuredChatAgent.getDefaultOutputParser({
+			llm,
+			toolNames: tools.map((tool) => tool.name)
+		});
+		const chain = new require_llm_chain.LLMChain({
+			prompt,
+			llm,
+			callbacks: args?.callbacks
+		});
+		return new StructuredChatAgent({
+			llmChain: chain,
+			outputParser,
+			allowedTools: tools.map((t) => t.name)
+		});
+	}
+};
+/**
+* Create an agent aimed at supporting tools with multiple inputs.
+* @param params Params required to create the agent. Includes an LLM, tools, and prompt.
+* @returns A runnable sequence representing an agent. It takes as input all the same input
+*     variables as the prompt passed in does. It returns as output either an
+*     AgentAction or AgentFinish.
+*
+* @example
+* ```typescript
+* import { AgentExecutor, createStructuredChatAgent } from "langchain/agents";
+* import { pull } from "langchain/hub";
+* import type { ChatPromptTemplate } from "@langchain/core/prompts";
+* import { AIMessage, HumanMessage } from "@langchain/core/messages";
+*
+* import { ChatOpenAI } from "@langchain/openai";
+*
+* // Define the tools the agent will have access to.
+* const tools = [...];
+*
+* // Get the prompt to use - you can modify this!
+* // If you want to see the prompt in full, you can at:
+* // https://smith.langchain.com/hub/hwchase17/structured-chat-agent
+* const prompt = await pull<ChatPromptTemplate>(
+*   "hwchase17/structured-chat-agent"
+* );
+*
+* const llm = new ChatOpenAI({
+*   temperature: 0,
+*   model: "gpt-3.5-turbo-1106",
+* });
+*
+* const agent = await createStructuredChatAgent({
+*   llm,
+*   tools,
+*   prompt,
+* });
+*
+* const agentExecutor = new AgentExecutor({
+*   agent,
+*   tools,
+* });
+*
+* const result = await agentExecutor.invoke({
+*   input: "what is LangChain?",
+* });
+*
+* // With chat history
+* const result2 = await agentExecutor.invoke({
+*   input: "what's my name?",
+*   chat_history: [
+*     new HumanMessage("hi! my name is cob"),
+*     new AIMessage("Hello Cob! How can I assist you today?"),
+*   ],
+* });
+* ```
+*/
+async function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }) {
+	const missingVariables = [
+		"tools",
+		"tool_names",
+		"agent_scratchpad"
+	].filter((v) => !prompt.inputVariables.includes(v));
+	if (missingVariables.length > 0) throw new Error(`Provided prompt is missing required input variables: ${JSON.stringify(missingVariables)}`);
+	let toolNames = [];
+	if (tools.every(__langchain_core_language_models_base.isOpenAITool)) toolNames = tools.map((tool) => tool.function.name);
+	else if (tools.every(__langchain_core_utils_function_calling.isStructuredTool)) toolNames = tools.map((tool) => tool.name);
+	else throw new Error("All tools must be either OpenAI or Structured tools, not a mix.");
+	const partialedPrompt = await prompt.partial({
+		tools: require_tools_render.renderTextDescriptionAndArgs(tools),
+		tool_names: toolNames.join(", ")
+	});
+	const llmWithStop = llm.withConfig({ stop: ["Observation"] });
+	const agent = require_agent.AgentRunnableSequence.fromRunnables([
+		__langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_agents_format_scratchpad_log.formatLogToString(input.steps) }),
+		partialedPrompt,
+		llmWithStop,
+		require_outputParser.StructuredChatOutputParserWithRetries.fromLLM(llm, { toolNames })
+	], {
+		name: "StructuredChatAgent",
+		streamRunnable,
+		singleAction: true
+	});
+	return agent;
+}
+
+//#endregion
+exports.StructuredChatAgent = StructuredChatAgent;
+exports.createStructuredChatAgent = createStructuredChatAgent;
+//# sourceMappingURL=index.cjs.map

package/dist/agents/structured_chat/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["Agent","input: StructuredChatAgentInput","tools: StructuredToolInterface[]","fields?: OutputParserArgs & {\n      toolNames: string[];\n    }","StructuredChatOutputParserWithRetries","steps: AgentStep[]","args?: StructuredChatCreatePromptArgs","PREFIX","SUFFIX","FORMAT_INSTRUCTIONS","SystemMessagePromptTemplate","PromptTemplate","HumanMessagePromptTemplate","ChatPromptTemplate","llm: BaseLanguageModelInterface","args?: StructuredChatCreatePromptArgs & AgentArgs","LLMChain","toolNames: string[]","isOpenAITool","isStructuredTool","renderTextDescriptionAndArgs","AgentRunnableSequence","RunnablePassthrough","input: { steps: AgentStep[] }","formatLogToString"],"sources":["../../../src/agents/structured_chat/index.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport {\n  isOpenAITool,\n  type BaseLanguageModel,\n  type BaseLanguageModelInterface,\n  type ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  BaseMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n  PromptTemplate,\n} from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { isStructuredTool } from \"@langchain/core/utils/function_calling\";\nimport { isInteropZodSchema } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7Type,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport {\n  Agent,\n  AgentArgs,\n  AgentRunnableSequence,\n  OutputParserArgs,\n} from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\nimport { renderTextDescriptionAndArgs } from \"../../tools/render.js\";\nimport { formatLogToString } from \"../format_scratchpad/log.js\";\n\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n  /** String to put after the list of tools. */\n  suffix?: string;\n  /** String to put before the list of tools. */\n  prefix?: string;\n  /** String to use directly as the human message template. */\n  humanMessageTemplate?: string;\n  /** List of input variables the final prompt will expect. */\n  inputVariables?: string[];\n  /** List of historical prompts from memory.  */\n  memoryPrompts?: BaseMessagePromptTemplate[];\n}\n\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport class StructuredChatAgent extends Agent {\n  static lc_name() {\n    return \"StructuredChatAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  constructor(input: StructuredChatAgentInput) {\n    const outputParser =\n      input?.outputParser ?? StructuredChatAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"structured-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 provided tools have a description. Throws an error\n   * if any tool lacks a description.\n   * @param tools Array of StructuredTool instances to validate.\n   */\n  static validateTools(tools: StructuredToolInterface[]) {\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 StructuredChatAgent. If an LLM\n   * is provided, it creates an output parser with retry logic from the LLM.\n   * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n   * @returns An instance of StructuredChatOutputParserWithRetries.\n   */\n  static getDefaultOutputParser(\n    fields?: OutputParserArgs & {\n      toolNames: string[];\n    }\n  ) {\n    if (fields?.llm) {\n      return StructuredChatOutputParserWithRetries.fromLLM(fields.llm, {\n        toolNames: fields.toolNames,\n      });\n    }\n    return new StructuredChatOutputParserWithRetries({\n      toolNames: fields?.toolNames,\n    });\n  }\n\n  /**\n   * Constructs the agent's scratchpad from a list of steps. If the agent's\n   * scratchpad is not empty, it prepends a message indicating that the\n   * agent has not seen any previous work.\n   * @param steps Array of AgentStep instances to construct the scratchpad from.\n   * @returns A Promise that resolves to a string representing the agent's scratchpad.\n   */\n  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   * Creates a string representation of the schemas of the provided tools.\n   * @param tools Array of StructuredTool instances to create the schemas string from.\n   * @returns A string representing the schemas of the provided tools.\n   */\n  static createToolSchemasString(tools: StructuredToolInterface[]) {\n    return tools\n      .map((tool) => {\n        const jsonSchema = (\n          isInteropZodSchema(tool.schema)\n            ? toJsonSchema(tool.schema)\n            : tool.schema\n        ) as { properties?: Record<string, JsonSchema7Type> } | undefined;\n        return `${tool.name}: ${tool.description}, args: ${JSON.stringify(\n          jsonSchema?.properties\n        )}`;\n      })\n      .join(\"\\n\");\n  }\n\n  /**\n   * Create prompt in the style of the agent.\n   *\n   * @param tools - List of tools the agent will have access to, used to format the prompt.\n   * @param args - Arguments to create the prompt with.\n   * @param args.suffix - String to put after the list of tools.\n   * @param args.prefix - String to put before the list of tools.\n   * @param args.inputVariables List of input variables the final prompt will expect.\n   * @param args.memoryPrompts List of historical prompts from memory.\n   */\n  static createPrompt(\n    tools: StructuredToolInterface[],\n    args?: StructuredChatCreatePromptArgs\n  ) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      inputVariables = [\"input\", \"agent_scratchpad\"],\n      humanMessageTemplate = \"{input}\\n\\n{agent_scratchpad}\",\n      memoryPrompts = [],\n    } = args ?? {};\n    const template = [prefix, FORMAT_INSTRUCTIONS, suffix].join(\"\\n\\n\");\n    const messages = [\n      new SystemMessagePromptTemplate(\n        new PromptTemplate({\n          template,\n          inputVariables,\n          partialVariables: {\n            tool_schemas: StructuredChatAgent.createToolSchemasString(tools),\n            tool_names: tools.map((tool) => tool.name).join(\", \"),\n          },\n        })\n      ),\n      ...memoryPrompts,\n      new HumanMessagePromptTemplate(\n        new PromptTemplate({\n          template: humanMessageTemplate,\n          inputVariables,\n        })\n      ),\n    ];\n    return ChatPromptTemplate.fromMessages(messages);\n  }\n\n  /**\n   * Creates a StructuredChatAgent from an LLM and a list of tools.\n   * Validates the tools, creates a prompt, and sets up an LLM chain for the\n   * agent.\n   * @param llm BaseLanguageModel instance to create the agent from.\n   * @param tools Array of StructuredTool instances to create the agent from.\n   * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n   * @returns A new instance of StructuredChatAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: StructuredToolInterface[],\n    args?: StructuredChatCreatePromptArgs & AgentArgs\n  ) {\n    StructuredChatAgent.validateTools(tools);\n    const prompt = StructuredChatAgent.createPrompt(tools, args);\n    const outputParser =\n      args?.outputParser ??\n      StructuredChatAgent.getDefaultOutputParser({\n        llm,\n        toolNames: tools.map((tool) => tool.name),\n      });\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks,\n    });\n\n    return new StructuredChatAgent({\n      llmChain: chain,\n      outputParser,\n      allowedTools: tools.map((t) => t.name),\n    });\n  }\n}\n\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n  /** LLM to use as the agent. */\n  llm: BaseLanguageModelInterface;\n  /** Tools this agent has access to. */\n  tools: (StructuredToolInterface | ToolDefinition)[];\n  /**\n   * The prompt to use. Must have input keys for\n   * `tools`, `tool_names`, and `agent_scratchpad`.\n   */\n  prompt: BasePromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent aimed at supporting tools with multiple inputs.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createStructuredChatAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateStructuredChatAgentParams) {\n  const missingVariables = [\"tools\", \"tool_names\", \"agent_scratchpad\"].filter(\n    (v) => !prompt.inputVariables.includes(v)\n  );\n  if (missingVariables.length > 0) {\n    throw new Error(\n      `Provided prompt is missing required input variables: ${JSON.stringify(\n        missingVariables\n      )}`\n    );\n  }\n  let toolNames: string[] = [];\n  if (tools.every(isOpenAITool)) {\n    toolNames = tools.map((tool) => tool.function.name);\n  } else if (tools.every(isStructuredTool)) {\n    toolNames = tools.map((tool) => tool.name);\n  } else {\n    throw new Error(\n      \"All tools must be either OpenAI or Structured tools, not a mix.\"\n    );\n  }\n  const partialedPrompt = await prompt.partial({\n    tools: renderTextDescriptionAndArgs(tools),\n    tool_names: toolNames.join(\", \"),\n  });\n  // TODO: Add .bind to core runnable interface.\n  const llmWithStop = (llm as BaseLanguageModel).withConfig({\n    stop: [\"Observation\"],\n  });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: AgentStep[] }) =>\n          formatLogToString(input.steps),\n      }),\n      partialedPrompt,\n      llmWithStop,\n      StructuredChatOutputParserWithRetries.fromLLM(llm, {\n        toolNames,\n      }),\n    ],\n    {\n      name: \"StructuredChatAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":"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"}