@langchain/classic 1.0.40 → 1.0.41

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

@@ -2,12 +2,10 @@ import { AgentInput } from "../types.cjs";
 import { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from "../agent.cjs";
 import { Optional } from "../../types/type-utils.cjs";
 import { StructuredChatOutputParserWithRetries } from "./outputParser.cjs";
-import * as _$_langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 import { BaseMessagePromptTemplate, BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface, ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
-
 //#region src/agents/structured_chat/index.d.ts
 /**
  * Interface for arguments used to create a prompt for a
@@ -97,7 +95,9 @@ declare class StructuredChatAgent extends Agent {
  * Params used by the createStructuredChatAgent function.
  */
 type CreateStructuredChatAgentParams = {
-  /** LLM to use as the agent. */llm: BaseLanguageModelInterface; /** Tools this agent has access to. */
+  /** LLM to use as the agent. */
+  llm: BaseLanguageModelInterface;
+  /** Tools this agent has access to. */
   tools: (StructuredToolInterface | ToolDefinition)[];
   /**
    * The prompt to use. Must have input keys for
@@ -166,14 +166,9 @@ type CreateStructuredChatAgentParams = {
  * });
  * ```
  */
-declare function createStructuredChatAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
+declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _$_langchain_core_agents0.AgentAction | _$_langchain_core_agents0.AgentFinish>>;
+}, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").AgentFinish>>;
 //#endregion
 export { CreateStructuredChatAgentParams, StructuredChatAgent, StructuredChatAgentInput, StructuredChatCreatePromptArgs, createStructuredChatAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/structured_chat/index.ts"],"mappings":";;;;;;;;;;;;;AAyCA;;UAAiB,8BAAA;EAU0B;EARzC,MAAA;EAEA;EAAA,MAAA;EAIA;EAFA,oBAAA;EAIgB;EAFhB,cAAA;EAEyC;EAAzC,aAAA,GAAgB,yBAAA;AAAA;;;;AAalB;KANY,wBAAA,GAA2B,QAAA,CAAS,UAAA;;;;;cAMnC,mBAAA,SAA4B,KAAA;EAAA,OAChC,OAAA,CAAA;EAIP,YAAA;EAEA,WAAA,CAAY,KAAA,EAAO,wBAAA;EAMnB,UAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,SAAA,CAAA;EAIA,KAAA,CAAA;EAkIS;;;;;EAAA,OAzHF,aAAA,CAAc,KAAA,EAAO,uBAAA;EAlCgB;;;;;;EAAA,OAkDrC,sBAAA,CACL,MAAA,GAAS,gBAAA;IACP,SAAA;EAAA,IACD,qCAAA;EAhCH;;;;;;;EAmDM,mBAAA,CAAoB,KAAA,EAAO,SAAA,KAAc,OAAA;EArB7C;;;;;EAAA,OAkCK,uBAAA,CAAwB,KAAA,EAAO,uBAAA;EAA/B;;;;;;;;;;EAAA,OAyBA,YAAA,CACL,KAAA,EAAO,uBAAA,IACP,IAAA,GAAO,8BAAA,GAA8B,kBAAA;EA0CrC;;;;;;;;;EAAA,OADK,eAAA,CACL,GAAA,EAAK,0BAAA,EACL,KAAA,EAAO,uBAAA,IACP,IAAA,GAAO,8BAAA,GAAiC,SAAA,GAAS,mBAAA;AAAA;;;;KA2BzC,+BAAA;EASF,+BAPR,GAAA,EAAK,0BAAA,EAOqB;EAL1B,KAAA,GAAQ,uBAAA,GAA0B,cAAA;EAF7B;;;;EAOL,MAAA,EAAQ,kBAAA;EAAA;;;;EAKR,cAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DoB,yBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,+BAAA,GAA+B,OAAA,CAAA,qBAAA;SAgCS,SAAA;AAAA,GAAS,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/structured_chat/index.ts"],"mappings":";;;;;;;;;;;;;UAyCiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,gBAAgB;;;;;;KAON,2BAA2B,SAAS;;;;;cAMnC,4BAA4B;SAChC;EAIP;EAEA,YAAY,OAAO;EAMnB;EAIA;EAIA;EAIA;;;;;;SASO,cAAc,OAAO;;;;;;;SAgBrB,uBACL,SAAS;IACP;MACD;;;;;;;;EAmBG,oBAAoB,OAAO,cAAc;;;;;;SAaxC,wBAAwB,OAAO;;;;;;;;;;;SAyB/B,aACL,OAAO,2BACP,OAAO,iCAA8B;;;;;;;;;;SAyChC,gBACL,KAAK,4BACL,OAAO,2BACP,OAAO,iCAAiC,YAAS;;;;;KA2BzC;;EAEV,KAAK;;EAEL,QAAQ,0BAA0B;;;;;EAKlC,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DoB,4BACpB,KACA,OACA,QACA,kBACC,kCAA+B,QAAA;EAgCS,OAAA;oCAgB1C,+CAAA"}

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

@@ -5,9 +5,7 @@ import { StructuredChatOutputParserWithRetries } from "./outputParser.js";
 import { BaseMessagePromptTemplate, BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseLanguageModelInterface, ToolDefinition } from "@langchain/core/language_models/base";
-import * as _$_langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
-
 //#region src/agents/structured_chat/index.d.ts
 /**
  * Interface for arguments used to create a prompt for a
@@ -97,7 +95,9 @@ declare class StructuredChatAgent extends Agent {
  * Params used by the createStructuredChatAgent function.
  */
 type CreateStructuredChatAgentParams = {
-  /** LLM to use as the agent. */llm: BaseLanguageModelInterface; /** Tools this agent has access to. */
+  /** LLM to use as the agent. */
+  llm: BaseLanguageModelInterface;
+  /** Tools this agent has access to. */
   tools: (StructuredToolInterface | ToolDefinition)[];
   /**
    * The prompt to use. Must have input keys for
@@ -166,14 +166,9 @@ type CreateStructuredChatAgentParams = {
  * });
  * ```
  */
-declare function createStructuredChatAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
+declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _$_langchain_core_agents0.AgentAction | _$_langchain_core_agents0.AgentFinish>>;
+}, import("@langchain/core/agents").AgentAction | import("@langchain/core/agents").AgentFinish>>;
 //#endregion
 export { CreateStructuredChatAgentParams, StructuredChatAgent, StructuredChatAgentInput, StructuredChatCreatePromptArgs, createStructuredChatAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/structured_chat/index.ts"],"mappings":";;;;;;;;;;;;;AAyCA;;UAAiB,8BAAA;EAU0B;EARzC,MAAA;EAEA;EAAA,MAAA;EAIA;EAFA,oBAAA;EAIgB;EAFhB,cAAA;EAEyC;EAAzC,aAAA,GAAgB,yBAAA;AAAA;;;;AAalB;KANY,wBAAA,GAA2B,QAAA,CAAS,UAAA;;;;;cAMnC,mBAAA,SAA4B,KAAA;EAAA,OAChC,OAAA,CAAA;EAIP,YAAA;EAEA,WAAA,CAAY,KAAA,EAAO,wBAAA;EAMnB,UAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,SAAA,CAAA;EAIA,KAAA,CAAA;EAkIS;;;;;EAAA,OAzHF,aAAA,CAAc,KAAA,EAAO,uBAAA;EAlCgB;;;;;;EAAA,OAkDrC,sBAAA,CACL,MAAA,GAAS,gBAAA;IACP,SAAA;EAAA,IACD,qCAAA;EAhCH;;;;;;;EAmDM,mBAAA,CAAoB,KAAA,EAAO,SAAA,KAAc,OAAA;EArB7C;;;;;EAAA,OAkCK,uBAAA,CAAwB,KAAA,EAAO,uBAAA;EAA/B;;;;;;;;;;EAAA,OAyBA,YAAA,CACL,KAAA,EAAO,uBAAA,IACP,IAAA,GAAO,8BAAA,GAA8B,kBAAA;EA0CrC;;;;;;;;;EAAA,OADK,eAAA,CACL,GAAA,EAAK,0BAAA,EACL,KAAA,EAAO,uBAAA,IACP,IAAA,GAAO,8BAAA,GAAiC,SAAA,GAAS,mBAAA;AAAA;;;;KA2BzC,+BAAA;EASF,+BAPR,GAAA,EAAK,0BAAA,EAOqB;EAL1B,KAAA,GAAQ,uBAAA,GAA0B,cAAA;EAF7B;;;;EAOL,MAAA,EAAQ,kBAAA;EAAA;;;;EAKR,cAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DoB,yBAAA,CAAA;EACpB,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,+BAAA,GAA+B,OAAA,CAAA,qBAAA;SAgCS,SAAA;AAAA,GAAS,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/structured_chat/index.ts"],"mappings":";;;;;;;;;;;;;UAyCiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,gBAAgB;;;;;;KAON,2BAA2B,SAAS;;;;;cAMnC,4BAA4B;SAChC;EAIP;EAEA,YAAY,OAAO;EAMnB;EAIA;EAIA;EAIA;;;;;;SASO,cAAc,OAAO;;;;;;;SAgBrB,uBACL,SAAS;IACP;MACD;;;;;;;;EAmBG,oBAAoB,OAAO,cAAc;;;;;;SAaxC,wBAAwB,OAAO;;;;;;;;;;;SAyB/B,aACL,OAAO,2BACP,OAAO,iCAA8B;;;;;;;;;;SAyChC,gBACL,KAAK,4BACL,OAAO,2BACP,OAAO,iCAAiC,YAAS;;;;;KA2BzC;;EAEV,KAAK;;EAEL,QAAQ,0BAA0B;;;;;EAKlC,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DoB,4BACpB,KACA,OACA,QACA,kBACC,kCAA+B,QAAA;EAgCS,OAAA;oCAgB1C,+CAAA"}

package/dist/agents/structured_chat/index.js

@@ -137,12 +137,13 @@ var StructuredChatAgent = class StructuredChatAgent extends Agent {
 			llm,
 			toolNames: tools.map((tool) => tool.name)
 		});
+		const chain = new LLMChain({
+			prompt,
+			llm,
+			callbacks: args?.callbacks
+		});
 		return new StructuredChatAgent({
-			llmChain: new LLMChain({
-				prompt,
-				llm,
-				callbacks: args?.callbacks
-			}),
+			llmChain: chain,
 			outputParser,
 			allowedTools: tools.map((t) => t.name)
 		});

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"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.js","names":[],"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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"}

package/dist/agents/structured_chat/outputParser.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_types = require("../types.cjs");
 const require_fix = require("../../output_parsers/fix.cjs");
 const require_prompt = require("./prompt.cjs");
@@ -118,9 +117,10 @@ var StructuredChatOutputParserWithRetries = class StructuredChatOutputParserWith
 	*/
 	static fromLLM(llm, options) {
 		const baseParser = options.baseParser ?? new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });
+		const outputFixingParser = require_fix.OutputFixingParser.fromLLM(llm, baseParser);
 		return new StructuredChatOutputParserWithRetries({
 			baseParser,
-			outputFixingParser: require_fix.OutputFixingParser.fromLLM(llm, baseParser),
+			outputFixingParser,
 			toolNames: options.toolNames
 		});
 	}

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.cjs","names":["AgentActionOutputParser","OutputParserException","AGENT_ACTION_FORMAT_INSTRUCTIONS","FORMAT_INSTRUCTIONS","OutputFixingParser"],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport {\n  AGENT_ACTION_FORMAT_INSTRUCTIONS,\n  FORMAT_INSTRUCTIONS,\n} from \"./prompt.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport class StructuredChatOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\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 and returns an `AgentAction` or `AgentFinish`\n   * object. If an `OutputFixingParser` is provided, it is used for parsing;\n   * otherwise, the base parser is used.\n   * @param text The text to parse.\n   * @param callbacks Optional callbacks for asynchronous operations.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    try {\n      const regex = /```(?:json)?(.*)(```)/gs;\n      const actionMatch = regex.exec(text);\n      if (actionMatch === null) {\n        throw new OutputParserException(\n          `Could not parse an action. The agent action must be within a markdown code block, and \"action\" must be a provided tool or \"Final Answer\"`\n        );\n      }\n      const response = JSON.parse(actionMatch[1].trim());\n      const { action, action_input } = response;\n\n      if (action === \"Final Answer\") {\n        return { returnValues: { output: action_input }, log: text };\n      }\n      return { tool: action, toolInput: action_input || {}, log: text };\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n  baseParser?: StructuredChatOutputParser;\n  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n  toolNames?: string[];\n}\n\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private baseParser: StructuredChatOutputParser;\n\n  private outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n\n  private toolNames: string[] = [];\n\n  constructor(fields: StructuredChatOutputParserArgs) {\n    super(fields);\n    this.toolNames = fields.toolNames ?? this.toolNames;\n    this.baseParser =\n      fields?.baseParser ??\n      new StructuredChatOutputParser({ toolNames: this.toolNames });\n    this.outputFixingParser = fields?.outputFixingParser;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. Throws an `OutputParserException` if the parsing fails.\n   * @param text The text to parse.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(\n    text: string,\n    callbacks?: Callbacks\n  ): Promise<AgentAction | AgentFinish> {\n    if (this.outputFixingParser !== undefined) {\n      return this.outputFixingParser.parse(text, callbacks);\n    }\n    return this.baseParser.parse(text);\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n\n  /**\n   * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n   * `BaseLanguageModel` and options. The options can include a base parser\n   * and tool names.\n   * @param llm A `BaseLanguageModel` instance.\n   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n   * @returns A new `StructuredChatOutputParserWithRetries` instance.\n   */\n  static fromLLM(\n    llm: BaseLanguageModelInterface,\n    options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">\n  ): StructuredChatOutputParserWithRetries {\n    const baseParser =\n      options.baseParser ??\n      new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });\n    const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);\n    return new StructuredChatOutputParserWithRetries({\n      baseParser,\n      outputFixingParser,\n      toolNames: options.toolNames,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAAgDA,cAAAA,wBAAwB;CACtE,eAAe;EAAC;EAAa;EAAU;EAAkB;CAEzD;CAEA,YAAY,QAAiC;AAC3C,QAAM,GAAG,UAAU;AACnB,OAAK,YAAY,OAAO;;;;;;;;;;CAW1B,MAAM,MAAM,MAAkD;AAC5D,MAAI;GAEF,MAAM,cAAc,0BAAM,KAAK,KAAK;AACpC,OAAI,gBAAgB,KAClB,OAAM,IAAIC,+BAAAA,sBACR,2IACD;GAGH,MAAM,EAAE,QAAQ,iBADC,KAAK,MAAM,YAAY,GAAG,MAAM,CACR;AAEzC,OAAI,WAAW,eACb,QAAO;IAAE,cAAc,EAAE,QAAQ,cAAc;IAAE,KAAK;IAAM;AAE9D,UAAO;IAAE,MAAM;IAAQ,WAAW,gBAAgB,EAAE;IAAE,KAAK;IAAM;WAC1D,GAAG;AACV,SAAM,IAAIA,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,IAC7C;;;;;;;;CASL,wBAAgC;AAC9B,UAAA,GAAA,wBAAA,gBAAsBC,eAAAA,kCAAkC,YAAY,EAClE,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC;;;;;;;;;;;;;;;;;;;;;AAgCN,IAAa,wCAAb,MAAa,8CAA8CF,cAAAA,wBAAwB;CACjF,eAAe;EAAC;EAAa;EAAU;EAAkB;CAEzD;CAEA;CAEA,YAA8B,EAAE;CAEhC,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO,aAAa,KAAK;AAC1C,OAAK,aACH,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,KAAK,WAAW,CAAC;AAC/D,OAAK,qBAAqB,QAAQ;;;;;;;;CASpC,MAAM,MACJ,MACA,WACoC;AACpC,MAAI,KAAK,uBAAuB,KAAA,EAC9B,QAAO,KAAK,mBAAmB,MAAM,MAAM,UAAU;AAEvD,SAAO,KAAK,WAAW,MAAM,KAAK;;;;;;;CAQpC,wBAAgC;AAC9B,UAAA,GAAA,wBAAA,gBAAsBG,eAAAA,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC;;;;;;;;;;CAWJ,OAAO,QACL,KACA,SACuC;EACvC,MAAM,aACJ,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,QAAQ,aAAa,EAAE,EAAE,CAAC;AAExE,SAAO,IAAI,sCAAsC;GAC/C;GACA,oBAHyBC,YAAAA,mBAAmB,QAAQ,KAAK,WAGvC;GAClB,WAAW,QAAQ;GACpB,CAAC"}
+{"version":3,"file":"outputParser.cjs","names":["AgentActionOutputParser","OutputParserException","AGENT_ACTION_FORMAT_INSTRUCTIONS","FORMAT_INSTRUCTIONS","OutputFixingParser"],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport {\n  AGENT_ACTION_FORMAT_INSTRUCTIONS,\n  FORMAT_INSTRUCTIONS,\n} from \"./prompt.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport class StructuredChatOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\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 and returns an `AgentAction` or `AgentFinish`\n   * object. If an `OutputFixingParser` is provided, it is used for parsing;\n   * otherwise, the base parser is used.\n   * @param text The text to parse.\n   * @param callbacks Optional callbacks for asynchronous operations.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    try {\n      const regex = /```(?:json)?(.*)(```)/gs;\n      const actionMatch = regex.exec(text);\n      if (actionMatch === null) {\n        throw new OutputParserException(\n          `Could not parse an action. The agent action must be within a markdown code block, and \"action\" must be a provided tool or \"Final Answer\"`\n        );\n      }\n      const response = JSON.parse(actionMatch[1].trim());\n      const { action, action_input } = response;\n\n      if (action === \"Final Answer\") {\n        return { returnValues: { output: action_input }, log: text };\n      }\n      return { tool: action, toolInput: action_input || {}, log: text };\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n  baseParser?: StructuredChatOutputParser;\n  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n  toolNames?: string[];\n}\n\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private baseParser: StructuredChatOutputParser;\n\n  private outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n\n  private toolNames: string[] = [];\n\n  constructor(fields: StructuredChatOutputParserArgs) {\n    super(fields);\n    this.toolNames = fields.toolNames ?? this.toolNames;\n    this.baseParser =\n      fields?.baseParser ??\n      new StructuredChatOutputParser({ toolNames: this.toolNames });\n    this.outputFixingParser = fields?.outputFixingParser;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. Throws an `OutputParserException` if the parsing fails.\n   * @param text The text to parse.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(\n    text: string,\n    callbacks?: Callbacks\n  ): Promise<AgentAction | AgentFinish> {\n    if (this.outputFixingParser !== undefined) {\n      return this.outputFixingParser.parse(text, callbacks);\n    }\n    return this.baseParser.parse(text);\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n\n  /**\n   * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n   * `BaseLanguageModel` and options. The options can include a base parser\n   * and tool names.\n   * @param llm A `BaseLanguageModel` instance.\n   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n   * @returns A new `StructuredChatOutputParserWithRetries` instance.\n   */\n  static fromLLM(\n    llm: BaseLanguageModelInterface,\n    options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">\n  ): StructuredChatOutputParserWithRetries {\n    const baseParser =\n      options.baseParser ??\n      new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });\n    const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);\n    return new StructuredChatOutputParserWithRetries({\n      baseParser,\n      outputFixingParser,\n      toolNames: options.toolNames,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAAgDA,cAAAA,wBAAwB;CACtE,eAAe;EAAC;EAAa;EAAU;CAAiB;CAExD;CAEA,YAAY,QAAiC;EAC3C,MAAM,GAAG,SAAS;EAClB,KAAK,YAAY,OAAO;CAC1B;;;;;;;;;CAUA,MAAM,MAAM,MAAkD;EAC5D,IAAI;GAEF,MAAM,cAAc,0BAAM,KAAK,IAAI;GACnC,IAAI,gBAAgB,MAClB,MAAM,IAAIC,+BAAAA,sBACR,0IACF;GAGF,MAAM,EAAE,QAAQ,iBADC,KAAK,MAAM,YAAY,EAAE,CAAC,KAAK,CACR;GAExC,IAAI,WAAW,gBACb,OAAO;IAAE,cAAc,EAAE,QAAQ,aAAa;IAAG,KAAK;GAAK;GAE7D,OAAO;IAAE,MAAM;IAAQ,WAAW,gBAAgB,CAAC;IAAG,KAAK;GAAK;EAClE,SAAS,GAAG;GACV,MAAM,IAAIA,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,GAC9C;EACF;CACF;;;;;;CAOA,wBAAgC;EAC9B,QAAA,GAAA,wBAAA,eAAA,CAAsBC,eAAAA,kCAAkC,YAAY,EAClE,YAAY,KAAK,UAAU,KAAK,IAAI,EACtC,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,wCAAb,MAAa,8CAA8CF,cAAAA,wBAAwB;CACjF,eAAe;EAAC;EAAa;EAAU;CAAiB;CAExD;CAEA;CAEA,YAA8B,CAAC;CAE/B,YAAY,QAAwC;EAClD,MAAM,MAAM;EACZ,KAAK,YAAY,OAAO,aAAa,KAAK;EAC1C,KAAK,aACH,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,KAAK,UAAU,CAAC;EAC9D,KAAK,qBAAqB,QAAQ;CACpC;;;;;;;CAQA,MAAM,MACJ,MACA,WACoC;EACpC,IAAI,KAAK,uBAAuB,KAAA,GAC9B,OAAO,KAAK,mBAAmB,MAAM,MAAM,SAAS;EAEtD,OAAO,KAAK,WAAW,MAAM,IAAI;CACnC;;;;;;CAOA,wBAAgC;EAC9B,QAAA,GAAA,wBAAA,eAAA,CAAsBG,eAAAA,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,IAAI,EACtC,CAAC;CACH;;;;;;;;;CAUA,OAAO,QACL,KACA,SACuC;EACvC,MAAM,aACJ,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,QAAQ,aAAa,CAAC,EAAE,CAAC;EACvE,MAAM,qBAAqBC,YAAAA,mBAAmB,QAAQ,KAAK,UAAU;EACrE,OAAO,IAAI,sCAAsC;GAC/C;GACA;GACA,WAAW,QAAQ;EACrB,CAAC;CACH;AACF"}

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

@@ -3,7 +3,6 @@ import { OutputFixingParser } from "../../output_parsers/fix.cjs";
 import { AgentAction, AgentFinish } from "@langchain/core/agents";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { Callbacks } from "@langchain/core/callbacks/manager";
-
 //#region src/agents/structured_chat/outputParser.d.ts
 /**
  * A class that provides a custom implementation for parsing the output of

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.cts","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"mappings":";;;;;;;;;AAkBA;;;;cAAa,0BAAA,SAAmC,uBAAA;EAC9C,YAAA;EAAA,QAEQ,SAAA;EAER,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA;EAJtB;;;;;;;;EAiBM,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;EAAA;;;;AAuCnD;EAXE,qBAAA,CAAA;AAAA;;;;;UAWe,8BAAA;EACf,UAAA,GAAa,0BAAA;EACb,kBAAA,GAAqB,kBAAA,CAAmB,WAAA,GAAc,WAAA;EACtD,SAAA;AAAA;;;;;;;AAqBF;;;;;;;;;;;;cAAa,qCAAA,SAA8C,uBAAA;EACzD,YAAA;EAAA,QAEQ,UAAA;EAAA,QAEA,kBAAA;EAAA,QAEA,SAAA;EAER,WAAA,CAAY,MAAA,EAAQ,8BAAA;EAJZ;;;;;;EAmBF,KAAA,CACJ,IAAA,UACA,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,WAAA,GAAc,WAAA;EADX;;;;;EAad,qBAAA,CAAA;EAcO;;;;;;;;EAAA,OAAA,OAAA,CACL,GAAA,EAAK,0BAAA,EACL,OAAA,EAAS,IAAA,CAAK,8BAAA,0BACb,qCAAA;AAAA"}
+{"version":3,"file":"outputParser.d.cts","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"mappings":";;;;;;;;;;;;cAkBa,mCAAmC;EAC9C;UAEQ;EAER,YAAY;IAAU;;;;;;;;;;EAahB,MAAM,eAAe,QAAQ,cAAc;;;;;;EA4BjD;;;;;;UAWe;EACf,aAAa;EACb,qBAAqB,mBAAmB,cAAc;EACtD;;;;;;;;;;;;;;;;;;;;cAqBW,8CAA8C;EACzD;UAEQ;UAEA;UAEA;EAER,YAAY,QAAQ;;;;;;;EAed,MACJ,cACA,YAAY,YACX,QAAQ,cAAc;;;;;;EAYzB;;;;;;;;;SAcO,QACL,KAAK,4BACL,SAAS,KAAK,wDACb"}

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

@@ -3,7 +3,6 @@ import { OutputFixingParser } from "../../output_parsers/fix.js";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { Callbacks } from "@langchain/core/callbacks/manager";
 import { AgentAction, AgentFinish } from "@langchain/core/agents";
-
 //#region src/agents/structured_chat/outputParser.d.ts
 /**
  * A class that provides a custom implementation for parsing the output of

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.ts","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"mappings":";;;;;;;;;AAkBA;;;;cAAa,0BAAA,SAAmC,uBAAA;EAC9C,YAAA;EAAA,QAEQ,SAAA;EAER,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA;EAJtB;;;;;;;;EAiBM,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;EAAA;;;;AAuCnD;EAXE,qBAAA,CAAA;AAAA;;;;;UAWe,8BAAA;EACf,UAAA,GAAa,0BAAA;EACb,kBAAA,GAAqB,kBAAA,CAAmB,WAAA,GAAc,WAAA;EACtD,SAAA;AAAA;;;;;;;AAqBF;;;;;;;;;;;;cAAa,qCAAA,SAA8C,uBAAA;EACzD,YAAA;EAAA,QAEQ,UAAA;EAAA,QAEA,kBAAA;EAAA,QAEA,SAAA;EAER,WAAA,CAAY,MAAA,EAAQ,8BAAA;EAJZ;;;;;;EAmBF,KAAA,CACJ,IAAA,UACA,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,WAAA,GAAc,WAAA;EADX;;;;;EAad,qBAAA,CAAA;EAcO;;;;;;;;EAAA,OAAA,OAAA,CACL,GAAA,EAAK,0BAAA,EACL,OAAA,EAAS,IAAA,CAAK,8BAAA,0BACb,qCAAA;AAAA"}
+{"version":3,"file":"outputParser.d.ts","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"mappings":";;;;;;;;;;;;cAkBa,mCAAmC;EAC9C;UAEQ;EAER,YAAY;IAAU;;;;;;;;;;EAahB,MAAM,eAAe,QAAQ,cAAc;;;;;;EA4BjD;;;;;;UAWe;EACf,aAAa;EACb,qBAAqB,mBAAmB,cAAc;EACtD;;;;;;;;;;;;;;;;;;;;cAqBW,8CAA8C;EACzD;UAEQ;UAEA;UAEA;EAER,YAAY,QAAQ;;;;;;;EAed,MACJ,cACA,YAAY,YACX,QAAQ,cAAc;;;;;;EAYzB;;;;;;;;;SAcO,QACL,KAAK,4BACL,SAAS,KAAK,wDACb"}

package/dist/agents/structured_chat/outputParser.js

@@ -117,9 +117,10 @@ var StructuredChatOutputParserWithRetries = class StructuredChatOutputParserWith
 	*/
 	static fromLLM(llm, options) {
 		const baseParser = options.baseParser ?? new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });
+		const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);
 		return new StructuredChatOutputParserWithRetries({
 			baseParser,
-			outputFixingParser: OutputFixingParser.fromLLM(llm, baseParser),
+			outputFixingParser,
 			toolNames: options.toolNames
 		});
 	}

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.js","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport {\n  AGENT_ACTION_FORMAT_INSTRUCTIONS,\n  FORMAT_INSTRUCTIONS,\n} from \"./prompt.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport class StructuredChatOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\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 and returns an `AgentAction` or `AgentFinish`\n   * object. If an `OutputFixingParser` is provided, it is used for parsing;\n   * otherwise, the base parser is used.\n   * @param text The text to parse.\n   * @param callbacks Optional callbacks for asynchronous operations.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    try {\n      const regex = /```(?:json)?(.*)(```)/gs;\n      const actionMatch = regex.exec(text);\n      if (actionMatch === null) {\n        throw new OutputParserException(\n          `Could not parse an action. The agent action must be within a markdown code block, and \"action\" must be a provided tool or \"Final Answer\"`\n        );\n      }\n      const response = JSON.parse(actionMatch[1].trim());\n      const { action, action_input } = response;\n\n      if (action === \"Final Answer\") {\n        return { returnValues: { output: action_input }, log: text };\n      }\n      return { tool: action, toolInput: action_input || {}, log: text };\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n  baseParser?: StructuredChatOutputParser;\n  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n  toolNames?: string[];\n}\n\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private baseParser: StructuredChatOutputParser;\n\n  private outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n\n  private toolNames: string[] = [];\n\n  constructor(fields: StructuredChatOutputParserArgs) {\n    super(fields);\n    this.toolNames = fields.toolNames ?? this.toolNames;\n    this.baseParser =\n      fields?.baseParser ??\n      new StructuredChatOutputParser({ toolNames: this.toolNames });\n    this.outputFixingParser = fields?.outputFixingParser;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. Throws an `OutputParserException` if the parsing fails.\n   * @param text The text to parse.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(\n    text: string,\n    callbacks?: Callbacks\n  ): Promise<AgentAction | AgentFinish> {\n    if (this.outputFixingParser !== undefined) {\n      return this.outputFixingParser.parse(text, callbacks);\n    }\n    return this.baseParser.parse(text);\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n\n  /**\n   * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n   * `BaseLanguageModel` and options. The options can include a base parser\n   * and tool names.\n   * @param llm A `BaseLanguageModel` instance.\n   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n   * @returns A new `StructuredChatOutputParserWithRetries` instance.\n   */\n  static fromLLM(\n    llm: BaseLanguageModelInterface,\n    options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">\n  ): StructuredChatOutputParserWithRetries {\n    const baseParser =\n      options.baseParser ??\n      new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });\n    const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);\n    return new StructuredChatOutputParserWithRetries({\n      baseParser,\n      outputFixingParser,\n      toolNames: options.toolNames,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAAgD,wBAAwB;CACtE,eAAe;EAAC;EAAa;EAAU;EAAkB;CAEzD;CAEA,YAAY,QAAiC;AAC3C,QAAM,GAAG,UAAU;AACnB,OAAK,YAAY,OAAO;;;;;;;;;;CAW1B,MAAM,MAAM,MAAkD;AAC5D,MAAI;GAEF,MAAM,cAAc,0BAAM,KAAK,KAAK;AACpC,OAAI,gBAAgB,KAClB,OAAM,IAAI,sBACR,2IACD;GAGH,MAAM,EAAE,QAAQ,iBADC,KAAK,MAAM,YAAY,GAAG,MAAM,CACR;AAEzC,OAAI,WAAW,eACb,QAAO;IAAE,cAAc,EAAE,QAAQ,cAAc;IAAE,KAAK;IAAM;AAE9D,UAAO;IAAE,MAAM;IAAQ,WAAW,gBAAgB,EAAE;IAAE,KAAK;IAAM;WAC1D,GAAG;AACV,SAAM,IAAI,sBACR,2BAA2B,KAAK,YAAY,IAC7C;;;;;;;;CASL,wBAAgC;AAC9B,SAAO,eAAe,kCAAkC,YAAY,EAClE,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC;;;;;;;;;;;;;;;;;;;;;AAgCN,IAAa,wCAAb,MAAa,8CAA8C,wBAAwB;CACjF,eAAe;EAAC;EAAa;EAAU;EAAkB;CAEzD;CAEA;CAEA,YAA8B,EAAE;CAEhC,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO,aAAa,KAAK;AAC1C,OAAK,aACH,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,KAAK,WAAW,CAAC;AAC/D,OAAK,qBAAqB,QAAQ;;;;;;;;CASpC,MAAM,MACJ,MACA,WACoC;AACpC,MAAI,KAAK,uBAAuB,KAAA,EAC9B,QAAO,KAAK,mBAAmB,MAAM,MAAM,UAAU;AAEvD,SAAO,KAAK,WAAW,MAAM,KAAK;;;;;;;CAQpC,wBAAgC;AAC9B,SAAO,eAAe,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,KAAK,EACtC,CAAC;;;;;;;;;;CAWJ,OAAO,QACL,KACA,SACuC;EACvC,MAAM,aACJ,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,QAAQ,aAAa,EAAE,EAAE,CAAC;AAExE,SAAO,IAAI,sCAAsC;GAC/C;GACA,oBAHyB,mBAAmB,QAAQ,KAAK,WAGvC;GAClB,WAAW,QAAQ;GACpB,CAAC"}
+{"version":3,"file":"outputParser.js","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { renderTemplate } from \"@langchain/core/prompts\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport {\n  AGENT_ACTION_FORMAT_INSTRUCTIONS,\n  FORMAT_INSTRUCTIONS,\n} from \"./prompt.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport class StructuredChatOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\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 and returns an `AgentAction` or `AgentFinish`\n   * object. If an `OutputFixingParser` is provided, it is used for parsing;\n   * otherwise, the base parser is used.\n   * @param text The text to parse.\n   * @param callbacks Optional callbacks for asynchronous operations.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(text: string): Promise<AgentAction | AgentFinish> {\n    try {\n      const regex = /```(?:json)?(.*)(```)/gs;\n      const actionMatch = regex.exec(text);\n      if (actionMatch === null) {\n        throw new OutputParserException(\n          `Could not parse an action. The agent action must be within a markdown code block, and \"action\" must be a provided tool or \"Final Answer\"`\n        );\n      }\n      const response = JSON.parse(actionMatch[1].trim());\n      const { action, action_input } = response;\n\n      if (action === \"Final Answer\") {\n        return { returnValues: { output: action_input }, log: text };\n      }\n      return { tool: action, toolInput: action_input || {}, log: text };\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(AGENT_ACTION_FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n}\n\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n  baseParser?: StructuredChatOutputParser;\n  outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n  toolNames?: string[];\n}\n\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"structured_chat\"];\n\n  private baseParser: StructuredChatOutputParser;\n\n  private outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n\n  private toolNames: string[] = [];\n\n  constructor(fields: StructuredChatOutputParserArgs) {\n    super(fields);\n    this.toolNames = fields.toolNames ?? this.toolNames;\n    this.baseParser =\n      fields?.baseParser ??\n      new StructuredChatOutputParser({ toolNames: this.toolNames });\n    this.outputFixingParser = fields?.outputFixingParser;\n  }\n\n  /**\n   * Parses the given text and returns an `AgentAction` or `AgentFinish`\n   * object. Throws an `OutputParserException` if the parsing fails.\n   * @param text The text to parse.\n   * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n   */\n  async parse(\n    text: string,\n    callbacks?: Callbacks\n  ): Promise<AgentAction | AgentFinish> {\n    if (this.outputFixingParser !== undefined) {\n      return this.outputFixingParser.parse(text, callbacks);\n    }\n    return this.baseParser.parse(text);\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the StructuredChatAgent.\n   * @returns A string representing the format instructions.\n   */\n  getFormatInstructions(): string {\n    return renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: this.toolNames.join(\", \"),\n    });\n  }\n\n  /**\n   * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n   * `BaseLanguageModel` and options. The options can include a base parser\n   * and tool names.\n   * @param llm A `BaseLanguageModel` instance.\n   * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n   * @returns A new `StructuredChatOutputParserWithRetries` instance.\n   */\n  static fromLLM(\n    llm: BaseLanguageModelInterface,\n    options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">\n  ): StructuredChatOutputParserWithRetries {\n    const baseParser =\n      options.baseParser ??\n      new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });\n    const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);\n    return new StructuredChatOutputParserWithRetries({\n      baseParser,\n      outputFixingParser,\n      toolNames: options.toolNames,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAkBA,IAAa,6BAAb,cAAgD,wBAAwB;CACtE,eAAe;EAAC;EAAa;EAAU;CAAiB;CAExD;CAEA,YAAY,QAAiC;EAC3C,MAAM,GAAG,SAAS;EAClB,KAAK,YAAY,OAAO;CAC1B;;;;;;;;;CAUA,MAAM,MAAM,MAAkD;EAC5D,IAAI;GAEF,MAAM,cAAc,0BAAM,KAAK,IAAI;GACnC,IAAI,gBAAgB,MAClB,MAAM,IAAI,sBACR,0IACF;GAGF,MAAM,EAAE,QAAQ,iBADC,KAAK,MAAM,YAAY,EAAE,CAAC,KAAK,CACR;GAExC,IAAI,WAAW,gBACb,OAAO;IAAE,cAAc,EAAE,QAAQ,aAAa;IAAG,KAAK;GAAK;GAE7D,OAAO;IAAE,MAAM;IAAQ,WAAW,gBAAgB,CAAC;IAAG,KAAK;GAAK;EAClE,SAAS,GAAG;GACV,MAAM,IAAI,sBACR,2BAA2B,KAAK,YAAY,GAC9C;EACF;CACF;;;;;;CAOA,wBAAgC;EAC9B,OAAO,eAAe,kCAAkC,YAAY,EAClE,YAAY,KAAK,UAAU,KAAK,IAAI,EACtC,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,wCAAb,MAAa,8CAA8C,wBAAwB;CACjF,eAAe;EAAC;EAAa;EAAU;CAAiB;CAExD;CAEA;CAEA,YAA8B,CAAC;CAE/B,YAAY,QAAwC;EAClD,MAAM,MAAM;EACZ,KAAK,YAAY,OAAO,aAAa,KAAK;EAC1C,KAAK,aACH,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,KAAK,UAAU,CAAC;EAC9D,KAAK,qBAAqB,QAAQ;CACpC;;;;;;;CAQA,MAAM,MACJ,MACA,WACoC;EACpC,IAAI,KAAK,uBAAuB,KAAA,GAC9B,OAAO,KAAK,mBAAmB,MAAM,MAAM,SAAS;EAEtD,OAAO,KAAK,WAAW,MAAM,IAAI;CACnC;;;;;;CAOA,wBAAgC;EAC9B,OAAO,eAAe,qBAAqB,YAAY,EACrD,YAAY,KAAK,UAAU,KAAK,IAAI,EACtC,CAAC;CACH;;;;;;;;;CAUA,OAAO,QACL,KACA,SACuC;EACvC,MAAM,aACJ,QAAQ,cACR,IAAI,2BAA2B,EAAE,WAAW,QAAQ,aAAa,CAAC,EAAE,CAAC;EACvE,MAAM,qBAAqB,mBAAmB,QAAQ,KAAK,UAAU;EACrE,OAAO,IAAI,sCAAsC;GAC/C;GACA;GACA,WAAW,QAAQ;EACrB,CAAC;CACH;AACF"}

package/dist/agents/tool_calling/index.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_tool_calling = require("../format_scratchpad/tool_calling.cjs");
 const require_agent = require("../agent.cjs");
 const require_output_parser = require("./output_parser.cjs");

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["AgentRunnableSequence","RunnablePassthrough","formatToToolMessages","ToolCallingAgentOutputParser"],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\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: LanguageModelLike;\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 tools.\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 * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\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  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;AAeA,SAAS,iBAAiB,GAA0C;CAClE,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,cAC5B,MAAM,YAAY,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2E3B,SAAgB,uBAAuB,EACrC,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,IAAI;AACJ,KAAI,iBAAiB,IAAI,EAAE;AACzB,MAAI,IAAI,cAAc,KAAA,EACpB,OAAM,IAAI,MACR,wFACD;AAEH,mBAAiB,IAAI,UAAU,MAAM;OAErC,kBAAiB;AAmBnB,QAhBcA,cAAAA,sBAAsB,cAClC;EACEC,0BAAAA,oBAAoB,OAAO,EACzB,mBAAmB,UACjBC,qBAAAA,qBAAqB,MAAM,MAAM,EACpC,CAAC;EACF;EACA;EACA,IAAIC,sBAAAA,8BAA8B;EACnC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CAES"}
+{"version":3,"file":"index.cjs","names":["AgentRunnableSequence","RunnablePassthrough","formatToToolMessages","ToolCallingAgentOutputParser"],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\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: LanguageModelLike;\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 tools.\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 * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\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  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;AAeA,SAAS,iBAAiB,GAA0C;CAClE,MAAM,QAAQ;CACd,OACE,OAAO,MAAM,eAAe,cAC5B,MAAM,WAAW,MAAM;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,uBAAuB,EACrC,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,IAAI;CACJ,IAAI,iBAAiB,GAAG,GAAG;EACzB,IAAI,IAAI,cAAc,KAAA,GACpB,MAAM,IAAI,MACR,uFACF;EAEF,iBAAiB,IAAI,UAAU,KAAK;CACtC,OACE,iBAAiB;CAmBnB,OAhBcA,cAAAA,sBAAsB,cAClC;EACEC,0BAAAA,oBAAoB,OAAO,EACzB,mBAAmB,UACjBC,qBAAAA,qBAAqB,MAAM,KAAK,EACpC,CAAC;EACD;EACA;EACA,IAAIC,sBAAAA,6BAA6B;CACnC,GACA;EACE,MAAM;EACN;EACA,cAAc;CAChB,CAES;AACb"}

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

@@ -1,10 +1,8 @@
 import { ToolsAgentStep } from "./output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
-import * as _$_langchain_core_agents0 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
-
 //#region src/agents/tool_calling/index.d.ts
 /**
  * Params used by the createOpenAIToolsAgent function.
@@ -15,8 +13,10 @@ type CreateToolCallingAgentParams = {
    * so must either be an OpenAI model that supports that or a wrapper of
    * a different model that adds in equivalent support.
    */
-  llm: LanguageModelLike; /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  llm: LanguageModelLike;
+  /** 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,
@@ -74,14 +74,9 @@ type CreateToolCallingAgentParams = {
  * );
  * ```
  */
-declare function createToolCallingAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateToolCallingAgentParams): AgentRunnableSequence<{
+declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _$_langchain_core_agents0.AgentFinish | _$_langchain_core_agents0.AgentAction[]>;
+}, import("@langchain/core/agents").AgentFinish | import("@langchain/core/agents").AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"mappings":";;;;;;;;;;;KA0BY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,iBAAA,EAIqB;EAF1B,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAFnC;EAIA,MAAA,EAAQ,kBAAA;EAFR;;;;EAOA,cAAA;AAAA;;;AAqDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,sBAAA,CAAA;EACd,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,qBAAA;SAwBY,cAAA;AAAA,GAAc,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"mappings":";;;;;;;;;KA0BY;;;;;;EAMV,KAAK;;EAEL,OAAO,4BAA4B;;EAEnC,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDc,yBACd,KACA,OACA,QACA,kBACC,+BAA4B;EAwBY,OAAA;oCAc1C,+CAAA"}

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

@@ -3,8 +3,6 @@ import { AgentRunnableSequence } from "../agent.js";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
-import * as _$_langchain_core_agents0 from "@langchain/core/agents";
-
 //#region src/agents/tool_calling/index.d.ts
 /**
  * Params used by the createOpenAIToolsAgent function.
@@ -15,8 +13,10 @@ type CreateToolCallingAgentParams = {
    * so must either be an OpenAI model that supports that or a wrapper of
    * a different model that adds in equivalent support.
    */
-  llm: LanguageModelLike; /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  llm: LanguageModelLike;
+  /** 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,
@@ -74,14 +74,9 @@ type CreateToolCallingAgentParams = {
  * );
  * ```
  */
-declare function createToolCallingAgent({
-  llm,
-  tools,
-  prompt,
-  streamRunnable
-}: CreateToolCallingAgentParams): AgentRunnableSequence<{
+declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _$_langchain_core_agents0.AgentFinish | _$_langchain_core_agents0.AgentAction[]>;
+}, import("@langchain/core/agents").AgentFinish | import("@langchain/core/agents").AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"mappings":";;;;;;;;;;;KA0BY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,iBAAA,EAIqB;EAF1B,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAFnC;EAIA,MAAA,EAAQ,kBAAA;EAFR;;;;EAOA,cAAA;AAAA;;;AAqDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,sBAAA,CAAA;EACd,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,qBAAA;SAwBY,cAAA;AAAA,GAAc,yBAAA,CAAA,WAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"mappings":";;;;;;;;;KA0BY;;;;;;EAMV,KAAK;;EAEL,OAAO,4BAA4B;;EAEnC,QAAQ;;;;;EAKR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDc,yBACd,KACA,OACA,QACA,kBACC,+BAA4B;EAwBY,OAAA;oCAc1C,+CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\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: LanguageModelLike;\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 tools.\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 * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\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  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;AAeA,SAAS,iBAAiB,GAA0C;CAClE,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,cAC5B,MAAM,YAAY,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2E3B,SAAgB,uBAAuB,EACrC,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,IAAI;AACJ,KAAI,iBAAiB,IAAI,EAAE;AACzB,MAAI,IAAI,cAAc,KAAA,EACpB,OAAM,IAAI,MACR,wFACD;AAEH,mBAAiB,IAAI,UAAU,MAAM;OAErC,kBAAiB;AAmBnB,QAhBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjB,qBAAqB,MAAM,MAAM,EACpC,CAAC;EACF;EACA;EACA,IAAI,8BAA8B;EACnC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CAES"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\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: LanguageModelLike;\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 tools.\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 * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\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  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;AAeA,SAAS,iBAAiB,GAA0C;CAClE,MAAM,QAAQ;CACd,OACE,OAAO,MAAM,eAAe,cAC5B,MAAM,WAAW,MAAM;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,uBAAuB,EACrC,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,IAAI;CACJ,IAAI,iBAAiB,GAAG,GAAG;EACzB,IAAI,IAAI,cAAc,KAAA,GACpB,MAAM,IAAI,MACR,uFACF;EAEF,iBAAiB,IAAI,UAAU,KAAK;CACtC,OACE,iBAAiB;CAmBnB,OAhBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjB,qBAAqB,MAAM,KAAK,EACpC,CAAC;EACD;EACA;EACA,IAAI,6BAA6B;CACnC,GACA;EACE,MAAM;EACN;EACA,cAAc;CAChB,CAES;AACb"}

package/dist/agents/tool_calling/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");
@@ -60,5 +59,6 @@ var ToolCallingAgentOutputParser = class extends require_types.AgentMultiActionO
 };
 //#endregion
 exports.ToolCallingAgentOutputParser = ToolCallingAgentOutputParser;
+exports.parseAIMessageToToolAction = parseAIMessageToToolAction;
 
 //# sourceMappingURL=output_parser.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.cjs","names":["OutputParserException","AgentMultiActionOutputParser"],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport {\n  AIMessage,\n  BaseMessage,\n  isBaseMessage,\n} from \"@langchain/core/messages\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n  toolCallId: string;\n  messageLog?: BaseMessage[];\n};\n\nexport type ToolsAgentStep = AgentStep & {\n  action: ToolsAgentAction;\n};\n\nexport function parseAIMessageToToolAction(\n  message: AIMessage\n): ToolsAgentAction[] | AgentFinish {\n  const stringifiedMessageContent =\n    typeof message.content === \"string\"\n      ? message.content\n      : JSON.stringify(message.content);\n  let toolCalls: ToolCall[] = [];\n  if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n    toolCalls = message.tool_calls;\n  } else {\n    if (\n      !message.additional_kwargs.tool_calls ||\n      message.additional_kwargs.tool_calls.length === 0\n    ) {\n      return {\n        returnValues: { output: message.content },\n        log: stringifiedMessageContent,\n      };\n    }\n    // Best effort parsing\n    for (const toolCall of message.additional_kwargs.tool_calls ?? []) {\n      const functionName = toolCall.function?.name;\n      try {\n        const args = JSON.parse(toolCall.function.arguments);\n        toolCalls.push({ name: functionName, args, id: toolCall.id });\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (e: any) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${e}`\n        );\n      }\n    }\n  }\n  return toolCalls.map((toolCall, i) => {\n    const messageLog = i === 0 ? [message] : [];\n    const log = `Invoking \"${toolCall.name}\" with ${JSON.stringify(\n      toolCall.args ?? {}\n    )}\\n${stringifiedMessageContent}`;\n    return {\n      tool: toolCall.name as string,\n      toolInput: toolCall.args,\n      toolCallId: toolCall.id ?? \"\",\n      log,\n      messageLog,\n    };\n  });\n}\n\nexport class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"tool_calling\"];\n\n  static lc_name() {\n    return \"ToolCallingAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `ToolCallingAgentOutputParser 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 parseAIMessageToToolAction(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside ToolCallingAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;AAuBA,SAAgB,2BACd,SACkC;CAClC,MAAM,4BACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,QAAQ;CACrC,IAAI,YAAwB,EAAE;AAC9B,KAAI,QAAQ,eAAe,KAAA,KAAa,QAAQ,WAAW,SAAS,EAClE,aAAY,QAAQ;MACf;AACL,MACE,CAAC,QAAQ,kBAAkB,cAC3B,QAAQ,kBAAkB,WAAW,WAAW,EAEhD,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK;GACN;AAGH,OAAK,MAAM,YAAY,QAAQ,kBAAkB,cAAc,EAAE,EAAE;GACjE,MAAM,eAAe,SAAS,UAAU;AACxC,OAAI;IACF,MAAM,OAAO,KAAK,MAAM,SAAS,SAAS,UAAU;AACpD,cAAU,KAAK;KAAE,MAAM;KAAc;KAAM,IAAI,SAAS;KAAI,CAAC;YAEtD,GAAQ;AACf,UAAM,IAAIA,+BAAAA,sBACR,mEAAmE,KAAK,UACtE,UACD,CAAC,KAAK,IACR;;;;AAIP,QAAO,UAAU,KAAK,UAAU,MAAM;EACpC,MAAM,aAAa,MAAM,IAAI,CAAC,QAAQ,GAAG,EAAE;EAC3C,MAAM,MAAM,aAAa,SAAS,KAAK,SAAS,KAAK,UACnD,SAAS,QAAQ,EAAE,CACpB,CAAC,IAAI;AACN,SAAO;GACL,MAAM,SAAS;GACf,WAAW,SAAS;GACpB,YAAY,SAAS,MAAM;GAC3B;GACA;GACD;GACD;;AAGJ,IAAa,+BAAb,cAAkDC,cAAAA,6BAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;EAAe;CAEtD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAoD;AAC9D,QAAM,IAAI,MACR,wEAAwE,OACzE;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,OAAA,GAAA,yBAAA,eAAoB,YAAY,GAAG,QAAQ,CACtE,QAAO,2BAA2B,YAAY,GAAG,QAAQ;AAE3D,QAAM,IAAI,MACR,kFACD;;CAGH,wBAAgC;AAC9B,QAAM,IAAI,MACR,6EACD"}
+{"version":3,"file":"output_parser.cjs","names":["OutputParserException","AgentMultiActionOutputParser"],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport {\n  AIMessage,\n  BaseMessage,\n  isBaseMessage,\n} from \"@langchain/core/messages\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n  toolCallId: string;\n  messageLog?: BaseMessage[];\n};\n\nexport type ToolsAgentStep = AgentStep & {\n  action: ToolsAgentAction;\n};\n\nexport function parseAIMessageToToolAction(\n  message: AIMessage\n): ToolsAgentAction[] | AgentFinish {\n  const stringifiedMessageContent =\n    typeof message.content === \"string\"\n      ? message.content\n      : JSON.stringify(message.content);\n  let toolCalls: ToolCall[] = [];\n  if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n    toolCalls = message.tool_calls;\n  } else {\n    if (\n      !message.additional_kwargs.tool_calls ||\n      message.additional_kwargs.tool_calls.length === 0\n    ) {\n      return {\n        returnValues: { output: message.content },\n        log: stringifiedMessageContent,\n      };\n    }\n    // Best effort parsing\n    for (const toolCall of message.additional_kwargs.tool_calls ?? []) {\n      const functionName = toolCall.function?.name;\n      try {\n        const args = JSON.parse(toolCall.function.arguments);\n        toolCalls.push({ name: functionName, args, id: toolCall.id });\n        // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (e: any) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${e}`\n        );\n      }\n    }\n  }\n  return toolCalls.map((toolCall, i) => {\n    const messageLog = i === 0 ? [message] : [];\n    const log = `Invoking \"${toolCall.name}\" with ${JSON.stringify(\n      toolCall.args ?? {}\n    )}\\n${stringifiedMessageContent}`;\n    return {\n      tool: toolCall.name as string,\n      toolInput: toolCall.args,\n      toolCallId: toolCall.id ?? \"\",\n      log,\n      messageLog,\n    };\n  });\n}\n\nexport class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"tool_calling\"];\n\n  static lc_name() {\n    return \"ToolCallingAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `ToolCallingAgentOutputParser 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 parseAIMessageToToolAction(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside ToolCallingAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;AAuBA,SAAgB,2BACd,SACkC;CAClC,MAAM,4BACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,OAAO;CACpC,IAAI,YAAwB,CAAC;CAC7B,IAAI,QAAQ,eAAe,KAAA,KAAa,QAAQ,WAAW,SAAS,GAClE,YAAY,QAAQ;MACf;EACL,IACE,CAAC,QAAQ,kBAAkB,cAC3B,QAAQ,kBAAkB,WAAW,WAAW,GAEhD,OAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAQ;GACxC,KAAK;EACP;EAGF,KAAK,MAAM,YAAY,QAAQ,kBAAkB,cAAc,CAAC,GAAG;GACjE,MAAM,eAAe,SAAS,UAAU;GACxC,IAAI;IACF,MAAM,OAAO,KAAK,MAAM,SAAS,SAAS,SAAS;IACnD,UAAU,KAAK;KAAE,MAAM;KAAc;KAAM,IAAI,SAAS;IAAG,CAAC;GAE9D,SAAS,GAAQ;IACf,MAAM,IAAIA,+BAAAA,sBACR,mEAAmE,KAAK,UACtE,SACF,EAAE,KAAK,GACT;GACF;EACF;CACF;CACA,OAAO,UAAU,KAAK,UAAU,MAAM;EACpC,MAAM,aAAa,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC;EAC1C,MAAM,MAAM,aAAa,SAAS,KAAK,SAAS,KAAK,UACnD,SAAS,QAAQ,CAAC,CACpB,EAAE,IAAI;EACN,OAAO;GACL,MAAM,SAAS;GACf,WAAW,SAAS;GACpB,YAAY,SAAS,MAAM;GAC3B;GACA;EACF;CACF,CAAC;AACH;AAEA,IAAa,+BAAb,cAAkDC,cAAAA,6BAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;CAAc;CAErD,OAAO,UAAU;EACf,OAAO;CACT;CAEA,MAAM,MAAM,MAAoD;EAC9D,MAAM,IAAI,MACR,wEAAwE,MAC1E;CACF;CAEA,MAAM,YAAY,aAA+B;EAC/C,IAAI,aAAa,YAAY,OAAA,GAAA,yBAAA,cAAA,CAAoB,YAAY,EAAE,CAAC,OAAO,GACrE,OAAO,2BAA2B,YAAY,EAAE,CAAC,OAAO;EAE1D,MAAM,IAAI,MACR,iFACF;CACF;CAEA,wBAAgC;EAC9B,MAAM,IAAI,MACR,4EACF;CACF;AACF"}

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

@@ -1,7 +1,7 @@
+import "../types.cjs";
 import { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";
 import { BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration } from "@langchain/core/outputs";
-
 //#region src/agents/tool_calling/output_parser.d.ts
 /**
  * Type that represents an agent action with an optional message log.

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"mappings":";;;;;;;AAcA;KAAY,gBAAA,GAAmB,WAAA;EAC7B,UAAA;EACA,UAAA,GAAa,WAAA;AAAA;AAAA,KAGH,cAAA,GAAiB,SAAA;EAC3B,MAAA,EAAQ,gBAAA;AAAA"}
+{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"mappings":";;;;;;;;KAcY,mBAAmB;EAC7B;EACA,aAAa;;KAGH,iBAAiB;EAC3B,QAAQ"}

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

@@ -1,7 +1,7 @@
+import "../types.js";
 import { AIMessage, BaseMessage } from "@langchain/core/messages";
 import { ChatGeneration } from "@langchain/core/outputs";
 import { AgentAction, AgentFinish, AgentStep } from "@langchain/core/agents";
-
 //#region src/agents/tool_calling/output_parser.d.ts
 /**
  * Type that represents an agent action with an optional message log.

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"mappings":";;;;;;;AAcA;KAAY,gBAAA,GAAmB,WAAA;EAC7B,UAAA;EACA,UAAA,GAAa,WAAA;AAAA;AAAA,KAGH,cAAA,GAAiB,SAAA;EAC3B,MAAA,EAAQ,gBAAA;AAAA"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"mappings":";;;;;;;;KAcY,mBAAmB;EAC7B;EACA,aAAa;;KAGH,iBAAiB;EAC3B,QAAQ"}

package/dist/agents/tool_calling/output_parser.js

@@ -58,6 +58,6 @@ var ToolCallingAgentOutputParser = class extends AgentMultiActionOutputParser {
 	}
 };
 //#endregion
-export { ToolCallingAgentOutputParser };
+export { ToolCallingAgentOutputParser, parseAIMessageToToolAction };
 
 //# sourceMappingURL=output_parser.js.map