@langchain/classic 1.0.17 → 1.0.18

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["Agent","input: ZeroShotAgentInput","fields?: OutputParserArgs","ZeroShotAgentOutputParser","tools: ToolInterface[]","args?: ZeroShotCreatePromptArgs","PREFIX","SUFFIX","FORMAT_INSTRUCTIONS","PromptTemplate","llm: BaseLanguageModelInterface","args?: ZeroShotCreatePromptArgs & AgentArgs","LLMChain","data: SerializedZeroShotAgent & {\n      llm?: BaseLanguageModelInterface;\n      tools?: ToolInterface[];\n    }","deserializeHelper","args: SerializedFromLLMAndTools","llm","tools"],"sources":["../../../src/agents/mrkl/index.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate, renderTemplate } from \"@langchain/core/prompts\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { deserializeHelper } from \"../helpers.js\";\nimport {\n  AgentInput,\n  SerializedFromLLMAndTools,\n  SerializedZeroShotAgent,\n} from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\n\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\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  /** List of input variables the final prompt will expect. */\n  inputVariables?: string[];\n}\n\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport class ZeroShotAgent extends Agent {\n  static lc_name() {\n    return \"ZeroShotAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  declare ToolType: ToolInterface;\n\n  constructor(input: ZeroShotAgentInput) {\n    const outputParser =\n      input?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"zero-shot-react-description\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  /**\n   * Returns the default output parser for the ZeroShotAgent.\n   * @param fields Optional arguments for the output parser.\n   * @returns An instance of ZeroShotAgentOutputParser.\n   */\n  static getDefaultOutputParser(fields?: OutputParserArgs) {\n    return new ZeroShotAgentOutputParser(fields);\n  }\n\n  /**\n   * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n   * does not have a description.\n   * @param tools List of tools to validate.\n   */\n  static validateTools(tools: ToolInterface[]) {\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   * Create prompt in the style of the zero shot 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   */\n  static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      inputVariables = [\"input\", \"agent_scratchpad\"],\n    } = args ?? {};\n    const toolStrings = tools\n      .map((tool) => `${tool.name}: ${tool.description}`)\n      .join(\"\\n\");\n\n    const toolNames = tools.map((tool) => `\"${tool.name}\"`).join(\", \");\n\n    const formatInstructions = renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: toolNames,\n    });\n\n    const template = [prefix, toolStrings, formatInstructions, suffix].join(\n      \"\\n\\n\"\n    );\n\n    return new PromptTemplate({\n      template,\n      inputVariables,\n    });\n  }\n\n  /**\n   * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n   * @param llm The Large Language Model to use.\n   * @param tools The tools for the agent to use.\n   * @param args Optional arguments for creating the agent.\n   * @returns A new instance of ZeroShotAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: ToolInterface[],\n    args?: ZeroShotCreatePromptArgs & AgentArgs\n  ) {\n    ZeroShotAgent.validateTools(tools);\n    const prompt = ZeroShotAgent.createPrompt(tools, args);\n    const outputParser =\n      args?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks ?? args?.callbackManager,\n    });\n\n    return new ZeroShotAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      outputParser,\n    });\n  }\n\n  static async deserialize(\n    data: SerializedZeroShotAgent & {\n      llm?: BaseLanguageModelInterface;\n      tools?: ToolInterface[];\n    }\n  ): Promise<ZeroShotAgent> {\n    const { llm, tools, ...rest } = data;\n    return deserializeHelper(\n      llm,\n      tools,\n      rest,\n      (\n        llm: BaseLanguageModelInterface,\n        tools: ToolInterface[],\n        args: SerializedFromLLMAndTools\n      ) =>\n        ZeroShotAgent.fromLLMAndTools(llm, tools, {\n          prefix: args.prefix,\n          suffix: args.suffix,\n          inputVariables: args.input_variables,\n        }),\n      (args) => new ZeroShotAgent(args)\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,gBAAb,MAAa,sBAAsBA,oBAAM;CACvC,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAU;CAAO;CAI9C,YAAYC,OAA2B;EACrC,MAAM,eACJ,OAAO,gBAAgB,cAAc,wBAAwB;EAC/D,MAAM;GAAE,GAAG;GAAO;EAAc,EAAC;CAClC;CAED,aAAa;AACX,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO;CACR;CAED,YAAY;AACV,SAAO;CACR;;;;;;CAOD,OAAO,uBAAuBC,QAA2B;AACvD,SAAO,IAAIC,+CAA0B;CACtC;;;;;;CAOD,OAAO,cAAcC,OAAwB;EAC3C,MAAM,sBAAsB,MAAM,KAAK,CAAC,SAAS,CAAC,KAAK,YAAY;AACnE,MAAI,qBAAqB;GACvB,MAAM,MACJ,CAAC,WAAW,EAAE,oBAAoB,KAAK,uEAAuB,CACZ;AACpD,SAAM,IAAI,MAAM;EACjB;CACF;;;;;;;;;;CAWD,OAAO,aAAaA,OAAwBC,MAAiC;EAC3E,MAAM,EACJ,SAASC,uBACT,SAASC,uBACT,iBAAiB,CAAC,SAAS,kBAAmB,GAC/C,GAAG,QAAQ,CAAE;EACd,MAAM,cAAc,MACjB,IAAI,CAAC,SAAS,GAAG,KAAK,KAAK,EAAE,EAAE,KAAK,aAAa,CAAC,CAClD,KAAK,KAAK;EAEb,MAAM,YAAY,MAAM,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;EAElE,MAAM,kEAAoCC,oCAAqB,YAAY,EACzE,YAAY,UACb,EAAC;EAEF,MAAM,WAAW;GAAC;GAAQ;GAAa;GAAoB;EAAO,EAAC,KACjE,OACD;AAED,SAAO,IAAIC,wCAAe;GACxB;GACA;EACD;CACF;;;;;;;;CASD,OAAO,gBACLC,KACAN,OACAO,MACA;EACA,cAAc,cAAc,MAAM;EAClC,MAAM,SAAS,cAAc,aAAa,OAAO,KAAK;EACtD,MAAM,eACJ,MAAM,gBAAgB,cAAc,wBAAwB;EAC9D,MAAM,QAAQ,IAAIC,2BAAS;GACzB;GACA;GACA,WAAW,MAAM,aAAa,MAAM;EACrC;AAED,SAAO,IAAI,cAAc;GACvB,UAAU;GACV,cAAc,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK;GACtC;EACD;CACF;CAED,aAAa,YACXC,MAIwB;EACxB,MAAM,EAAE,KAAK,MAAO,GAAG,MAAM,GAAG;AAChC,SAAOC,kCACL,KACA,OACA,MACA,CACEJ,OACAN,SACAW,SAEA,cAAc,gBAAgBC,OAAKC,SAAO;GACxC,QAAQ,KAAK;GACb,QAAQ,KAAK;GACb,gBAAgB,KAAK;EACtB,EAAC,EACJ,CAAC,SAAS,IAAI,cAAc,MAC7B;CACF;AACF"}
+{"version":3,"file":"index.cjs","names":["Agent","ZeroShotAgentOutputParser","PREFIX","SUFFIX","PromptTemplate","FORMAT_INSTRUCTIONS","LLMChain","deserializeHelper"],"sources":["../../../src/agents/mrkl/index.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate, renderTemplate } from \"@langchain/core/prompts\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { deserializeHelper } from \"../helpers.js\";\nimport {\n  AgentInput,\n  SerializedFromLLMAndTools,\n  SerializedZeroShotAgent,\n} from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\n\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\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  /** List of input variables the final prompt will expect. */\n  inputVariables?: string[];\n}\n\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport class ZeroShotAgent extends Agent {\n  static lc_name() {\n    return \"ZeroShotAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  declare ToolType: ToolInterface;\n\n  constructor(input: ZeroShotAgentInput) {\n    const outputParser =\n      input?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"zero-shot-react-description\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  /**\n   * Returns the default output parser for the ZeroShotAgent.\n   * @param fields Optional arguments for the output parser.\n   * @returns An instance of ZeroShotAgentOutputParser.\n   */\n  static getDefaultOutputParser(fields?: OutputParserArgs) {\n    return new ZeroShotAgentOutputParser(fields);\n  }\n\n  /**\n   * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n   * does not have a description.\n   * @param tools List of tools to validate.\n   */\n  static validateTools(tools: ToolInterface[]) {\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   * Create prompt in the style of the zero shot 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   */\n  static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      inputVariables = [\"input\", \"agent_scratchpad\"],\n    } = args ?? {};\n    const toolStrings = tools\n      .map((tool) => `${tool.name}: ${tool.description}`)\n      .join(\"\\n\");\n\n    const toolNames = tools.map((tool) => `\"${tool.name}\"`).join(\", \");\n\n    const formatInstructions = renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: toolNames,\n    });\n\n    const template = [prefix, toolStrings, formatInstructions, suffix].join(\n      \"\\n\\n\"\n    );\n\n    return new PromptTemplate({\n      template,\n      inputVariables,\n    });\n  }\n\n  /**\n   * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n   * @param llm The Large Language Model to use.\n   * @param tools The tools for the agent to use.\n   * @param args Optional arguments for creating the agent.\n   * @returns A new instance of ZeroShotAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: ToolInterface[],\n    args?: ZeroShotCreatePromptArgs & AgentArgs\n  ) {\n    ZeroShotAgent.validateTools(tools);\n    const prompt = ZeroShotAgent.createPrompt(tools, args);\n    const outputParser =\n      args?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks ?? args?.callbackManager,\n    });\n\n    return new ZeroShotAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      outputParser,\n    });\n  }\n\n  static async deserialize(\n    data: SerializedZeroShotAgent & {\n      llm?: BaseLanguageModelInterface;\n      tools?: ToolInterface[];\n    }\n  ): Promise<ZeroShotAgent> {\n    const { llm, tools, ...rest } = data;\n    return deserializeHelper(\n      llm,\n      tools,\n      rest,\n      (\n        llm: BaseLanguageModelInterface,\n        tools: ToolInterface[],\n        args: SerializedFromLLMAndTools\n      ) =>\n        ZeroShotAgent.fromLLMAndTools(llm, tools, {\n          prefix: args.prefix,\n          suffix: args.suffix,\n          inputVariables: args.input_variables,\n        }),\n      (args) => new ZeroShotAgent(args)\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,gBAAb,MAAa,sBAAsBA,oBAAM;CACvC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAU;EAAO;CAI9C,YAAY,OAA2B;EACrC,MAAM,eACJ,OAAO,gBAAgB,cAAc,wBAAwB;AAC/D,QAAM;GAAE,GAAG;GAAO;GAAc,CAAC;;CAGnC,aAAa;AACX,SAAO;;CAGT,oBAAoB;AAClB,SAAO;;CAGT,YAAY;AACV,SAAO;;;;;;;CAQT,OAAO,uBAAuB,QAA2B;AACvD,SAAO,IAAIC,+CAA0B,OAAO;;;;;;;CAQ9C,OAAO,cAAc,OAAwB;EAC3C,MAAM,sBAAsB,MAAM,MAAM,SAAS,CAAC,KAAK,YAAY;AACnE,MAAI,qBAAqB;GACvB,MAAM,MACJ,cAAc,oBAAoB,KAAK;AAEzC,SAAM,IAAI,MAAM,IAAI;;;;;;;;;;;;CAaxB,OAAO,aAAa,OAAwB,MAAiC;EAC3E,MAAM,EACJ,SAASC,uBACT,SAASC,uBACT,iBAAiB,CAAC,SAAS,mBAAmB,KAC5C,QAAQ,EAAE;AAed,SAAO,IAAIC,uCAAe;GACxB,UALe;IAAC;IAVE,MACjB,KAAK,SAAS,GAAG,KAAK,KAAK,IAAI,KAAK,cAAc,CAClD,KAAK,KAAK;gDAI6BC,oCAAqB,YAAY,EACzE,YAHgB,MAAM,KAAK,SAAS,IAAI,KAAK,KAAK,GAAG,CAAC,KAAK,KAAK,EAIjE,CAAC;IAEyD;IAAO,CAAC,KACjE,OACD;GAIC;GACD,CAAC;;;;;;;;;CAUJ,OAAO,gBACL,KACA,OACA,MACA;AACA,gBAAc,cAAc,MAAM;EAClC,MAAM,SAAS,cAAc,aAAa,OAAO,KAAK;EACtD,MAAM,eACJ,MAAM,gBAAgB,cAAc,wBAAwB;AAO9D,SAAO,IAAI,cAAc;GACvB,UAPY,IAAIC,2BAAS;IACzB;IACA;IACA,WAAW,MAAM,aAAa,MAAM;IACrC,CAAC;GAIA,cAAc,MAAM,KAAK,MAAM,EAAE,KAAK;GACtC;GACD,CAAC;;CAGJ,aAAa,YACX,MAIwB;EACxB,MAAM,EAAE,KAAK,OAAO,GAAG,SAAS;AAChC,SAAOC,kCACL,KACA,OACA,OAEE,KACA,OACA,SAEA,cAAc,gBAAgB,KAAK,OAAO;GACxC,QAAQ,KAAK;GACb,QAAQ,KAAK;GACb,gBAAgB,KAAK;GACtB,CAAC,GACH,SAAS,IAAI,cAAc,KAAK,CAClC"}

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

@@ -7,7 +7,6 @@ import { BaseLanguageModelInterface } from "@langchain/core/language_models/base
 import { ToolInterface } from "@langchain/core/tools";
 
 //#region src/agents/mrkl/index.d.ts
-
 /**
  * Interface for creating a prompt for the ZeroShotAgent.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["BaseLanguageModelInterface","ToolInterface","PromptTemplate","Optional","Agent","AgentArgs","OutputParserArgs","AgentInput","SerializedZeroShotAgent","ZeroShotAgentOutputParser","ZeroShotCreatePromptArgs","ZeroShotAgentInput","ZeroShotAgent","Promise"],"sources":["../../../src/agents/mrkl/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput, SerializedZeroShotAgent } from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\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    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n}\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport declare class ZeroShotAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ZeroShotAgentInput);\n    _agentType(): \"zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    /**\n     * Returns the default output parser for the ZeroShotAgent.\n     * @param fields Optional arguments for the output parser.\n     * @returns An instance of ZeroShotAgentOutputParser.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs): ZeroShotAgentOutputParser;\n    /**\n     * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n     * does not have a description.\n     * @param tools List of tools to validate.\n     */\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Create prompt in the style of the zero shot 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     */\n    static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs): PromptTemplate<any, any>;\n    /**\n     * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n     * @param llm The Large Language Model to use.\n     * @param tools The tools for the agent to use.\n     * @param args Optional arguments for creating the agent.\n     * @returns A new instance of ZeroShotAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ZeroShotCreatePromptArgs & AgentArgs): ZeroShotAgent;\n    static deserialize(data: SerializedZeroShotAgent & {\n        llm?: BaseLanguageModelInterface;\n        tools?: ToolInterface[];\n    }): Promise<ZeroShotAgent>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;AAUA;AAYYW,UAZKD,wBAAAA,CAYyBH;EA0BrBK;EAGPX,MAAAA,CAAAA,EAAAA,MAAAA;EACSU;EASoBL,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBG;EAM9BR,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AAkB2DS,KA/D/EC,kBAAAA,GAAqBR,QA+D0DO,CA/DjDH,UA+DiDG,EAAAA,cAAAA,CAAAA;;;;;;;;;AArC3C;;;;;;;;;;;;;;;;;cAA3BE,aAAAA,SAAsBR,KAAAA;;;YAG7BH;qBACSU;;;;;;;;;yCASoBL,mBAAmBG;;;;;;8BAM9BR;;;;;;;;;;6BAUDA,wBAAwBS,2BAA2BR;;;;;;;;8BAQlDF,mCAAmCC,wBAAwBS,2BAA2BL,YAAYO;2BACrGJ;UACfR;YACEC;MACRY,QAAQD"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/mrkl/index.ts"],"mappings":";;;;;;;;;;;AAkBA;UAAiB,wBAAA;;EAEf,MAAA;EAAA;EAEA,MAAA;EAEA;EAAA,cAAA;AAAA;AAOF;;;;AAAA,KAAY,kBAAA,GAAqB,QAAA,CAAS,UAAA;AA2B1C;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,cAAa,aAAA,SAAsB,KAAA;EAAA,OAC1B,OAAA,CAAA;EAIP,YAAA;EAEQ,QAAA,EAAU,aAAA;EAElB,WAAA,CAAY,KAAA,EAAO,kBAAA;EAMnB,UAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,SAAA,CAAA;EAJA;;;;;EAAA,OAaO,sBAAA,CAAuB,MAAA,GAAS,gBAAA,GAAgB,yBAAA;EAShD;;;;;EAAA,OAAA,aAAA,CAAc,KAAA,EAAO,aAAA;EAmBuB;;;;;;;;;EAAA,OAA5C,YAAA,CAAa,KAAA,EAAO,aAAA,IAAiB,IAAA,GAAO,wBAAA,GAAwB,cAAA;EAoCzE;;;;;;;EAAA,OAHK,eAAA,CACL,GAAA,EAAK,0BAAA,EACL,KAAA,EAAO,aAAA,IACP,IAAA,GAAO,wBAAA,GAA2B,SAAA,GAAS,aAAA;EAAA,OAmBhC,WAAA,CACX,IAAA,EAAM,uBAAA;IACJ,GAAA,GAAM,0BAAA;IACN,KAAA,GAAQ,aAAA;EAAA,IAET,OAAA,CAAQ,aAAA;AAAA"}

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

@@ -7,7 +7,6 @@ import { ToolInterface } from "@langchain/core/tools";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 
 //#region src/agents/mrkl/index.d.ts
-
 /**
  * Interface for creating a prompt for the ZeroShotAgent.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["BaseLanguageModelInterface","ToolInterface","PromptTemplate","Optional","Agent","AgentArgs","OutputParserArgs","AgentInput","SerializedZeroShotAgent","ZeroShotAgentOutputParser","ZeroShotCreatePromptArgs","ZeroShotAgentInput","ZeroShotAgent","Promise"],"sources":["../../../src/agents/mrkl/index.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput, SerializedZeroShotAgent } from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\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    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n}\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport declare class ZeroShotAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    ToolType: ToolInterface;\n    constructor(input: ZeroShotAgentInput);\n    _agentType(): \"zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    /**\n     * Returns the default output parser for the ZeroShotAgent.\n     * @param fields Optional arguments for the output parser.\n     * @returns An instance of ZeroShotAgentOutputParser.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs): ZeroShotAgentOutputParser;\n    /**\n     * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n     * does not have a description.\n     * @param tools List of tools to validate.\n     */\n    static validateTools(tools: ToolInterface[]): void;\n    /**\n     * Create prompt in the style of the zero shot 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     */\n    static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs): PromptTemplate<any, any>;\n    /**\n     * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n     * @param llm The Large Language Model to use.\n     * @param tools The tools for the agent to use.\n     * @param args Optional arguments for creating the agent.\n     * @returns A new instance of ZeroShotAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: ToolInterface[], args?: ZeroShotCreatePromptArgs & AgentArgs): ZeroShotAgent;\n    static deserialize(data: SerializedZeroShotAgent & {\n        llm?: BaseLanguageModelInterface;\n        tools?: ToolInterface[];\n    }): Promise<ZeroShotAgent>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;AAUA;AAYYW,UAZKD,wBAAAA,CAYyBH;EA0BrBK;EAGPX,MAAAA,CAAAA,EAAAA,MAAAA;EACSU;EASoBL,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBG;EAM9BR,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;;;;;;AAkB2DS,KA/D/EC,kBAAAA,GAAqBR,QA+D0DO,CA/DjDH,UA+DiDG,EAAAA,cAAAA,CAAAA;;;;;;;;;AArC3C;;;;;;;;;;;;;;;;;cAA3BE,aAAAA,SAAsBR,KAAAA;;;YAG7BH;qBACSU;;;;;;;;;yCASoBL,mBAAmBG;;;;;;8BAM9BR;;;;;;;;;;6BAUDA,wBAAwBS,2BAA2BR;;;;;;;;8BAQlDF,mCAAmCC,wBAAwBS,2BAA2BL,YAAYO;2BACrGJ;UACfR;YACEC;MACRY,QAAQD"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/mrkl/index.ts"],"mappings":";;;;;;;;;;;AAkBA;UAAiB,wBAAA;;EAEf,MAAA;EAAA;EAEA,MAAA;EAEA;EAAA,cAAA;AAAA;AAOF;;;;AAAA,KAAY,kBAAA,GAAqB,QAAA,CAAS,UAAA;AA2B1C;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,cAAa,aAAA,SAAsB,KAAA;EAAA,OAC1B,OAAA,CAAA;EAIP,YAAA;EAEQ,QAAA,EAAU,aAAA;EAElB,WAAA,CAAY,KAAA,EAAO,kBAAA;EAMnB,UAAA,CAAA;EAIA,iBAAA,CAAA;EAIA,SAAA,CAAA;EAJA;;;;;EAAA,OAaO,sBAAA,CAAuB,MAAA,GAAS,gBAAA,GAAgB,yBAAA;EAShD;;;;;EAAA,OAAA,aAAA,CAAc,KAAA,EAAO,aAAA;EAmBuB;;;;;;;;;EAAA,OAA5C,YAAA,CAAa,KAAA,EAAO,aAAA,IAAiB,IAAA,GAAO,wBAAA,GAAwB,cAAA;EAoCzE;;;;;;;EAAA,OAHK,eAAA,CACL,GAAA,EAAK,0BAAA,EACL,KAAA,EAAO,aAAA,IACP,IAAA,GAAO,wBAAA,GAA2B,SAAA,GAAS,aAAA;EAAA,OAmBhC,WAAA,CACX,IAAA,EAAM,uBAAA;IACJ,GAAA,GAAM,0BAAA;IACN,KAAA,GAAQ,aAAA;EAAA,IAET,OAAA,CAAQ,aAAA;AAAA"}

package/dist/agents/mrkl/index.js

@@ -87,17 +87,13 @@ var ZeroShotAgent = class ZeroShotAgent extends Agent {
 	*/
 	static createPrompt(tools, args) {
 		const { prefix = PREFIX, suffix = SUFFIX, inputVariables = ["input", "agent_scratchpad"] } = args ?? {};
-		const toolStrings = tools.map((tool) => `${tool.name}: ${tool.description}`).join("\n");
-		const toolNames = tools.map((tool) => `"${tool.name}"`).join(", ");
-		const formatInstructions = renderTemplate(FORMAT_INSTRUCTIONS, "f-string", { tool_names: toolNames });
-		const template = [
-			prefix,
-			toolStrings,
-			formatInstructions,
-			suffix
-		].join("\n\n");
 		return new PromptTemplate({
-			template,
+			template: [
+				prefix,
+				tools.map((tool) => `${tool.name}: ${tool.description}`).join("\n"),
+				renderTemplate(FORMAT_INSTRUCTIONS, "f-string", { tool_names: tools.map((tool) => `"${tool.name}"`).join(", ") }),
+				suffix
+			].join("\n\n"),
 			inputVariables
 		});
 	}
@@ -112,20 +108,19 @@ var ZeroShotAgent = class ZeroShotAgent extends Agent {
 		ZeroShotAgent.validateTools(tools);
 		const prompt = ZeroShotAgent.createPrompt(tools, args);
 		const outputParser = args?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();
-		const chain = new LLMChain({
-			prompt,
-			llm,
-			callbacks: args?.callbacks ?? args?.callbackManager
-		});
 		return new ZeroShotAgent({
-			llmChain: chain,
+			llmChain: new LLMChain({
+				prompt,
+				llm,
+				callbacks: args?.callbacks ?? args?.callbackManager
+			}),
 			allowedTools: tools.map((t) => t.name),
 			outputParser
 		});
 	}
 	static async deserialize(data) {
-		const { llm, tools,...rest } = data;
-		return deserializeHelper(llm, tools, rest, (llm$1, tools$1, args) => ZeroShotAgent.fromLLMAndTools(llm$1, tools$1, {
+		const { llm, tools, ...rest } = data;
+		return deserializeHelper(llm, tools, rest, (llm, tools, args) => ZeroShotAgent.fromLLMAndTools(llm, tools, {
 			prefix: args.prefix,
 			suffix: args.suffix,
 			inputVariables: args.input_variables

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["input: ZeroShotAgentInput","fields?: OutputParserArgs","tools: ToolInterface[]","args?: ZeroShotCreatePromptArgs","llm: BaseLanguageModelInterface","args?: ZeroShotCreatePromptArgs & AgentArgs","data: SerializedZeroShotAgent & {\n      llm?: BaseLanguageModelInterface;\n      tools?: ToolInterface[];\n    }","args: SerializedFromLLMAndTools","llm","tools"],"sources":["../../../src/agents/mrkl/index.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate, renderTemplate } from \"@langchain/core/prompts\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { deserializeHelper } from \"../helpers.js\";\nimport {\n  AgentInput,\n  SerializedFromLLMAndTools,\n  SerializedZeroShotAgent,\n} from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\n\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\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  /** List of input variables the final prompt will expect. */\n  inputVariables?: string[];\n}\n\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport class ZeroShotAgent extends Agent {\n  static lc_name() {\n    return \"ZeroShotAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  declare ToolType: ToolInterface;\n\n  constructor(input: ZeroShotAgentInput) {\n    const outputParser =\n      input?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"zero-shot-react-description\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  /**\n   * Returns the default output parser for the ZeroShotAgent.\n   * @param fields Optional arguments for the output parser.\n   * @returns An instance of ZeroShotAgentOutputParser.\n   */\n  static getDefaultOutputParser(fields?: OutputParserArgs) {\n    return new ZeroShotAgentOutputParser(fields);\n  }\n\n  /**\n   * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n   * does not have a description.\n   * @param tools List of tools to validate.\n   */\n  static validateTools(tools: ToolInterface[]) {\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   * Create prompt in the style of the zero shot 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   */\n  static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      inputVariables = [\"input\", \"agent_scratchpad\"],\n    } = args ?? {};\n    const toolStrings = tools\n      .map((tool) => `${tool.name}: ${tool.description}`)\n      .join(\"\\n\");\n\n    const toolNames = tools.map((tool) => `\"${tool.name}\"`).join(\", \");\n\n    const formatInstructions = renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: toolNames,\n    });\n\n    const template = [prefix, toolStrings, formatInstructions, suffix].join(\n      \"\\n\\n\"\n    );\n\n    return new PromptTemplate({\n      template,\n      inputVariables,\n    });\n  }\n\n  /**\n   * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n   * @param llm The Large Language Model to use.\n   * @param tools The tools for the agent to use.\n   * @param args Optional arguments for creating the agent.\n   * @returns A new instance of ZeroShotAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: ToolInterface[],\n    args?: ZeroShotCreatePromptArgs & AgentArgs\n  ) {\n    ZeroShotAgent.validateTools(tools);\n    const prompt = ZeroShotAgent.createPrompt(tools, args);\n    const outputParser =\n      args?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks ?? args?.callbackManager,\n    });\n\n    return new ZeroShotAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      outputParser,\n    });\n  }\n\n  static async deserialize(\n    data: SerializedZeroShotAgent & {\n      llm?: BaseLanguageModelInterface;\n      tools?: ToolInterface[];\n    }\n  ): Promise<ZeroShotAgent> {\n    const { llm, tools, ...rest } = data;\n    return deserializeHelper(\n      llm,\n      tools,\n      rest,\n      (\n        llm: BaseLanguageModelInterface,\n        tools: ToolInterface[],\n        args: SerializedFromLLMAndTools\n      ) =>\n        ZeroShotAgent.fromLLMAndTools(llm, tools, {\n          prefix: args.prefix,\n          suffix: args.suffix,\n          inputVariables: args.input_variables,\n        }),\n      (args) => new ZeroShotAgent(args)\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,gBAAb,MAAa,sBAAsB,MAAM;CACvC,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAU;CAAO;CAI9C,YAAYA,OAA2B;EACrC,MAAM,eACJ,OAAO,gBAAgB,cAAc,wBAAwB;EAC/D,MAAM;GAAE,GAAG;GAAO;EAAc,EAAC;CAClC;CAED,aAAa;AACX,SAAO;CACR;CAED,oBAAoB;AAClB,SAAO;CACR;CAED,YAAY;AACV,SAAO;CACR;;;;;;CAOD,OAAO,uBAAuBC,QAA2B;AACvD,SAAO,IAAI,0BAA0B;CACtC;;;;;;CAOD,OAAO,cAAcC,OAAwB;EAC3C,MAAM,sBAAsB,MAAM,KAAK,CAAC,SAAS,CAAC,KAAK,YAAY;AACnE,MAAI,qBAAqB;GACvB,MAAM,MACJ,CAAC,WAAW,EAAE,oBAAoB,KAAK,uEAAuB,CACZ;AACpD,SAAM,IAAI,MAAM;EACjB;CACF;;;;;;;;;;CAWD,OAAO,aAAaA,OAAwBC,MAAiC;EAC3E,MAAM,EACJ,SAAS,QACT,SAAS,QACT,iBAAiB,CAAC,SAAS,kBAAmB,GAC/C,GAAG,QAAQ,CAAE;EACd,MAAM,cAAc,MACjB,IAAI,CAAC,SAAS,GAAG,KAAK,KAAK,EAAE,EAAE,KAAK,aAAa,CAAC,CAClD,KAAK,KAAK;EAEb,MAAM,YAAY,MAAM,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;EAElE,MAAM,qBAAqB,eAAe,qBAAqB,YAAY,EACzE,YAAY,UACb,EAAC;EAEF,MAAM,WAAW;GAAC;GAAQ;GAAa;GAAoB;EAAO,EAAC,KACjE,OACD;AAED,SAAO,IAAI,eAAe;GACxB;GACA;EACD;CACF;;;;;;;;CASD,OAAO,gBACLC,KACAF,OACAG,MACA;EACA,cAAc,cAAc,MAAM;EAClC,MAAM,SAAS,cAAc,aAAa,OAAO,KAAK;EACtD,MAAM,eACJ,MAAM,gBAAgB,cAAc,wBAAwB;EAC9D,MAAM,QAAQ,IAAI,SAAS;GACzB;GACA;GACA,WAAW,MAAM,aAAa,MAAM;EACrC;AAED,SAAO,IAAI,cAAc;GACvB,UAAU;GACV,cAAc,MAAM,IAAI,CAAC,MAAM,EAAE,KAAK;GACtC;EACD;CACF;CAED,aAAa,YACXC,MAIwB;EACxB,MAAM,EAAE,KAAK,MAAO,GAAG,MAAM,GAAG;AAChC,SAAO,kBACL,KACA,OACA,MACA,CACEF,OACAF,SACAK,SAEA,cAAc,gBAAgBC,OAAKC,SAAO;GACxC,QAAQ,KAAK;GACb,QAAQ,KAAK;GACb,gBAAgB,KAAK;EACtB,EAAC,EACJ,CAAC,SAAS,IAAI,cAAc,MAC7B;CACF;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/agents/mrkl/index.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { ToolInterface } from \"@langchain/core/tools\";\nimport { PromptTemplate, renderTemplate } from \"@langchain/core/prompts\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, OutputParserArgs } from \"../agent.js\";\nimport { deserializeHelper } from \"../helpers.js\";\nimport {\n  AgentInput,\n  SerializedFromLLMAndTools,\n  SerializedZeroShotAgent,\n} from \"../types.js\";\nimport { ZeroShotAgentOutputParser } from \"./outputParser.js\";\nimport { FORMAT_INSTRUCTIONS, PREFIX, SUFFIX } from \"./prompt.js\";\n\n/**\n * Interface for creating a prompt for the ZeroShotAgent.\n */\nexport interface ZeroShotCreatePromptArgs {\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  /** List of input variables the final prompt will expect. */\n  inputVariables?: string[];\n}\n\n/**\n * Type for the input to the ZeroShotAgent, with the 'outputParser'\n * property made optional.\n */\nexport type ZeroShotAgentInput = Optional<AgentInput, \"outputParser\">;\n\n/**\n * Agent for the MRKL chain.\n * @augments Agent\n * @example\n * ```typescript\n *\n * const agent = new ZeroShotAgent({\n *   llmChain: new LLMChain({\n *     llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *     prompt: ZeroShotAgent.createPrompt([new SerpAPI(), new Calculator()], {\n *       prefix: `Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:`,\n *       suffix: `Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n * Question: {input}\n * {agent_scratchpad}`,\n *       inputVariables: [\"input\", \"agent_scratchpad\"],\n *     }),\n *   }),\n *   allowedTools: [\"search\", \"calculator\"],\n * });\n *\n * const result = await agent.invoke({\n *   input: `Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?`,\n * });\n * ```\n */\nexport class ZeroShotAgent extends Agent {\n  static lc_name() {\n    return \"ZeroShotAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  declare ToolType: ToolInterface;\n\n  constructor(input: ZeroShotAgentInput) {\n    const outputParser =\n      input?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    super({ ...input, outputParser });\n  }\n\n  _agentType() {\n    return \"zero-shot-react-description\" as const;\n  }\n\n  observationPrefix() {\n    return \"Observation: \";\n  }\n\n  llmPrefix() {\n    return \"Thought:\";\n  }\n\n  /**\n   * Returns the default output parser for the ZeroShotAgent.\n   * @param fields Optional arguments for the output parser.\n   * @returns An instance of ZeroShotAgentOutputParser.\n   */\n  static getDefaultOutputParser(fields?: OutputParserArgs) {\n    return new ZeroShotAgentOutputParser(fields);\n  }\n\n  /**\n   * Validates the tools for the ZeroShotAgent. Throws an error if any tool\n   * does not have a description.\n   * @param tools List of tools to validate.\n   */\n  static validateTools(tools: ToolInterface[]) {\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   * Create prompt in the style of the zero shot 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   */\n  static createPrompt(tools: ToolInterface[], args?: ZeroShotCreatePromptArgs) {\n    const {\n      prefix = PREFIX,\n      suffix = SUFFIX,\n      inputVariables = [\"input\", \"agent_scratchpad\"],\n    } = args ?? {};\n    const toolStrings = tools\n      .map((tool) => `${tool.name}: ${tool.description}`)\n      .join(\"\\n\");\n\n    const toolNames = tools.map((tool) => `\"${tool.name}\"`).join(\", \");\n\n    const formatInstructions = renderTemplate(FORMAT_INSTRUCTIONS, \"f-string\", {\n      tool_names: toolNames,\n    });\n\n    const template = [prefix, toolStrings, formatInstructions, suffix].join(\n      \"\\n\\n\"\n    );\n\n    return new PromptTemplate({\n      template,\n      inputVariables,\n    });\n  }\n\n  /**\n   * Creates a ZeroShotAgent from a Large Language Model and a set of tools.\n   * @param llm The Large Language Model to use.\n   * @param tools The tools for the agent to use.\n   * @param args Optional arguments for creating the agent.\n   * @returns A new instance of ZeroShotAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: ToolInterface[],\n    args?: ZeroShotCreatePromptArgs & AgentArgs\n  ) {\n    ZeroShotAgent.validateTools(tools);\n    const prompt = ZeroShotAgent.createPrompt(tools, args);\n    const outputParser =\n      args?.outputParser ?? ZeroShotAgent.getDefaultOutputParser();\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks ?? args?.callbackManager,\n    });\n\n    return new ZeroShotAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      outputParser,\n    });\n  }\n\n  static async deserialize(\n    data: SerializedZeroShotAgent & {\n      llm?: BaseLanguageModelInterface;\n      tools?: ToolInterface[];\n    }\n  ): Promise<ZeroShotAgent> {\n    const { llm, tools, ...rest } = data;\n    return deserializeHelper(\n      llm,\n      tools,\n      rest,\n      (\n        llm: BaseLanguageModelInterface,\n        tools: ToolInterface[],\n        args: SerializedFromLLMAndTools\n      ) =>\n        ZeroShotAgent.fromLLMAndTools(llm, tools, {\n          prefix: args.prefix,\n          suffix: args.suffix,\n          inputVariables: args.input_variables,\n        }),\n      (args) => new ZeroShotAgent(args)\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,IAAa,gBAAb,MAAa,sBAAsB,MAAM;CACvC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAU;EAAO;CAI9C,YAAY,OAA2B;EACrC,MAAM,eACJ,OAAO,gBAAgB,cAAc,wBAAwB;AAC/D,QAAM;GAAE,GAAG;GAAO;GAAc,CAAC;;CAGnC,aAAa;AACX,SAAO;;CAGT,oBAAoB;AAClB,SAAO;;CAGT,YAAY;AACV,SAAO;;;;;;;CAQT,OAAO,uBAAuB,QAA2B;AACvD,SAAO,IAAI,0BAA0B,OAAO;;;;;;;CAQ9C,OAAO,cAAc,OAAwB;EAC3C,MAAM,sBAAsB,MAAM,MAAM,SAAS,CAAC,KAAK,YAAY;AACnE,MAAI,qBAAqB;GACvB,MAAM,MACJ,cAAc,oBAAoB,KAAK;AAEzC,SAAM,IAAI,MAAM,IAAI;;;;;;;;;;;;CAaxB,OAAO,aAAa,OAAwB,MAAiC;EAC3E,MAAM,EACJ,SAAS,QACT,SAAS,QACT,iBAAiB,CAAC,SAAS,mBAAmB,KAC5C,QAAQ,EAAE;AAed,SAAO,IAAI,eAAe;GACxB,UALe;IAAC;IAVE,MACjB,KAAK,SAAS,GAAG,KAAK,KAAK,IAAI,KAAK,cAAc,CAClD,KAAK,KAAK;IAIc,eAAe,qBAAqB,YAAY,EACzE,YAHgB,MAAM,KAAK,SAAS,IAAI,KAAK,KAAK,GAAG,CAAC,KAAK,KAAK,EAIjE,CAAC;IAEyD;IAAO,CAAC,KACjE,OACD;GAIC;GACD,CAAC;;;;;;;;;CAUJ,OAAO,gBACL,KACA,OACA,MACA;AACA,gBAAc,cAAc,MAAM;EAClC,MAAM,SAAS,cAAc,aAAa,OAAO,KAAK;EACtD,MAAM,eACJ,MAAM,gBAAgB,cAAc,wBAAwB;AAO9D,SAAO,IAAI,cAAc;GACvB,UAPY,IAAI,SAAS;IACzB;IACA;IACA,WAAW,MAAM,aAAa,MAAM;IACrC,CAAC;GAIA,cAAc,MAAM,KAAK,MAAM,EAAE,KAAK;GACtC;GACD,CAAC;;CAGJ,aAAa,YACX,MAIwB;EACxB,MAAM,EAAE,KAAK,OAAO,GAAG,SAAS;AAChC,SAAO,kBACL,KACA,OACA,OAEE,KACA,OACA,SAEA,cAAc,gBAAgB,KAAK,OAAO;GACxC,QAAQ,KAAK;GACb,QAAQ,KAAK;GACb,gBAAgB,KAAK;GACtB,CAAC,GACH,SAAS,IAAI,cAAc,KAAK,CAClC"}

package/dist/agents/mrkl/outputParser.cjs

@@ -1,7 +1,7 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_types = require('../types.cjs');
 const require_prompt = require('./prompt.cjs');
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/agents/mrkl/outputParser.ts
 const FINAL_ANSWER_ACTION = "Final Answer:";
@@ -29,14 +29,13 @@ var ZeroShotAgentOutputParser = class extends require_types.AgentActionOutputPar
 	async parse(text) {
 		if (text.includes(this.finishToolName)) {
 			const parts = text.split(this.finishToolName);
-			const output = parts[parts.length - 1].trim();
 			return {
-				returnValues: { output },
+				returnValues: { output: parts[parts.length - 1].trim() },
 				log: text
 			};
 		}
 		const match = /Action:([\s\S]*?)(?:\nAction Input:([\s\S]*?))?$/.exec(text);
-		if (!match) throw new __langchain_core_output_parsers.OutputParserException(`Could not parse LLM output: ${text}`);
+		if (!match) throw new _langchain_core_output_parsers.OutputParserException(`Could not parse LLM output: ${text}`);
 		return {
 			tool: match[1].trim(),
 			toolInput: match[2] ? match[2].trim().replace(/^("+)(.*?)(\1)$/, "$2") : "",

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.cjs","names":["AgentActionOutputParser","fields?: OutputParserArgs","text: string","OutputParserException","FORMAT_INSTRUCTIONS"],"sources":["../../../src/agents/mrkl/outputParser.ts"],"sourcesContent":["import { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nexport const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  finishToolName: string;\n\n  constructor(fields?: OutputParserArgs) {\n    super(fields);\n    this.finishToolName = fields?.finishToolName || FINAL_ANSWER_ACTION;\n  }\n\n  /**\n   * Parses the text output of an agent action, extracting the tool, tool\n   * input, and output.\n   * @param text The text output of an agent action.\n   * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n   */\n  async parse(text: string) {\n    if (text.includes(this.finishToolName)) {\n      const parts = text.split(this.finishToolName);\n      const output = parts[parts.length - 1].trim();\n      return {\n        returnValues: { output },\n        log: text,\n      };\n    }\n\n    const match = /Action:([\\s\\S]*?)(?:\\nAction Input:([\\s\\S]*?))?$/.exec(text);\n    if (!match) {\n      throw new OutputParserException(`Could not parse LLM output: ${text}`);\n    }\n\n    return {\n      tool: match[1].trim(),\n      toolInput: match[2]\n        ? match[2].trim().replace(/^(\"+)(.*?)(\\1)$/, \"$2\")\n        : \"\",\n      log: text,\n    };\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the ZeroShotAgent.\n   * @returns The format instructions for parsing the output.\n   */\n  getFormatInstructions(): string {\n    return FORMAT_INSTRUCTIONS;\n  }\n}\n"],"mappings":";;;;;;AAMA,MAAa,sBAAsB;;;;;AAKnC,IAAa,4BAAb,cAA+CA,sCAAwB;CACrE,eAAe;EAAC;EAAa;EAAU;CAAO;CAE9C;CAEA,YAAYC,QAA2B;EACrC,MAAM,OAAO;EACb,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;;;;;;;CAQD,MAAM,MAAMC,MAAc;AACxB,MAAI,KAAK,SAAS,KAAK,eAAe,EAAE;GACtC,MAAM,QAAQ,KAAK,MAAM,KAAK,eAAe;GAC7C,MAAM,SAAS,MAAM,MAAM,SAAS,GAAG,MAAM;AAC7C,UAAO;IACL,cAAc,EAAE,OAAQ;IACxB,KAAK;GACN;EACF;EAED,MAAM,QAAQ,mDAAmD,KAAK,KAAK;AAC3E,MAAI,CAAC,MACH,OAAM,IAAIC,sDAAsB,CAAC,4BAA4B,EAAE,MAAM;AAGvE,SAAO;GACL,MAAM,MAAM,GAAG,MAAM;GACrB,WAAW,MAAM,KACb,MAAM,GAAG,MAAM,CAAC,QAAQ,mBAAmB,KAAK,GAChD;GACJ,KAAK;EACN;CACF;;;;;;CAOD,wBAAgC;AAC9B,SAAOC;CACR;AACF"}
+{"version":3,"file":"outputParser.cjs","names":["AgentActionOutputParser","OutputParserException","FORMAT_INSTRUCTIONS"],"sources":["../../../src/agents/mrkl/outputParser.ts"],"sourcesContent":["import { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nexport const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  finishToolName: string;\n\n  constructor(fields?: OutputParserArgs) {\n    super(fields);\n    this.finishToolName = fields?.finishToolName || FINAL_ANSWER_ACTION;\n  }\n\n  /**\n   * Parses the text output of an agent action, extracting the tool, tool\n   * input, and output.\n   * @param text The text output of an agent action.\n   * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n   */\n  async parse(text: string) {\n    if (text.includes(this.finishToolName)) {\n      const parts = text.split(this.finishToolName);\n      const output = parts[parts.length - 1].trim();\n      return {\n        returnValues: { output },\n        log: text,\n      };\n    }\n\n    const match = /Action:([\\s\\S]*?)(?:\\nAction Input:([\\s\\S]*?))?$/.exec(text);\n    if (!match) {\n      throw new OutputParserException(`Could not parse LLM output: ${text}`);\n    }\n\n    return {\n      tool: match[1].trim(),\n      toolInput: match[2]\n        ? match[2].trim().replace(/^(\"+)(.*?)(\\1)$/, \"$2\")\n        : \"\",\n      log: text,\n    };\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the ZeroShotAgent.\n   * @returns The format instructions for parsing the output.\n   */\n  getFormatInstructions(): string {\n    return FORMAT_INSTRUCTIONS;\n  }\n}\n"],"mappings":";;;;;;AAMA,MAAa,sBAAsB;;;;;AAKnC,IAAa,4BAAb,cAA+CA,sCAAwB;CACrE,eAAe;EAAC;EAAa;EAAU;EAAO;CAE9C;CAEA,YAAY,QAA2B;AACrC,QAAM,OAAO;AACb,OAAK,iBAAiB,QAAQ,kBAAkB;;;;;;;;CASlD,MAAM,MAAM,MAAc;AACxB,MAAI,KAAK,SAAS,KAAK,eAAe,EAAE;GACtC,MAAM,QAAQ,KAAK,MAAM,KAAK,eAAe;AAE7C,UAAO;IACL,cAAc,EAAE,QAFH,MAAM,MAAM,SAAS,GAAG,MAAM,EAEnB;IACxB,KAAK;IACN;;EAGH,MAAM,QAAQ,mDAAmD,KAAK,KAAK;AAC3E,MAAI,CAAC,MACH,OAAM,IAAIC,qDAAsB,+BAA+B,OAAO;AAGxE,SAAO;GACL,MAAM,MAAM,GAAG,MAAM;GACrB,WAAW,MAAM,KACb,MAAM,GAAG,MAAM,CAAC,QAAQ,mBAAmB,KAAK,GAChD;GACJ,KAAK;GACN;;;;;;;CAQH,wBAAgC;AAC9B,SAAOC"}

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

@@ -2,7 +2,6 @@ import { AgentActionOutputParser } from "../types.cjs";
 import { OutputParserArgs } from "../agent.cjs";
 
 //#region src/agents/mrkl/outputParser.d.ts
-
 /**
  * A class that extends `AgentActionOutputParser` to provide a custom
  * implementation for parsing the output of a ZeroShotAgent action.
@@ -25,10 +24,10 @@ declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {
     tool?: undefined;
     toolInput?: undefined;
   } | {
+    returnValues?: undefined;
     tool: string;
     toolInput: string;
     log: string;
-    returnValues?: undefined;
   }>;
   /**
    * Returns the format instructions for parsing the output of an agent

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.cts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        tool: string;\n        toolInput: string;\n        log: string;\n        returnValues?: undefined;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}
+{"version":3,"file":"outputParser.d.cts","names":[],"sources":["../../../src/agents/mrkl/outputParser.ts"],"mappings":";;;;;AAWA;;;cAAa,yBAAA,SAAkC,uBAAA;EAC7C,YAAA;EAEA,cAAA;EAEA,WAAA,CAAY,MAAA,GAAS,gBAAA;EAL+C;;;;;;EAgB9D,KAAA,CAAM,IAAA,WAAY,OAAA;;;;;;;;;;;;;EA6BxB;;;;;EAAA,qBAAA,CAAA;AAAA"}

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

@@ -2,7 +2,6 @@ import { AgentActionOutputParser } from "../types.js";
 import { OutputParserArgs } from "../agent.js";
 
 //#region src/agents/mrkl/outputParser.d.ts
-
 /**
  * A class that extends `AgentActionOutputParser` to provide a custom
  * implementation for parsing the output of a ZeroShotAgent action.

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.ts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        tool: string;\n        toolInput: string;\n        log: string;\n        returnValues?: undefined;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}
+{"version":3,"file":"outputParser.d.ts","names":[],"sources":["../../../src/agents/mrkl/outputParser.ts"],"mappings":";;;;;AAWA;;;cAAa,yBAAA,SAAkC,uBAAA;EAC7C,YAAA;EAEA,cAAA;EAEA,WAAA,CAAY,MAAA,GAAS,gBAAA;EAL+C;;;;;;EAgB9D,KAAA,CAAM,IAAA,WAAY,OAAA;;;;;;;;;;;;;EA6BxB;;;;;EAAA,qBAAA,CAAA;AAAA"}

package/dist/agents/mrkl/outputParser.js

@@ -28,9 +28,8 @@ var ZeroShotAgentOutputParser = class extends AgentActionOutputParser {
 	async parse(text) {
 		if (text.includes(this.finishToolName)) {
 			const parts = text.split(this.finishToolName);
-			const output = parts[parts.length - 1].trim();
 			return {
-				returnValues: { output },
+				returnValues: { output: parts[parts.length - 1].trim() },
 				log: text
 			};
 		}

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.js","names":["fields?: OutputParserArgs","text: string"],"sources":["../../../src/agents/mrkl/outputParser.ts"],"sourcesContent":["import { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nexport const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  finishToolName: string;\n\n  constructor(fields?: OutputParserArgs) {\n    super(fields);\n    this.finishToolName = fields?.finishToolName || FINAL_ANSWER_ACTION;\n  }\n\n  /**\n   * Parses the text output of an agent action, extracting the tool, tool\n   * input, and output.\n   * @param text The text output of an agent action.\n   * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n   */\n  async parse(text: string) {\n    if (text.includes(this.finishToolName)) {\n      const parts = text.split(this.finishToolName);\n      const output = parts[parts.length - 1].trim();\n      return {\n        returnValues: { output },\n        log: text,\n      };\n    }\n\n    const match = /Action:([\\s\\S]*?)(?:\\nAction Input:([\\s\\S]*?))?$/.exec(text);\n    if (!match) {\n      throw new OutputParserException(`Could not parse LLM output: ${text}`);\n    }\n\n    return {\n      tool: match[1].trim(),\n      toolInput: match[2]\n        ? match[2].trim().replace(/^(\"+)(.*?)(\\1)$/, \"$2\")\n        : \"\",\n      log: text,\n    };\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the ZeroShotAgent.\n   * @returns The format instructions for parsing the output.\n   */\n  getFormatInstructions(): string {\n    return FORMAT_INSTRUCTIONS;\n  }\n}\n"],"mappings":";;;;;AAMA,MAAa,sBAAsB;;;;;AAKnC,IAAa,4BAAb,cAA+C,wBAAwB;CACrE,eAAe;EAAC;EAAa;EAAU;CAAO;CAE9C;CAEA,YAAYA,QAA2B;EACrC,MAAM,OAAO;EACb,KAAK,iBAAiB,QAAQ,kBAAkB;CACjD;;;;;;;CAQD,MAAM,MAAMC,MAAc;AACxB,MAAI,KAAK,SAAS,KAAK,eAAe,EAAE;GACtC,MAAM,QAAQ,KAAK,MAAM,KAAK,eAAe;GAC7C,MAAM,SAAS,MAAM,MAAM,SAAS,GAAG,MAAM;AAC7C,UAAO;IACL,cAAc,EAAE,OAAQ;IACxB,KAAK;GACN;EACF;EAED,MAAM,QAAQ,mDAAmD,KAAK,KAAK;AAC3E,MAAI,CAAC,MACH,OAAM,IAAI,sBAAsB,CAAC,4BAA4B,EAAE,MAAM;AAGvE,SAAO;GACL,MAAM,MAAM,GAAG,MAAM;GACrB,WAAW,MAAM,KACb,MAAM,GAAG,MAAM,CAAC,QAAQ,mBAAmB,KAAK,GAChD;GACJ,KAAK;EACN;CACF;;;;;;CAOD,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"version":3,"file":"outputParser.js","names":[],"sources":["../../../src/agents/mrkl/outputParser.ts"],"sourcesContent":["import { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\n\nimport { FORMAT_INSTRUCTIONS } from \"./prompt.js\";\n\nexport const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"mrkl\"];\n\n  finishToolName: string;\n\n  constructor(fields?: OutputParserArgs) {\n    super(fields);\n    this.finishToolName = fields?.finishToolName || FINAL_ANSWER_ACTION;\n  }\n\n  /**\n   * Parses the text output of an agent action, extracting the tool, tool\n   * input, and output.\n   * @param text The text output of an agent action.\n   * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n   */\n  async parse(text: string) {\n    if (text.includes(this.finishToolName)) {\n      const parts = text.split(this.finishToolName);\n      const output = parts[parts.length - 1].trim();\n      return {\n        returnValues: { output },\n        log: text,\n      };\n    }\n\n    const match = /Action:([\\s\\S]*?)(?:\\nAction Input:([\\s\\S]*?))?$/.exec(text);\n    if (!match) {\n      throw new OutputParserException(`Could not parse LLM output: ${text}`);\n    }\n\n    return {\n      tool: match[1].trim(),\n      toolInput: match[2]\n        ? match[2].trim().replace(/^(\"+)(.*?)(\\1)$/, \"$2\")\n        : \"\",\n      log: text,\n    };\n  }\n\n  /**\n   * Returns the format instructions for parsing the output of an agent\n   * action in the style of the ZeroShotAgent.\n   * @returns The format instructions for parsing the output.\n   */\n  getFormatInstructions(): string {\n    return FORMAT_INSTRUCTIONS;\n  }\n}\n"],"mappings":";;;;;AAMA,MAAa,sBAAsB;;;;;AAKnC,IAAa,4BAAb,cAA+C,wBAAwB;CACrE,eAAe;EAAC;EAAa;EAAU;EAAO;CAE9C;CAEA,YAAY,QAA2B;AACrC,QAAM,OAAO;AACb,OAAK,iBAAiB,QAAQ,kBAAkB;;;;;;;;CASlD,MAAM,MAAM,MAAc;AACxB,MAAI,KAAK,SAAS,KAAK,eAAe,EAAE;GACtC,MAAM,QAAQ,KAAK,MAAM,KAAK,eAAe;AAE7C,UAAO;IACL,cAAc,EAAE,QAFH,MAAM,MAAM,SAAS,GAAG,MAAM,EAEnB;IACxB,KAAK;IACN;;EAGH,MAAM,QAAQ,mDAAmD,KAAK,KAAK;AAC3E,MAAI,CAAC,MACH,OAAM,IAAI,sBAAsB,+BAA+B,OAAO;AAGxE,SAAO;GACL,MAAM,MAAM,GAAG,MAAM;GACrB,WAAW,MAAM,KACb,MAAM,GAAG,MAAM,CAAC,QAAQ,mBAAmB,KAAK,GAChD;GACJ,KAAK;GACN;;;;;;;CAQH,wBAAgC;AAC9B,SAAO"}

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

@@ -1 +1 @@
-{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/mrkl/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions as best you can. You have access to the following tools:`;\nexport const FORMAT_INSTRUCTIONS = `Use the following format in your response:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question`;\nexport const SUFFIX = `Begin!\n\nQuestion: {input}\nThought:{agent_scratchpad}`;\n"],"mappings":";;AAAA,MAAa,SAAS,CAAC,uFAAuF,CAAC;AAC/G,MAAa,sBAAsB,CAAC;;;;;;;;;6DASyB,CAAC;AAC9D,MAAa,SAAS,CAAC;;;0BAGG,CAAC"}
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/mrkl/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions as best you can. You have access to the following tools:`;\nexport const FORMAT_INSTRUCTIONS = `Use the following format in your response:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question`;\nexport const SUFFIX = `Begin!\n\nQuestion: {input}\nThought:{agent_scratchpad}`;\n"],"mappings":";;AAAA,MAAa,SAAS;AACtB,MAAa,sBAAsB;;;;;;;;;;AAUnC,MAAa,SAAS"}

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

@@ -1 +1 @@
-{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/mrkl/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions as best you can. You have access to the following tools:`;\nexport const FORMAT_INSTRUCTIONS = `Use the following format in your response:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question`;\nexport const SUFFIX = `Begin!\n\nQuestion: {input}\nThought:{agent_scratchpad}`;\n"],"mappings":";AAAA,MAAa,SAAS,CAAC,uFAAuF,CAAC;AAC/G,MAAa,sBAAsB,CAAC;;;;;;;;;6DASyB,CAAC;AAC9D,MAAa,SAAS,CAAC;;;0BAGG,CAAC"}
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/mrkl/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions as best you can. You have access to the following tools:`;\nexport const FORMAT_INSTRUCTIONS = `Use the following format in your response:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction: the action to take, should be one of [{tool_names}]\nAction Input: the input to the action\nObservation: the result of the action\n... (this Thought/Action/Action Input/Observation can repeat N times)\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question`;\nexport const SUFFIX = `Begin!\n\nQuestion: {input}\nThought:{agent_scratchpad}`;\n"],"mappings":";AAAA,MAAa,SAAS;AACtB,MAAa,sBAAsB;;;;;;;;;;AAUnC,MAAa,SAAS"}

package/dist/agents/openai/output_parser.cjs

@@ -1,10 +1,10 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_output_parser = require('../openai_functions/output_parser.cjs');
 const require_output_parser$1 = require('../openai_tools/output_parser.cjs');
 
 //#region src/agents/openai/output_parser.ts
-var output_parser_exports = {};
-require_rolldown_runtime.__export(output_parser_exports, {
+var output_parser_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	OpenAIFunctionsAgentOutputParser: () => require_output_parser.OpenAIFunctionsAgentOutputParser,
 	OpenAIToolsAgentOutputParser: () => require_output_parser$1.OpenAIToolsAgentOutputParser
 });

package/dist/agents/openai/output_parser.js

@@ -1,10 +1,9 @@
-import { __export } from "../../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { OpenAIFunctionsAgentOutputParser } from "../openai_functions/output_parser.js";
 import { OpenAIToolsAgentOutputParser } from "../openai_tools/output_parser.js";
 
 //#region src/agents/openai/output_parser.ts
-var output_parser_exports = {};
-__export(output_parser_exports, {
+var output_parser_exports = /* @__PURE__ */ __exportAll({
 	OpenAIFunctionsAgentOutputParser: () => OpenAIFunctionsAgentOutputParser,
 	OpenAIToolsAgentOutputParser: () => OpenAIToolsAgentOutputParser
 });

package/dist/agents/openai_functions/index.cjs

@@ -1,14 +1,14 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+const require_agents_format_scratchpad_openai_functions = require('../format_scratchpad/openai_functions.cjs');
 const require_agent = require('../agent.cjs');
 const require_llm_chain = require('../../chains/llm_chain.cjs');
 const require_prompt = require('./prompt.cjs');
 const require_output_parser = require('./output_parser.cjs');
 require('../openai/output_parser.cjs');
-const require_agents_format_scratchpad_openai_functions = require('../format_scratchpad/openai_functions.cjs');
-const __langchain_core_prompts = require_rolldown_runtime.__toESM(require("@langchain/core/prompts"));
-const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
-const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
-const __langchain_core_utils_function_calling = require_rolldown_runtime.__toESM(require("@langchain/core/utils/function_calling"));
+let _langchain_core_messages = require("@langchain/core/messages");
+let _langchain_core_prompts = require("@langchain/core/prompts");
+let _langchain_core_runnables = require("@langchain/core/runnables");
+let _langchain_core_utils_function_calling = require("@langchain/core/utils/function_calling");
 
 //#region src/agents/openai_functions/index.ts
 /**
@@ -20,8 +20,8 @@ function isFunctionsAgentAction(action) {
 	return action.messageLog !== void 0;
 }
 function _convertAgentStepToMessages(action, observation) {
-	if (isFunctionsAgentAction(action) && action.messageLog !== void 0) return action.messageLog?.concat(new __langchain_core_messages.FunctionMessage(observation, action.tool));
-	else return [new __langchain_core_messages.AIMessage(action.log)];
+	if (isFunctionsAgentAction(action) && action.messageLog !== void 0) return action.messageLog?.concat(new _langchain_core_messages.FunctionMessage(observation, action.tool));
+	else return [new _langchain_core_messages.AIMessage(action.log)];
 }
 function _formatIntermediateSteps(intermediateSteps) {
 	return intermediateSteps.flatMap(({ action, observation }) => _convertAgentStepToMessages(action, observation));
@@ -70,11 +70,11 @@ var OpenAIAgent = class OpenAIAgent extends require_agent.Agent {
 	*/
 	static createPrompt(_tools, fields) {
 		const { prefix = require_prompt.PREFIX } = fields || {};
-		return __langchain_core_prompts.ChatPromptTemplate.fromMessages([
-			__langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate(prefix),
-			new __langchain_core_prompts.MessagesPlaceholder("chat_history"),
-			__langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate("{input}"),
-			new __langchain_core_prompts.MessagesPlaceholder("agent_scratchpad")
+		return _langchain_core_prompts.ChatPromptTemplate.fromMessages([
+			_langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate(prefix),
+			new _langchain_core_prompts.MessagesPlaceholder("chat_history"),
+			_langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate("{input}"),
+			new _langchain_core_prompts.MessagesPlaceholder("agent_scratchpad")
 		]);
 	}
 	/**
@@ -87,14 +87,12 @@ var OpenAIAgent = class OpenAIAgent extends require_agent.Agent {
 	static fromLLMAndTools(llm, tools, args) {
 		OpenAIAgent.validateTools(tools);
 		if (llm._modelType() !== "base_chat_model" || llm._llmType() !== "openai") throw new Error("OpenAIAgent requires an OpenAI chat model");
-		const prompt = OpenAIAgent.createPrompt(tools, args);
-		const chain = new require_llm_chain.LLMChain({
-			prompt,
-			llm,
-			callbacks: args?.callbacks
-		});
 		return new OpenAIAgent({
-			llmChain: chain,
+			llmChain: new require_llm_chain.LLMChain({
+				prompt: OpenAIAgent.createPrompt(tools, args),
+				llm,
+				callbacks: args?.callbacks
+			}),
 			allowedTools: tools.map((t) => t.name),
 			tools
 		});
@@ -124,7 +122,7 @@ var OpenAIAgent = class OpenAIAgent extends require_agent.Agent {
 		if (this._stop().length !== 0) newInputs.stop = this._stop();
 		const llm = this.llmChain.llm;
 		const valuesForPrompt = { ...newInputs };
-		const valuesForLLM = { functions: this.tools.map((tool) => (0, __langchain_core_utils_function_calling.convertToOpenAIFunction)(tool)) };
+		const valuesForLLM = { functions: this.tools.map((tool) => (0, _langchain_core_utils_function_calling.convertToOpenAIFunction)(tool)) };
 		const callKeys = "callKeys" in this.llmChain.llm ? this.llmChain.llm.callKeys : [];
 		for (const key of callKeys) if (key in inputs) {
 			valuesForLLM[key] = inputs[key];
@@ -196,9 +194,9 @@ var OpenAIAgent = class OpenAIAgent extends require_agent.Agent {
 */
 async function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }) {
 	if (!prompt.inputVariables.includes("agent_scratchpad")) throw new Error([`Prompt must have an input variable named "agent_scratchpad".`, `Found ${JSON.stringify(prompt.inputVariables)} instead.`].join("\n"));
-	const llmWithTools = llm.bindTools ? llm.bindTools(tools) : llm.withConfig({ functions: tools.map((tool) => (0, __langchain_core_utils_function_calling.convertToOpenAIFunction)(tool)) });
-	const agent = require_agent.AgentRunnableSequence.fromRunnables([
-		__langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_agents_format_scratchpad_openai_functions.formatToOpenAIFunctionMessages(input.steps) }),
+	const llmWithTools = llm.bindTools ? llm.bindTools(tools) : llm.withConfig({ functions: tools.map((tool) => (0, _langchain_core_utils_function_calling.convertToOpenAIFunction)(tool)) });
+	return require_agent.AgentRunnableSequence.fromRunnables([
+		_langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_agents_format_scratchpad_openai_functions.formatToOpenAIFunctionMessages(input.steps) }),
 		prompt,
 		llmWithTools,
 		new require_output_parser.OpenAIFunctionsAgentOutputParser()
@@ -207,7 +205,6 @@ async function createOpenAIFunctionsAgent({ llm, tools, prompt, streamRunnable }
 		streamRunnable,
 		singleAction: true
 	});
-	return agent;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["action: AgentAction | FunctionsAgentAction","observation: string","FunctionMessage","AIMessage","intermediateSteps: AgentStep[]","Agent","OpenAIFunctionsAgentOutputParser","input: Omit<OpenAIAgentInput, \"outputParser\">","_tools: StructuredToolInterface[]","fields?: OpenAIAgentCreatePromptArgs","PREFIX","ChatPromptTemplate","SystemMessagePromptTemplate","MessagesPlaceholder","HumanMessagePromptTemplate","llm: BaseLanguageModelInterface","tools: StructuredToolInterface[]","args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">","LLMChain","steps: AgentStep[]","steps: Array<AgentStep>","inputs: ChainValues","callbackManager?: CallbackManager","newInputs: ChainValues","valuesForLLM: CallOptionsIfAvailable<typeof llm>","AgentRunnableSequence","RunnablePassthrough","input: { steps: AgentStep[] }","formatToOpenAIFunctionMessages"],"sources":["../../../src/agents/openai_functions/index.ts"],"sourcesContent":["import type {\n  BaseLanguageModelInterface,\n  BaseLanguageModelInput,\n  BaseFunctionCallOptions,\n} from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { Runnable, RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { ChatOpenAI, ChatOpenAICallOptions } from \"@langchain/openai\";\nimport type {\n  AgentAction,\n  AgentFinish,\n  AgentStep,\n} from \"@langchain/core/agents\";\nimport { convertToOpenAIFunction } from \"@langchain/core/utils/function_calling\";\nimport {\n  AIMessage,\n  BaseMessage,\n  FunctionMessage,\n  SystemMessage,\n  BaseMessageChunk,\n} from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport {\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  MessagesPlaceholder,\n  SystemMessagePromptTemplate,\n  BasePromptTemplate,\n} from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { PREFIX } from \"./prompt.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport {\n  FunctionsAgentAction,\n  OpenAIFunctionsAgentOutputParser,\n} from \"../openai/output_parser.js\";\nimport { formatToOpenAIFunctionMessages } from \"../format_scratchpad/openai_functions.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CallOptionsIfAvailable<T> = T extends { CallOptions: infer CO } ? CO : any;\n\n/**\n * Checks if the given action is a FunctionsAgentAction.\n * @param action The action to check.\n * @returns True if the action is a FunctionsAgentAction, false otherwise.\n */\nfunction isFunctionsAgentAction(\n  action: AgentAction | FunctionsAgentAction\n): action is FunctionsAgentAction {\n  return (action as FunctionsAgentAction).messageLog !== undefined;\n}\n\nfunction _convertAgentStepToMessages(\n  action: AgentAction | FunctionsAgentAction,\n  observation: string\n) {\n  if (isFunctionsAgentAction(action) && action.messageLog !== undefined) {\n    return action.messageLog?.concat(\n      new FunctionMessage(observation, action.tool)\n    );\n  } else {\n    return [new AIMessage(action.log)];\n  }\n}\n\nexport function _formatIntermediateSteps(\n  intermediateSteps: AgentStep[]\n): BaseMessage[] {\n  return intermediateSteps.flatMap(({ action, observation }) =>\n    _convertAgentStepToMessages(action, observation)\n  );\n}\n\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n  tools: StructuredToolInterface[];\n}\n\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n  prefix?: string;\n  systemMessage?: SystemMessage;\n}\n\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport class OpenAIAgent extends Agent {\n  static lc_name() {\n    return \"OpenAIAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  _agentType() {\n    return \"openai-functions\" 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  tools: StructuredToolInterface[];\n\n  outputParser: OpenAIFunctionsAgentOutputParser =\n    new OpenAIFunctionsAgentOutputParser();\n\n  constructor(input: Omit<OpenAIAgentInput, \"outputParser\">) {\n    super({ ...input, outputParser: undefined });\n    this.tools = input.tools;\n  }\n\n  /**\n   * Creates a prompt for the OpenAIAgent using the provided tools and\n   * fields.\n   * @param _tools The tools to be used in the prompt.\n   * @param fields Optional fields for creating the prompt.\n   * @returns A BasePromptTemplate object representing the created prompt.\n   */\n  static createPrompt(\n    _tools: StructuredToolInterface[],\n    fields?: OpenAIAgentCreatePromptArgs\n  ): BasePromptTemplate {\n    const { prefix = PREFIX } = fields || {};\n    return ChatPromptTemplate.fromMessages([\n      SystemMessagePromptTemplate.fromTemplate(prefix),\n      new MessagesPlaceholder(\"chat_history\"),\n      HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n      new MessagesPlaceholder(\"agent_scratchpad\"),\n    ]);\n  }\n\n  /**\n   * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.\n   * @param llm The BaseLanguageModel to use.\n   * @param tools The tools to be used by the agent.\n   * @param args Optional arguments for creating the agent.\n   * @returns An instance of OpenAIAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: StructuredToolInterface[],\n    args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">\n  ) {\n    OpenAIAgent.validateTools(tools);\n    if (llm._modelType() !== \"base_chat_model\" || llm._llmType() !== \"openai\") {\n      throw new Error(\"OpenAIAgent requires an OpenAI chat model\");\n    }\n    const prompt = OpenAIAgent.createPrompt(tools, args);\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks,\n    });\n    return new OpenAIAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      tools,\n    });\n  }\n\n  /**\n   * Constructs a scratch pad from a list of agent steps.\n   * @param steps The steps to include in the scratch pad.\n   * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n   */\n  async constructScratchPad(\n    steps: AgentStep[]\n  ): Promise<string | BaseMessage[]> {\n    return _formatIntermediateSteps(steps);\n  }\n\n  /**\n   * Plans the next action or finish state of the agent based on the\n   * provided steps, inputs, and optional callback manager.\n   * @param steps The steps to consider in planning.\n   * @param inputs The inputs to consider in planning.\n   * @param callbackManager Optional CallbackManager to use in planning.\n   * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n   */\n  async plan(\n    steps: Array<AgentStep>,\n    inputs: ChainValues,\n    callbackManager?: CallbackManager\n  ): Promise<AgentAction | AgentFinish> {\n    // Add scratchpad and stop to inputs\n    const thoughts = await this.constructScratchPad(steps);\n    const newInputs: ChainValues = {\n      ...inputs,\n      agent_scratchpad: thoughts,\n    };\n    if (this._stop().length !== 0) {\n      newInputs.stop = this._stop();\n    }\n\n    // Split inputs between prompt and llm\n    const llm = this.llmChain.llm as\n      | ChatOpenAI\n      | Runnable<\n          BaseLanguageModelInput,\n          BaseMessageChunk,\n          ChatOpenAICallOptions\n        >;\n\n    const valuesForPrompt = { ...newInputs };\n    const valuesForLLM: CallOptionsIfAvailable<typeof llm> = {\n      functions: this.tools.map((tool) => convertToOpenAIFunction(tool)),\n    };\n    const callKeys =\n      \"callKeys\" in this.llmChain.llm ? this.llmChain.llm.callKeys : [];\n    for (const key of callKeys) {\n      if (key in inputs) {\n        valuesForLLM[key as keyof CallOptionsIfAvailable<typeof llm>] =\n          inputs[key];\n        delete valuesForPrompt[key];\n      }\n    }\n\n    const promptValue =\n      await this.llmChain.prompt.formatPromptValue(valuesForPrompt);\n\n    const message = await (\n      llm as Runnable<\n        BaseLanguageModelInput,\n        BaseMessageChunk,\n        ChatOpenAICallOptions\n      >\n    ).invoke(promptValue.toChatMessages(), {\n      ...valuesForLLM,\n      callbacks: callbackManager,\n    });\n    return this.outputParser.parseAIMessage(message);\n  }\n}\n\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI function calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<BaseFunctionCallOptions>;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[];\n  /** The prompt to use, must have an input key for `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style function calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\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 createOpenAIFunctionsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIFunctionsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const llmWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        functions: tools.map((tool) => convertToOpenAIFunction(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: AgentStep[] }) =>\n          formatToOpenAIFunctionMessages(input.steps),\n      }),\n      prompt,\n      llmWithTools,\n      new OpenAIFunctionsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIFunctionsAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["FunctionMessage","AIMessage","Agent","OpenAIFunctionsAgentOutputParser","PREFIX","ChatPromptTemplate","SystemMessagePromptTemplate","MessagesPlaceholder","HumanMessagePromptTemplate","LLMChain","AgentRunnableSequence","RunnablePassthrough","formatToOpenAIFunctionMessages"],"sources":["../../../src/agents/openai_functions/index.ts"],"sourcesContent":["import type {\n  BaseLanguageModelInterface,\n  BaseLanguageModelInput,\n  BaseFunctionCallOptions,\n} from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { Runnable, RunnablePassthrough } from \"@langchain/core/runnables\";\nimport { ChatOpenAI, ChatOpenAICallOptions } from \"@langchain/openai\";\nimport type {\n  AgentAction,\n  AgentFinish,\n  AgentStep,\n} from \"@langchain/core/agents\";\nimport { convertToOpenAIFunction } from \"@langchain/core/utils/function_calling\";\nimport {\n  AIMessage,\n  BaseMessage,\n  FunctionMessage,\n  SystemMessage,\n  BaseMessageChunk,\n} from \"@langchain/core/messages\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport {\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  MessagesPlaceholder,\n  SystemMessagePromptTemplate,\n  BasePromptTemplate,\n} from \"@langchain/core/prompts\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { Agent, AgentArgs, AgentRunnableSequence } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { PREFIX } from \"./prompt.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport {\n  FunctionsAgentAction,\n  OpenAIFunctionsAgentOutputParser,\n} from \"../openai/output_parser.js\";\nimport { formatToOpenAIFunctionMessages } from \"../format_scratchpad/openai_functions.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CallOptionsIfAvailable<T> = T extends { CallOptions: infer CO } ? CO : any;\n\n/**\n * Checks if the given action is a FunctionsAgentAction.\n * @param action The action to check.\n * @returns True if the action is a FunctionsAgentAction, false otherwise.\n */\nfunction isFunctionsAgentAction(\n  action: AgentAction | FunctionsAgentAction\n): action is FunctionsAgentAction {\n  return (action as FunctionsAgentAction).messageLog !== undefined;\n}\n\nfunction _convertAgentStepToMessages(\n  action: AgentAction | FunctionsAgentAction,\n  observation: string\n) {\n  if (isFunctionsAgentAction(action) && action.messageLog !== undefined) {\n    return action.messageLog?.concat(\n      new FunctionMessage(observation, action.tool)\n    );\n  } else {\n    return [new AIMessage(action.log)];\n  }\n}\n\nexport function _formatIntermediateSteps(\n  intermediateSteps: AgentStep[]\n): BaseMessage[] {\n  return intermediateSteps.flatMap(({ action, observation }) =>\n    _convertAgentStepToMessages(action, observation)\n  );\n}\n\n/**\n * Interface for the input data required to create an OpenAIAgent.\n */\nexport interface OpenAIAgentInput extends AgentInput {\n  tools: StructuredToolInterface[];\n}\n\n/**\n * Interface for the arguments required to create a prompt for an\n * OpenAIAgent.\n */\nexport interface OpenAIAgentCreatePromptArgs {\n  prefix?: string;\n  systemMessage?: SystemMessage;\n}\n\n/**\n * Class representing an agent for the OpenAI chat model in LangChain. It\n * extends the Agent class and provides additional functionality specific\n * to the OpenAIAgent type.\n */\nexport class OpenAIAgent extends Agent {\n  static lc_name() {\n    return \"OpenAIAgent\";\n  }\n\n  lc_namespace = [\"langchain\", \"agents\", \"openai\"];\n\n  _agentType() {\n    return \"openai-functions\" 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  tools: StructuredToolInterface[];\n\n  outputParser: OpenAIFunctionsAgentOutputParser =\n    new OpenAIFunctionsAgentOutputParser();\n\n  constructor(input: Omit<OpenAIAgentInput, \"outputParser\">) {\n    super({ ...input, outputParser: undefined });\n    this.tools = input.tools;\n  }\n\n  /**\n   * Creates a prompt for the OpenAIAgent using the provided tools and\n   * fields.\n   * @param _tools The tools to be used in the prompt.\n   * @param fields Optional fields for creating the prompt.\n   * @returns A BasePromptTemplate object representing the created prompt.\n   */\n  static createPrompt(\n    _tools: StructuredToolInterface[],\n    fields?: OpenAIAgentCreatePromptArgs\n  ): BasePromptTemplate {\n    const { prefix = PREFIX } = fields || {};\n    return ChatPromptTemplate.fromMessages([\n      SystemMessagePromptTemplate.fromTemplate(prefix),\n      new MessagesPlaceholder(\"chat_history\"),\n      HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n      new MessagesPlaceholder(\"agent_scratchpad\"),\n    ]);\n  }\n\n  /**\n   * Creates an OpenAIAgent from a BaseLanguageModel and a list of tools.\n   * @param llm The BaseLanguageModel to use.\n   * @param tools The tools to be used by the agent.\n   * @param args Optional arguments for creating the agent.\n   * @returns An instance of OpenAIAgent.\n   */\n  static fromLLMAndTools(\n    llm: BaseLanguageModelInterface,\n    tools: StructuredToolInterface[],\n    args?: OpenAIAgentCreatePromptArgs & Pick<AgentArgs, \"callbacks\">\n  ) {\n    OpenAIAgent.validateTools(tools);\n    if (llm._modelType() !== \"base_chat_model\" || llm._llmType() !== \"openai\") {\n      throw new Error(\"OpenAIAgent requires an OpenAI chat model\");\n    }\n    const prompt = OpenAIAgent.createPrompt(tools, args);\n    const chain = new LLMChain({\n      prompt,\n      llm,\n      callbacks: args?.callbacks,\n    });\n    return new OpenAIAgent({\n      llmChain: chain,\n      allowedTools: tools.map((t) => t.name),\n      tools,\n    });\n  }\n\n  /**\n   * Constructs a scratch pad from a list of agent steps.\n   * @param steps The steps to include in the scratch pad.\n   * @returns A string or a list of BaseMessages representing the constructed scratch pad.\n   */\n  async constructScratchPad(\n    steps: AgentStep[]\n  ): Promise<string | BaseMessage[]> {\n    return _formatIntermediateSteps(steps);\n  }\n\n  /**\n   * Plans the next action or finish state of the agent based on the\n   * provided steps, inputs, and optional callback manager.\n   * @param steps The steps to consider in planning.\n   * @param inputs The inputs to consider in planning.\n   * @param callbackManager Optional CallbackManager to use in planning.\n   * @returns A Promise that resolves to an AgentAction or AgentFinish object representing the planned action or finish state.\n   */\n  async plan(\n    steps: Array<AgentStep>,\n    inputs: ChainValues,\n    callbackManager?: CallbackManager\n  ): Promise<AgentAction | AgentFinish> {\n    // Add scratchpad and stop to inputs\n    const thoughts = await this.constructScratchPad(steps);\n    const newInputs: ChainValues = {\n      ...inputs,\n      agent_scratchpad: thoughts,\n    };\n    if (this._stop().length !== 0) {\n      newInputs.stop = this._stop();\n    }\n\n    // Split inputs between prompt and llm\n    const llm = this.llmChain.llm as\n      | ChatOpenAI\n      | Runnable<\n          BaseLanguageModelInput,\n          BaseMessageChunk,\n          ChatOpenAICallOptions\n        >;\n\n    const valuesForPrompt = { ...newInputs };\n    const valuesForLLM: CallOptionsIfAvailable<typeof llm> = {\n      functions: this.tools.map((tool) => convertToOpenAIFunction(tool)),\n    };\n    const callKeys =\n      \"callKeys\" in this.llmChain.llm ? this.llmChain.llm.callKeys : [];\n    for (const key of callKeys) {\n      if (key in inputs) {\n        valuesForLLM[key as keyof CallOptionsIfAvailable<typeof llm>] =\n          inputs[key];\n        delete valuesForPrompt[key];\n      }\n    }\n\n    const promptValue =\n      await this.llmChain.prompt.formatPromptValue(valuesForPrompt);\n\n    const message = await (\n      llm as Runnable<\n        BaseLanguageModelInput,\n        BaseMessageChunk,\n        ChatOpenAICallOptions\n      >\n    ).invoke(promptValue.toChatMessages(), {\n      ...valuesForLLM,\n      callbacks: callbackManager,\n    });\n    return this.outputParser.parseAIMessage(message);\n  }\n}\n\n/**\n * Params used by the createOpenAIFunctionsAgent function.\n */\nexport type CreateOpenAIFunctionsAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI function calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: BaseChatModel<BaseFunctionCallOptions>;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[];\n  /** The prompt to use, must have an input key for `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses OpenAI-style function calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIFunctionsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-functions-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-functions-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   model: \"gpt-4o-mini\",\n *   temperature: 0,\n * });\n *\n * const agent = await createOpenAIFunctionsAgent({\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 createOpenAIFunctionsAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateOpenAIFunctionsAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  const llmWithTools = llm.bindTools\n    ? llm.bindTools(tools)\n    : llm.withConfig({\n        functions: tools.map((tool) => convertToOpenAIFunction(tool)),\n      });\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: AgentStep[] }) =>\n          formatToOpenAIFunctionMessages(input.steps),\n      }),\n      prompt,\n      llmWithTools,\n      new OpenAIFunctionsAgentOutputParser(),\n    ],\n    {\n      name: \"OpenAIFunctionsAgent\",\n      streamRunnable,\n      singleAction: true,\n    }\n  );\n  return agent;\n}\n"],"mappings":"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"}

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

@@ -11,7 +11,6 @@ import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 
 //#region src/agents/openai_functions/index.d.ts
-
 /**
  * Interface for the input data required to create an OpenAIAgent.
  */
@@ -82,10 +81,8 @@ type CreateOpenAIFunctionsAgentParams = {
    * so must either be an OpenAI model that supports that or a wrapper of
    * a different model that adds in equivalent support.
    */
-  llm: BaseChatModel<BaseFunctionCallOptions>;
-  /** Tools this agent has access to. */
-  tools: StructuredToolInterface[];
-  /** The prompt to use, must have an input key for `agent_scratchpad`. */
+  llm: BaseChatModel<BaseFunctionCallOptions>; /** Tools this agent has access to. */
+  tools: StructuredToolInterface[]; /** The prompt to use, must have an input key for `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,