@langchain/classic 1.0.17 → 1.0.18

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["input: { steps: ToolsAgentStep[] }","formatToOpenAIToolMessages"],"sources":["../../../src/agents/openai_tools/index.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { convertToOpenAITool } from \"@langchain/core/utils/function_calling\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { formatToOpenAIToolMessages } from \"../format_scratchpad/openai_tools.js\";\nimport {\n  OpenAIToolsAgentOutputParser,\n  type ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<\n    BaseChatModelCallOptions & {\n      tools?:\n        | StructuredToolInterface[]\n        | OpenAIClient.ChatCompletionTool[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        | any[];\n    }\n  >;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createOpenAIToolsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIToolsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const modelWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        tools: tools.map((tool) => convertToOpenAITool(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToOpenAIToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new OpenAIToolsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIToolsAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,eAAsB,uBAAuB,EAC3C,KACA,OACA,QACA,gBAC6B,EAAE;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,CAAC,4DAA4D,CAAC,EAC9D,CAAC,MAAM,EAAE,KAAK,UAAU,OAAO,eAAe,CAAC,SAAS,CAAC,AAC1D,EAAC,KAAK,KAAK;CAGhB,MAAM,iBAAiB,IAAI,YACvB,IAAI,UAAU,MAAM,GACpB,IAAI,WAAW,EACb,OAAO,MAAM,IAAI,CAAC,SAAS,oBAAoB,KAAK,CAAC,CACtD,EAAC;CACN,MAAM,QAAQ,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,kBAAkB,CAACA,UACjBC,qBAA2B,MAAM,MAAM,CAC1C,EAAC;EACF;EACA;EACA,IAAI;CACL,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}
+{"version":3,"file":"index.js","names":["formatToOpenAIToolMessages"],"sources":["../../../src/agents/openai_tools/index.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type {\n  BaseChatModel,\n  BaseChatModelCallOptions,\n} from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { convertToOpenAITool } from \"@langchain/core/utils/function_calling\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { formatToOpenAIToolMessages } from \"../format_scratchpad/openai_tools.js\";\nimport {\n  OpenAIToolsAgentOutputParser,\n  type ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<\n    BaseChatModelCallOptions & {\n      tools?:\n        | StructuredToolInterface[]\n        | OpenAIClient.ChatCompletionTool[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        | any[];\n    }\n  >;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport async function createOpenAIToolsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIToolsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const modelWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        tools: tools.map((tool) => convertToOpenAITool(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToOpenAIToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new OpenAIToolsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIToolsAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGA,eAAsB,uBAAuB,EAC3C,KACA,OACA,QACA,kBAC+B;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,gEACA,SAAS,KAAK,UAAU,OAAO,eAAe,CAAC,WAChD,CAAC,KAAK,KAAK,CACb;CAEH,MAAM,iBAAiB,IAAI,YACvB,IAAI,UAAU,MAAM,GACpB,IAAI,WAAW,EACb,OAAO,MAAM,KAAK,SAAS,oBAAoB,KAAK,CAAC,EACtD,CAAC;AAiBN,QAhBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjBA,qBAA2B,MAAM,MAAM,EAC1C,CAAC;EACF;EACA;EACA,IAAI,8BAA8B;EACnC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

package/dist/agents/openai_tools/output_parser.cjs

@@ -1,7 +1,7 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_types = require('../types.cjs');
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
-const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+let _langchain_core_messages = require("@langchain/core/messages");
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/agents/openai_tools/output_parser.ts
 /**
@@ -46,7 +46,7 @@ var OpenAIToolsAgentOutputParser = class extends require_types.AgentMultiActionO
 		throw new Error(`OpenAIFunctionsAgentOutputParser can only parse messages.\nPassed input: ${text}`);
 	}
 	async parseResult(generations) {
-		if ("message" in generations[0] && (0, __langchain_core_messages.isBaseMessage)(generations[0].message)) return this.parseAIMessage(generations[0].message);
+		if ("message" in generations[0] && (0, _langchain_core_messages.isBaseMessage)(generations[0].message)) return this.parseAIMessage(generations[0].message);
 		throw new Error("parseResult on OpenAIFunctionsAgentOutputParser only works on ChatGeneration output");
 	}
 	/**
@@ -72,10 +72,9 @@ var OpenAIToolsAgentOutputParser = class extends require_types.AgentMultiActionO
 							messageLog
 						};
 					}
-					return void 0;
 				}).filter(Boolean);
 			} catch (error) {
-				throw new __langchain_core_output_parsers.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
+				throw new _langchain_core_output_parsers.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${error}`);
 			}
 		} else return {
 			returnValues: { output: message.content },

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.cjs","names":["AgentMultiActionOutputParser","text: string","generations: ChatGeneration[]","message: BaseMessage","toolCalls: OpenAIClient.Chat.ChatCompletionMessageToolCall[]","OutputParserException"],"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,cAAkDA,2CAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;CAAS;CAEhD,OAAO,UAAU;AACf,SAAO;CACR;CAED,MAAM,MAAMC,MAAoD;AAC9D,QAAM,IAAI,MACR,CAAC,yEAAyE,EAAE,MAAM;CAErF;CAED,MAAM,YAAYC,aAA+B;AAC/C,MAAI,aAAa,YAAY,mDAAoB,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,IAAIC,sDACR,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"}
+{"version":3,"file":"output_parser.cjs","names":["AgentMultiActionOutputParser","OutputParserException"],"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,cAAkDA,2CAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;EAAS;CAEhD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAoD;AAC9D,QAAM,IAAI,MACR,4EAA4E,OAC7E;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,kDAAoB,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR,sFACD;;;;;;;;CASH,eAAe,SAAwD;AACrE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM,sDAAsD;AAExE,MAAI,QAAQ,kBAAkB,YAAY;GACxC,MAAM,YACJ,QAAQ,kBAAkB;AAC5B,OAAI;AACF,WAAO,UACJ,KAAK,UAAU,MAAM;AACpB,SAAI,SAAS,SAAS,YAAY;MAChC,MAAM,YAAY,SAAS,SAAS,YAChC,KAAK,MAAM,SAAS,SAAS,UAAU,GACvC,EAAE;MACN,MAAM,aAAa,MAAM,IAAI,CAAC,QAAQ,GAAG,EAAE;AAC3C,aAAO;OACL,MAAM,SAAS,SAAS;OACxB;OACA,YAAY,SAAS;OACrB,KAAK,aAAa,SAAS,SAAS,KAAK,SACvC,SAAS,SAAS,aAAa,KAChC,IAAI,QAAQ;OACb;OACD;;MAGH,CACD,OAAO,QAAQ;YACX,OAAO;AACd,UAAM,IAAIC,qDACR,mEAAmE,KAAK,UACtE,UACD,CAAC,KAAK,QACR;;QAGH,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK,QAAQ;GACd;;CAIL,wBAAgC;AAC9B,QAAM,IAAI,MACR,6EACD"}

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

@@ -5,7 +5,6 @@ import { BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration } from "@langchain/core/outputs";
 
 //#region src/agents/openai_tools/output_parser.d.ts
-
 /**
  * @example
  * ```typescript

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

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

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

@@ -1,11 +1,10 @@
 import { AgentMultiActionOutputParser } from "../types.js";
 import { ToolsAgentAction, ToolsAgentStep } from "../tool_calling/output_parser.js";
-import { ChatGeneration } from "@langchain/core/outputs";
 import { BaseMessage } from "@langchain/core/messages";
+import { ChatGeneration } from "@langchain/core/outputs";
 import { AgentAction, AgentFinish } from "@langchain/core/agents";
 
 //#region src/agents/openai_tools/output_parser.d.ts
-
 /**
  * @example
  * ```typescript

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

@@ -1 +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//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAmCA;;;;;;;;;;;;AAAsF;;;;;;;;;;;;;;;;cAAjEO,4BAAAA,SAAqCH,4BAAAA;;;uBAGjCI,QAAQR,gBAAgBC;2BACpBE,mBAAmBK,QAAQP,cAAcI;;;;;;;0BAO1CH,cAAcG,qBAAqBJ"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/openai_tools/output_parser.ts"],"mappings":";;;;;;;;AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,4BAAA,SAAqC,4BAAA;EAChD,YAAA;EAAA,OAEO,OAAA,CAAA;EAID,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,KAAgB,WAAA;EAM7C,WAAA,CAAY,WAAA,EAAa,cAAA,KAAgB,OAAA,CAAA,WAAA,GAAA,gBAAA;EAeT;;;;;;EAAtC,cAAA,CAAe,OAAA,EAAS,WAAA,GAAc,gBAAA,KAAqB,WAAA;EA2C3D,qBAAA,CAAA;AAAA"}

package/dist/agents/openai_tools/output_parser.js

@@ -1,6 +1,6 @@
 import { AgentMultiActionOutputParser } from "../types.js";
-import { OutputParserException } from "@langchain/core/output_parsers";
 import { isBaseMessage } from "@langchain/core/messages";
+import { OutputParserException } from "@langchain/core/output_parsers";
 
 //#region src/agents/openai_tools/output_parser.ts
 /**
@@ -71,7 +71,6 @@ var OpenAIToolsAgentOutputParser = class extends AgentMultiActionOutputParser {
 							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}`);

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

@@ -1 +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"}
+{"version":3,"file":"output_parser.js","names":[],"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;EAAS;CAEhD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAoD;AAC9D,QAAM,IAAI,MACR,4EAA4E,OAC7E;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,MAAM,cAAc,YAAY,GAAG,QAAQ,CACtE,QAAO,KAAK,eAAe,YAAY,GAAG,QAAQ;AAEpD,QAAM,IAAI,MACR,sFACD;;;;;;;;CASH,eAAe,SAAwD;AACrE,MAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,SAChD,OAAM,IAAI,MAAM,sDAAsD;AAExE,MAAI,QAAQ,kBAAkB,YAAY;GACxC,MAAM,YACJ,QAAQ,kBAAkB;AAC5B,OAAI;AACF,WAAO,UACJ,KAAK,UAAU,MAAM;AACpB,SAAI,SAAS,SAAS,YAAY;MAChC,MAAM,YAAY,SAAS,SAAS,YAChC,KAAK,MAAM,SAAS,SAAS,UAAU,GACvC,EAAE;MACN,MAAM,aAAa,MAAM,IAAI,CAAC,QAAQ,GAAG,EAAE;AAC3C,aAAO;OACL,MAAM,SAAS,SAAS;OACxB;OACA,YAAY,SAAS;OACrB,KAAK,aAAa,SAAS,SAAS,KAAK,SACvC,SAAS,SAAS,aAAa,KAChC,IAAI,QAAQ;OACb;OACD;;MAGH,CACD,OAAO,QAAQ;YACX,OAAO;AACd,UAAM,IAAI,sBACR,mEAAmE,KAAK,UACtE,UACD,CAAC,KAAK,QACR;;QAGH,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK,QAAQ;GACd;;CAIL,wBAAgC;AAC9B,QAAM,IAAI,MACR,6EACD"}

package/dist/agents/react/index.cjs

@@ -1,9 +1,9 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+const require_agents_format_scratchpad_log = require('../format_scratchpad/log.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"));
+let _langchain_core_runnables = require("@langchain/core/runnables");
 
 //#region src/agents/react/index.ts
 /**
@@ -62,8 +62,8 @@ async function createReactAgent({ llm, tools, prompt, streamRunnable }) {
 		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) }),
+	return 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 })
@@ -72,7 +72,6 @@ async function createReactAgent({ llm, tools, prompt, streamRunnable }) {
 		streamRunnable,
 		singleAction: true
 	});
-	return agent;
 }
 
 //#endregion

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

@@ -1 +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"}
+{"version":3,"file":"index.cjs","names":["renderTextDescription","AgentRunnableSequence","RunnablePassthrough","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,kBACyB;CACzB,MAAM,mBAAmB;EAAC;EAAS;EAAc;EAAmB,CAAC,QAClE,MAAM,CAAC,OAAO,eAAe,SAAS,EAAE,CAC1C;AACD,KAAI,iBAAiB,SAAS,EAC5B,OAAM,IAAI,MACR,wDAAwD,KAAK,UAC3D,iBACD,GACF;CAEH,MAAM,YAAY,MAAM,KAAK,SAAS,KAAK,KAAK;CAChD,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAOA,2CAAsB,MAAM;EACnC,YAAY,UAAU,KAAK,KAAK;EACjC,CAAC;CACF,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,iBAAiB,EACzB,CAAC;AAmBF,QAlBcC,oCAAsB,cAClC;EACEC,8CAAoB,OAAO,EACzB,mBAAmB,UACjBC,uDAAkB,MAAM,MAAM,EACjC,CAAC;EACF;EACA;EACA,IAAIC,gEAA6B,EAC/B,WACD,CAAC;EACH,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

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

@@ -1,5 +1,5 @@
 import { AgentRunnableSequence } from "../agent.cjs";
-import * as _langchain_core_agents5 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
@@ -10,9 +10,7 @@ import { ToolInterface } from "@langchain/core/tools";
  * Params used by the createXmlAgent function.
  */
 type CreateReactAgentParams = {
-  /** LLM to use for the agent. */
-  llm: BaseLanguageModelInterface;
-  /** Tools this agent has access to. */
+  /** 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
@@ -75,7 +73,7 @@ declare function createReactAgent({
   streamRunnable
 }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents5.AgentAction | _langchain_core_agents5.AgentFinish>>;
+}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
 //#endregion
 export { CreateReactAgentParams, createReactAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAEzBH;EAEEF,GAAAA,EAFFE,0BAEEF;EAKCC;EAAkB,KAAA,EALnBD,aAKmB,EAAA;EAkDNM;;;;EAAuCI,MAAAA,EAlDnDT,kBAkDmDS;EAAkBL;;;;EAAiCD,cAAAA,CAAAA,EAAAA,OAAAA;CAARU;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFR,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/react/index.ts"],"mappings":";;;;;;;;;;;KAgBY,sBAAA;EAAsB,gCAEhC,GAAA,EAAK,0BAAA,EAAA;EAEL,KAAA,EAAO,aAAA;EAKC;;;;EAAR,MAAA,EAAQ,kBAAA;EALR;;;;EAUA,cAAA;AAAA;;AA8CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,sBAAA,GAAsB,OAAA,CAAA,qBAAA"}

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

@@ -2,7 +2,7 @@ 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_agents3 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 
 //#region src/agents/react/index.d.ts
@@ -10,9 +10,7 @@ import { AgentStep } from "@langchain/core/agents";
  * Params used by the createXmlAgent function.
  */
 type CreateReactAgentParams = {
-  /** LLM to use for the agent. */
-  llm: BaseLanguageModelInterface;
-  /** Tools this agent has access to. */
+  /** 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
@@ -75,7 +73,7 @@ declare function createReactAgent({
   streamRunnable
 }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents3.AgentAction | _langchain_core_agents3.AgentFinish>>;
+}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
 //#endregion
 export { CreateReactAgentParams, createReactAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","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//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAEzBH;EAEEF,GAAAA,EAFFE,0BAEEF;EAKCC;EAAkB,KAAA,EALnBD,aAKmB,EAAA;EAkDNM;;;;EAAuCI,MAAAA,EAlDnDT,kBAkDmDS;EAAkBL;;;;EAAiCD,cAAAA,CAAAA,EAAAA,OAAAA;CAARU;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFR,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/react/index.ts"],"mappings":";;;;;;;;;;;KAgBY,sBAAA;EAAsB,gCAEhC,GAAA,EAAK,0BAAA,EAAA;EAEL,KAAA,EAAO,aAAA;EAKC;;;;EAAR,MAAA,EAAQ,kBAAA;EALR;;;;EAUA,cAAA;AAAA;;AA8CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,gBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,sBAAA,GAAsB,OAAA,CAAA,qBAAA"}

package/dist/agents/react/index.js

@@ -1,6 +1,6 @@
+import { formatLogToString } from "../format_scratchpad/log.js";
 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";
 
@@ -61,7 +61,7 @@ async function createReactAgent({ llm, tools, prompt, streamRunnable }) {
 		tool_names: toolNames.join(", ")
 	});
 	const llmWithStop = llm.withConfig({ stop: ["\nObservation:"] });
-	const agent = AgentRunnableSequence.fromRunnables([
+	return AgentRunnableSequence.fromRunnables([
 		RunnablePassthrough.assign({ agent_scratchpad: (input) => formatLogToString(input.steps) }),
 		partialedPrompt,
 		llmWithStop,
@@ -71,7 +71,6 @@ async function createReactAgent({ llm, tools, prompt, streamRunnable }) {
 		streamRunnable,
 		singleAction: true
 	});
-	return agent;
 }
 
 //#endregion

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

@@ -1 +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"}
+{"version":3,"file":"index.js","names":[],"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,kBACyB;CACzB,MAAM,mBAAmB;EAAC;EAAS;EAAc;EAAmB,CAAC,QAClE,MAAM,CAAC,OAAO,eAAe,SAAS,EAAE,CAC1C;AACD,KAAI,iBAAiB,SAAS,EAC5B,OAAM,IAAI,MACR,wDAAwD,KAAK,UAC3D,iBACD,GACF;CAEH,MAAM,YAAY,MAAM,KAAK,SAAS,KAAK,KAAK;CAChD,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAO,sBAAsB,MAAM;EACnC,YAAY,UAAU,KAAK,KAAK;EACjC,CAAC;CACF,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,iBAAiB,EACzB,CAAC;AAmBF,QAlBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjB,kBAAkB,MAAM,MAAM,EACjC,CAAC;EACF;EACA;EACA,IAAI,6BAA6B,EAC/B,WACD,CAAC;EACH,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

package/dist/agents/react/output_parser.cjs

@@ -1,12 +1,12 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_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"));
+let _langchain_core_prompts = require("@langchain/core/prompts");
+let _langchain_core_output_parsers = 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 });
+var output_parser_exports = /* @__PURE__ */ require_runtime.__exportAll({ 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:";
 /**
@@ -67,27 +67,20 @@ var ReActSingleInputOutputParser = class extends require_types.AgentActionOutput
 	*/
 	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);
+		const actionMatch = text.match(/Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)/);
 		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, "");
+			if (includesAnswer) throw new _langchain_core_output_parsers.OutputParserException(`${FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: ${text}`);
 			return {
-				tool: action,
-				toolInput,
+				tool: actionMatch[1],
+				toolInput: actionMatch[2].trim().replace(/^"|"$/g, ""),
 				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}`);
+		if (includesAnswer) return {
+			returnValues: { output: text.split(FINAL_ANSWER_ACTION)[1].trim() },
+			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
@@ -96,7 +89,7 @@ var ReActSingleInputOutputParser = class extends require_types.AgentActionOutput
 	* @returns Format instructions as a string.
 	*/
 	getFormatInstructions() {
-		return (0, __langchain_core_prompts.renderTemplate)(require_prompt.FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
+		return (0, _langchain_core_prompts.renderTemplate)(require_prompt.FORMAT_INSTRUCTIONS, "f-string", { tool_names: this.toolNames.join(", ") });
 	}
 };
 

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

@@ -1 +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"}
+{"version":3,"file":"output_parser.cjs","names":["AgentActionOutputParser","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;EAAQ;CAE/C,AAAQ;CAER,YAAY,QAAiC;AAC3C,QAAM,GAAG,UAAU;AACnB,OAAK,YAAY,OAAO;;;;;;;;CAS1B,MAAM,MAAM,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,oBAAoB;EAGzD,MAAM,cAAc,KAAK,MADvB,yEACmC;AACrC,MAAI,aAAa;AACf,OAAI,eACF,OAAM,IAAIC,qDACR,GAAG,+CAA+C,IAAI,OACvD;AAOH,UAAO;IACL,MALa,YAAY;IAMzB,WALkB,YAAY,GACF,MAAM,CAAC,QAAQ,UAAU,GAAG;IAKxD,KAAK;IACN;;AAGH,MAAI,eAEF,QAAO;GACL,cAAc,EACZ,QAHoB,KAAK,MAAM,oBAAoB,CAAC,GAAG,MAAM,EAI9D;GACD,KAAK;GACN;AAGH,QAAM,IAAIA,qDAAsB,+BAA+B,OAAO;;;;;;;;CASxE,wBAAgC;AAC9B,qDAAsBC,oCAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC"}

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

@@ -2,7 +2,6 @@ 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.
  *

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

@@ -1 +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//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;AAyCA;;;;;AAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5DG,4BAAAA,SAAqCD,uBAAAA;;;;;;;;;;;;uBAYjCE,QAAQJ,cAAcC"}
+{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/react/output_parser.ts"],"mappings":";;;;;;AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,4BAAA,SAAqC,uBAAA;EAChD,YAAA;EAAA,QAEQ,SAAA;EAER,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA;;;;;;;EAWhB,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;;;;;;;EA0CjD,qBAAA,CAAA;AAAA"}

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

@@ -2,7 +2,6 @@ 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.
  *

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

@@ -1 +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//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;AAyCA;;;;;AAAiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA5DG,4BAAAA,SAAqCD,uBAAAA;;;;;;;;;;;;uBAYjCE,QAAQJ,cAAcC"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/react/output_parser.ts"],"mappings":";;;;;;AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,4BAAA,SAAqC,uBAAA;EAChD,YAAA;EAAA,QAEQ,SAAA;EAER,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA;;;;;;;EAWhB,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;;;;;;;EA0CjD,qBAAA,CAAA;AAAA"}

package/dist/agents/react/output_parser.js

@@ -1,12 +1,11 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } 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 });
+var output_parser_exports = /* @__PURE__ */ __exportAll({ 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:";
 /**
@@ -67,26 +66,19 @@ var ReActSingleInputOutputParser = class extends AgentActionOutputParser {
 	*/
 	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);
+		const actionMatch = text.match(/Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)/);
 		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 },
+				tool: actionMatch[1],
+				toolInput: actionMatch[2].trim().replace(/^"|"$/g, ""),
 				log: text
 			};
 		}
+		if (includesAnswer) return {
+			returnValues: { output: text.split(FINAL_ANSWER_ACTION)[1].trim() },
+			log: text
+		};
 		throw new OutputParserException(`Could not parse LLM output: ${text}`);
 	}
 	/**

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

@@ -1 +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"}
+{"version":3,"file":"output_parser.js","names":[],"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;EAAQ;CAE/C,AAAQ;CAER,YAAY,QAAiC;AAC3C,QAAM,GAAG,UAAU;AACnB,OAAK,YAAY,OAAO;;;;;;;;CAS1B,MAAM,MAAM,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,oBAAoB;EAGzD,MAAM,cAAc,KAAK,MADvB,yEACmC;AACrC,MAAI,aAAa;AACf,OAAI,eACF,OAAM,IAAI,sBACR,GAAG,+CAA+C,IAAI,OACvD;AAOH,UAAO;IACL,MALa,YAAY;IAMzB,WALkB,YAAY,GACF,MAAM,CAAC,QAAQ,UAAU,GAAG;IAKxD,KAAK;IACN;;AAGH,MAAI,eAEF,QAAO;GACL,cAAc,EACZ,QAHoB,KAAK,MAAM,oBAAoB,CAAC,GAAG,MAAM,EAI9D;GACD,KAAK;GACN;AAGH,QAAM,IAAI,sBAAsB,+BAA+B,OAAO;;;;;;;;CASxE,wBAAgC;AAC9B,SAAO,eAAe,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC"}