@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/output_parsers/base.cjs

@@ -1,124 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutputParserException = exports.BaseOutputParser = exports.BaseLLMOutputParser = void 0;
-const index_js_1 = require("../runnables/index.cjs");
-const index_js_2 = require("../errors/index.cjs");
+const require_index = require('../errors/index.cjs');
+const require_base = require('../runnables/base.cjs');
+require('../runnables/index.cjs');
+
+//#region src/output_parsers/base.ts
 /**
- * Abstract base class for parsing the output of a Large Language Model
- * (LLM) call. It provides methods for parsing the result of an LLM call
- * and invoking the parser with a given input.
- */
-class BaseLLMOutputParser extends index_js_1.Runnable {
-    /**
-     * Parses the result of an LLM call with a given prompt. By default, it
-     * simply calls `parseResult`.
-     * @param generations The generations from an LLM call.
-     * @param _prompt The prompt used in the LLM call.
-     * @param callbacks Optional callbacks.
-     * @returns A promise of the parsed output.
-     */
-    parseResultWithPrompt(generations, _prompt, callbacks) {
-        return this.parseResult(generations, callbacks);
-    }
-    _baseMessageToString(message) {
-        return typeof message.content === "string"
-            ? message.content
-            : this._baseMessageContentToString(message.content);
-    }
-    _baseMessageContentToString(content) {
-        return JSON.stringify(content);
-    }
-    /**
-     * Calls the parser with a given input and optional configuration options.
-     * If the input is a string, it creates a generation with the input as
-     * text and calls `parseResult`. If the input is a `BaseMessage`, it
-     * creates a generation with the input as a message and the content of the
-     * input as text, and then calls `parseResult`.
-     * @param input The input to the parser, which can be a string or a `BaseMessage`.
-     * @param options Optional configuration options.
-     * @returns A promise of the parsed output.
-     */
-    async invoke(input, options) {
-        if (typeof input === "string") {
-            return this._callWithConfig(async (input, options) => this.parseResult([{ text: input }], options?.callbacks), input, { ...options, runType: "parser" });
-        }
-        else {
-            return this._callWithConfig(async (input, options) => this.parseResult([
-                {
-                    message: input,
-                    text: this._baseMessageToString(input),
-                },
-            ], options?.callbacks), input, { ...options, runType: "parser" });
-        }
-    }
-}
-exports.BaseLLMOutputParser = BaseLLMOutputParser;
+* Abstract base class for parsing the output of a Large Language Model
+* (LLM) call. It provides methods for parsing the result of an LLM call
+* and invoking the parser with a given input.
+*/
+var BaseLLMOutputParser = class extends require_base.Runnable {
+	/**
+	* Parses the result of an LLM call with a given prompt. By default, it
+	* simply calls `parseResult`.
+	* @param generations The generations from an LLM call.
+	* @param _prompt The prompt used in the LLM call.
+	* @param callbacks Optional callbacks.
+	* @returns A promise of the parsed output.
+	*/
+	parseResultWithPrompt(generations, _prompt, callbacks) {
+		return this.parseResult(generations, callbacks);
+	}
+	_baseMessageToString(message) {
+		return typeof message.content === "string" ? message.content : this._baseMessageContentToString(message.content);
+	}
+	_baseMessageContentToString(content) {
+		return JSON.stringify(content);
+	}
+	/**
+	* Calls the parser with a given input and optional configuration options.
+	* If the input is a string, it creates a generation with the input as
+	* text and calls `parseResult`. If the input is a `BaseMessage`, it
+	* creates a generation with the input as a message and the content of the
+	* input as text, and then calls `parseResult`.
+	* @param input The input to the parser, which can be a string or a `BaseMessage`.
+	* @param options Optional configuration options.
+	* @returns A promise of the parsed output.
+	*/
+	async invoke(input, options) {
+		if (typeof input === "string") return this._callWithConfig(async (input$1, options$1) => this.parseResult([{ text: input$1 }], options$1?.callbacks), input, {
+			...options,
+			runType: "parser"
+		});
+		else return this._callWithConfig(async (input$1, options$1) => this.parseResult([{
+			message: input$1,
+			text: this._baseMessageToString(input$1)
+		}], options$1?.callbacks), input, {
+			...options,
+			runType: "parser"
+		});
+	}
+};
 /**
- * Class to parse the output of an LLM call.
- */
-class BaseOutputParser extends BaseLLMOutputParser {
-    parseResult(generations, callbacks) {
-        return this.parse(generations[0].text, callbacks);
-    }
-    async parseWithPrompt(text, _prompt, callbacks) {
-        return this.parse(text, callbacks);
-    }
-    /**
-     * Return the string type key uniquely identifying this class of parser
-     */
-    _type() {
-        throw new Error("_type not implemented");
-    }
-}
-exports.BaseOutputParser = BaseOutputParser;
+* Class to parse the output of an LLM call.
+*/
+var BaseOutputParser = class extends BaseLLMOutputParser {
+	parseResult(generations, callbacks) {
+		return this.parse(generations[0].text, callbacks);
+	}
+	async parseWithPrompt(text, _prompt, callbacks) {
+		return this.parse(text, callbacks);
+	}
+	/**
+	* Return the string type key uniquely identifying this class of parser
+	*/
+	_type() {
+		throw new Error("_type not implemented");
+	}
+};
 /**
- * Exception that output parsers should raise to signify a parsing error.
- *
- * This exists to differentiate parsing errors from other code or execution errors
- * that also may arise inside the output parser. OutputParserExceptions will be
- * available to catch and handle in ways to fix the parsing error, while other
- * errors will be raised.
- *
- * @param message - The error that's being re-raised or an error message.
- * @param llmOutput - String model output which is error-ing.
- * @param observation - String explanation of error which can be passed to a
- *     model to try and remediate the issue.
- * @param sendToLLM - Whether to send the observation and llm_output back to an Agent
- *     after an OutputParserException has been raised. This gives the underlying
- *     model driving the agent the context that the previous output was improperly
- *     structured, in the hopes that it will update the output to the correct
- *     format.
- */
-class OutputParserException extends Error {
-    constructor(message, llmOutput, observation, sendToLLM = false) {
-        super(message);
-        Object.defineProperty(this, "llmOutput", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "observation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "sendToLLM", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.llmOutput = llmOutput;
-        this.observation = observation;
-        this.sendToLLM = sendToLLM;
-        if (sendToLLM) {
-            if (observation === undefined || llmOutput === undefined) {
-                throw new Error("Arguments 'observation' & 'llmOutput' are required if 'sendToLlm' is true");
-            }
-        }
-        (0, index_js_2.addLangChainErrorFields)(this, "OUTPUT_PARSING_FAILURE");
-    }
-}
+* Exception that output parsers should raise to signify a parsing error.
+*
+* This exists to differentiate parsing errors from other code or execution errors
+* that also may arise inside the output parser. OutputParserExceptions will be
+* available to catch and handle in ways to fix the parsing error, while other
+* errors will be raised.
+*
+* @param message - The error that's being re-raised or an error message.
+* @param llmOutput - String model output which is error-ing.
+* @param observation - String explanation of error which can be passed to a
+*     model to try and remediate the issue.
+* @param sendToLLM - Whether to send the observation and llm_output back to an Agent
+*     after an OutputParserException has been raised. This gives the underlying
+*     model driving the agent the context that the previous output was improperly
+*     structured, in the hopes that it will update the output to the correct
+*     format.
+*/
+var OutputParserException = class extends Error {
+	llmOutput;
+	observation;
+	sendToLLM;
+	constructor(message, llmOutput, observation, sendToLLM = false) {
+		super(message);
+		this.llmOutput = llmOutput;
+		this.observation = observation;
+		this.sendToLLM = sendToLLM;
+		if (sendToLLM) {
+			if (observation === void 0 || llmOutput === void 0) throw new Error("Arguments 'observation' & 'llmOutput' are required if 'sendToLlm' is true");
+		}
+		require_index.addLangChainErrorFields(this, "OUTPUT_PARSING_FAILURE");
+	}
+};
+
+//#endregion
+exports.BaseLLMOutputParser = BaseLLMOutputParser;
+exports.BaseOutputParser = BaseOutputParser;
 exports.OutputParserException = OutputParserException;
+//# sourceMappingURL=base.cjs.map

package/dist/output_parsers/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.cjs","names":["Runnable","generations: Generation[] | ChatGeneration[]","_prompt: BasePromptValueInterface","callbacks?: Callbacks","message: BaseMessage","content: ContentBlock[]","input: string | BaseMessage","options?: RunnableConfig","input: string","options","input","input: BaseMessage","text: string","message: string","llmOutput?: string","observation?: string","addLangChainErrorFields"],"sources":["../../src/output_parsers/base.ts"],"sourcesContent":["import { Runnable } from \"../runnables/index.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport type { BaseMessage, ContentBlock } from \"../messages/index.js\";\nimport type { Callbacks } from \"../callbacks/manager.js\";\nimport type { Generation, ChatGeneration } from \"../outputs.js\";\nimport { addLangChainErrorFields } from \"../errors/index.js\";\n\n/**\n * Options for formatting instructions.\n */\nexport interface FormatInstructionsOptions {}\n\n/**\n * Abstract base class for parsing the output of a Large Language Model\n * (LLM) call. It provides methods for parsing the result of an LLM call\n * and invoking the parser with a given input.\n */\nexport abstract class BaseLLMOutputParser<T = unknown> extends Runnable<\n  string | BaseMessage,\n  T\n> {\n  /**\n   * Parses the result of an LLM call. This method is meant to be\n   * implemented by subclasses to define how the output from the LLM should\n   * be parsed.\n   * @param generations The generations from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  abstract parseResult(\n    generations: Generation[] | ChatGeneration[],\n    callbacks?: Callbacks\n  ): Promise<T>;\n\n  /**\n   * Parses the result of an LLM call with a given prompt. By default, it\n   * simply calls `parseResult`.\n   * @param generations The generations from an LLM call.\n   * @param _prompt The prompt used in the LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  parseResultWithPrompt(\n    generations: Generation[] | ChatGeneration[],\n    _prompt: BasePromptValueInterface,\n    callbacks?: Callbacks\n  ): Promise<T> {\n    return this.parseResult(generations, callbacks);\n  }\n\n  protected _baseMessageToString(message: BaseMessage): string {\n    return typeof message.content === \"string\"\n      ? message.content\n      : this._baseMessageContentToString(message.content);\n  }\n\n  protected _baseMessageContentToString(content: ContentBlock[]): string {\n    return JSON.stringify(content);\n  }\n\n  /**\n   * Calls the parser with a given input and optional configuration options.\n   * If the input is a string, it creates a generation with the input as\n   * text and calls `parseResult`. If the input is a `BaseMessage`, it\n   * creates a generation with the input as a message and the content of the\n   * input as text, and then calls `parseResult`.\n   * @param input The input to the parser, which can be a string or a `BaseMessage`.\n   * @param options Optional configuration options.\n   * @returns A promise of the parsed output.\n   */\n  async invoke(\n    input: string | BaseMessage,\n    options?: RunnableConfig\n  ): Promise<T> {\n    if (typeof input === \"string\") {\n      return this._callWithConfig(\n        async (input: string, options): Promise<T> =>\n          this.parseResult([{ text: input }], options?.callbacks),\n        input,\n        { ...options, runType: \"parser\" }\n      );\n    } else {\n      return this._callWithConfig(\n        async (input: BaseMessage, options): Promise<T> =>\n          this.parseResult(\n            [\n              {\n                message: input,\n                text: this._baseMessageToString(input),\n              },\n            ],\n            options?.callbacks\n          ),\n        input,\n        { ...options, runType: \"parser\" }\n      );\n    }\n  }\n}\n\n/**\n * Class to parse the output of an LLM call.\n */\nexport abstract class BaseOutputParser<\n  T = unknown\n> extends BaseLLMOutputParser<T> {\n  parseResult(\n    generations: Generation[] | ChatGeneration[],\n    callbacks?: Callbacks\n  ): Promise<T> {\n    return this.parse(generations[0].text, callbacks);\n  }\n\n  /**\n   * Parse the output of an LLM call.\n   *\n   * @param text - LLM output to parse.\n   * @returns Parsed output.\n   */\n  abstract parse(text: string, callbacks?: Callbacks): Promise<T>;\n\n  async parseWithPrompt(\n    text: string,\n    _prompt: BasePromptValueInterface,\n    callbacks?: Callbacks\n  ): Promise<T> {\n    return this.parse(text, callbacks);\n  }\n\n  /**\n   * Return a string describing the format of the output.\n   * @returns Format instructions.\n   * @param options - Options for formatting instructions.\n   * @example\n   * ```json\n   * {\n   *  \"foo\": \"bar\"\n   * }\n   * ```\n   */\n  abstract getFormatInstructions(options?: FormatInstructionsOptions): string;\n\n  /**\n   * Return the string type key uniquely identifying this class of parser\n   */\n  _type(): string {\n    throw new Error(\"_type not implemented\");\n  }\n}\n\n/**\n * Exception that output parsers should raise to signify a parsing error.\n *\n * This exists to differentiate parsing errors from other code or execution errors\n * that also may arise inside the output parser. OutputParserExceptions will be\n * available to catch and handle in ways to fix the parsing error, while other\n * errors will be raised.\n *\n * @param message - The error that's being re-raised or an error message.\n * @param llmOutput - String model output which is error-ing.\n * @param observation - String explanation of error which can be passed to a\n *     model to try and remediate the issue.\n * @param sendToLLM - Whether to send the observation and llm_output back to an Agent\n *     after an OutputParserException has been raised. This gives the underlying\n *     model driving the agent the context that the previous output was improperly\n *     structured, in the hopes that it will update the output to the correct\n *     format.\n */\nexport class OutputParserException extends Error {\n  llmOutput?: string;\n\n  observation?: string;\n\n  sendToLLM: boolean;\n\n  constructor(\n    message: string,\n    llmOutput?: string,\n    observation?: string,\n    sendToLLM = false\n  ) {\n    super(message);\n    this.llmOutput = llmOutput;\n    this.observation = observation;\n    this.sendToLLM = sendToLLM;\n\n    if (sendToLLM) {\n      if (observation === undefined || llmOutput === undefined) {\n        throw new Error(\n          \"Arguments 'observation' & 'llmOutput' are required if 'sendToLlm' is true\"\n        );\n      }\n    }\n\n    addLangChainErrorFields(this, \"OUTPUT_PARSING_FAILURE\");\n  }\n}\n"],"mappings":";;;;;;;;;;AAkBA,IAAsB,sBAAtB,cAA+DA,sBAG7D;;;;;;;;;CAsBA,sBACEC,aACAC,SACAC,WACY;AACZ,SAAO,KAAK,YAAY,aAAa,UAAU;CAChD;CAED,AAAU,qBAAqBC,SAA8B;AAC3D,SAAO,OAAO,QAAQ,YAAY,WAC9B,QAAQ,UACR,KAAK,4BAA4B,QAAQ,QAAQ;CACtD;CAED,AAAU,4BAA4BC,SAAiC;AACrE,SAAO,KAAK,UAAU,QAAQ;CAC/B;;;;;;;;;;;CAYD,MAAM,OACJC,OACAC,SACY;AACZ,MAAI,OAAO,UAAU,SACnB,QAAO,KAAK,gBACV,OAAOC,SAAeC,cACpB,KAAK,YAAY,CAAC,EAAE,MAAMC,QAAO,CAAC,GAAED,WAAS,UAAU,EACzD,OACA;GAAE,GAAG;GAAS,SAAS;EAAU,EAClC;MAED,QAAO,KAAK,gBACV,OAAOE,SAAoBF,cACzB,KAAK,YACH,CACE;GACE,SAASC;GACT,MAAM,KAAK,qBAAqBA,QAAM;EACvC,CACF,GACDD,WAAS,UACV,EACH,OACA;GAAE,GAAG;GAAS,SAAS;EAAU,EAClC;CAEJ;AACF;;;;AAKD,IAAsB,mBAAtB,cAEU,oBAAuB;CAC/B,YACER,aACAE,WACY;AACZ,SAAO,KAAK,MAAM,YAAY,GAAG,MAAM,UAAU;CAClD;CAUD,MAAM,gBACJS,MACAV,SACAC,WACY;AACZ,SAAO,KAAK,MAAM,MAAM,UAAU;CACnC;;;;CAkBD,QAAgB;AACd,QAAM,IAAI,MAAM;CACjB;AACF;;;;;;;;;;;;;;;;;;;AAoBD,IAAa,wBAAb,cAA2C,MAAM;CAC/C;CAEA;CAEA;CAEA,YACEU,SACAC,WACAC,aACA,YAAY,OACZ;EACA,MAAM,QAAQ;EACd,KAAK,YAAY;EACjB,KAAK,cAAc;EACnB,KAAK,YAAY;AAEjB,MAAI,WACF;OAAI,gBAAgB,UAAa,cAAc,OAC7C,OAAM,IAAI,MACR;EAEH;EAGHC,sCAAwB,MAAM,yBAAyB;CACxD;AACF"}

package/dist/output_parsers/base.d.cts

@@ -0,0 +1,108 @@
+import { ContentBlock } from "../messages/content/index.cjs";
+import { BaseMessage } from "../messages/base.cjs";
+import { ChatGeneration, Generation } from "../outputs.cjs";
+import { Callbacks } from "../callbacks/manager.cjs";
+import { RunnableConfig } from "../runnables/types.cjs";
+import { Runnable } from "../runnables/base.cjs";
+import { BasePromptValueInterface } from "../prompt_values.cjs";
+
+//#region src/output_parsers/base.d.ts
+/**
+ * Options for formatting instructions.
+ */
+interface FormatInstructionsOptions {}
+/**
+ * Abstract base class for parsing the output of a Large Language Model
+ * (LLM) call. It provides methods for parsing the result of an LLM call
+ * and invoking the parser with a given input.
+ */
+declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {
+  /**
+   * Parses the result of an LLM call. This method is meant to be
+   * implemented by subclasses to define how the output from the LLM should
+   * be parsed.
+   * @param generations The generations from an LLM call.
+   * @param callbacks Optional callbacks.
+   * @returns A promise of the parsed output.
+   */
+  abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
+  /**
+   * Parses the result of an LLM call with a given prompt. By default, it
+   * simply calls `parseResult`.
+   * @param generations The generations from an LLM call.
+   * @param _prompt The prompt used in the LLM call.
+   * @param callbacks Optional callbacks.
+   * @returns A promise of the parsed output.
+   */
+  parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
+  protected _baseMessageToString(message: BaseMessage): string;
+  protected _baseMessageContentToString(content: ContentBlock[]): string;
+  /**
+   * Calls the parser with a given input and optional configuration options.
+   * If the input is a string, it creates a generation with the input as
+   * text and calls `parseResult`. If the input is a `BaseMessage`, it
+   * creates a generation with the input as a message and the content of the
+   * input as text, and then calls `parseResult`.
+   * @param input The input to the parser, which can be a string or a `BaseMessage`.
+   * @param options Optional configuration options.
+   * @returns A promise of the parsed output.
+   */
+  invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;
+}
+/**
+ * Class to parse the output of an LLM call.
+ */
+declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {
+  parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
+  /**
+   * Parse the output of an LLM call.
+   *
+   * @param text - LLM output to parse.
+   * @returns Parsed output.
+   */
+  abstract parse(text: string, callbacks?: Callbacks): Promise<T>;
+  parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
+  /**
+   * Return a string describing the format of the output.
+   * @returns Format instructions.
+   * @param options - Options for formatting instructions.
+   * @example
+   * ```json
+   * {
+   *  "foo": "bar"
+   * }
+   * ```
+   */
+  abstract getFormatInstructions(options?: FormatInstructionsOptions): string;
+  /**
+   * Return the string type key uniquely identifying this class of parser
+   */
+  _type(): string;
+}
+/**
+ * Exception that output parsers should raise to signify a parsing error.
+ *
+ * This exists to differentiate parsing errors from other code or execution errors
+ * that also may arise inside the output parser. OutputParserExceptions will be
+ * available to catch and handle in ways to fix the parsing error, while other
+ * errors will be raised.
+ *
+ * @param message - The error that's being re-raised or an error message.
+ * @param llmOutput - String model output which is error-ing.
+ * @param observation - String explanation of error which can be passed to a
+ *     model to try and remediate the issue.
+ * @param sendToLLM - Whether to send the observation and llm_output back to an Agent
+ *     after an OutputParserException has been raised. This gives the underlying
+ *     model driving the agent the context that the previous output was improperly
+ *     structured, in the hopes that it will update the output to the correct
+ *     format.
+ */
+declare class OutputParserException extends Error {
+  llmOutput?: string;
+  observation?: string;
+  sendToLLM: boolean;
+  constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);
+}
+//#endregion
+export { BaseLLMOutputParser, BaseOutputParser, FormatInstructionsOptions, OutputParserException };
+//# sourceMappingURL=base.d.cts.map

package/dist/output_parsers/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["Runnable","RunnableConfig","BasePromptValueInterface","BaseMessage","ContentBlock","Callbacks","Generation","ChatGeneration","FormatInstructionsOptions","BaseLLMOutputParser","T","Promise","BaseOutputParser","OutputParserException","Error"],"sources":["../../src/output_parsers/base.d.ts"],"sourcesContent":["import { Runnable } from \"../runnables/index.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport type { BaseMessage, ContentBlock } from \"../messages/index.js\";\nimport type { Callbacks } from \"../callbacks/manager.js\";\nimport type { Generation, ChatGeneration } from \"../outputs.js\";\n/**\n * Options for formatting instructions.\n */\nexport interface FormatInstructionsOptions {\n}\n/**\n * Abstract base class for parsing the output of a Large Language Model\n * (LLM) call. It provides methods for parsing the result of an LLM call\n * and invoking the parser with a given input.\n */\nexport declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {\n    /**\n     * Parses the result of an LLM call. This method is meant to be\n     * implemented by subclasses to define how the output from the LLM should\n     * be parsed.\n     * @param generations The generations from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parses the result of an LLM call with a given prompt. By default, it\n     * simply calls `parseResult`.\n     * @param generations The generations from an LLM call.\n     * @param _prompt The prompt used in the LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    protected _baseMessageToString(message: BaseMessage): string;\n    protected _baseMessageContentToString(content: ContentBlock[]): string;\n    /**\n     * Calls the parser with a given input and optional configuration options.\n     * If the input is a string, it creates a generation with the input as\n     * text and calls `parseResult`. If the input is a `BaseMessage`, it\n     * creates a generation with the input as a message and the content of the\n     * input as text, and then calls `parseResult`.\n     * @param input The input to the parser, which can be a string or a `BaseMessage`.\n     * @param options Optional configuration options.\n     * @returns A promise of the parsed output.\n     */\n    invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;\n}\n/**\n * Class to parse the output of an LLM call.\n */\nexport declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {\n    parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parse the output of an LLM call.\n     *\n     * @param text - LLM output to parse.\n     * @returns Parsed output.\n     */\n    abstract parse(text: string, callbacks?: Callbacks): Promise<T>;\n    parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Return a string describing the format of the output.\n     * @returns Format instructions.\n     * @param options - Options for formatting instructions.\n     * @example\n     * ```json\n     * {\n     *  \"foo\": \"bar\"\n     * }\n     * ```\n     */\n    abstract getFormatInstructions(options?: FormatInstructionsOptions): string;\n    /**\n     * Return the string type key uniquely identifying this class of parser\n     */\n    _type(): string;\n}\n/**\n * Exception that output parsers should raise to signify a parsing error.\n *\n * This exists to differentiate parsing errors from other code or execution errors\n * that also may arise inside the output parser. OutputParserExceptions will be\n * available to catch and handle in ways to fix the parsing error, while other\n * errors will be raised.\n *\n * @param message - The error that's being re-raised or an error message.\n * @param llmOutput - String model output which is error-ing.\n * @param observation - String explanation of error which can be passed to a\n *     model to try and remediate the issue.\n * @param sendToLLM - Whether to send the observation and llm_output back to an Agent\n *     after an OutputParserException has been raised. This gives the underlying\n *     model driving the agent the context that the previous output was improperly\n *     structured, in the hopes that it will update the output to the correct\n *     format.\n */\nexport declare class OutputParserException extends Error {\n    llmOutput?: string;\n    observation?: string;\n    sendToLLM: boolean;\n    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);\n}\n"],"mappings":";;;;;;;;;;;;AASiBQ,UAAAA,yBAAAA,CAAyB,CAO1C;;;;;;AASmFH,uBATrDI,mBASqDJ,CAAAA,IAAAA,OAAAA,CAAAA,SATZL,QASYK,CAAAA,MAAAA,GATMF,WASNE,EATmBK,CASnBL,CAAAA,CAAAA;EAAS;;;;;;;;EAS8C,SAC9FF,WAAAA,CAAAA,WAAAA,EAVNG,UAUMH,EAAAA,GAVSI,cAUTJ,EAAAA,EAAAA,SAAAA,CAAAA,EAVuCE,SAUvCF,CAAAA,EAVmDQ,OAUnDR,CAV2DO,CAU3DP,CAAAA;EAAW;;;;;;AAnBwB;AAoC/E;EAA8C,qBAAA,CAAA,WAAA,EAlBPG,UAkBO,EAAA,GAlBQC,cAkBR,EAAA,EAAA,OAAA,EAlBmCL,wBAkBnC,EAAA,SAAA,CAAA,EAlByEG,SAkBzE,CAAA,EAlBqFM,OAkBrF,CAlB6FD,CAkB7F,CAAA;EAAA,UAA0CA,oBAAAA,CAAAA,OAAAA,EAjB5CP,WAiB4CO,CAAAA,EAAAA,MAAAA;EAAC,UAC5DJ,2BAAAA,CAAAA,OAAAA,EAjBsBF,YAiBtBE,EAAAA,CAAAA,EAAAA,MAAAA;EAAU;;;;;;;;;;EAQ+D,MAATK,CAAAA,KAAAA,EAAAA,MAAAA,GAdlER,WAckEQ,EAAAA,OAAAA,CAAAA,EAd3CV,cAc2CU,CAAAA,EAd1BA,OAc0BA,CAdlBD,CAckBC,CAAAA;;;AATN;AA6CvF;uBA7C8BC,sCAAsCH,oBAAoBC;2BAC3DJ,eAAeC,8BAA8BF,YAAYM,QAAQD;;;;;;;2CAOjDL,YAAYM,QAAQD;yCACtBR,sCAAsCG,YAAYM,QAAQD;;;;;;;;;;;;2CAYxDF;;;;;;;;;;;;;;;;;;;;;;;;cAwBxBK,qBAAAA,SAA8BC,KAAK"}

package/dist/output_parsers/base.d.ts

@@ -1,81 +1,83 @@
-import { Runnable } from "../runnables/index.js";
-import type { RunnableConfig } from "../runnables/config.js";
-import type { BasePromptValueInterface } from "../prompt_values.js";
-import type { BaseMessage, MessageContentComplex } from "../messages/index.js";
-import type { Callbacks } from "../callbacks/manager.js";
-import type { Generation, ChatGeneration } from "../outputs.js";
+import { ContentBlock } from "../messages/content/index.js";
+import { BaseMessage } from "../messages/base.js";
+import { ChatGeneration, Generation } from "../outputs.js";
+import { Callbacks } from "../callbacks/manager.js";
+import { RunnableConfig } from "../runnables/types.js";
+import { Runnable } from "../runnables/base.js";
+import { BasePromptValueInterface } from "../prompt_values.js";
+
+//#region src/output_parsers/base.d.ts
 /**
  * Options for formatting instructions.
  */
-export interface FormatInstructionsOptions {
-}
+interface FormatInstructionsOptions {}
 /**
  * Abstract base class for parsing the output of a Large Language Model
  * (LLM) call. It provides methods for parsing the result of an LLM call
  * and invoking the parser with a given input.
  */
-export declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {
-    /**
-     * Parses the result of an LLM call. This method is meant to be
-     * implemented by subclasses to define how the output from the LLM should
-     * be parsed.
-     * @param generations The generations from an LLM call.
-     * @param callbacks Optional callbacks.
-     * @returns A promise of the parsed output.
-     */
-    abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
-    /**
-     * Parses the result of an LLM call with a given prompt. By default, it
-     * simply calls `parseResult`.
-     * @param generations The generations from an LLM call.
-     * @param _prompt The prompt used in the LLM call.
-     * @param callbacks Optional callbacks.
-     * @returns A promise of the parsed output.
-     */
-    parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
-    protected _baseMessageToString(message: BaseMessage): string;
-    protected _baseMessageContentToString(content: MessageContentComplex[]): string;
-    /**
-     * Calls the parser with a given input and optional configuration options.
-     * If the input is a string, it creates a generation with the input as
-     * text and calls `parseResult`. If the input is a `BaseMessage`, it
-     * creates a generation with the input as a message and the content of the
-     * input as text, and then calls `parseResult`.
-     * @param input The input to the parser, which can be a string or a `BaseMessage`.
-     * @param options Optional configuration options.
-     * @returns A promise of the parsed output.
-     */
-    invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;
+declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {
+  /**
+   * Parses the result of an LLM call. This method is meant to be
+   * implemented by subclasses to define how the output from the LLM should
+   * be parsed.
+   * @param generations The generations from an LLM call.
+   * @param callbacks Optional callbacks.
+   * @returns A promise of the parsed output.
+   */
+  abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
+  /**
+   * Parses the result of an LLM call with a given prompt. By default, it
+   * simply calls `parseResult`.
+   * @param generations The generations from an LLM call.
+   * @param _prompt The prompt used in the LLM call.
+   * @param callbacks Optional callbacks.
+   * @returns A promise of the parsed output.
+   */
+  parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
+  protected _baseMessageToString(message: BaseMessage): string;
+  protected _baseMessageContentToString(content: ContentBlock[]): string;
+  /**
+   * Calls the parser with a given input and optional configuration options.
+   * If the input is a string, it creates a generation with the input as
+   * text and calls `parseResult`. If the input is a `BaseMessage`, it
+   * creates a generation with the input as a message and the content of the
+   * input as text, and then calls `parseResult`.
+   * @param input The input to the parser, which can be a string or a `BaseMessage`.
+   * @param options Optional configuration options.
+   * @returns A promise of the parsed output.
+   */
+  invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;
 }
 /**
  * Class to parse the output of an LLM call.
  */
-export declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {
-    parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
-    /**
-     * Parse the output of an LLM call.
-     *
-     * @param text - LLM output to parse.
-     * @returns Parsed output.
-     */
-    abstract parse(text: string, callbacks?: Callbacks): Promise<T>;
-    parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
-    /**
-     * Return a string describing the format of the output.
-     * @returns Format instructions.
-     * @param options - Options for formatting instructions.
-     * @example
-     * ```json
-     * {
-     *  "foo": "bar"
-     * }
-     * ```
-     */
-    abstract getFormatInstructions(options?: FormatInstructionsOptions): string;
-    /**
-     * Return the string type key uniquely identifying this class of parser
-     */
-    _type(): string;
+declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {
+  parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;
+  /**
+   * Parse the output of an LLM call.
+   *
+   * @param text - LLM output to parse.
+   * @returns Parsed output.
+   */
+  abstract parse(text: string, callbacks?: Callbacks): Promise<T>;
+  parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;
+  /**
+   * Return a string describing the format of the output.
+   * @returns Format instructions.
+   * @param options - Options for formatting instructions.
+   * @example
+   * ```json
+   * {
+   *  "foo": "bar"
+   * }
+   * ```
+   */
+  abstract getFormatInstructions(options?: FormatInstructionsOptions): string;
+  /**
+   * Return the string type key uniquely identifying this class of parser
+   */
+  _type(): string;
 }
 /**
  * Exception that output parsers should raise to signify a parsing error.
@@ -95,9 +97,12 @@ export declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutpu
  *     structured, in the hopes that it will update the output to the correct
  *     format.
  */
-export declare class OutputParserException extends Error {
-    llmOutput?: string;
-    observation?: string;
-    sendToLLM: boolean;
-    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);
+declare class OutputParserException extends Error {
+  llmOutput?: string;
+  observation?: string;
+  sendToLLM: boolean;
+  constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);
 }
+//#endregion
+export { BaseLLMOutputParser, BaseOutputParser, FormatInstructionsOptions, OutputParserException };
+//# sourceMappingURL=base.d.ts.map

package/dist/output_parsers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Runnable","RunnableConfig","BasePromptValueInterface","BaseMessage","ContentBlock","Callbacks","Generation","ChatGeneration","FormatInstructionsOptions","BaseLLMOutputParser","T","Promise","BaseOutputParser","OutputParserException","Error"],"sources":["../../src/output_parsers/base.d.ts"],"sourcesContent":["import { Runnable } from \"../runnables/index.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport type { BasePromptValueInterface } from \"../prompt_values.js\";\nimport type { BaseMessage, ContentBlock } from \"../messages/index.js\";\nimport type { Callbacks } from \"../callbacks/manager.js\";\nimport type { Generation, ChatGeneration } from \"../outputs.js\";\n/**\n * Options for formatting instructions.\n */\nexport interface FormatInstructionsOptions {\n}\n/**\n * Abstract base class for parsing the output of a Large Language Model\n * (LLM) call. It provides methods for parsing the result of an LLM call\n * and invoking the parser with a given input.\n */\nexport declare abstract class BaseLLMOutputParser<T = unknown> extends Runnable<string | BaseMessage, T> {\n    /**\n     * Parses the result of an LLM call. This method is meant to be\n     * implemented by subclasses to define how the output from the LLM should\n     * be parsed.\n     * @param generations The generations from an LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    abstract parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parses the result of an LLM call with a given prompt. By default, it\n     * simply calls `parseResult`.\n     * @param generations The generations from an LLM call.\n     * @param _prompt The prompt used in the LLM call.\n     * @param callbacks Optional callbacks.\n     * @returns A promise of the parsed output.\n     */\n    parseResultWithPrompt(generations: Generation[] | ChatGeneration[], _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    protected _baseMessageToString(message: BaseMessage): string;\n    protected _baseMessageContentToString(content: ContentBlock[]): string;\n    /**\n     * Calls the parser with a given input and optional configuration options.\n     * If the input is a string, it creates a generation with the input as\n     * text and calls `parseResult`. If the input is a `BaseMessage`, it\n     * creates a generation with the input as a message and the content of the\n     * input as text, and then calls `parseResult`.\n     * @param input The input to the parser, which can be a string or a `BaseMessage`.\n     * @param options Optional configuration options.\n     * @returns A promise of the parsed output.\n     */\n    invoke(input: string | BaseMessage, options?: RunnableConfig): Promise<T>;\n}\n/**\n * Class to parse the output of an LLM call.\n */\nexport declare abstract class BaseOutputParser<T = unknown> extends BaseLLMOutputParser<T> {\n    parseResult(generations: Generation[] | ChatGeneration[], callbacks?: Callbacks): Promise<T>;\n    /**\n     * Parse the output of an LLM call.\n     *\n     * @param text - LLM output to parse.\n     * @returns Parsed output.\n     */\n    abstract parse(text: string, callbacks?: Callbacks): Promise<T>;\n    parseWithPrompt(text: string, _prompt: BasePromptValueInterface, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Return a string describing the format of the output.\n     * @returns Format instructions.\n     * @param options - Options for formatting instructions.\n     * @example\n     * ```json\n     * {\n     *  \"foo\": \"bar\"\n     * }\n     * ```\n     */\n    abstract getFormatInstructions(options?: FormatInstructionsOptions): string;\n    /**\n     * Return the string type key uniquely identifying this class of parser\n     */\n    _type(): string;\n}\n/**\n * Exception that output parsers should raise to signify a parsing error.\n *\n * This exists to differentiate parsing errors from other code or execution errors\n * that also may arise inside the output parser. OutputParserExceptions will be\n * available to catch and handle in ways to fix the parsing error, while other\n * errors will be raised.\n *\n * @param message - The error that's being re-raised or an error message.\n * @param llmOutput - String model output which is error-ing.\n * @param observation - String explanation of error which can be passed to a\n *     model to try and remediate the issue.\n * @param sendToLLM - Whether to send the observation and llm_output back to an Agent\n *     after an OutputParserException has been raised. This gives the underlying\n *     model driving the agent the context that the previous output was improperly\n *     structured, in the hopes that it will update the output to the correct\n *     format.\n */\nexport declare class OutputParserException extends Error {\n    llmOutput?: string;\n    observation?: string;\n    sendToLLM: boolean;\n    constructor(message: string, llmOutput?: string, observation?: string, sendToLLM?: boolean);\n}\n"],"mappings":";;;;;;;;;;;;AASiBQ,UAAAA,yBAAAA,CAAyB,CAO1C;;;;;;AASmFH,uBATrDI,mBASqDJ,CAAAA,IAAAA,OAAAA,CAAAA,SATZL,QASYK,CAAAA,MAAAA,GATMF,WASNE,EATmBK,CASnBL,CAAAA,CAAAA;EAAS;;;;;;;;EAS8C,SAC9FF,WAAAA,CAAAA,WAAAA,EAVNG,UAUMH,EAAAA,GAVSI,cAUTJ,EAAAA,EAAAA,SAAAA,CAAAA,EAVuCE,SAUvCF,CAAAA,EAVmDQ,OAUnDR,CAV2DO,CAU3DP,CAAAA;EAAW;;;;;;AAnBwB;AAoC/E;EAA8C,qBAAA,CAAA,WAAA,EAlBPG,UAkBO,EAAA,GAlBQC,cAkBR,EAAA,EAAA,OAAA,EAlBmCL,wBAkBnC,EAAA,SAAA,CAAA,EAlByEG,SAkBzE,CAAA,EAlBqFM,OAkBrF,CAlB6FD,CAkB7F,CAAA;EAAA,UAA0CA,oBAAAA,CAAAA,OAAAA,EAjB5CP,WAiB4CO,CAAAA,EAAAA,MAAAA;EAAC,UAC5DJ,2BAAAA,CAAAA,OAAAA,EAjBsBF,YAiBtBE,EAAAA,CAAAA,EAAAA,MAAAA;EAAU;;;;;;;;;;EAQ+D,MAATK,CAAAA,KAAAA,EAAAA,MAAAA,GAdlER,WAckEQ,EAAAA,OAAAA,CAAAA,EAd3CV,cAc2CU,CAAAA,EAd1BA,OAc0BA,CAdlBD,CAckBC,CAAAA;;;AATN;AA6CvF;uBA7C8BC,sCAAsCH,oBAAoBC;2BAC3DJ,eAAeC,8BAA8BF,YAAYM,QAAQD;;;;;;;2CAOjDL,YAAYM,QAAQD;yCACtBR,sCAAsCG,YAAYM,QAAQD;;;;;;;;;;;;2CAYxDF;;;;;;;;;;;;;;;;;;;;;;;;cAwBxBK,qBAAAA,SAA8BC,KAAK"}