@langchain/classic 1.0.17 → 1.0.18

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.cts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;;;;;AAWA;;;;AAAwDI,cAAnCE,0BAAAA,SAAmCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;EA0B9DI,QAAAA,SAAAA;EACAF,WAAAA,CAAAA,MAAAA,EAAAA;IAC2BJ,SAAAA,EAAAA,MAAAA,EAAAA;EAAcC,CAAAA;EAAjCE;AAAkB;AAqB3C;;;;;;EA2BwBL,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9DCO,OA8DDP,CA9DSE,WA8DTF,GA9DuBG,WA8DvBH,CAAAA;EAA0CQ;;;;AA3BwB;;;;;;;UAvBzEA,8BAAAA;eACAF;uBACQD,mBAAmBH,cAAcC;;;;;;;;;;;;;;;;;;;;;cAqBrCM,qCAAAA,SAA8CL,uBAAAA;;;;;sBAK3CI;;;;;;;kCAOYP,YAAYM,QAAQL,cAAcC;;;;;;;;;;;;;;;sBAe9CH,qCAAqCU,KAAKF,wDAAwDC"}
+{"version":3,"file":"outputParser.d.cts","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"mappings":";;;;;;;;;AAkBA;;;;cAAa,0BAAA,SAAmC,uBAAA;EAC9C,YAAA;EAAA,QAEQ,SAAA;EAER,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA;EAJtB;;;;;;;;EAiBM,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;EAAA;;;;AAuCnD;EAXE,qBAAA,CAAA;AAAA;;;;;UAWe,8BAAA;EACf,UAAA,GAAa,0BAAA;EACb,kBAAA,GAAqB,kBAAA,CAAmB,WAAA,GAAc,WAAA;EACtD,SAAA;AAAA;;;;;;;AAqBF;;;;;;;;;;;;cAAa,qCAAA,SAA8C,uBAAA;EACzD,YAAA;EAAA,QAEQ,UAAA;EAAA,QAEA,kBAAA;EAAA,QAEA,SAAA;EAER,WAAA,CAAY,MAAA,EAAQ,8BAAA;EAJZ;;;;;;EAmBF,KAAA,CACJ,IAAA,UACA,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,WAAA,GAAc,WAAA;EADX;;;;;EAad,qBAAA,CAAA;EAcO;;;;;;;;EAAA,OAAA,OAAA,CACL,GAAA,EAAK,0BAAA,EACL,OAAA,EAAS,IAAA,CAAK,8BAAA,0BACb,qCAAA;AAAA"}

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

@@ -5,7 +5,6 @@ import { Callbacks } from "@langchain/core/callbacks/manager";
 import { AgentAction, AgentFinish } from "@langchain/core/agents";
 
 //#region src/agents/structured_chat/outputParser.d.ts
-
 /**
  * A class that provides a custom implementation for parsing the output of
  * a StructuredChatAgent action. It extends the `AgentActionOutputParser`

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

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.ts","names":["BaseLanguageModelInterface","Callbacks","AgentAction","AgentFinish","AgentActionOutputParser","OutputFixingParser","StructuredChatOutputParser","Promise","StructuredChatOutputParserArgs","StructuredChatOutputParserWithRetries","Omit"],"sources":["../../../src/agents/structured_chat/outputParser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { AgentAction, AgentFinish } from \"@langchain/core/agents\";\nimport { AgentActionOutputParser } from \"../types.js\";\nimport { OutputFixingParser } from \"../../output_parsers/fix.js\";\n/**\n * A class that provides a custom implementation for parsing the output of\n * a StructuredChatAgent action. It extends the `AgentActionOutputParser`\n * class and extracts the action and action input from the text output,\n * returning an `AgentAction` or `AgentFinish` object.\n */\nexport declare class StructuredChatOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private toolNames;\n    constructor(fields: {\n        toolNames: string[];\n    });\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. If an `OutputFixingParser` is provided, it is used for parsing;\n     * otherwise, the base parser is used.\n     * @param text The text to parse.\n     * @param callbacks Optional callbacks for asynchronous operations.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n}\n/**\n * An interface for the arguments used to construct a\n * `StructuredChatOutputParserWithRetries` instance.\n */\nexport interface StructuredChatOutputParserArgs {\n    baseParser?: StructuredChatOutputParser;\n    outputFixingParser?: OutputFixingParser<AgentAction | AgentFinish>;\n    toolNames?: string[];\n}\n/**\n * A class that provides a wrapper around the `StructuredChatOutputParser`\n * and `OutputFixingParser` classes. It extends the\n * `AgentActionOutputParser` class and allows for retrying the output\n * parsing using the `OutputFixingParser` if it is provided.\n * @example\n * ```typescript\n * const outputParser = new StructuredChatOutputParserWithRetries.fromLLM(\n *   new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   {\n *     toolNames: [\"calculator\", \"random-number-generator\"],\n *   },\n * );\n * const result = await outputParser.parse(\n *  \"What is a random number between 5 and 10 raised to the second power?\"\n * );\n * ```\n */\nexport declare class StructuredChatOutputParserWithRetries extends AgentActionOutputParser {\n    lc_namespace: string[];\n    private baseParser;\n    private outputFixingParser?;\n    private toolNames;\n    constructor(fields: StructuredChatOutputParserArgs);\n    /**\n     * Parses the given text and returns an `AgentAction` or `AgentFinish`\n     * object. Throws an `OutputParserException` if the parsing fails.\n     * @param text The text to parse.\n     * @returns A Promise that resolves to an `AgentAction` or `AgentFinish` object.\n     */\n    parse(text: string, callbacks?: Callbacks): Promise<AgentAction | AgentFinish>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the StructuredChatAgent.\n     * @returns A string representing the format instructions.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Creates a new `StructuredChatOutputParserWithRetries` instance from a\n     * `BaseLanguageModel` and options. The options can include a base parser\n     * and tool names.\n     * @param llm A `BaseLanguageModel` instance.\n     * @param options Options for creating a `StructuredChatOutputParserWithRetries` instance.\n     * @returns A new `StructuredChatOutputParserWithRetries` instance.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, options: Omit<StructuredChatOutputParserArgs, \"outputFixingParser\">): StructuredChatOutputParserWithRetries;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;;;;;AAWA;;;;AAAwDI,cAAnCE,0BAAAA,SAAmCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;EA0B9DI,QAAAA,SAAAA;EACAF,WAAAA,CAAAA,MAAAA,EAAAA;IAC2BJ,SAAAA,EAAAA,MAAAA,EAAAA;EAAcC,CAAAA;EAAjCE;AAAkB;AAqB3C;;;;;;EA2BwBL,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9DCO,OA8DDP,CA9DSE,WA8DTF,GA9DuBG,WA8DvBH,CAAAA;EAA0CQ;;;;AA3BwB;;;;;;;UAvBzEA,8BAAAA;eACAF;uBACQD,mBAAmBH,cAAcC;;;;;;;;;;;;;;;;;;;;;cAqBrCM,qCAAAA,SAA8CL,uBAAAA;;;;;sBAK3CI;;;;;;;kCAOYP,YAAYM,QAAQL,cAAcC;;;;;;;;;;;;;;;sBAe9CH,qCAAqCU,KAAKF,wDAAwDC"}
+{"version":3,"file":"outputParser.d.ts","names":[],"sources":["../../../src/agents/structured_chat/outputParser.ts"],"mappings":";;;;;;;;;AAkBA;;;;cAAa,0BAAA,SAAmC,uBAAA;EAC9C,YAAA;EAAA,QAEQ,SAAA;EAER,WAAA,CAAY,MAAA;IAAU,SAAA;EAAA;EAJtB;;;;;;;;EAiBM,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,WAAA,GAAc,WAAA;EAAA;;;;AAuCnD;EAXE,qBAAA,CAAA;AAAA;;;;;UAWe,8BAAA;EACf,UAAA,GAAa,0BAAA;EACb,kBAAA,GAAqB,kBAAA,CAAmB,WAAA,GAAc,WAAA;EACtD,SAAA;AAAA;;;;;;;AAqBF;;;;;;;;;;;;cAAa,qCAAA,SAA8C,uBAAA;EACzD,YAAA;EAAA,QAEQ,UAAA;EAAA,QAEA,kBAAA;EAAA,QAEA,SAAA;EAER,WAAA,CAAY,MAAA,EAAQ,8BAAA;EAJZ;;;;;;EAmBF,KAAA,CACJ,IAAA,UACA,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,WAAA,GAAc,WAAA;EADX;;;;;EAad,qBAAA,CAAA;EAcO;;;;;;;;EAAA,OAAA,OAAA,CACL,GAAA,EAAK,0BAAA,EACL,OAAA,EAAS,IAAA,CAAK,8BAAA,0BACb,qCAAA;AAAA"}

package/dist/agents/structured_chat/outputParser.js

@@ -32,11 +32,9 @@ var StructuredChatOutputParser = class extends AgentActionOutputParser {
 	*/
 	async parse(text) {
 		try {
-			const regex = /```(?:json)?(.*)(```)/gs;
-			const actionMatch = regex.exec(text);
+			const actionMatch = /```(?:json)?(.*)(```)/gs.exec(text);
 			if (actionMatch === null) throw new OutputParserException(`Could not parse an action. The agent action must be within a markdown code block, and "action" must be a provided tool or "Final Answer"`);
-			const response = JSON.parse(actionMatch[1].trim());
-			const { action, action_input } = response;
+			const { action, action_input } = JSON.parse(actionMatch[1].trim());
 			if (action === "Final Answer") return {
 				returnValues: { output: action_input },
 				log: text
@@ -120,10 +118,9 @@ var StructuredChatOutputParserWithRetries = class StructuredChatOutputParserWith
 	*/
 	static fromLLM(llm, options) {
 		const baseParser = options.baseParser ?? new StructuredChatOutputParser({ toolNames: options.toolNames ?? [] });
-		const outputFixingParser = OutputFixingParser.fromLLM(llm, baseParser);
 		return new StructuredChatOutputParserWithRetries({
 			baseParser,
-			outputFixingParser,
+			outputFixingParser: OutputFixingParser.fromLLM(llm, baseParser),
 			toolNames: options.toolNames
 		});
 	}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/structured_chat/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions truthfully and as best you can.`;\nexport const AGENT_ACTION_FORMAT_INSTRUCTIONS = `Output a JSON markdown code snippet containing a valid JSON blob (denoted below by $JSON_BLOB).\nThis $JSON_BLOB must have a \"action\" key (with the name of the tool to use) and an \"action_input\" key (tool input).\n\nValid \"action\" values: \"Final Answer\" (which you must use when giving your final response to the user), or one of [{tool_names}].\n\nThe $JSON_BLOB must be valid, parseable JSON and only contain a SINGLE action. Here is an example of an acceptable output:\n\n\\`\\`\\`json\n{{\n  \"action\": $TOOL_NAME,\n  \"action_input\": $INPUT\n}}\n\\`\\`\\`\n\nRemember to include the surrounding markdown code snippet delimiters (begin with \"\\`\\`\\`\" json and close with \"\\`\\`\\`\")!\n`;\nexport const FORMAT_INSTRUCTIONS = `You have access to the following tools.\nYou must format your inputs to these tools to match their \"JSON schema\" definitions below.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nHere are the JSON Schema instances for the tools you have access to:\n\n{tool_schemas}\n\nThe way you use the tools is as follows:\n\n------------------------\n\n${AGENT_ACTION_FORMAT_INSTRUCTIONS}\n\nIf you are using a tool, \"action_input\" must adhere to the tool's input schema, given above.\n\n------------------------\n\nALWAYS use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction:\n\\`\\`\\`json\n$JSON_BLOB\n\\`\\`\\`\nObservation: the result of the action\n... (this Thought/Action/Observation can repeat N times)\nThought: I now know the final answer\nAction:\n\\`\\`\\`json\n{{\n  \"action\": \"Final Answer\",\n  \"action_input\": \"Final response to human\"\n}}\n\\`\\`\\``;\nexport const SUFFIX = `Begin! Reminder to ALWAYS use the above format, and to use tools if appropriate.`;\n"],"mappings":";;AAAA,MAAa,SAAS,CAAC,8DAA8D,CAAC;AACtF,MAAa,mCAAmC,CAAC;;;;;;;;;;;;;;;AAejD,CAAC;AACD,MAAa,sBAAsB,CAAC;;;;;;;;;;;;;;;;;AAiBpC,EAAE,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;MAuB7B,CAAC;AACP,MAAa,SAAS,CAAC,gFAAgF,CAAC"}
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/agents/structured_chat/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions truthfully and as best you can.`;\nexport const AGENT_ACTION_FORMAT_INSTRUCTIONS = `Output a JSON markdown code snippet containing a valid JSON blob (denoted below by $JSON_BLOB).\nThis $JSON_BLOB must have a \"action\" key (with the name of the tool to use) and an \"action_input\" key (tool input).\n\nValid \"action\" values: \"Final Answer\" (which you must use when giving your final response to the user), or one of [{tool_names}].\n\nThe $JSON_BLOB must be valid, parseable JSON and only contain a SINGLE action. Here is an example of an acceptable output:\n\n\\`\\`\\`json\n{{\n  \"action\": $TOOL_NAME,\n  \"action_input\": $INPUT\n}}\n\\`\\`\\`\n\nRemember to include the surrounding markdown code snippet delimiters (begin with \"\\`\\`\\`\" json and close with \"\\`\\`\\`\")!\n`;\nexport const FORMAT_INSTRUCTIONS = `You have access to the following tools.\nYou must format your inputs to these tools to match their \"JSON schema\" definitions below.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nHere are the JSON Schema instances for the tools you have access to:\n\n{tool_schemas}\n\nThe way you use the tools is as follows:\n\n------------------------\n\n${AGENT_ACTION_FORMAT_INSTRUCTIONS}\n\nIf you are using a tool, \"action_input\" must adhere to the tool's input schema, given above.\n\n------------------------\n\nALWAYS use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction:\n\\`\\`\\`json\n$JSON_BLOB\n\\`\\`\\`\nObservation: the result of the action\n... (this Thought/Action/Observation can repeat N times)\nThought: I now know the final answer\nAction:\n\\`\\`\\`json\n{{\n  \"action\": \"Final Answer\",\n  \"action_input\": \"Final response to human\"\n}}\n\\`\\`\\``;\nexport const SUFFIX = `Begin! Reminder to ALWAYS use the above format, and to use tools if appropriate.`;\n"],"mappings":";;AAAA,MAAa,SAAS;AACtB,MAAa,mCAAmC;;;;;;;;;;;;;;;;AAgBhD,MAAa,sBAAsB;;;;;;;;;;;;;;;;;EAiBjC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;AAwBnC,MAAa,SAAS"}

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

@@ -1 +1 @@
-{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/structured_chat/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions truthfully and as best you can.`;\nexport const AGENT_ACTION_FORMAT_INSTRUCTIONS = `Output a JSON markdown code snippet containing a valid JSON blob (denoted below by $JSON_BLOB).\nThis $JSON_BLOB must have a \"action\" key (with the name of the tool to use) and an \"action_input\" key (tool input).\n\nValid \"action\" values: \"Final Answer\" (which you must use when giving your final response to the user), or one of [{tool_names}].\n\nThe $JSON_BLOB must be valid, parseable JSON and only contain a SINGLE action. Here is an example of an acceptable output:\n\n\\`\\`\\`json\n{{\n  \"action\": $TOOL_NAME,\n  \"action_input\": $INPUT\n}}\n\\`\\`\\`\n\nRemember to include the surrounding markdown code snippet delimiters (begin with \"\\`\\`\\`\" json and close with \"\\`\\`\\`\")!\n`;\nexport const FORMAT_INSTRUCTIONS = `You have access to the following tools.\nYou must format your inputs to these tools to match their \"JSON schema\" definitions below.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nHere are the JSON Schema instances for the tools you have access to:\n\n{tool_schemas}\n\nThe way you use the tools is as follows:\n\n------------------------\n\n${AGENT_ACTION_FORMAT_INSTRUCTIONS}\n\nIf you are using a tool, \"action_input\" must adhere to the tool's input schema, given above.\n\n------------------------\n\nALWAYS use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction:\n\\`\\`\\`json\n$JSON_BLOB\n\\`\\`\\`\nObservation: the result of the action\n... (this Thought/Action/Observation can repeat N times)\nThought: I now know the final answer\nAction:\n\\`\\`\\`json\n{{\n  \"action\": \"Final Answer\",\n  \"action_input\": \"Final response to human\"\n}}\n\\`\\`\\``;\nexport const SUFFIX = `Begin! Reminder to ALWAYS use the above format, and to use tools if appropriate.`;\n"],"mappings":";AAAA,MAAa,SAAS,CAAC,8DAA8D,CAAC;AACtF,MAAa,mCAAmC,CAAC;;;;;;;;;;;;;;;AAejD,CAAC;AACD,MAAa,sBAAsB,CAAC;;;;;;;;;;;;;;;;;AAiBpC,EAAE,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;MAuB7B,CAAC;AACP,MAAa,SAAS,CAAC,gFAAgF,CAAC"}
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/agents/structured_chat/prompt.ts"],"sourcesContent":["export const PREFIX = `Answer the following questions truthfully and as best you can.`;\nexport const AGENT_ACTION_FORMAT_INSTRUCTIONS = `Output a JSON markdown code snippet containing a valid JSON blob (denoted below by $JSON_BLOB).\nThis $JSON_BLOB must have a \"action\" key (with the name of the tool to use) and an \"action_input\" key (tool input).\n\nValid \"action\" values: \"Final Answer\" (which you must use when giving your final response to the user), or one of [{tool_names}].\n\nThe $JSON_BLOB must be valid, parseable JSON and only contain a SINGLE action. Here is an example of an acceptable output:\n\n\\`\\`\\`json\n{{\n  \"action\": $TOOL_NAME,\n  \"action_input\": $INPUT\n}}\n\\`\\`\\`\n\nRemember to include the surrounding markdown code snippet delimiters (begin with \"\\`\\`\\`\" json and close with \"\\`\\`\\`\")!\n`;\nexport const FORMAT_INSTRUCTIONS = `You have access to the following tools.\nYou must format your inputs to these tools to match their \"JSON schema\" definitions below.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nHere are the JSON Schema instances for the tools you have access to:\n\n{tool_schemas}\n\nThe way you use the tools is as follows:\n\n------------------------\n\n${AGENT_ACTION_FORMAT_INSTRUCTIONS}\n\nIf you are using a tool, \"action_input\" must adhere to the tool's input schema, given above.\n\n------------------------\n\nALWAYS use the following format:\n\nQuestion: the input question you must answer\nThought: you should always think about what to do\nAction:\n\\`\\`\\`json\n$JSON_BLOB\n\\`\\`\\`\nObservation: the result of the action\n... (this Thought/Action/Observation can repeat N times)\nThought: I now know the final answer\nAction:\n\\`\\`\\`json\n{{\n  \"action\": \"Final Answer\",\n  \"action_input\": \"Final response to human\"\n}}\n\\`\\`\\``;\nexport const SUFFIX = `Begin! Reminder to ALWAYS use the above format, and to use tools if appropriate.`;\n"],"mappings":";AAAA,MAAa,SAAS;AACtB,MAAa,mCAAmC;;;;;;;;;;;;;;;;AAgBhD,MAAa,sBAAsB;;;;;;;;;;;;;;;;;EAiBjC,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;AAwBnC,MAAa,SAAS"}

package/dist/agents/tool_calling/index.cjs

@@ -1,8 +1,8 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_agent = require('../agent.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_tool_calling = require('../format_scratchpad/tool_calling.cjs');
+const require_agent = require('../agent.cjs');
 const require_output_parser = require('./output_parser.cjs');
-const __langchain_core_runnables = require_rolldown_runtime.__toESM(require("@langchain/core/runnables"));
+let _langchain_core_runnables = require("@langchain/core/runnables");
 
 //#region src/agents/tool_calling/index.ts
 function _isBaseChatModel(x) {
@@ -66,8 +66,8 @@ function createToolCallingAgent({ llm, tools, prompt, streamRunnable }) {
 		if (llm.bindTools === void 0) throw new Error(`This agent requires that the "bind_tools()" method be implemented on the input model.`);
 		modelWithTools = llm.bindTools(tools);
 	} else modelWithTools = llm;
-	const agent = require_agent.AgentRunnableSequence.fromRunnables([
-		__langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_tool_calling.formatToToolMessages(input.steps) }),
+	return require_agent.AgentRunnableSequence.fromRunnables([
+		_langchain_core_runnables.RunnablePassthrough.assign({ agent_scratchpad: (input) => require_tool_calling.formatToToolMessages(input.steps) }),
 		prompt,
 		modelWithTools,
 		new require_output_parser.ToolCallingAgentOutputParser()
@@ -76,7 +76,6 @@ function createToolCallingAgent({ llm, tools, prompt, streamRunnable }) {
 		streamRunnable,
 		singleAction: false
 	});
-	return agent;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["x: LanguageModelLike","AgentRunnableSequence","RunnablePassthrough","input: { steps: ToolsAgentStep[] }","formatToToolMessages","ToolCallingAgentOutputParser"],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: LanguageModelLike;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;AAeA,SAAS,iBAAiBA,GAA0C;CAClE,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,cAC5B,MAAM,YAAY,KAAK;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyED,SAAgB,uBAAuB,EACrC,KACA,OACA,QACA,gBAC6B,EAAE;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,CAAC,4DAA4D,CAAC,EAC9D,CAAC,MAAM,EAAE,KAAK,UAAU,OAAO,eAAe,CAAC,SAAS,CAAC,AAC1D,EAAC,KAAK,KAAK;CAGhB,IAAI;AACJ,KAAI,iBAAiB,IAAI,EAAE;AACzB,MAAI,IAAI,cAAc,OACpB,OAAM,IAAI,MACR,CAAC,qFAAqF,CAAC;EAG3F,iBAAiB,IAAI,UAAU,MAAM;CACtC,OACC,iBAAiB;CAGnB,MAAM,QAAQC,oCAAsB,cAClC;EACEC,+CAAoB,OAAO,EACzB,kBAAkB,CAACC,UACjBC,0CAAqB,MAAM,MAAM,CACpC,EAAC;EACF;EACA;EACA,IAAIC;CACL,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}
+{"version":3,"file":"index.cjs","names":["AgentRunnableSequence","RunnablePassthrough","formatToToolMessages","ToolCallingAgentOutputParser"],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: LanguageModelLike;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;;AAeA,SAAS,iBAAiB,GAA0C;CAClE,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,cAC5B,MAAM,YAAY,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2E3B,SAAgB,uBAAuB,EACrC,KACA,OACA,QACA,kBAC+B;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,gEACA,SAAS,KAAK,UAAU,OAAO,eAAe,CAAC,WAChD,CAAC,KAAK,KAAK,CACb;CAEH,IAAI;AACJ,KAAI,iBAAiB,IAAI,EAAE;AACzB,MAAI,IAAI,cAAc,OACpB,OAAM,IAAI,MACR,wFACD;AAEH,mBAAiB,IAAI,UAAU,MAAM;OAErC,kBAAiB;AAmBnB,QAhBcA,oCAAsB,cAClC;EACEC,8CAAoB,OAAO,EACzB,mBAAmB,UACjBC,0CAAqB,MAAM,MAAM,EACpC,CAAC;EACF;EACA;EACA,IAAIC,oDAA8B;EACnC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

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

@@ -1,6 +1,6 @@
 import { ToolsAgentStep } from "./output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
-import * as _langchain_core_agents3 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -15,10 +15,8 @@ type CreateToolCallingAgentParams = {
    * so must either be an OpenAI model that supports that or a wrapper of
    * a different model that adds in equivalent support.
    */
-  llm: LanguageModelLike;
-  /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[];
-  /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  llm: LanguageModelLike; /** Tools this agent has access to. */
+  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,
@@ -83,7 +81,7 @@ declare function createToolCallingAgent({
   streamRunnable
 }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>;
+}, _langchain_core_agents0.AgentFinish | _langchain_core_agents0.AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.cts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"mappings":";;;;;;;;;;;KA0BY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,iBAAA,EAIqB;EAF1B,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAFnC;EAIA,MAAA,EAAQ,kBAAA;EAFR;;;;EAOA,cAAA;AAAA;;;AAqDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,sBAAA,CAAA;EACd,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,qBAAA"}

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

@@ -15,10 +15,8 @@ type CreateToolCallingAgentParams = {
    * so must either be an OpenAI model that supports that or a wrapper of
    * a different model that adds in equivalent support.
    */
-  llm: LanguageModelLike;
-  /** Tools this agent has access to. */
-  tools: StructuredToolInterface[] | ToolDefinition[];
-  /** The prompt to use, must have an input key of `agent_scratchpad`. */
+  llm: LanguageModelLike; /** Tools this agent has access to. */
+  tools: StructuredToolInterface[] | ToolDefinition[]; /** The prompt to use, must have an input key of `agent_scratchpad`. */
   prompt: ChatPromptTemplate;
   /**
    * Whether to invoke the underlying model in streaming mode,

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"mappings":";;;;;;;;;;;KA0BY,4BAAA;EAA4B;;;;;EAMtC,GAAA,EAAK,iBAAA,EAIqB;EAF1B,KAAA,EAAO,uBAAA,KAA4B,cAAA,IAFnC;EAIA,MAAA,EAAQ,kBAAA;EAFR;;;;EAOA,cAAA;AAAA;;;AAqDF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,sBAAA,CAAA;EACd,GAAA;EACA,KAAA;EACA,MAAA;EACA;AAAA,GACC,4BAAA,GAA4B,qBAAA"}

package/dist/agents/tool_calling/index.js

@@ -1,5 +1,5 @@
-import { AgentRunnableSequence } from "../agent.js";
 import { formatToToolMessages } from "../format_scratchpad/tool_calling.js";
+import { AgentRunnableSequence } from "../agent.js";
 import { ToolCallingAgentOutputParser } from "./output_parser.js";
 import { RunnablePassthrough } from "@langchain/core/runnables";
 
@@ -65,7 +65,7 @@ function createToolCallingAgent({ llm, tools, prompt, streamRunnable }) {
 		if (llm.bindTools === void 0) throw new Error(`This agent requires that the "bind_tools()" method be implemented on the input model.`);
 		modelWithTools = llm.bindTools(tools);
 	} else modelWithTools = llm;
-	const agent = AgentRunnableSequence.fromRunnables([
+	return AgentRunnableSequence.fromRunnables([
 		RunnablePassthrough.assign({ agent_scratchpad: (input) => formatToToolMessages(input.steps) }),
 		prompt,
 		modelWithTools,
@@ -75,7 +75,6 @@ function createToolCallingAgent({ llm, tools, prompt, streamRunnable }) {
 		streamRunnable,
 		singleAction: false
 	});
-	return agent;
 }
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["x: LanguageModelLike","input: { steps: ToolsAgentStep[] }"],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: LanguageModelLike;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;AAeA,SAAS,iBAAiBA,GAA0C;CAClE,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,cAC5B,MAAM,YAAY,KAAK;AAE1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyED,SAAgB,uBAAuB,EACrC,KACA,OACA,QACA,gBAC6B,EAAE;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,CAAC,4DAA4D,CAAC,EAC9D,CAAC,MAAM,EAAE,KAAK,UAAU,OAAO,eAAe,CAAC,SAAS,CAAC,AAC1D,EAAC,KAAK,KAAK;CAGhB,IAAI;AACJ,KAAI,iBAAiB,IAAI,EAAE;AACzB,MAAI,IAAI,cAAc,OACpB,OAAM,IAAI,MACR,CAAC,qFAAqF,CAAC;EAG3F,iBAAiB,IAAI,UAAU,MAAM;CACtC,OACC,iBAAiB;CAGnB,MAAM,QAAQ,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,kBAAkB,CAACC,UACjB,qBAAqB,MAAM,MAAM,CACpC,EAAC;EACF;EACA;EACA,IAAI;CACL,GACD;EACE,MAAM;EACN;EACA,cAAc;CACf,EACF;AACD,QAAO;AACR"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/agents/tool_calling/index.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { RunnablePassthrough } from \"@langchain/core/runnables\";\nimport {\n  LanguageModelLike,\n  ToolDefinition,\n} from \"@langchain/core/language_models/base\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport {\n  ToolCallingAgentOutputParser,\n  ToolsAgentStep,\n} from \"./output_parser.js\";\nimport { formatToToolMessages } from \"../format_scratchpad/tool_calling.js\";\n\nfunction _isBaseChatModel(x: LanguageModelLike): x is BaseChatModel {\n  const model = x as BaseChatModel;\n  return (\n    typeof model._modelType === \"function\" &&\n    model._modelType() === \"base_chat_model\"\n  );\n}\n\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n  /**\n   * LLM to use as the agent. Should work with OpenAI tool calling,\n   * so must either be an OpenAI model that supports that or a wrapper of\n   * a different model that adds in equivalent support.\n   */\n  llm: LanguageModelLike;\n  /** Tools this agent has access to. */\n  tools: StructuredToolInterface[] | ToolDefinition[];\n  /** The prompt to use, must have an input key of `agent_scratchpad`. */\n  prompt: ChatPromptTemplate;\n  /**\n   * Whether to invoke the underlying model in streaming mode,\n   * allowing streaming of intermediate steps. Defaults to true.\n   */\n  streamRunnable?: boolean;\n};\n\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport function createToolCallingAgent({\n  llm,\n  tools,\n  prompt,\n  streamRunnable,\n}: CreateToolCallingAgentParams) {\n  if (!prompt.inputVariables.includes(\"agent_scratchpad\")) {\n    throw new Error(\n      [\n        `Prompt must have an input variable named \"agent_scratchpad\".`,\n        `Found ${JSON.stringify(prompt.inputVariables)} instead.`,\n      ].join(\"\\n\")\n    );\n  }\n  let modelWithTools;\n  if (_isBaseChatModel(llm)) {\n    if (llm.bindTools === undefined) {\n      throw new Error(\n        `This agent requires that the \"bind_tools()\" method be implemented on the input model.`\n      );\n    }\n    modelWithTools = llm.bindTools(tools);\n  } else {\n    modelWithTools = llm;\n  }\n\n  const agent = AgentRunnableSequence.fromRunnables(\n    [\n      RunnablePassthrough.assign({\n        agent_scratchpad: (input: { steps: ToolsAgentStep[] }) =>\n          formatToToolMessages(input.steps),\n      }),\n      prompt,\n      modelWithTools,\n      new ToolCallingAgentOutputParser(),\n    ],\n    {\n      name: \"ToolCallingAgent\",\n      streamRunnable,\n      singleAction: false,\n    }\n  );\n  return agent;\n}\n"],"mappings":";;;;;;AAeA,SAAS,iBAAiB,GAA0C;CAClE,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,cAC5B,MAAM,YAAY,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2E3B,SAAgB,uBAAuB,EACrC,KACA,OACA,QACA,kBAC+B;AAC/B,KAAI,CAAC,OAAO,eAAe,SAAS,mBAAmB,CACrD,OAAM,IAAI,MACR,CACE,gEACA,SAAS,KAAK,UAAU,OAAO,eAAe,CAAC,WAChD,CAAC,KAAK,KAAK,CACb;CAEH,IAAI;AACJ,KAAI,iBAAiB,IAAI,EAAE;AACzB,MAAI,IAAI,cAAc,OACpB,OAAM,IAAI,MACR,wFACD;AAEH,mBAAiB,IAAI,UAAU,MAAM;OAErC,kBAAiB;AAmBnB,QAhBc,sBAAsB,cAClC;EACE,oBAAoB,OAAO,EACzB,mBAAmB,UACjB,qBAAqB,MAAM,MAAM,EACpC,CAAC;EACF;EACA;EACA,IAAI,8BAA8B;EACnC,EACD;EACE,MAAM;EACN;EACA,cAAc;EACf,CACF"}

package/dist/agents/tool_calling/output_parser.cjs

@@ -1,7 +1,7 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_types = require('../types.cjs');
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
-const __langchain_core_messages = require_rolldown_runtime.__toESM(require("@langchain/core/messages"));
+let _langchain_core_messages = require("@langchain/core/messages");
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/agents/tool_calling/output_parser.ts
 function parseAIMessageToToolAction(message) {
@@ -23,7 +23,7 @@ function parseAIMessageToToolAction(message) {
 					id: toolCall.id
 				});
 			} catch (e) {
-				throw new __langchain_core_output_parsers.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${e}`);
+				throw new _langchain_core_output_parsers.OutputParserException(`Failed to parse tool arguments from chat model response. Text: "${JSON.stringify(toolCalls)}". ${e}`);
 			}
 		}
 	}
@@ -52,7 +52,7 @@ var ToolCallingAgentOutputParser = class extends require_types.AgentMultiActionO
 		throw new Error(`ToolCallingAgentOutputParser can only parse messages.\nPassed input: ${text}`);
 	}
 	async parseResult(generations) {
-		if ("message" in generations[0] && (0, __langchain_core_messages.isBaseMessage)(generations[0].message)) return parseAIMessageToToolAction(generations[0].message);
+		if ("message" in generations[0] && (0, _langchain_core_messages.isBaseMessage)(generations[0].message)) return parseAIMessageToToolAction(generations[0].message);
 		throw new Error("parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output");
 	}
 	getFormatInstructions() {

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.cjs","names":["message: AIMessage","toolCalls: ToolCall[]","e: any","OutputParserException","AgentMultiActionOutputParser","text: string","generations: ChatGeneration[]"],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport {\n  AIMessage,\n  BaseMessage,\n  isBaseMessage,\n} from \"@langchain/core/messages\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n  toolCallId: string;\n  messageLog?: BaseMessage[];\n};\n\nexport type ToolsAgentStep = AgentStep & {\n  action: ToolsAgentAction;\n};\n\nexport function parseAIMessageToToolAction(\n  message: AIMessage\n): ToolsAgentAction[] | AgentFinish {\n  const stringifiedMessageContent =\n    typeof message.content === \"string\"\n      ? message.content\n      : JSON.stringify(message.content);\n  let toolCalls: ToolCall[] = [];\n  if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n    toolCalls = message.tool_calls;\n  } else {\n    if (\n      !message.additional_kwargs.tool_calls ||\n      message.additional_kwargs.tool_calls.length === 0\n    ) {\n      return {\n        returnValues: { output: message.content },\n        log: stringifiedMessageContent,\n      };\n    }\n    // Best effort parsing\n    for (const toolCall of message.additional_kwargs.tool_calls ?? []) {\n      const functionName = toolCall.function?.name;\n      try {\n        const args = JSON.parse(toolCall.function.arguments);\n        toolCalls.push({ name: functionName, args, id: toolCall.id });\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (e: any) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${e}`\n        );\n      }\n    }\n  }\n  return toolCalls.map((toolCall, i) => {\n    const messageLog = i === 0 ? [message] : [];\n    const log = `Invoking \"${toolCall.name}\" with ${JSON.stringify(\n      toolCall.args ?? {}\n    )}\\n${stringifiedMessageContent}`;\n    return {\n      tool: toolCall.name as string,\n      toolInput: toolCall.args,\n      toolCallId: toolCall.id ?? \"\",\n      log,\n      messageLog,\n    };\n  });\n}\n\nexport class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"tool_calling\"];\n\n  static lc_name() {\n    return \"ToolCallingAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `ToolCallingAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return parseAIMessageToToolAction(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside ToolCallingAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;AAuBA,SAAgB,2BACdA,SACkC;CAClC,MAAM,4BACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,QAAQ;CACrC,IAAIC,YAAwB,CAAE;AAC9B,KAAI,QAAQ,eAAe,UAAa,QAAQ,WAAW,SAAS,GAClE,YAAY,QAAQ;MACf;AACL,MACE,CAAC,QAAQ,kBAAkB,cAC3B,QAAQ,kBAAkB,WAAW,WAAW,EAEhD,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAS;GACzC,KAAK;EACN;AAGH,OAAK,MAAM,YAAY,QAAQ,kBAAkB,cAAc,CAAE,GAAE;GACjE,MAAM,eAAe,SAAS,UAAU;AACxC,OAAI;IACF,MAAM,OAAO,KAAK,MAAM,SAAS,SAAS,UAAU;IACpD,UAAU,KAAK;KAAE,MAAM;KAAc;KAAM,IAAI,SAAS;IAAI,EAAC;GAE9D,SAAQC,GAAQ;AACf,UAAM,IAAIC,sDACR,CAAC,gEAAgE,EAAE,KAAK,UACtE,UACD,CAAC,GAAG,EAAE,GAAG;GAEb;EACF;CACF;AACD,QAAO,UAAU,IAAI,CAAC,UAAU,MAAM;EACpC,MAAM,aAAa,MAAM,IAAI,CAAC,OAAQ,IAAG,CAAE;EAC3C,MAAM,MAAM,CAAC,UAAU,EAAE,SAAS,KAAK,OAAO,EAAE,KAAK,UACnD,SAAS,QAAQ,CAAE,EACpB,CAAC,EAAE,EAAE,2BAA2B;AACjC,SAAO;GACL,MAAM,SAAS;GACf,WAAW,SAAS;GACpB,YAAY,SAAS,MAAM;GAC3B;GACA;EACD;CACF,EAAC;AACH;AAED,IAAa,+BAAb,cAAkDC,2CAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;CAAe;CAEtD,OAAO,UAAU;AACf,SAAO;CACR;CAED,MAAM,MAAMC,MAAoD;AAC9D,QAAM,IAAI,MACR,CAAC,qEAAqE,EAAE,MAAM;CAEjF;CAED,MAAM,YAAYC,aAA+B;AAC/C,MAAI,aAAa,YAAY,mDAAoB,YAAY,GAAG,QAAQ,CACtE,QAAO,2BAA2B,YAAY,GAAG,QAAQ;AAE3D,QAAM,IAAI,MACR;CAEH;CAED,wBAAgC;AAC9B,QAAM,IAAI,MACR;CAEH;AACF"}
+{"version":3,"file":"output_parser.cjs","names":["OutputParserException","AgentMultiActionOutputParser"],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport {\n  AIMessage,\n  BaseMessage,\n  isBaseMessage,\n} from \"@langchain/core/messages\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n  toolCallId: string;\n  messageLog?: BaseMessage[];\n};\n\nexport type ToolsAgentStep = AgentStep & {\n  action: ToolsAgentAction;\n};\n\nexport function parseAIMessageToToolAction(\n  message: AIMessage\n): ToolsAgentAction[] | AgentFinish {\n  const stringifiedMessageContent =\n    typeof message.content === \"string\"\n      ? message.content\n      : JSON.stringify(message.content);\n  let toolCalls: ToolCall[] = [];\n  if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n    toolCalls = message.tool_calls;\n  } else {\n    if (\n      !message.additional_kwargs.tool_calls ||\n      message.additional_kwargs.tool_calls.length === 0\n    ) {\n      return {\n        returnValues: { output: message.content },\n        log: stringifiedMessageContent,\n      };\n    }\n    // Best effort parsing\n    for (const toolCall of message.additional_kwargs.tool_calls ?? []) {\n      const functionName = toolCall.function?.name;\n      try {\n        const args = JSON.parse(toolCall.function.arguments);\n        toolCalls.push({ name: functionName, args, id: toolCall.id });\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (e: any) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${e}`\n        );\n      }\n    }\n  }\n  return toolCalls.map((toolCall, i) => {\n    const messageLog = i === 0 ? [message] : [];\n    const log = `Invoking \"${toolCall.name}\" with ${JSON.stringify(\n      toolCall.args ?? {}\n    )}\\n${stringifiedMessageContent}`;\n    return {\n      tool: toolCall.name as string,\n      toolInput: toolCall.args,\n      toolCallId: toolCall.id ?? \"\",\n      log,\n      messageLog,\n    };\n  });\n}\n\nexport class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"tool_calling\"];\n\n  static lc_name() {\n    return \"ToolCallingAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `ToolCallingAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return parseAIMessageToToolAction(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside ToolCallingAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;;AAuBA,SAAgB,2BACd,SACkC;CAClC,MAAM,4BACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,QAAQ;CACrC,IAAI,YAAwB,EAAE;AAC9B,KAAI,QAAQ,eAAe,UAAa,QAAQ,WAAW,SAAS,EAClE,aAAY,QAAQ;MACf;AACL,MACE,CAAC,QAAQ,kBAAkB,cAC3B,QAAQ,kBAAkB,WAAW,WAAW,EAEhD,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK;GACN;AAGH,OAAK,MAAM,YAAY,QAAQ,kBAAkB,cAAc,EAAE,EAAE;GACjE,MAAM,eAAe,SAAS,UAAU;AACxC,OAAI;IACF,MAAM,OAAO,KAAK,MAAM,SAAS,SAAS,UAAU;AACpD,cAAU,KAAK;KAAE,MAAM;KAAc;KAAM,IAAI,SAAS;KAAI,CAAC;YAEtD,GAAQ;AACf,UAAM,IAAIA,qDACR,mEAAmE,KAAK,UACtE,UACD,CAAC,KAAK,IACR;;;;AAIP,QAAO,UAAU,KAAK,UAAU,MAAM;EACpC,MAAM,aAAa,MAAM,IAAI,CAAC,QAAQ,GAAG,EAAE;EAC3C,MAAM,MAAM,aAAa,SAAS,KAAK,SAAS,KAAK,UACnD,SAAS,QAAQ,EAAE,CACpB,CAAC,IAAI;AACN,SAAO;GACL,MAAM,SAAS;GACf,WAAW,SAAS;GACpB,YAAY,SAAS,MAAM;GAC3B;GACA;GACD;GACD;;AAGJ,IAAa,+BAAb,cAAkDC,2CAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;EAAe;CAEtD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAoD;AAC9D,QAAM,IAAI,MACR,wEAAwE,OACzE;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,kDAAoB,YAAY,GAAG,QAAQ,CACtE,QAAO,2BAA2B,YAAY,GAAG,QAAQ;AAE3D,QAAM,IAAI,MACR,kFACD;;CAGH,wBAAgC;AAC9B,QAAM,IAAI,MACR,6EACD"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.d.cts","names":["AgentAction","AgentFinish","AgentStep","AIMessage","BaseMessage","ChatGeneration","AgentMultiActionOutputParser","ToolsAgentAction","ToolsAgentStep","parseAIMessageToToolAction","ToolCallingAgentOutputParser","Promise"],"sources":["../../../src/agents/tool_calling/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { AIMessage, BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n    toolCallId: string;\n    messageLog?: BaseMessage[];\n};\nexport type ToolsAgentStep = AgentStep & {\n    action: ToolsAgentAction;\n};\nexport declare function parseAIMessageToToolAction(message: AIMessage): ToolsAgentAction[] | AgentFinish;\nexport declare class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction[] | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;AAOA;AAIA;KAJYO,gBAAAA,GAAmBP;;eAEdI;;KAELI,cAAAA,GAAiBN;UACjBK"}
+{"version":3,"file":"output_parser.d.cts","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"mappings":";;;;;;AAcA;;KAAY,gBAAA,GAAmB,WAAA;EAC7B,UAAA;EACA,UAAA,GAAa,WAAA;AAAA;AAAA,KAGH,cAAA,GAAiB,SAAA;EAC3B,MAAA,EAAQ,gBAAA;AAAA"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.d.ts","names":["AgentAction","AgentFinish","AgentStep","AIMessage","BaseMessage","ChatGeneration","AgentMultiActionOutputParser","ToolsAgentAction","ToolsAgentStep","parseAIMessageToToolAction","ToolCallingAgentOutputParser","Promise"],"sources":["../../../src/agents/tool_calling/output_parser.d.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport { AIMessage, BaseMessage } from \"@langchain/core/messages\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n    toolCallId: string;\n    messageLog?: BaseMessage[];\n};\nexport type ToolsAgentStep = AgentStep & {\n    action: ToolsAgentAction;\n};\nexport declare function parseAIMessageToToolAction(message: AIMessage): ToolsAgentAction[] | AgentFinish;\nexport declare class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n    lc_namespace: string[];\n    static lc_name(): string;\n    parse(text: string): Promise<AgentAction[] | AgentFinish>;\n    parseResult(generations: ChatGeneration[]): Promise<AgentFinish | ToolsAgentAction[]>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=output_parser.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAIYQ,KAJAD,gBAAAA,GAAmBP,WAIFE,GACjBK;;eAHKH;;KAELI,cAAAA,GAAiBN;UACjBK"}
+{"version":3,"file":"output_parser.d.ts","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"mappings":";;;;;;;;AAcA;KAAY,gBAAA,GAAmB,WAAA;EAC7B,UAAA;EACA,UAAA,GAAa,WAAA;AAAA;AAAA,KAGH,cAAA,GAAiB,SAAA;EAC3B,MAAA,EAAQ,gBAAA;AAAA"}

package/dist/agents/tool_calling/output_parser.js

@@ -1,6 +1,6 @@
 import { AgentMultiActionOutputParser } from "../types.js";
-import { OutputParserException } from "@langchain/core/output_parsers";
 import { isBaseMessage } from "@langchain/core/messages";
+import { OutputParserException } from "@langchain/core/output_parsers";
 
 //#region src/agents/tool_calling/output_parser.ts
 function parseAIMessageToToolAction(message) {

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

@@ -1 +1 @@
-{"version":3,"file":"output_parser.js","names":["message: AIMessage","toolCalls: ToolCall[]","e: any","text: string","generations: ChatGeneration[]"],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport {\n  AIMessage,\n  BaseMessage,\n  isBaseMessage,\n} from \"@langchain/core/messages\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n  toolCallId: string;\n  messageLog?: BaseMessage[];\n};\n\nexport type ToolsAgentStep = AgentStep & {\n  action: ToolsAgentAction;\n};\n\nexport function parseAIMessageToToolAction(\n  message: AIMessage\n): ToolsAgentAction[] | AgentFinish {\n  const stringifiedMessageContent =\n    typeof message.content === \"string\"\n      ? message.content\n      : JSON.stringify(message.content);\n  let toolCalls: ToolCall[] = [];\n  if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n    toolCalls = message.tool_calls;\n  } else {\n    if (\n      !message.additional_kwargs.tool_calls ||\n      message.additional_kwargs.tool_calls.length === 0\n    ) {\n      return {\n        returnValues: { output: message.content },\n        log: stringifiedMessageContent,\n      };\n    }\n    // Best effort parsing\n    for (const toolCall of message.additional_kwargs.tool_calls ?? []) {\n      const functionName = toolCall.function?.name;\n      try {\n        const args = JSON.parse(toolCall.function.arguments);\n        toolCalls.push({ name: functionName, args, id: toolCall.id });\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (e: any) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${e}`\n        );\n      }\n    }\n  }\n  return toolCalls.map((toolCall, i) => {\n    const messageLog = i === 0 ? [message] : [];\n    const log = `Invoking \"${toolCall.name}\" with ${JSON.stringify(\n      toolCall.args ?? {}\n    )}\\n${stringifiedMessageContent}`;\n    return {\n      tool: toolCall.name as string,\n      toolInput: toolCall.args,\n      toolCallId: toolCall.id ?? \"\",\n      log,\n      messageLog,\n    };\n  });\n}\n\nexport class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"tool_calling\"];\n\n  static lc_name() {\n    return \"ToolCallingAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `ToolCallingAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return parseAIMessageToToolAction(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside ToolCallingAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;AAuBA,SAAgB,2BACdA,SACkC;CAClC,MAAM,4BACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,QAAQ;CACrC,IAAIC,YAAwB,CAAE;AAC9B,KAAI,QAAQ,eAAe,UAAa,QAAQ,WAAW,SAAS,GAClE,YAAY,QAAQ;MACf;AACL,MACE,CAAC,QAAQ,kBAAkB,cAC3B,QAAQ,kBAAkB,WAAW,WAAW,EAEhD,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,QAAS;GACzC,KAAK;EACN;AAGH,OAAK,MAAM,YAAY,QAAQ,kBAAkB,cAAc,CAAE,GAAE;GACjE,MAAM,eAAe,SAAS,UAAU;AACxC,OAAI;IACF,MAAM,OAAO,KAAK,MAAM,SAAS,SAAS,UAAU;IACpD,UAAU,KAAK;KAAE,MAAM;KAAc;KAAM,IAAI,SAAS;IAAI,EAAC;GAE9D,SAAQC,GAAQ;AACf,UAAM,IAAI,sBACR,CAAC,gEAAgE,EAAE,KAAK,UACtE,UACD,CAAC,GAAG,EAAE,GAAG;GAEb;EACF;CACF;AACD,QAAO,UAAU,IAAI,CAAC,UAAU,MAAM;EACpC,MAAM,aAAa,MAAM,IAAI,CAAC,OAAQ,IAAG,CAAE;EAC3C,MAAM,MAAM,CAAC,UAAU,EAAE,SAAS,KAAK,OAAO,EAAE,KAAK,UACnD,SAAS,QAAQ,CAAE,EACpB,CAAC,EAAE,EAAE,2BAA2B;AACjC,SAAO;GACL,MAAM,SAAS;GACf,WAAW,SAAS;GACpB,YAAY,SAAS,MAAM;GAC3B;GACA;EACD;CACF,EAAC;AACH;AAED,IAAa,+BAAb,cAAkD,6BAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;CAAe;CAEtD,OAAO,UAAU;AACf,SAAO;CACR;CAED,MAAM,MAAMC,MAAoD;AAC9D,QAAM,IAAI,MACR,CAAC,qEAAqE,EAAE,MAAM;CAEjF;CAED,MAAM,YAAYC,aAA+B;AAC/C,MAAI,aAAa,YAAY,MAAM,cAAc,YAAY,GAAG,QAAQ,CACtE,QAAO,2BAA2B,YAAY,GAAG,QAAQ;AAE3D,QAAM,IAAI,MACR;CAEH;CAED,wBAAgC;AAC9B,QAAM,IAAI,MACR;CAEH;AACF"}
+{"version":3,"file":"output_parser.js","names":[],"sources":["../../../src/agents/tool_calling/output_parser.ts"],"sourcesContent":["import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\nimport {\n  AIMessage,\n  BaseMessage,\n  isBaseMessage,\n} from \"@langchain/core/messages\";\nimport { OutputParserException } from \"@langchain/core/output_parsers\";\nimport { ChatGeneration } from \"@langchain/core/outputs\";\nimport { ToolCall } from \"@langchain/core/messages/tool\";\nimport { AgentMultiActionOutputParser } from \"../types.js\";\n\n/**\n * Type that represents an agent action with an optional message log.\n */\nexport type ToolsAgentAction = AgentAction & {\n  toolCallId: string;\n  messageLog?: BaseMessage[];\n};\n\nexport type ToolsAgentStep = AgentStep & {\n  action: ToolsAgentAction;\n};\n\nexport function parseAIMessageToToolAction(\n  message: AIMessage\n): ToolsAgentAction[] | AgentFinish {\n  const stringifiedMessageContent =\n    typeof message.content === \"string\"\n      ? message.content\n      : JSON.stringify(message.content);\n  let toolCalls: ToolCall[] = [];\n  if (message.tool_calls !== undefined && message.tool_calls.length > 0) {\n    toolCalls = message.tool_calls;\n  } else {\n    if (\n      !message.additional_kwargs.tool_calls ||\n      message.additional_kwargs.tool_calls.length === 0\n    ) {\n      return {\n        returnValues: { output: message.content },\n        log: stringifiedMessageContent,\n      };\n    }\n    // Best effort parsing\n    for (const toolCall of message.additional_kwargs.tool_calls ?? []) {\n      const functionName = toolCall.function?.name;\n      try {\n        const args = JSON.parse(toolCall.function.arguments);\n        toolCalls.push({ name: functionName, args, id: toolCall.id });\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (e: any) {\n        throw new OutputParserException(\n          `Failed to parse tool arguments from chat model response. Text: \"${JSON.stringify(\n            toolCalls\n          )}\". ${e}`\n        );\n      }\n    }\n  }\n  return toolCalls.map((toolCall, i) => {\n    const messageLog = i === 0 ? [message] : [];\n    const log = `Invoking \"${toolCall.name}\" with ${JSON.stringify(\n      toolCall.args ?? {}\n    )}\\n${stringifiedMessageContent}`;\n    return {\n      tool: toolCall.name as string,\n      toolInput: toolCall.args,\n      toolCallId: toolCall.id ?? \"\",\n      log,\n      messageLog,\n    };\n  });\n}\n\nexport class ToolCallingAgentOutputParser extends AgentMultiActionOutputParser {\n  lc_namespace = [\"langchain\", \"agents\", \"tool_calling\"];\n\n  static lc_name() {\n    return \"ToolCallingAgentOutputParser\";\n  }\n\n  async parse(text: string): Promise<AgentAction[] | AgentFinish> {\n    throw new Error(\n      `ToolCallingAgentOutputParser can only parse messages.\\nPassed input: ${text}`\n    );\n  }\n\n  async parseResult(generations: ChatGeneration[]) {\n    if (\"message\" in generations[0] && isBaseMessage(generations[0].message)) {\n      return parseAIMessageToToolAction(generations[0].message);\n    }\n    throw new Error(\n      \"parseResult on ToolCallingAgentOutputParser only works on ChatGeneration output\"\n    );\n  }\n\n  getFormatInstructions(): string {\n    throw new Error(\n      \"getFormatInstructions not implemented inside ToolCallingAgentOutputParser.\"\n    );\n  }\n}\n"],"mappings":";;;;;AAuBA,SAAgB,2BACd,SACkC;CAClC,MAAM,4BACJ,OAAO,QAAQ,YAAY,WACvB,QAAQ,UACR,KAAK,UAAU,QAAQ,QAAQ;CACrC,IAAI,YAAwB,EAAE;AAC9B,KAAI,QAAQ,eAAe,UAAa,QAAQ,WAAW,SAAS,EAClE,aAAY,QAAQ;MACf;AACL,MACE,CAAC,QAAQ,kBAAkB,cAC3B,QAAQ,kBAAkB,WAAW,WAAW,EAEhD,QAAO;GACL,cAAc,EAAE,QAAQ,QAAQ,SAAS;GACzC,KAAK;GACN;AAGH,OAAK,MAAM,YAAY,QAAQ,kBAAkB,cAAc,EAAE,EAAE;GACjE,MAAM,eAAe,SAAS,UAAU;AACxC,OAAI;IACF,MAAM,OAAO,KAAK,MAAM,SAAS,SAAS,UAAU;AACpD,cAAU,KAAK;KAAE,MAAM;KAAc;KAAM,IAAI,SAAS;KAAI,CAAC;YAEtD,GAAQ;AACf,UAAM,IAAI,sBACR,mEAAmE,KAAK,UACtE,UACD,CAAC,KAAK,IACR;;;;AAIP,QAAO,UAAU,KAAK,UAAU,MAAM;EACpC,MAAM,aAAa,MAAM,IAAI,CAAC,QAAQ,GAAG,EAAE;EAC3C,MAAM,MAAM,aAAa,SAAS,KAAK,SAAS,KAAK,UACnD,SAAS,QAAQ,EAAE,CACpB,CAAC,IAAI;AACN,SAAO;GACL,MAAM,SAAS;GACf,WAAW,SAAS;GACpB,YAAY,SAAS,MAAM;GAC3B;GACA;GACD;GACD;;AAGJ,IAAa,+BAAb,cAAkD,6BAA6B;CAC7E,eAAe;EAAC;EAAa;EAAU;EAAe;CAEtD,OAAO,UAAU;AACf,SAAO;;CAGT,MAAM,MAAM,MAAoD;AAC9D,QAAM,IAAI,MACR,wEAAwE,OACzE;;CAGH,MAAM,YAAY,aAA+B;AAC/C,MAAI,aAAa,YAAY,MAAM,cAAc,YAAY,GAAG,QAAQ,CACtE,QAAO,2BAA2B,YAAY,GAAG,QAAQ;AAE3D,QAAM,IAAI,MACR,kFACD;;CAGH,wBAAgC;AAC9B,QAAM,IAAI,MACR,6EACD"}

package/dist/agents/toolkits/base.cjs

@@ -1,2 +1,2 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const __langchain_core_tools = require_rolldown_runtime.__toESM(require("@langchain/core/tools"));
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_tools = require("@langchain/core/tools");

package/dist/agents/toolkits/conversational_retrieval/openai_functions.cjs

@@ -30,14 +30,13 @@ async function createConversationalRetrievalAgent(llm, tools, options) {
 		outputKey,
 		inputKey
 	});
-	const executor = await require_initialize.initializeAgentExecutorWithOptions(tools, llm, {
+	return await require_initialize.initializeAgentExecutorWithOptions(tools, llm, {
 		agentType: "openai-functions",
 		memory,
 		verbose,
 		returnIntermediateSteps: rememberIntermediateSteps,
 		agentArgs: { prefix: prefix ?? `Do your best to answer the questions. Feel free to use any tools available to look up relevant information, only if necessary.` }
 	});
-	return executor;
 }
 
 //#endregion

package/dist/agents/toolkits/conversational_retrieval/openai_functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.cjs","names":["llm: ChatOpenAI","tools: StructuredToolInterface[]","options?: ConversationalRetrievalAgentOptions","OpenAIAgentTokenBufferMemory","ConversationSummaryBufferMemory","initializeAgentExecutorWithOptions"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { ConversationSummaryBufferMemory } from \"../../../memory/summary_buffer.js\";\nimport { initializeAgentExecutorWithOptions } from \"../../initialize.js\";\nimport { OpenAIAgentTokenBufferMemory } from \"./token_buffer_memory.js\";\n\nexport type ConversationalRetrievalAgentOptions = {\n  rememberIntermediateSteps?: boolean;\n  memoryKey?: string;\n  outputKey?: string;\n  inputKey?: string;\n  prefix?: string;\n  verbose?: boolean;\n};\n\n/**\n * Asynchronous function that creates a conversational retrieval agent\n * using a language model, tools, and options. It initializes the buffer\n * memory based on the provided options and initializes the AgentExecutor\n * with the tools, language model, and memory.\n * @param llm Instance of ChatOpenAI used as the language model for the agent.\n * @param tools Array of StructuredTool instances used by the agent.\n * @param options Optional ConversationalRetrievalAgentOptions to customize the agent.\n * @returns A Promise that resolves to an initialized AgentExecutor.\n */\nexport async function createConversationalRetrievalAgent(\n  llm: ChatOpenAI,\n  tools: StructuredToolInterface[],\n  options?: ConversationalRetrievalAgentOptions\n) {\n  const {\n    rememberIntermediateSteps = true,\n    memoryKey = \"chat_history\",\n    outputKey = \"output\",\n    inputKey = \"input\",\n    prefix,\n    verbose,\n  } = options ?? {};\n  let memory;\n  if (rememberIntermediateSteps) {\n    memory = new OpenAIAgentTokenBufferMemory({\n      memoryKey,\n      llm,\n      outputKey,\n      inputKey,\n    });\n  } else {\n    memory = new ConversationSummaryBufferMemory({\n      memoryKey,\n      llm,\n      maxTokenLimit: 12000,\n      returnMessages: true,\n      outputKey,\n      inputKey,\n    });\n  }\n  const executor = await initializeAgentExecutorWithOptions(tools, llm, {\n    agentType: \"openai-functions\",\n    memory,\n    verbose,\n    returnIntermediateSteps: rememberIntermediateSteps,\n    agentArgs: {\n      prefix:\n        prefix ??\n        `Do your best to answer the questions. Feel free to use any tools available to look up relevant information, only if necessary.`,\n    },\n  });\n  return executor;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,eAAsB,mCACpBA,KACAC,OACAC,SACA;CACA,MAAM,EACJ,4BAA4B,MAC5B,YAAY,gBACZ,YAAY,UACZ,WAAW,SACX,QACA,SACD,GAAG,WAAW,CAAE;CACjB,IAAI;AACJ,KAAI,2BACF,SAAS,IAAIC,yDAA6B;EACxC;EACA;EACA;EACA;CACD;MAED,SAAS,IAAIC,uDAAgC;EAC3C;EACA;EACA,eAAe;EACf,gBAAgB;EAChB;EACA;CACD;CAEH,MAAM,WAAW,MAAMC,sDAAmC,OAAO,KAAK;EACpE,WAAW;EACX;EACA;EACA,yBAAyB;EACzB,WAAW,EACT,QACE,UACA,CAAC,8HAA8H,CAAC,CACnI;CACF,EAAC;AACF,QAAO;AACR"}
+{"version":3,"file":"openai_functions.cjs","names":["OpenAIAgentTokenBufferMemory","ConversationSummaryBufferMemory","initializeAgentExecutorWithOptions"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { ConversationSummaryBufferMemory } from \"../../../memory/summary_buffer.js\";\nimport { initializeAgentExecutorWithOptions } from \"../../initialize.js\";\nimport { OpenAIAgentTokenBufferMemory } from \"./token_buffer_memory.js\";\n\nexport type ConversationalRetrievalAgentOptions = {\n  rememberIntermediateSteps?: boolean;\n  memoryKey?: string;\n  outputKey?: string;\n  inputKey?: string;\n  prefix?: string;\n  verbose?: boolean;\n};\n\n/**\n * Asynchronous function that creates a conversational retrieval agent\n * using a language model, tools, and options. It initializes the buffer\n * memory based on the provided options and initializes the AgentExecutor\n * with the tools, language model, and memory.\n * @param llm Instance of ChatOpenAI used as the language model for the agent.\n * @param tools Array of StructuredTool instances used by the agent.\n * @param options Optional ConversationalRetrievalAgentOptions to customize the agent.\n * @returns A Promise that resolves to an initialized AgentExecutor.\n */\nexport async function createConversationalRetrievalAgent(\n  llm: ChatOpenAI,\n  tools: StructuredToolInterface[],\n  options?: ConversationalRetrievalAgentOptions\n) {\n  const {\n    rememberIntermediateSteps = true,\n    memoryKey = \"chat_history\",\n    outputKey = \"output\",\n    inputKey = \"input\",\n    prefix,\n    verbose,\n  } = options ?? {};\n  let memory;\n  if (rememberIntermediateSteps) {\n    memory = new OpenAIAgentTokenBufferMemory({\n      memoryKey,\n      llm,\n      outputKey,\n      inputKey,\n    });\n  } else {\n    memory = new ConversationSummaryBufferMemory({\n      memoryKey,\n      llm,\n      maxTokenLimit: 12000,\n      returnMessages: true,\n      outputKey,\n      inputKey,\n    });\n  }\n  const executor = await initializeAgentExecutorWithOptions(tools, llm, {\n    agentType: \"openai-functions\",\n    memory,\n    verbose,\n    returnIntermediateSteps: rememberIntermediateSteps,\n    agentArgs: {\n      prefix:\n        prefix ??\n        `Do your best to answer the questions. Feel free to use any tools available to look up relevant information, only if necessary.`,\n    },\n  });\n  return executor;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,eAAsB,mCACpB,KACA,OACA,SACA;CACA,MAAM,EACJ,4BAA4B,MAC5B,YAAY,gBACZ,YAAY,UACZ,WAAW,SACX,QACA,YACE,WAAW,EAAE;CACjB,IAAI;AACJ,KAAI,0BACF,UAAS,IAAIA,yDAA6B;EACxC;EACA;EACA;EACA;EACD,CAAC;KAEF,UAAS,IAAIC,uDAAgC;EAC3C;EACA;EACA,eAAe;EACf,gBAAgB;EAChB;EACA;EACD,CAAC;AAaJ,QAXiB,MAAMC,sDAAmC,OAAO,KAAK;EACpE,WAAW;EACX;EACA;EACA,yBAAyB;EACzB,WAAW,EACT,QACE,UACA,kIACH;EACF,CAAC"}

package/dist/agents/toolkits/conversational_retrieval/openai_functions.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.cts","names":["StructuredToolInterface","ChatOpenAI","ConversationalRetrievalAgentOptions","createConversationalRetrievalAgent","______executor_js0","AgentExecutor","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nexport type ConversationalRetrievalAgentOptions = {\n    rememberIntermediateSteps?: boolean;\n    memoryKey?: string;\n    outputKey?: string;\n    inputKey?: string;\n    prefix?: string;\n    verbose?: boolean;\n};\n/**\n * Asynchronous function that creates a conversational retrieval agent\n * using a language model, tools, and options. It initializes the buffer\n * memory based on the provided options and initializes the AgentExecutor\n * with the tools, language model, and memory.\n * @param llm Instance of ChatOpenAI used as the language model for the agent.\n * @param tools Array of StructuredTool instances used by the agent.\n * @param options Optional ConversationalRetrievalAgentOptions to customize the agent.\n * @returns A Promise that resolves to an initialized AgentExecutor.\n */\nexport declare function createConversationalRetrievalAgent(llm: ChatOpenAI, tools: StructuredToolInterface[], options?: ConversationalRetrievalAgentOptions): Promise<import(\"../../executor.js\").AgentExecutor>;\n//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;KAEYE,mCAAAA;;;EAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAkBYC,QAAAA,CAAAA,EAAAA,MAAAA;EAAwCF,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBD,OAAAA,CAAAA,EAAAA,OAAAA;CAAqCE;;;AAA6C;;;;;;;;iBAA7IC,kCAAAA,MAAwCF,mBAAmBD,qCAAqCE,sCAAsCI"}
+{"version":3,"file":"openai_functions.d.cts","names":[],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.ts"],"mappings":";;;;;KAMY,mCAAA;EACV,yBAAA;EACA,SAAA;EACA,SAAA;EACA,QAAA;EACA,MAAA;EACA,OAAA;AAAA;;;;;;;;AAaF;;;iBAAsB,kCAAA,CACpB,GAAA,EAAK,UAAA,EACL,KAAA,EAAO,uBAAA,IACP,OAAA,GAAU,mCAAA,GAAmC,OAAA,CAAA,aAAA"}

package/dist/agents/toolkits/conversational_retrieval/openai_functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.ts","names":["StructuredToolInterface","ChatOpenAI","ConversationalRetrievalAgentOptions","createConversationalRetrievalAgent","______executor_js0","AgentExecutor","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nexport type ConversationalRetrievalAgentOptions = {\n    rememberIntermediateSteps?: boolean;\n    memoryKey?: string;\n    outputKey?: string;\n    inputKey?: string;\n    prefix?: string;\n    verbose?: boolean;\n};\n/**\n * Asynchronous function that creates a conversational retrieval agent\n * using a language model, tools, and options. It initializes the buffer\n * memory based on the provided options and initializes the AgentExecutor\n * with the tools, language model, and memory.\n * @param llm Instance of ChatOpenAI used as the language model for the agent.\n * @param tools Array of StructuredTool instances used by the agent.\n * @param options Optional ConversationalRetrievalAgentOptions to customize the agent.\n * @returns A Promise that resolves to an initialized AgentExecutor.\n */\nexport declare function createConversationalRetrievalAgent(llm: ChatOpenAI, tools: StructuredToolInterface[], options?: ConversationalRetrievalAgentOptions): Promise<import(\"../../executor.js\").AgentExecutor>;\n//# sourceMappingURL=openai_functions.d.ts.map"],"mappings":";;;;;KAEYE,mCAAAA;;;EAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAkBYC,QAAAA,CAAAA,EAAAA,MAAAA;EAAwCF,MAAAA,CAAAA,EAAAA,MAAAA;EAAmBD,OAAAA,CAAAA,EAAAA,OAAAA;CAAqCE;;;AAA6C;;;;;;;;iBAA7IC,kCAAAA,MAAwCF,mBAAmBD,qCAAqCE,sCAAsCI"}
+{"version":3,"file":"openai_functions.d.ts","names":[],"sources":["../../../../src/agents/toolkits/conversational_retrieval/openai_functions.ts"],"mappings":";;;;;KAMY,mCAAA;EACV,yBAAA;EACA,SAAA;EACA,SAAA;EACA,QAAA;EACA,MAAA;EACA,OAAA;AAAA;;;;;;;;AAaF;;;iBAAsB,kCAAA,CACpB,GAAA,EAAK,UAAA,EACL,KAAA,EAAO,uBAAA,IACP,OAAA,GAAU,mCAAA,GAAmC,OAAA,CAAA,aAAA"}

package/dist/agents/toolkits/conversational_retrieval/openai_functions.js

@@ -30,14 +30,13 @@ async function createConversationalRetrievalAgent(llm, tools, options) {
 		outputKey,
 		inputKey
 	});
-	const executor = await initializeAgentExecutorWithOptions(tools, llm, {
+	return await initializeAgentExecutorWithOptions(tools, llm, {
 		agentType: "openai-functions",
 		memory,
 		verbose,
 		returnIntermediateSteps: rememberIntermediateSteps,
 		agentArgs: { prefix: prefix ?? `Do your best to answer the questions. Feel free to use any tools available to look up relevant information, only if necessary.` }
 	});
-	return executor;
 }
 
 //#endregion