@langchain/classic 1.0.0-alpha.1

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

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

package/dist/agents/openai_tools/output_parser.js

@@ -0,0 +1,91 @@
+import { AgentMultiActionOutputParser } from "../types.js";
+import { OutputParserException } from "@langchain/core/output_parsers";
+import { isBaseMessage } from "@langchain/core/messages";
+
+//#region src/agents/openai_tools/output_parser.ts
+/**
+* @example
+* ```typescript
+* const prompt = ChatPromptTemplate.fromMessages([
+*   ["ai", "You are a helpful assistant"],
+*   ["human", "{input}"],
+*   new MessagesPlaceholder("agent_scratchpad"),
+* ]);
+*
+* const runnableAgent = RunnableSequence.from([
+*   {
+*     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,
+*     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>
+*       formatToOpenAIToolMessages(i.steps),
+*   },
+*   prompt,
+*   new ChatOpenAI({
+*     model: "gpt-3.5-turbo-1106",
+*     temperature: 0,
+*   }).bindTools(tools),
+*   new OpenAIToolsAgentOutputParser(),
+* ]).withConfig({ runName: "OpenAIToolsAgent" });
+*
+* const result = await runnableAgent.invoke({
+*   input:
+*     "What is the sum of the current temperature in San Francisco, New York, and Tokyo?",
+* });
+* ```
+*/
+var OpenAIToolsAgentOutputParser = class extends AgentMultiActionOutputParser {
+	lc_namespace = [
+		"langchain",
+		"agents",
+		"openai"
+	];
+	static lc_name() {
+		return "OpenAIToolsAgentOutputParser";
+	}
+	async parse(text) {
+		throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
+	}
+	async parseResult(generations) {
+		if ("message" in generations[0] && isBaseMessage(generations[0].message)) return this.parseAIMessage(generations[0].message);
+		throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
+	}
+	/**
+	* Parses the output message into a ToolsAgentAction[] or AgentFinish
+	* object.
+	* @param message The BaseMessage to parse.
+	* @returns A ToolsAgentAction[] or AgentFinish object.
+	*/
+	parseAIMessage(message) {
+		if (message.content && typeof message.content !== "string") throw new Error("This agent cannot parse non-string model responses.");
+		if (message.additional_kwargs.tool_calls) {
+			const toolCalls = message.additional_kwargs.tool_calls;
+			try {
+				return toolCalls.map((toolCall, i) => {
+					if (toolCall.type === "function") {
+						const toolInput = toolCall.function.arguments ? JSON.parse(toolCall.function.arguments) : {};
+						const messageLog = i === 0 ? [message] : [];
+						return {
+							tool: toolCall.function.name,
+							toolInput,
+							toolCallId: toolCall.id,
+							log: `Invoking "${toolCall.function.name}" with ${toolCall.function.arguments ?? "{}"}\n${message.content}`,
+							messageLog
+						};
+					}
+					return void 0;
+				}).filter(Boolean);
+			} catch (error) {
+				throw new OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
+			}
+		} else return {
+			returnValues: { output: message.content },
+			log: message.content
+		};
+	}
+	getFormatInstructions() {
+		throw new Error("getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.");
+	}
+};
+
+//#endregion
+export { OpenAIToolsAgentOutputParser };
+//# sourceMappingURL=output_parser.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.js","names":["text: string","generations: ChatGeneration[]","message: BaseMessage","toolCalls: OpenAIClient.Chat.ChatCompletionMessageToolCall[]"],"sources":["../../../src/agents/openai_tools/output_parser.ts"],"sourcesContent":["import type { OpenAIClient } from \"@langchain/openai\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { BaseMessage, isBaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\nimport {\n  ToolsAgentAction,\n  ToolsAgentStep,\n} from \"../tool_calling/output_parser.js\";\n\nexport type { ToolsAgentAction, ToolsAgentStep };\n\n/**\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"ai\", \"You are a helpful assistant\"],\n *   [\"human\", \"{input}\"],\n *   new MessagesPlaceholder(\"agent_scratchpad\"),\n * ]);\n *\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: ToolsAgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: ToolsAgentStep[] }) =>\n *       formatToOpenAIToolMessages(i.steps),\n *   },\n *   prompt,\n *   new ChatOpenAI({\n *     model: \"gpt-3.5-turbo-1106\",\n *     temperature: 0,\n *   }).bindTools(tools),\n *   new OpenAIToolsAgentOutputParser(),\n * ]).withConfig({ runName: \"OpenAIToolsAgent\" });\n *\n * const result = await runnableAgent.invoke({\n *   input:\n *     \"What is the sum of the current temperature in San Francisco, New York, and Tokyo?\",\n * });\n * ```\n */\nexport class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  static lc_name() {\n    return \"OpenAIToolsAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `OpenAIFunctionsAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return this.parseAIMessage(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  /**\n   * Parses the output message into a ToolsAgentAction[] or AgentFinish\n   * object.\n   * @param message The BaseMessage to parse.\n   * @returns A ToolsAgentAction[] or AgentFinish object.\n   */\n  parseAIMessage(message: BaseMessage): ToolsAgentAction[] | AgentFinish {\n    if (message.content && typeof message.content !== \"string\") {\n      throw new Error(\"This agent cannot parse non-string model responses.\");\n    }\n    if (message.additional_kwargs.tool_calls) {\n      const toolCalls: OpenAIClient.Chat.ChatCompletionMessageToolCall[] =\n        message.additional_kwargs.tool_calls;\n      try {\n        return toolCalls\n          .map((toolCall, i) => {\n            if (toolCall.type === \"function\") {\n              const toolInput = toolCall.function.arguments\n                ? JSON.parse(toolCall.function.arguments)\n                : {};\n              const messageLog = i === 0 ? [message] : [];\n              return {\n                tool: toolCall.function.name as string,\n                toolInput,\n                toolCallId: toolCall.id,\n                log: `Invoking \"${toolCall.function.name}\" with ${\n                  toolCall.function.arguments ?? \"{}\"\n                }\\n${message.content}`,\n                messageLog,\n              };\n            }\n            return undefined;\n          })\n          .filter(Boolean) as ToolsAgentAction[];\n      } catch (error) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${error}`\n        );\n      }\n    } else {\n      return {\n        returnValues: { output: message.content },\n        log: message.content,\n      };\n    }\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside OpenAIToolsAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,+BAAb,cAAkD,6BAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;CAAS;CAEhD,OAAO,UAAU;AACf,SAAO;CACR;CAED,MAAM,MAAMA,MAAoD;AAC9D,QAAM,IAAI,MACR,CAAC,yEAAyE,EAAE,MAAM;CAErF;CAED,MAAM,YAAYC,aAA+B;AAC/C,MAAI,aAAa,YAAY,MAAM,cAAc,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR;CAEH;;;;;;;CAQD,eAAeC,SAAwD;AACrE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM;AAElB,MAAI,QAAQ,kBAAkB,YAAY;GACxC,MAAMC,YACJ,QAAQ,kBAAkB;AAC5B,OAAI;AACF,WAAO,UACJ,IAAI,CAAC,UAAU,MAAM;AACpB,SAAI,SAAS,SAAS,YAAY;MAChC,MAAM,YAAY,SAAS,SAAS,YAChC,KAAK,MAAM,SAAS,SAAS,UAAU,GACvC,CAAE;MACN,MAAM,aAAa,MAAM,IAAI,CAAC,OAAQ,IAAG,CAAE;AAC3C,aAAO;OACL,MAAM,SAAS,SAAS;OACxB;OACA,YAAY,SAAS;OACrB,KAAK,CAAC,UAAU,EAAE,SAAS,SAAS,KAAK,OAAO,EAC9C,SAAS,SAAS,aAAa,KAChC,EAAE,EAAE,QAAQ,SAAS;OACtB;MACD;KACF;AACD,YAAO;IACR,EAAC,CACD,OAAO,QAAQ;GACnB,SAAQ,OAAO;AACd,UAAM,IAAI,sBACR,CAAC,gEAAgE,EAAE,KAAK,UACtE,UACD,CAAC,GAAG,EAAE,OAAO;GAEjB;EACF,MACC,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAS;GACzC,KAAK,QAAQ;EACd;CAEJ;CAED,wBAAgC;AAC9B,QAAM,IAAI,MACR;CAEH;AACF"}

package/dist/agents/react/index.cjs

@@ -0,0 +1,80 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_agent = require('../agent.cjs');
+const require_tools_render = require('../../tools/render.cjs');
+const require_agents_format_scratchpad_log = require('../format_scratchpad/log.cjs');
+const require_agents_react_output_parser = require('./output_parser.cjs');
+const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
+
+//#region src/agents/react/index.ts
+/**
+* Create an agent that uses ReAct prompting.
+* @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, createReactAgent } from "langchain/agents";
+* import { pull } from "langchain/hub";
+* import type { PromptTemplate } from "@langchain/core/prompts";
+*
+* import { OpenAI } 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/react
+* const prompt = await pull<PromptTemplate>("hwchase17/react");
+*
+* const llm = new OpenAI({
+*   temperature: 0,
+* });
+*
+* const agent = await createReactAgent({
+*   llm,
+*   tools,
+*   prompt,
+* });
+*
+* const agentExecutor = new AgentExecutor({
+*   agent,
+*   tools,
+* });
+*
+* const result = await agentExecutor.invoke({
+*   input: "what is LangChain?",
+* });
+* ```
+*/
+async function createReactAgent({ 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)}`);
+	const toolNames = tools.map((tool) => tool.name);
+	const partialedPrompt = await prompt.partial({
+		tools: require_tools_render.renderTextDescription(tools),
+		tool_names: toolNames.join(", ")
+	});
+	const llmWithStop = llm.withConfig({ stop: ["\nObservation:"] });
+	const agent = require_agent.AgentRunnableSequence.fromRunnables([
+		__langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_agents_format_scratchpad_log.formatLogToString(input.steps) }),
+		partialedPrompt,
+		llmWithStop,
+		new require_agents_react_output_parser.ReActSingleInputOutputParser({ toolNames })
+	], {
+		name: "ReactAgent",
+		streamRunnable,
+		singleAction: true
+	});
+	return agent;
+}
+
+//#endregion
+exports.createReactAgent = createReactAgent;
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["renderTextDescription","AgentRunnableSequence","RunnablePassthrough","input: { steps: AgentStep[] }","formatLogToString","ReActSingleInputOutputParser"],"sources":["../../../src/agents/react/index.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type {\n  BaseLanguageModel,\n  BaseLanguageModelInterface,\n} from \"@langchain/core/language_models/base\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { renderTextDescription } from \"../../tools/render.js\";\nimport { formatLogToString } from \"../format_scratchpad/log.js\";\nimport { ReActSingleInputOutputParser } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\n  /** LLM to use for the agent. */\n  llm: BaseLanguageModelInterface;\n  /** Tools this agent has access to. */\n  tools: ToolInterface[];\n  /**\n   * The prompt to use. Must have input keys for\n   * `tools`, `tool_names`, and `agent_scratchpad`.\n   */\n  prompt: BasePromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses ReAct prompting.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n * ```\n */\nexport async function createReactAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateReactAgentParams) {\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  const toolNames = tools.map((tool) => tool.name);\n  const partialedPrompt = await prompt.partial({\n    tools: renderTextDescription(tools),\n    tool_names: toolNames.join(\", \"),\n  });\n  const llmWithStop = (llm as BaseLanguageModel).withConfig({\n    stop: [\"\\nObservation:\"],\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      new ReActSingleInputOutputParser({\n        toolNames,\n      }),\n    ],\n    {\n      name: \"ReactAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,eAAsB,iBAAiB,EACrC,KACA,OACA,QACA,gBACuB,EAAE;CACzB,MAAM,mBAAmB;EAAC;EAAS;EAAc;CAAmB,EAAC,OACnE,CAAC,MAAM,CAAC,OAAO,eAAe,SAAS,EAAE,CAC1C;AACD,KAAI,iBAAiB,SAAS,EAC5B,OAAM,IAAI,MACR,CAAC,qDAAqD,EAAE,KAAK,UAC3D,iBACD,EAAE;CAGP,MAAM,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK;CAChD,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAOA,2CAAsB,MAAM;EACnC,YAAY,UAAU,KAAK,KAAK;CACjC,EAAC;CACF,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,gBAAiB,EACzB,EAAC;CACF,MAAM,QAAQC,oCAAsB,cAClC;EACEC,+CAAoB,OAAO,EACzB,kBAAkB,CAACC,UACjBC,uDAAkB,MAAM,MAAM,CACjC,EAAC;EACF;EACA;EACA,IAAIC,gEAA6B,EAC/B,UACD;CACF,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}

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

@@ -0,0 +1,81 @@
+import { AgentRunnableSequence } from "../agent.cjs";
+import * as _langchain_core_agents1 from "@langchain/core/agents";
+import { AgentStep } from "@langchain/core/agents";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { ToolInterface } from "@langchain/core/tools";
+
+//#region src/agents/react/index.d.ts
+/**
+ * Params used by the createXmlAgent function.
+ */
+type CreateReactAgentParams = {
+  /** LLM to use for the agent. */
+  llm: BaseLanguageModelInterface;
+  /** Tools this agent has access to. */
+  tools: ToolInterface[];
+  /**
+   * The prompt to use. Must have input keys for
+   * `tools`, `tool_names`, and `agent_scratchpad`.
+   */
+  prompt: BasePromptTemplate;
+  /**
+   * Whether to invoke the underlying model in streaming mode,
+   * allowing streaming of intermediate steps. Defaults to true.
+   */
+  streamRunnable?: boolean;
+};
+/**
+ * Create an agent that uses ReAct prompting.
+ * @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, createReactAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { PromptTemplate } from "@langchain/core/prompts";
+ *
+ * import { OpenAI } 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/react
+ * const prompt = await pull<PromptTemplate>("hwchase17/react");
+ *
+ * const llm = new OpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createReactAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ * ```
+ */
+declare function createReactAgent({
+  llm,
+  tools,
+  prompt,
+  streamRunnable
+}: CreateReactAgentParams): Promise<AgentRunnableSequence<{
+  steps: AgentStep[];
+}, _langchain_core_agents1.AgentAction | _langchain_core_agents1.AgentFinish>>;
+//#endregion
+export { CreateReactAgentParams, createReactAgent };
+//# sourceMappingURL=index.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentAction","AgentFinish","Promise"],"sources":["../../../src/agents/react/index.d.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\n    /** LLM to use for the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: ToolInterface[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses ReAct prompting.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n * ```\n */\nexport declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAAA;EAAA,GAEzBH,EAAAA,0BAAAA;EAA0B;EAEX,KAKZD,EALDD,aAKCC,EAAAA;EAAkB;AAkD9B;;;EAA8C,MAAEO,EAlDpCP,kBAkDoCO;EAAK;;;;EACjC,cAAAG,CAAAA,EAAAA,OAAAA;CAC2B;;;AAFkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFL,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

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

@@ -0,0 +1,81 @@
+import { AgentRunnableSequence } from "../agent.js";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { ToolInterface } from "@langchain/core/tools";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import * as _langchain_core_agents1 from "@langchain/core/agents";
+import { AgentStep } from "@langchain/core/agents";
+
+//#region src/agents/react/index.d.ts
+/**
+ * Params used by the createXmlAgent function.
+ */
+type CreateReactAgentParams = {
+  /** LLM to use for the agent. */
+  llm: BaseLanguageModelInterface;
+  /** Tools this agent has access to. */
+  tools: ToolInterface[];
+  /**
+   * The prompt to use. Must have input keys for
+   * `tools`, `tool_names`, and `agent_scratchpad`.
+   */
+  prompt: BasePromptTemplate;
+  /**
+   * Whether to invoke the underlying model in streaming mode,
+   * allowing streaming of intermediate steps. Defaults to true.
+   */
+  streamRunnable?: boolean;
+};
+/**
+ * Create an agent that uses ReAct prompting.
+ * @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, createReactAgent } from "langchain/agents";
+ * import { pull } from "langchain/hub";
+ * import type { PromptTemplate } from "@langchain/core/prompts";
+ *
+ * import { OpenAI } 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/react
+ * const prompt = await pull<PromptTemplate>("hwchase17/react");
+ *
+ * const llm = new OpenAI({
+ *   temperature: 0,
+ * });
+ *
+ * const agent = await createReactAgent({
+ *   llm,
+ *   tools,
+ *   prompt,
+ * });
+ *
+ * const agentExecutor = new AgentExecutor({
+ *   agent,
+ *   tools,
+ * });
+ *
+ * const result = await agentExecutor.invoke({
+ *   input: "what is LangChain?",
+ * });
+ * ```
+ */
+declare function createReactAgent({
+  llm,
+  tools,
+  prompt,
+  streamRunnable
+}: CreateReactAgentParams): Promise<AgentRunnableSequence<{
+  steps: AgentStep[];
+}, _langchain_core_agents1.AgentAction | _langchain_core_agents1.AgentFinish>>;
+//#endregion
+export { CreateReactAgentParams, createReactAgent };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentAction","AgentFinish","Promise"],"sources":["../../../src/agents/react/index.d.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\n    /** LLM to use for the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: ToolInterface[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses ReAct prompting.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n * ```\n */\nexport declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAAA;EAAA,GAEzBH,EAAAA,0BAAAA;EAA0B;EAEX,KAKZD,EALDD,aAKCC,EAAAA;EAAkB;AAkD9B;;;EAA8C,MAAEO,EAlDpCP,kBAkDoCO;EAAK;;;;EACjC,cAAAG,CAAAA,EAAAA,OAAAA;CAC2B;;;AAFkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFL,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

package/dist/agents/react/index.js

@@ -0,0 +1,79 @@
+import { AgentRunnableSequence } from "../agent.js";
+import { renderTextDescription } from "../../tools/render.js";
+import { formatLogToString } from "../format_scratchpad/log.js";
+import { ReActSingleInputOutputParser } from "./output_parser.js";
+import { RunnablePassthrough } from "@langchain/core/runnables";
+
+//#region src/agents/react/index.ts
+/**
+* Create an agent that uses ReAct prompting.
+* @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, createReactAgent } from "langchain/agents";
+* import { pull } from "langchain/hub";
+* import type { PromptTemplate } from "@langchain/core/prompts";
+*
+* import { OpenAI } 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/react
+* const prompt = await pull<PromptTemplate>("hwchase17/react");
+*
+* const llm = new OpenAI({
+*   temperature: 0,
+* });
+*
+* const agent = await createReactAgent({
+*   llm,
+*   tools,
+*   prompt,
+* });
+*
+* const agentExecutor = new AgentExecutor({
+*   agent,
+*   tools,
+* });
+*
+* const result = await agentExecutor.invoke({
+*   input: "what is LangChain?",
+* });
+* ```
+*/
+async function createReactAgent({ 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)}`);
+	const toolNames = tools.map((tool) => tool.name);
+	const partialedPrompt = await prompt.partial({
+		tools: renderTextDescription(tools),
+		tool_names: toolNames.join(", ")
+	});
+	const llmWithStop = llm.withConfig({ stop: ["\nObservation:"] });
+	const agent = AgentRunnableSequence.fromRunnables([
+		RunnablePassthrough.assign({ agent_scratchpad: (input) => formatLogToString(input.steps) }),
+		partialedPrompt,
+		llmWithStop,
+		new ReActSingleInputOutputParser({ toolNames })
+	], {
+		name: "ReactAgent",
+		streamRunnable,
+		singleAction: true
+	});
+	return agent;
+}
+
+//#endregion
+export { createReactAgent };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["input: { steps: AgentStep[] }"],"sources":["../../../src/agents/react/index.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type {\n  BaseLanguageModel,\n  BaseLanguageModelInterface,\n} from \"@langchain/core/language_models/base\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { renderTextDescription } from \"../../tools/render.js\";\nimport { formatLogToString } from \"../format_scratchpad/log.js\";\nimport { ReActSingleInputOutputParser } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\n  /** LLM to use for the agent. */\n  llm: BaseLanguageModelInterface;\n  /** Tools this agent has access to. */\n  tools: ToolInterface[];\n  /**\n   * The prompt to use. Must have input keys for\n   * `tools`, `tool_names`, and `agent_scratchpad`.\n   */\n  prompt: BasePromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses ReAct prompting.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n * ```\n */\nexport async function createReactAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateReactAgentParams) {\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  const toolNames = tools.map((tool) => tool.name);\n  const partialedPrompt = await prompt.partial({\n    tools: renderTextDescription(tools),\n    tool_names: toolNames.join(\", \"),\n  });\n  const llmWithStop = (llm as BaseLanguageModel).withConfig({\n    stop: [\"\\nObservation:\"],\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      new ReActSingleInputOutputParser({\n        toolNames,\n      }),\n    ],\n    {\n      name: \"ReactAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,eAAsB,iBAAiB,EACrC,KACA,OACA,QACA,gBACuB,EAAE;CACzB,MAAM,mBAAmB;EAAC;EAAS;EAAc;CAAmB,EAAC,OACnE,CAAC,MAAM,CAAC,OAAO,eAAe,SAAS,EAAE,CAC1C;AACD,KAAI,iBAAiB,SAAS,EAC5B,OAAM,IAAI,MACR,CAAC,qDAAqD,EAAE,KAAK,UAC3D,iBACD,EAAE;CAGP,MAAM,YAAY,MAAM,IAAI,CAAC,SAAS,KAAK,KAAK;CAChD,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAO,sBAAsB,MAAM;EACnC,YAAY,UAAU,KAAK,KAAK;CACjC,EAAC;CACF,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,gBAAiB,EACzB,EAAC;CACF,MAAM,QAAQ,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,kBAAkB,CAACA,UACjB,kBAAkB,MAAM,MAAM,CACjC,EAAC;EACF;EACA;EACA,IAAI,6BAA6B,EAC/B,UACD;CACF,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}

package/dist/agents/react/output_parser.cjs

@@ -0,0 +1,111 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_types = require('../types.cjs');
+const require_prompt = require('./prompt.cjs');
+const __langchain_core_prompts = require_rolldown_runtime.__toESM(require("@langchain/core/prompts"));
+const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+
+//#region src/agents/react/output_parser.ts
+var output_parser_exports = {};
+require_rolldown_runtime.__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 require_types.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 __langchain_core_output_parsers.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 __langchain_core_output_parsers.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 (0, __langchain_core_prompts.renderTemplate)(require_prompt.FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+	}
+};
+
+//#endregion
+exports.ReActSingleInputOutputParser = ReActSingleInputOutputParser;
+Object.defineProperty(exports, 'output_parser_exports', {
+  enumerable: true,
+  get: function () {
+    return output_parser_exports;
+  }
+});
+//# sourceMappingURL=output_parser.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"output_parser.cjs","names":["AgentActionOutputParser","fields: { toolNames: string[] }","text: string","OutputParserException","FORMAT_INSTRUCTIONS"],"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,cAAkDA,sCAAwB;CACxE,eAAe;EAAC;EAAa;EAAU;CAAQ;CAE/C,AAAQ;CAER,YAAYC,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,IAAIC,sDACR,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,IAAIA,sDAAsB,CAAC,4BAA4B,EAAE,MAAM;CACtE;;;;;;;CAQD,wBAAgC;AAC9B,sDAAsBC,oCAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,CACtC,EAAC;CACH;AACF"}