@langchain/classic 1.0.40 → 1.0.42

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

@@ -1,13 +1,11 @@
 import { ToolsAgentStep } from "../tool_calling/output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
 import { OpenAIToolsAgentOutputParser } from "./output_parser.cjs";
-import * as _$_langchain_core_agents0 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { OpenAIClient } from "@langchain/openai";
 import { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
-
 //#region src/agents/openai_tools/index.d.ts
 /**
  * Params used by the createOpenAIToolsAgent function.
@@ -20,8 +18,10 @@ type CreateOpenAIToolsAgentParams = {
    */
   llm: BaseChatModel<BaseChatModelCallOptions & {
     tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
-  }>; /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  }>;
+  /** Tools this agent has access to. */
+  tools: StructuredToolInterface[] | ToolDefinition[];
+  /** The prompt to use, must have an input key of `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,
@@ -85,14 +85,9 @@ type CreateOpenAIToolsAgentParams = {
  * });
  * ```
  */
-declare function createOpenAIToolsAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
+declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _$_langchain_core_agents0.AgentFinish | _$_langchain_core_agents0.AgentAction[]>>;
+}, import("@langchain/core/agents").AgentFinish | import("@langchain/core/agents").AgentAction[]>>;
 //#endregion
-export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
+export { CreateOpenAIToolsAgentParams, type ToolsAgentStep, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/openai_tools/index.ts"],"mappings":";;;;;;;;;;;;;;KAsBY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,aAAA,CACH,wBAAA;IACE,KAAA,GACI,uBAAA,KACA,YAAA,CAAa,kBAAA;EAAA,IAQb;EAFR,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAET;EAA1B,MAAA,EAAQ,kBAAA;EAZH;;;;EAiBL,cAAA;AAAA;;;;;;;;;AA2DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,sBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,OAAA,CAAA,qBAAA;SAiBY,cAAA;AAAA,GAAc,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/openai_tools/index.ts"],"mappings":";;;;;;;;;;;;KAsBY;;;;;;EAMV,KAAK,cACH;IACE,QACI,4BACA,aAAa;;;EAMrB,OAAO,4BAA4B;;EAEnC,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DoB,yBACpB,KACA,OACA,QACA,kBACC,+BAA4B,QAAA;EAiBY,OAAA;oCAc1C,+CAAA"}

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

@@ -6,8 +6,6 @@ import { StructuredToolInterface } from "@langchain/core/tools";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { OpenAIClient } from "@langchain/openai";
 import { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
-import * as _$_langchain_core_agents0 from "@langchain/core/agents";
-
 //#region src/agents/openai_tools/index.d.ts
 /**
  * Params used by the createOpenAIToolsAgent function.
@@ -20,8 +18,10 @@ type CreateOpenAIToolsAgentParams = {
    */
   llm: BaseChatModel<BaseChatModelCallOptions & {
     tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];
-  }>; /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  }>;
+  /** Tools this agent has access to. */
+  tools: StructuredToolInterface[] | ToolDefinition[];
+  /** The prompt to use, must have an input key of `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,
@@ -85,14 +85,9 @@ type CreateOpenAIToolsAgentParams = {
  * });
  * ```
  */
-declare function createOpenAIToolsAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
+declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _$_langchain_core_agents0.AgentFinish | _$_langchain_core_agents0.AgentAction[]>>;
+}, import("@langchain/core/agents").AgentFinish | import("@langchain/core/agents").AgentAction[]>>;
 //#endregion
-export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
+export { CreateOpenAIToolsAgentParams, type ToolsAgentStep, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/openai_tools/index.ts"],"mappings":";;;;;;;;;;;;;;KAsBY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,aAAA,CACH,wBAAA;IACE,KAAA,GACI,uBAAA,KACA,YAAA,CAAa,kBAAA;EAAA,IAQb;EAFR,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAET;EAA1B,MAAA,EAAQ,kBAAA;EAZH;;;;EAiBL,cAAA;AAAA;;;;;;;;;AA2DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,sBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,OAAA,CAAA,qBAAA;SAiBY,cAAA;AAAA,GAAc,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/openai_tools/index.ts"],"mappings":";;;;;;;;;;;;KAsBY;;;;;;EAMV,KAAK,cACH;IACE,QACI,4BACA,aAAa;;;EAMrB,OAAO,4BAA4B;;EAEnC,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DoB,yBACpB,KACA,OACA,QACA,kBACC,+BAA4B,QAAA;EAiBY,OAAA;oCAc1C,+CAAA"}

package/dist/agents/openai_tools/index.js

@@ -76,6 +76,6 @@ async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }) {
 	});
 }
 //#endregion
-export { createOpenAIToolsAgent };
+export { OpenAIToolsAgentOutputParser, createOpenAIToolsAgent };
 
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"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        // oxlint-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,CAES"}
+{"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        // oxlint-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;CAC/B,IAAI,CAAC,OAAO,eAAe,SAAS,kBAAkB,GACpD,MAAM,IAAI,MACR,CACE,gEACA,SAAS,KAAK,UAAU,OAAO,cAAc,EAAE,UACjD,CAAC,CAAC,KAAK,IAAI,CACb;CAEF,MAAM,iBAAiB,IAAI,YACvB,IAAI,UAAU,KAAK,IACnB,IAAI,WAAW,EACb,OAAO,MAAM,KAAK,SAAS,oBAAoB,IAAI,CAAC,EACtD,CAAC;CAiBL,OAhBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjBA,qBAA2B,MAAM,KAAK,EAC1C,CAAC;EACD;EACA;EACA,IAAI,6BAA6B;CACnC,GACA;EACE,MAAM;EACN;EACA,cAAc;CAChB,CAES;AACb"}

package/dist/agents/openai_tools/output_parser.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_types = require("../types.cjs");
 let _langchain_core_messages = require("@langchain/core/messages");
 let _langchain_core_output_parsers = require("@langchain/core/output_parsers");

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

@@ -1 +1 @@
-{"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,cAAAA,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,OAAA,GAAA,yBAAA,eAAoB,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,+BAAAA,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"}
+{"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,cAAAA,6BAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;CAAQ;CAE/C,OAAO,UAAU;EACf,OAAO;CACT;CAEA,MAAM,MAAM,MAAoD;EAC9D,MAAM,IAAI,MACR,4EAA4E,MAC9E;CACF;CAEA,MAAM,YAAY,aAA+B;EAC/C,IAAI,aAAa,YAAY,OAAA,GAAA,yBAAA,cAAA,CAAoB,YAAY,EAAE,CAAC,OAAO,GACrE,OAAO,KAAK,eAAe,YAAY,EAAE,CAAC,OAAO;EAEnD,MAAM,IAAI,MACR,qFACF;CACF;;;;;;;CAQA,eAAe,SAAwD;EACrE,IAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,UAChD,MAAM,IAAI,MAAM,qDAAqD;EAEvE,IAAI,QAAQ,kBAAkB,YAAY;GACxC,MAAM,YACJ,QAAQ,kBAAkB;GAC5B,IAAI;IACF,OAAO,UACJ,KAAK,UAAU,MAAM;KACpB,IAAI,SAAS,SAAS,YAAY;MAChC,MAAM,YAAY,SAAS,SAAS,YAChC,KAAK,MAAM,SAAS,SAAS,SAAS,IACtC,CAAC;MACL,MAAM,aAAa,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC;MAC1C,OAAO;OACL,MAAM,SAAS,SAAS;OACxB;OACA,YAAY,SAAS;OACrB,KAAK,aAAa,SAAS,SAAS,KAAK,SACvC,SAAS,SAAS,aAAa,KAChC,IAAI,QAAQ;OACb;MACF;KACF;IAEF,CAAC,CAAC,CACD,OAAO,OAAO;GACnB,SAAS,OAAO;IACd,MAAM,IAAIC,+BAAAA,sBACR,mEAAmE,KAAK,UACtE,SACF,EAAE,KAAK,OACT;GACF;EACF,OACE,OAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAQ;GACxC,KAAK,QAAQ;EACf;CAEJ;CAEA,wBAAgC;EAC9B,MAAM,IAAI,MACR,4EACF;CACF;AACF"}

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

@@ -3,7 +3,6 @@ import { ToolsAgentAction, ToolsAgentStep } from "../tool_calling/output_parser.
 import { AgentAction, AgentFinish } from "@langchain/core/agents";
 import { BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration } from "@langchain/core/outputs";
-
 //#region src/agents/openai_tools/output_parser.d.ts
 /**
  * @example
@@ -49,5 +48,5 @@ declare class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser
   getFormatInstructions(): string;
 }
 //#endregion
-export { OpenAIToolsAgentOutputParser };
+export { OpenAIToolsAgentOutputParser, type ToolsAgentAction, type ToolsAgentStep };
 //# sourceMappingURL=output_parser.d.cts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/openai_tools/output_parser.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ca,qCAAqC;EAChD;SAEO;EAID,MAAM,eAAe,QAAQ,gBAAgB;EAM7C,YAAY,aAAa,mBAAgB,QAAA,cAAA;;;;;;;EAe/C,eAAe,SAAS,cAAc,qBAAqB;EA2C3D"}

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

@@ -3,7 +3,6 @@ import { ToolsAgentAction, ToolsAgentStep } from "../tool_calling/output_parser.
 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
@@ -49,5 +48,5 @@ declare class OpenAIToolsAgentOutputParser extends AgentMultiActionOutputParser
   getFormatInstructions(): string;
 }
 //#endregion
-export { OpenAIToolsAgentOutputParser };
+export { OpenAIToolsAgentOutputParser, type ToolsAgentAction, type ToolsAgentStep };
 //# sourceMappingURL=output_parser.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/openai_tools/output_parser.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Ca,qCAAqC;EAChD;SAEO;EAID,MAAM,eAAe,QAAQ,gBAAgB;EAM7C,YAAY,aAAa,mBAAgB,QAAA,cAAA;;;;;;;EAe/C,eAAe,SAAS,cAAc,qBAAqB;EA2C3D"}

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

@@ -1 +1 @@
-{"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"}
+{"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;CAAQ;CAE/C,OAAO,UAAU;EACf,OAAO;CACT;CAEA,MAAM,MAAM,MAAoD;EAC9D,MAAM,IAAI,MACR,4EAA4E,MAC9E;CACF;CAEA,MAAM,YAAY,aAA+B;EAC/C,IAAI,aAAa,YAAY,MAAM,cAAc,YAAY,EAAE,CAAC,OAAO,GACrE,OAAO,KAAK,eAAe,YAAY,EAAE,CAAC,OAAO;EAEnD,MAAM,IAAI,MACR,qFACF;CACF;;;;;;;CAQA,eAAe,SAAwD;EACrE,IAAI,QAAQ,WAAW,OAAO,QAAQ,YAAY,UAChD,MAAM,IAAI,MAAM,qDAAqD;EAEvE,IAAI,QAAQ,kBAAkB,YAAY;GACxC,MAAM,YACJ,QAAQ,kBAAkB;GAC5B,IAAI;IACF,OAAO,UACJ,KAAK,UAAU,MAAM;KACpB,IAAI,SAAS,SAAS,YAAY;MAChC,MAAM,YAAY,SAAS,SAAS,YAChC,KAAK,MAAM,SAAS,SAAS,SAAS,IACtC,CAAC;MACL,MAAM,aAAa,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC;MAC1C,OAAO;OACL,MAAM,SAAS,SAAS;OACxB;OACA,YAAY,SAAS;OACrB,KAAK,aAAa,SAAS,SAAS,KAAK,SACvC,SAAS,SAAS,aAAa,KAChC,IAAI,QAAQ;OACb;MACF;KACF;IAEF,CAAC,CAAC,CACD,OAAO,OAAO;GACnB,SAAS,OAAO;IACd,MAAM,IAAI,sBACR,mEAAmE,KAAK,UACtE,SACF,EAAE,KAAK,OACT;GACF;EACF,OACE,OAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAQ;GACxC,KAAK,QAAQ;EACf;CAEJ;CAEA,wBAAgC;EAC9B,MAAM,IAAI,MACR,4EACF;CACF;AACF"}

package/dist/agents/react/index.cjs

@@ -1,4 +1,3 @@
-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");

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

@@ -1 +1 @@
-{"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,qBAAAA,sBAAsB,MAAM;EACnC,YAAY,UAAU,KAAK,KAAK;EACjC,CAAC;CACF,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,iBAAiB,EACzB,CAAC;AAmBF,QAlBcC,cAAAA,sBAAsB,cAClC;EACEC,0BAAAA,oBAAoB,OAAO,EACzB,mBAAmB,UACjBC,qCAAAA,kBAAkB,MAAM,MAAM,EACjC,CAAC;EACF;EACA;EACA,IAAIC,mCAAAA,6BAA6B,EAC/B,WACD,CAAC;EACH,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CAES"}
+{"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;CAAkB,CAAC,CAAC,QAClE,MAAM,CAAC,OAAO,eAAe,SAAS,CAAC,CAC1C;CACA,IAAI,iBAAiB,SAAS,GAC5B,MAAM,IAAI,MACR,wDAAwD,KAAK,UAC3D,gBACF,GACF;CAEF,MAAM,YAAY,MAAM,KAAK,SAAS,KAAK,IAAI;CAC/C,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAOA,qBAAAA,sBAAsB,KAAK;EAClC,YAAY,UAAU,KAAK,IAAI;CACjC,CAAC;CACD,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,gBAAgB,EACzB,CAAC;CAmBD,OAlBcC,cAAAA,sBAAsB,cAClC;EACEC,0BAAAA,oBAAoB,OAAO,EACzB,mBAAmB,UACjBC,qCAAAA,kBAAkB,MAAM,KAAK,EACjC,CAAC;EACD;EACA;EACA,IAAIC,mCAAAA,6BAA6B,EAC/B,UACF,CAAC;CACH,GACA;EACE,MAAM;EACN;EACA,cAAc;CAChB,CAES;AACb"}

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

@@ -1,16 +1,16 @@
 import { AgentRunnableSequence } from "../agent.cjs";
-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";
 import { ToolInterface } from "@langchain/core/tools";
-
 //#region src/agents/react/index.d.ts
 /**
  * Params used by the createXmlAgent function.
  */
 type CreateReactAgentParams = {
-  /** LLM to use for the agent. */llm: BaseLanguageModelInterface; /** Tools this agent has access to. */
+  /** 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
@@ -66,14 +66,9 @@ type CreateReactAgentParams = {
  * });
  * ```
  */
-declare function createReactAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateReactAgentParams): Promise<AgentRunnableSequence<{
+declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _$_langchain_core_agents0.AgentAction | _$_langchain_core_agents0.AgentFinish>>;
+}, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").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":[],"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;SAsBkB,SAAA;AAAA,GAAS,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/react/index.ts"],"mappings":";;;;;;;;;KAgBY;;EAEV,KAAK;;EAEL,OAAO;;;;;EAKP,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CoB,mBACpB,KACA,OACA,QACA,kBACC,yBAAsB,QAAA;EAsBkB,OAAA;oCAgB1C,+CAAA"}

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

@@ -2,15 +2,15 @@ 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_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
-
 //#region src/agents/react/index.d.ts
 /**
  * Params used by the createXmlAgent function.
  */
 type CreateReactAgentParams = {
-  /** LLM to use for the agent. */llm: BaseLanguageModelInterface; /** Tools this agent has access to. */
+  /** 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
@@ -66,14 +66,9 @@ type CreateReactAgentParams = {
  * });
  * ```
  */
-declare function createReactAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateReactAgentParams): Promise<AgentRunnableSequence<{
+declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _$_langchain_core_agents0.AgentAction | _$_langchain_core_agents0.AgentFinish>>;
+}, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").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":[],"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;SAsBkB,SAAA;AAAA,GAAS,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/react/index.ts"],"mappings":";;;;;;;;;KAgBY;;EAEV,KAAK;;EAEL,OAAO;;;;;EAKP,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CoB,mBACpB,KACA,OACA,QACA,kBACC,yBAAsB,QAAA;EAsBkB,OAAA;oCAgB1C,+CAAA"}

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

@@ -1 +1 @@
-{"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,CAES"}
+{"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;CAAkB,CAAC,CAAC,QAClE,MAAM,CAAC,OAAO,eAAe,SAAS,CAAC,CAC1C;CACA,IAAI,iBAAiB,SAAS,GAC5B,MAAM,IAAI,MACR,wDAAwD,KAAK,UAC3D,gBACF,GACF;CAEF,MAAM,YAAY,MAAM,KAAK,SAAS,KAAK,IAAI;CAC/C,MAAM,kBAAkB,MAAM,OAAO,QAAQ;EAC3C,OAAO,sBAAsB,KAAK;EAClC,YAAY,UAAU,KAAK,IAAI;CACjC,CAAC;CACD,MAAM,cAAe,IAA0B,WAAW,EACxD,MAAM,CAAC,gBAAgB,EACzB,CAAC;CAmBD,OAlBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjB,kBAAkB,MAAM,KAAK,EACjC,CAAC;EACD;EACA;EACA,IAAI,6BAA6B,EAC/B,UACF,CAAC;CACH,GACA;EACE,MAAM;EACN;EACA,cAAc;CAChB,CAES;AACb"}

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

@@ -1 +1 @@
-{"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,cAAAA,wBAAwB;CACxE,eAAe;EAAC;EAAa;EAAU;EAAQ;CAE/C;CAEA,YAAY,QAAiC;AAC3C,QAAM,GAAG,UAAU;AACnB,OAAK,YAAY,OAAO;;;;;;;;CAS1B,MAAM,MAAM,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,oBAAoB;EAGzD,MAAM,cAAc,KAAK,MAAM,yEAAM;AACrC,MAAI,aAAa;AACf,OAAI,eACF,OAAM,IAAIC,+BAAAA,sBACR,GAAG,+CAA+C,IAAI,OACvD;AAOH,UAAO;IACL,MALa,YAAY;IAMzB,WALkB,YAAY,GACF,MAAM,CAAC,QAAQ,UAAU,GAI5C;IACT,KAAK;IACN;;AAGH,MAAI,eAEF,QAAO;GACL,cAAc,EACZ,QAHoB,KAAK,MAAM,oBAAoB,CAAC,GAAG,MAGhC,EACxB;GACD,KAAK;GACN;AAGH,QAAM,IAAIA,+BAAAA,sBAAsB,+BAA+B,OAAO;;;;;;;;CASxE,wBAAgC;AAC9B,UAAA,GAAA,wBAAA,gBAAsBC,eAAAA,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC"}
+{"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,cAAAA,wBAAwB;CACxE,eAAe;EAAC;EAAa;EAAU;CAAO;CAE9C;CAEA,YAAY,QAAiC;EAC3C,MAAM,GAAG,SAAS;EAClB,KAAK,YAAY,OAAO;CAC1B;;;;;;;CAQA,MAAM,MAAM,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,mBAAmB;EAGxD,MAAM,cAAc,KAAK,MAAM,wEAAK;EACpC,IAAI,aAAa;GACf,IAAI,gBACF,MAAM,IAAIC,+BAAAA,sBACR,GAAG,+CAA+C,IAAI,MACxD;GAOF,OAAO;IACL,MALa,YAAY;IAMzB,WALkB,YAAY,EACH,CAAC,KAAK,CAAC,CAAC,QAAQ,UAAU,EAI7C;IACR,KAAK;GACP;EACF;EAEA,IAAI,gBAEF,OAAO;GACL,cAAc,EACZ,QAHoB,KAAK,MAAM,mBAAmB,CAAC,CAAC,EAAE,CAAC,KAGjC,EACxB;GACA,KAAK;EACP;EAGF,MAAM,IAAIA,+BAAAA,sBAAsB,+BAA+B,MAAM;CACvE;;;;;;;CAQA,wBAAgC;EAC9B,QAAA,GAAA,wBAAA,eAAA,CAAsBC,eAAAA,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,IAAI,EACtC,CAAC;CACH;AACF"}

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

@@ -1,6 +1,5 @@
 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":[],"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"}
+{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/react/output_parser.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiDa,qCAAqC;EAChD;UAEQ;EAER,YAAY;IAAU;;;;;;;;EAWhB,MAAM,eAAe,QAAQ,cAAc;;;;;;;EA0CjD"}

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

@@ -1,6 +1,5 @@
 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":[],"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"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/react/output_parser.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiDa,qCAAqC;EAChD;UAEQ;EAER,YAAY;IAAU;;;;;;;;EAWhB,MAAM,eAAe,QAAQ,cAAc;;;;;;;EA0CjD"}

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

@@ -1 +1 @@
-{"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;CAEA,YAAY,QAAiC;AAC3C,QAAM,GAAG,UAAU;AACnB,OAAK,YAAY,OAAO;;;;;;;;CAS1B,MAAM,MAAM,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,oBAAoB;EAGzD,MAAM,cAAc,KAAK,MAAM,yEAAM;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,GAI5C;IACT,KAAK;IACN;;AAGH,MAAI,eAEF,QAAO;GACL,cAAc,EACZ,QAHoB,KAAK,MAAM,oBAAoB,CAAC,GAAG,MAGhC,EACxB;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"}
+{"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;CAAO;CAE9C;CAEA,YAAY,QAAiC;EAC3C,MAAM,GAAG,SAAS;EAClB,KAAK,YAAY,OAAO;CAC1B;;;;;;;CAQA,MAAM,MAAM,MAAkD;EAC5D,MAAM,iBAAiB,KAAK,SAAS,mBAAmB;EAGxD,MAAM,cAAc,KAAK,MAAM,wEAAK;EACpC,IAAI,aAAa;GACf,IAAI,gBACF,MAAM,IAAI,sBACR,GAAG,+CAA+C,IAAI,MACxD;GAOF,OAAO;IACL,MALa,YAAY;IAMzB,WALkB,YAAY,EACH,CAAC,KAAK,CAAC,CAAC,QAAQ,UAAU,EAI7C;IACR,KAAK;GACP;EACF;EAEA,IAAI,gBAEF,OAAO;GACL,cAAc,EACZ,QAHoB,KAAK,MAAM,mBAAmB,CAAC,CAAC,EAAE,CAAC,KAGjC,EACxB;GACA,KAAK;EACP;EAGF,MAAM,IAAI,sBAAsB,+BAA+B,MAAM;CACvE;;;;;;;CAQA,wBAAgC;EAC9B,OAAO,eAAe,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,IAAI,EACtC,CAAC;CACH;AACF"}

package/dist/agents/structured_chat/index.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_agents_format_scratchpad_log = require("../format_scratchpad/log.cjs");
 const require_agent = require("../agent.cjs");
 const require_llm_chain = require("../../chains/llm_chain.cjs");
@@ -138,12 +137,13 @@ var StructuredChatAgent = class StructuredChatAgent extends require_agent.Agent
 			llm,
 			toolNames: tools.map((tool) => tool.name)
 		});
+		const chain = new require_llm_chain.LLMChain({
+			prompt,
+			llm,
+			callbacks: args?.callbacks
+		});
 		return new StructuredChatAgent({
-			llmChain: new require_llm_chain.LLMChain({
-				prompt,
-				llm,
-				callbacks: args?.callbacks
-			}),
+			llmChain: chain,
 			outputParser,
 			allowedTools: tools.map((t) => t.name)
 		});

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

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