@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/output_parsers/base.cjs.map

@@ -1 +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"}
+{"version":3,"file":"base.cjs","names":["Runnable"],"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,aAAAA,SAG7D;;;;;;;;;CAsBA,sBACE,aACA,SACA,WACY;AACZ,SAAO,KAAK,YAAY,aAAa,UAAU;;CAGjD,qBAA+B,SAA8B;AAC3D,SAAO,OAAO,QAAQ,YAAY,WAC9B,QAAQ,UACR,KAAK,4BAA4B,QAAQ,QAAQ;;CAGvD,4BAAsC,SAAiC;AACrE,SAAO,KAAK,UAAU,QAAQ;;;;;;;;;;;;CAahC,MAAM,OACJ,OACA,SACY;AACZ,MAAI,OAAO,UAAU,SACnB,QAAO,KAAK,gBACV,OAAO,OAAe,YACpB,KAAK,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,SAAS,UAAU,EACzD,OACA;GAAE,GAAG;GAAS,SAAS;GAAU,CAClC;MAED,QAAO,KAAK,gBACV,OAAO,OAAoB,YACzB,KAAK,YACH,CACE;GACE,SAAS;GACT,MAAM,KAAK,qBAAqB,MAAM;GACvC,CACF,EACD,SAAS,UACV,EACH,OACA;GAAE,GAAG;GAAS,SAAS;GAAU,CAClC;;;;;;AAQP,IAAsB,mBAAtB,cAEU,oBAAuB;CAC/B,YACE,aACA,WACY;AACZ,SAAO,KAAK,MAAM,YAAY,GAAG,MAAM,UAAU;;CAWnD,MAAM,gBACJ,MACA,SACA,WACY;AACZ,SAAO,KAAK,MAAM,MAAM,UAAU;;;;;CAmBpC,QAAgB;AACd,QAAM,IAAI,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;AAsB5C,IAAa,wBAAb,cAA2C,MAAM;CAC/C;CAEA;CAEA;CAEA,YACE,SACA,WACA,aACA,YAAY,OACZ;AACA,QAAM,QAAQ;AACd,OAAK,YAAY;AACjB,OAAK,cAAc;AACnB,OAAK,YAAY;AAEjB,MAAI;OACE,gBAAgB,KAAA,KAAa,cAAc,KAAA,EAC7C,OAAM,IAAI,MACR,4EACD;;AAIL,uBAAA,wBAAwB,MAAM,yBAAyB"}

package/dist/output_parsers/base.d.cts

@@ -5,7 +5,6 @@ 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.

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

@@ -1 +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//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;;;;;;AASiBQ,UAAAA,yBAAAA,CAAyB,CAO1C;;;;;;AASuGE,uBATzED,mBASyEC,CAAAA,IAAAA,OAAAA,CAAAA,SAThCV,QASgCU,CAAAA,MAAAA,GATdP,WAScO,EATDA,CASCA,CAAAA,CAAAA;EAARC;;;;;;;;EAW5CP,SAAAA,WAAAA,CAAAA,WAAAA,EAXbE,UAWaF,EAAAA,GAXEG,cAWFH,EAAAA,EAAAA,SAAAA,CAAAA,EAXgCC,SAWhCD,CAAAA,EAX4CO,OAW5CP,CAXoDM,CAWpDN,CAAAA;EAWxBD;;;;;AA/BoD;AAoC/E;;EAC6BG,qBAAAA,CAAAA,WAAAA,EAnBUA,UAmBVA,EAAAA,GAnByBC,cAmBzBD,EAAAA,EAAAA,OAAAA,EAnBoDJ,wBAmBpDI,EAAAA,SAAAA,CAAAA,EAnB0FD,SAmB1FC,CAAAA,EAnBsGK,OAmBtGL,CAnB8GI,CAmB9GJ,CAAAA;EAAeC,UAAAA,oBAAAA,CAAAA,OAAAA,EAlBAJ,WAkBAI,CAAAA,EAAAA,MAAAA;EAA8BF,UAAAA,2BAAAA,CAAAA,OAAAA,EAjBvBD,YAiBuBC,EAAAA,CAAAA,EAAAA,MAAAA;EAAoBK;;;;;;;;;;EAD1BD,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,GALzCN,WAKyCM,EAAAA,OAAAA,CAAAA,EALlBR,cAKkBQ,CAAAA,EALDE,OAKCF,CALOC,CAKPD,CAAAA;AAAmB;AA6CvF;;;uBA7C8BG,sCAAsCH,oBAAoBC;2BAC3DJ,eAAeC,8BAA8BF,YAAYM,QAAQD;;;;;;;2CAOjDL,YAAYM,QAAQD;yCACtBR,sCAAsCG,YAAYM,QAAQD;;;;;;;;;;;;2CAYxDF;;;;;;;;;;;;;;;;;;;;;;;;cAwBxBK,qBAAAA,SAA8BC,KAAK"}
+{"version":3,"file":"base.d.cts","names":[],"sources":["../../src/output_parsers/base.ts"],"mappings":";;;;;;;;;;;UAWiB,yBAAA;;AAAjB;;;;uBAOsB,mBAAA,sBAAyC,QAAA,UACpD,WAAA,EACT,CAAA;EAFoB;;;;;;;;EAAA,SAYX,WAAA,CACP,WAAA,EAAa,UAAA,KAAe,cAAA,IAC5B,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EAAR;;;;;;;;EAUH,qBAAA,CACE,WAAA,EAAa,UAAA,KAAe,cAAA,IAC5B,OAAA,EAAS,wBAAA,EACT,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EAAA,UAID,oBAAA,CAAqB,OAAA,EAAS,WAAA;EAAA,UAM9B,2BAAA,CAA4B,OAAA,EAAS,YAAA;EAiBpC;;;;;;;;;;EAHL,MAAA,CACJ,KAAA,WAAgB,WAAA,EAChB,OAAA,GAAU,cAAA,GACT,OAAA,CAAQ,CAAA;AAAA;;;;uBA8BS,gBAAA,sBAEZ,mBAAA,CAAoB,CAAA;EAC5B,WAAA,CACE,WAAA,EAAa,UAAA,KAAe,cAAA,IAC5B,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EAnEX;;;;;;EAAA,SA6ES,KAAA,CAAM,IAAA,UAAc,SAAA,GAAY,SAAA,GAAY,OAAA,CAAQ,CAAA;EAEvD,eAAA,CACJ,IAAA,UACA,OAAA,EAAS,wBAAA,EACT,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EA/ER;;;;;;;;;;;EAAA,SA8FM,qBAAA,CAAsB,OAAA,GAAU,yBAAA;EApEvC;;;EAyEF,KAAA,CAAA;AAAA;AA1CF;;;;;;;;;;;;;;;;;;AAAA,cAiEa,qBAAA,SAA8B,KAAA;EACzC,SAAA;EAEA,WAAA;EAEA,SAAA;EAEA,WAAA,CACE,OAAA,UACA,SAAA,WACA,WAAA,WACA,SAAA;AAAA"}

package/dist/output_parsers/base.d.ts

@@ -3,12 +3,8 @@ 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 "../runnables/config.js";
 import { Runnable } from "../runnables/base.js";
 import { BasePromptValueInterface } from "../prompt_values.js";
-import "../messages/index.js";
-import "../runnables/index.js";
-
 //#region src/output_parsers/base.d.ts
 /**
  * Options for formatting instructions.

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

@@ -1 +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//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;;;;;;;;;UASiBQ,yBAAAA;;AAAjB;AAOA;;;AASsCF,uBATRG,mBASQH,CAAAA,IAAAA,OAAAA,CAAAA,SATiCN,QASjCM,CAAAA,MAAAA,GATmDH,WASnDG,EATgEI,CAShEJ,CAAAA,CAAAA;EAAeC;;;;;;;;EASsFG,SAAAA,WAAAA,CAAAA,WAAAA,EATrGJ,UASqGI,EAAAA,GATtFH,cASsFG,EAAAA,EAAAA,SAAAA,CAAAA,EATxDL,SASwDK,CAAAA,EAT5CC,OAS4CD,CATpCA,CASoCA,CAAAA;EAARC;;;;;;;;EAlBpD,qBAAA,CAAA,WAAA,EAkBxCL,UAlBwC,EAAA,GAkBzBC,cAlByB,EAAA,EAAA,OAAA,EAkBEL,wBAlBF,EAAA,SAAA,CAAA,EAkBwCG,SAlBxC,CAAA,EAkBoDM,OAlBpD,CAkB4DD,CAlB5D,CAAA;EAoCjDE,UAAAA,oBAAgBF,CAAAA,OAAA,EAjBFP,WAiBE,CAAA,EAAA,MAAA;EAA0CO,UAAAA,2BAAAA,CAAAA,OAAAA,EAhBrCN,YAgBqCM,EAAAA,CAAAA,EAAAA,MAAAA;EAC3DJ;;;;;;;;;;EAQwEI,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,GAd1EP,WAc0EO,EAAAA,OAAAA,CAAAA,EAdnDT,cAcmDS,CAAAA,EAdlCC,OAckCD,CAd1BA,CAc0BA,CAAAA;;;;AATd;AA6ClEG,uBA7CSD,gBA6C0B,CAAA,IAAA,OAAA,CAAA,SA7CYH,mBA6CZ,CA7CgCC,CA6ChC,CAAA,CAAA;2BA5C3BJ,eAAeC,8BAA8BF,YAAYM,QAAQD;;;;;;;2CAOjDL,YAAYM,QAAQD;yCACtBR,sCAAsCG,YAAYM,QAAQD;;;;;;;;;;;;2CAYxDF;;;;;;;;;;;;;;;;;;;;;;;;cAwBxBK,qBAAAA,SAA8BC,KAAK"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/output_parsers/base.ts"],"mappings":";;;;;;;;;;;UAWiB,yBAAA;;AAAjB;;;;uBAOsB,mBAAA,sBAAyC,QAAA,UACpD,WAAA,EACT,CAAA;EAFoB;;;;;;;;EAAA,SAYX,WAAA,CACP,WAAA,EAAa,UAAA,KAAe,cAAA,IAC5B,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EAAR;;;;;;;;EAUH,qBAAA,CACE,WAAA,EAAa,UAAA,KAAe,cAAA,IAC5B,OAAA,EAAS,wBAAA,EACT,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EAAA,UAID,oBAAA,CAAqB,OAAA,EAAS,WAAA;EAAA,UAM9B,2BAAA,CAA4B,OAAA,EAAS,YAAA;EAiBpC;;;;;;;;;;EAHL,MAAA,CACJ,KAAA,WAAgB,WAAA,EAChB,OAAA,GAAU,cAAA,GACT,OAAA,CAAQ,CAAA;AAAA;;;;uBA8BS,gBAAA,sBAEZ,mBAAA,CAAoB,CAAA;EAC5B,WAAA,CACE,WAAA,EAAa,UAAA,KAAe,cAAA,IAC5B,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EAnEX;;;;;;EAAA,SA6ES,KAAA,CAAM,IAAA,UAAc,SAAA,GAAY,SAAA,GAAY,OAAA,CAAQ,CAAA;EAEvD,eAAA,CACJ,IAAA,UACA,OAAA,EAAS,wBAAA,EACT,SAAA,GAAY,SAAA,GACX,OAAA,CAAQ,CAAA;EA/ER;;;;;;;;;;;EAAA,SA8FM,qBAAA,CAAsB,OAAA,GAAU,yBAAA;EApEvC;;;EAyEF,KAAA,CAAA;AAAA;AA1CF;;;;;;;;;;;;;;;;;;AAAA,cAiEa,qBAAA,SAA8B,KAAA;EACzC,SAAA;EAEA,WAAA;EAEA,SAAA;EAEA,WAAA,CACE,OAAA,UACA,SAAA,WACA,WAAA,WACA,SAAA;AAAA"}

package/dist/output_parsers/base.js

@@ -1,7 +1,6 @@
 import { addLangChainErrorFields } from "../errors/index.js";
 import { Runnable } from "../runnables/base.js";
 import "../runnables/index.js";
-
 //#region src/output_parsers/base.ts
 /**
 * Abstract base class for parsing the output of a Large Language Model
@@ -37,14 +36,14 @@ var BaseLLMOutputParser = class extends Runnable {
 	* @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, {
+		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$1, options$1) => this.parseResult([{
-			message: input$1,
-			text: this._baseMessageToString(input$1)
-		}], options$1?.callbacks), input, {
+		else return this._callWithConfig(async (input, options) => this.parseResult([{
+			message: input,
+			text: this._baseMessageToString(input)
+		}], options?.callbacks), input, {
 			...options,
 			runType: "parser"
 		});
@@ -100,7 +99,7 @@ var OutputParserException = class extends Error {
 		addLangChainErrorFields(this, "OUTPUT_PARSING_FAILURE");
 	}
 };
-
 //#endregion
 export { BaseLLMOutputParser, BaseOutputParser, OutputParserException };
+
 //# sourceMappingURL=base.js.map

package/dist/output_parsers/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":["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"],"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+D,SAG7D;;;;;;;;;CAsBA,sBACEA,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;EAGH,wBAAwB,MAAM,yBAAyB;CACxD;AACF"}
+{"version":3,"file":"base.js","names":[],"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+D,SAG7D;;;;;;;;;CAsBA,sBACE,aACA,SACA,WACY;AACZ,SAAO,KAAK,YAAY,aAAa,UAAU;;CAGjD,qBAA+B,SAA8B;AAC3D,SAAO,OAAO,QAAQ,YAAY,WAC9B,QAAQ,UACR,KAAK,4BAA4B,QAAQ,QAAQ;;CAGvD,4BAAsC,SAAiC;AACrE,SAAO,KAAK,UAAU,QAAQ;;;;;;;;;;;;CAahC,MAAM,OACJ,OACA,SACY;AACZ,MAAI,OAAO,UAAU,SACnB,QAAO,KAAK,gBACV,OAAO,OAAe,YACpB,KAAK,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,EAAE,SAAS,UAAU,EACzD,OACA;GAAE,GAAG;GAAS,SAAS;GAAU,CAClC;MAED,QAAO,KAAK,gBACV,OAAO,OAAoB,YACzB,KAAK,YACH,CACE;GACE,SAAS;GACT,MAAM,KAAK,qBAAqB,MAAM;GACvC,CACF,EACD,SAAS,UACV,EACH,OACA;GAAE,GAAG;GAAS,SAAS;GAAU,CAClC;;;;;;AAQP,IAAsB,mBAAtB,cAEU,oBAAuB;CAC/B,YACE,aACA,WACY;AACZ,SAAO,KAAK,MAAM,YAAY,GAAG,MAAM,UAAU;;CAWnD,MAAM,gBACJ,MACA,SACA,WACY;AACZ,SAAO,KAAK,MAAM,MAAM,UAAU;;;;;CAmBpC,QAAgB;AACd,QAAM,IAAI,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;AAsB5C,IAAa,wBAAb,cAA2C,MAAM;CAC/C;CAEA;CAEA;CAEA,YACE,SACA,WACA,aACA,YAAY,OACZ;AACA,QAAM,QAAQ;AACd,OAAK,YAAY;AACjB,OAAK,cAAc;AACnB,OAAK,YAAY;AAEjB,MAAI;OACE,gBAAgB,KAAA,KAAa,cAAc,KAAA,EAC7C,OAAM,IAAI,MACR,4EACD;;AAIL,0BAAwB,MAAM,yBAAyB"}

package/dist/output_parsers/bytes.cjs

@@ -1,5 +1,4 @@
-const require_transform = require('./transform.cjs');
-
+const require_transform = require("./transform.cjs");
 //#region src/output_parsers/bytes.ts
 /**
 * OutputParser that parses LLMResult into the top likely string and
@@ -23,7 +22,7 @@ var BytesOutputParser = class extends require_transform.BaseTransformOutputParse
 		return "";
 	}
 };
-
 //#endregion
 exports.BytesOutputParser = BytesOutputParser;
+
 //# sourceMappingURL=bytes.cjs.map

package/dist/output_parsers/bytes.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.cjs","names":["BaseTransformOutputParser","text: string"],"sources":["../../src/output_parsers/bytes.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"BytesOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\", \"bytes\"];\n\n  lc_serializable = true;\n\n  protected textEncoder: InstanceType<typeof TextEncoder> = new TextEncoder();\n\n  parse(text: string): Promise<Uint8Array> {\n    return Promise.resolve(this.textEncoder.encode(text));\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,oBAAb,cAAuCA,4CAAsC;CAC3E,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAkB;EAAkB;CAAQ;CAE5D,kBAAkB;CAElB,AAAU,cAAgD,IAAI;CAE9D,MAAMC,MAAmC;AACvC,SAAO,QAAQ,QAAQ,KAAK,YAAY,OAAO,KAAK,CAAC;CACtD;CAED,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"version":3,"file":"bytes.cjs","names":["BaseTransformOutputParser"],"sources":["../../src/output_parsers/bytes.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"BytesOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\", \"bytes\"];\n\n  lc_serializable = true;\n\n  protected textEncoder: InstanceType<typeof TextEncoder> = new TextEncoder();\n\n  parse(text: string): Promise<Uint8Array> {\n    return Promise.resolve(this.textEncoder.encode(text));\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;AAMA,IAAa,oBAAb,cAAuCA,kBAAAA,0BAAsC;CAC3E,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAkB;EAAkB;EAAQ;CAE5D,kBAAkB;CAElB,cAA0D,IAAI,aAAa;CAE3E,MAAM,MAAmC;AACvC,SAAO,QAAQ,QAAQ,KAAK,YAAY,OAAO,KAAK,CAAC;;CAGvD,wBAAgC;AAC9B,SAAO"}

package/dist/output_parsers/bytes.d.cts

@@ -1,7 +1,6 @@
 import { BaseTransformOutputParser } from "./transform.cjs";
 
 //#region src/output_parsers/bytes.d.ts
-
 /**
  * OutputParser that parses LLMResult into the top likely string and
  * encodes it into bytes.

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

@@ -1 +1 @@
-{"version":3,"file":"bytes.d.cts","names":["BaseTransformOutputParser","BytesOutputParser","Uint8Array","TextEncoder","InstanceType","Promise"],"sources":["../../src/output_parsers/bytes.d.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport declare class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    protected textEncoder: InstanceType<typeof TextEncoder>;\n    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=bytes.d.ts.map"],"mappings":";;;;;;AAKA;;AAI+CG,cAJ1BF,iBAAAA,SAA0BD,yBAIAG,CAJ0BD,UAI1BC,CAAAA,CAAAA;EAApBC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACMF,YAAAA,EAAAA,MAAAA,EAAAA;EAARG,eAAAA,EAAAA,OAAAA;EALsBL,UAAAA,WAAAA,EAIpBI,YAJoBJ,CAAAA,OAIAG,WAJAH,CAAAA;EAAyB,KAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAK/CK,OAL+C,CAKvCH,UALuC,CAAA"}
+{"version":3,"file":"bytes.d.cts","names":[],"sources":["../../src/output_parsers/bytes.ts"],"mappings":";;;;;AAMA;;cAAa,iBAAA,SAA0B,yBAAA,CAA0B,UAAA;EAAA,OACxD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAAA,UAEU,WAAA,EAAa,YAAA,QAAoB,WAAA;EAE3C,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,UAAA;EAI7B,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/bytes.d.ts

@@ -1,7 +1,6 @@
 import { BaseTransformOutputParser } from "./transform.js";
 
 //#region src/output_parsers/bytes.d.ts
-
 /**
  * OutputParser that parses LLMResult into the top likely string and
  * encodes it into bytes.

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

@@ -1 +1 @@
-{"version":3,"file":"bytes.d.ts","names":["BaseTransformOutputParser","BytesOutputParser","Uint8Array","TextEncoder","InstanceType","Promise"],"sources":["../../src/output_parsers/bytes.d.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport declare class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    protected textEncoder: InstanceType<typeof TextEncoder>;\n    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=bytes.d.ts.map"],"mappings":";;;;;;AAKA;;AAI+CG,cAJ1BF,iBAAAA,SAA0BD,yBAIAG,CAJ0BD,UAI1BC,CAAAA,CAAAA;EAApBC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACMF,YAAAA,EAAAA,MAAAA,EAAAA;EAARG,eAAAA,EAAAA,OAAAA;EALsBL,UAAAA,WAAAA,EAIpBI,YAJoBJ,CAAAA,OAIAG,WAJAH,CAAAA;EAAyB,KAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAK/CK,OAL+C,CAKvCH,UALuC,CAAA"}
+{"version":3,"file":"bytes.d.ts","names":[],"sources":["../../src/output_parsers/bytes.ts"],"mappings":";;;;;AAMA;;cAAa,iBAAA,SAA0B,yBAAA,CAA0B,UAAA;EAAA,OACxD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAAA,UAEU,WAAA,EAAa,YAAA,QAAoB,WAAA;EAE3C,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,UAAA;EAI7B,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/bytes.js

@@ -1,5 +1,4 @@
 import { BaseTransformOutputParser } from "./transform.js";
-
 //#region src/output_parsers/bytes.ts
 /**
 * OutputParser that parses LLMResult into the top likely string and
@@ -23,7 +22,7 @@ var BytesOutputParser = class extends BaseTransformOutputParser {
 		return "";
 	}
 };
-
 //#endregion
 export { BytesOutputParser };
+
 //# sourceMappingURL=bytes.js.map

package/dist/output_parsers/bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.js","names":["text: string"],"sources":["../../src/output_parsers/bytes.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"BytesOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\", \"bytes\"];\n\n  lc_serializable = true;\n\n  protected textEncoder: InstanceType<typeof TextEncoder> = new TextEncoder();\n\n  parse(text: string): Promise<Uint8Array> {\n    return Promise.resolve(this.textEncoder.encode(text));\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,oBAAb,cAAuC,0BAAsC;CAC3E,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAkB;EAAkB;CAAQ;CAE5D,kBAAkB;CAElB,AAAU,cAAgD,IAAI;CAE9D,MAAMA,MAAmC;AACvC,SAAO,QAAQ,QAAQ,KAAK,YAAY,OAAO,KAAK,CAAC;CACtD;CAED,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"version":3,"file":"bytes.js","names":[],"sources":["../../src/output_parsers/bytes.ts"],"sourcesContent":["import { BaseTransformOutputParser } from \"./transform.js\";\n\n/**\n * OutputParser that parses LLMResult into the top likely string and\n * encodes it into bytes.\n */\nexport class BytesOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"BytesOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\", \"bytes\"];\n\n  lc_serializable = true;\n\n  protected textEncoder: InstanceType<typeof TextEncoder> = new TextEncoder();\n\n  parse(text: string): Promise<Uint8Array> {\n    return Promise.resolve(this.textEncoder.encode(text));\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;AAMA,IAAa,oBAAb,cAAuC,0BAAsC;CAC3E,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAkB;EAAkB;EAAQ;CAE5D,kBAAkB;CAElB,cAA0D,IAAI,aAAa;CAE3E,MAAM,MAAmC;AACvC,SAAO,QAAQ,QAAQ,KAAK,YAAY,OAAO,KAAK,CAAC;;CAGvD,wBAAgC;AAC9B,SAAO"}

package/dist/output_parsers/index.cjs

@@ -1,17 +1,17 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_json = require('../utils/json.cjs');
-const require_base = require('./base.cjs');
-const require_transform = require('./transform.cjs');
-const require_json$1 = require('./json.cjs');
-const require_bytes = require('./bytes.cjs');
-const require_list = require('./list.cjs');
-const require_string = require('./string.cjs');
-const require_structured = require('./structured.cjs');
-const require_xml = require('./xml.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_json = require("../utils/json.cjs");
+const require_base = require("./base.cjs");
+const require_transform = require("./transform.cjs");
+const require_bytes = require("./bytes.cjs");
+const require_list = require("./list.cjs");
+const require_string = require("./string.cjs");
+const require_json$1 = require("./json.cjs");
+const require_standard_schema = require("./standard_schema.cjs");
+const require_structured = require("./structured.cjs");
+const require_xml = require("./xml.cjs");
 //#region src/output_parsers/index.ts
-var output_parsers_exports = {};
-require_rolldown_runtime.__export(output_parsers_exports, {
+var output_parsers_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	AsymmetricStructuredOutputParser: () => require_structured.AsymmetricStructuredOutputParser,
 	BaseCumulativeTransformOutputParser: () => require_transform.BaseCumulativeTransformOutputParser,
 	BaseLLMOutputParser: () => require_base.BaseLLMOutputParser,
@@ -26,6 +26,7 @@ require_rolldown_runtime.__export(output_parsers_exports, {
 	MarkdownListOutputParser: () => require_list.MarkdownListOutputParser,
 	NumberedListOutputParser: () => require_list.NumberedListOutputParser,
 	OutputParserException: () => require_base.OutputParserException,
+	StandardSchemaOutputParser: () => require_standard_schema.StandardSchemaOutputParser,
 	StringOutputParser: () => require_string.StringOutputParser,
 	StructuredOutputParser: () => require_structured.StructuredOutputParser,
 	XMLOutputParser: () => require_xml.XMLOutputParser,
@@ -34,7 +35,6 @@ require_rolldown_runtime.__export(output_parsers_exports, {
 	parsePartialJson: () => require_json.parsePartialJson,
 	parseXMLMarkdown: () => require_xml.parseXMLMarkdown
 });
-
 //#endregion
 exports.AsymmetricStructuredOutputParser = require_structured.AsymmetricStructuredOutputParser;
 exports.BaseCumulativeTransformOutputParser = require_transform.BaseCumulativeTransformOutputParser;
@@ -50,17 +50,19 @@ exports.ListOutputParser = require_list.ListOutputParser;
 exports.MarkdownListOutputParser = require_list.MarkdownListOutputParser;
 exports.NumberedListOutputParser = require_list.NumberedListOutputParser;
 exports.OutputParserException = require_base.OutputParserException;
+exports.StandardSchemaOutputParser = require_standard_schema.StandardSchemaOutputParser;
 exports.StringOutputParser = require_string.StringOutputParser;
 exports.StructuredOutputParser = require_structured.StructuredOutputParser;
 exports.XMLOutputParser = require_xml.XMLOutputParser;
 exports.XML_FORMAT_INSTRUCTIONS = require_xml.XML_FORMAT_INSTRUCTIONS;
-Object.defineProperty(exports, 'output_parsers_exports', {
-  enumerable: true,
-  get: function () {
-    return output_parsers_exports;
-  }
+Object.defineProperty(exports, "output_parsers_exports", {
+	enumerable: true,
+	get: function() {
+		return output_parsers_exports;
+	}
 });
 exports.parseJsonMarkdown = require_json.parseJsonMarkdown;
 exports.parsePartialJson = require_json.parsePartialJson;
 exports.parseXMLMarkdown = require_xml.parseXMLMarkdown;
+
 //# sourceMappingURL=index.cjs.map

package/dist/output_parsers/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/output_parsers/index.ts"],"sourcesContent":["export * from \"./base.js\";\nexport * from \"./bytes.js\";\nexport * from \"./list.js\";\nexport * from \"./string.js\";\nexport * from \"./structured.js\";\nexport * from \"./transform.js\";\nexport * from \"./json.js\";\nexport * from \"./xml.js\";\n"],"mappings":""}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/output_parsers/index.ts"],"sourcesContent":["export * from \"./base.js\";\nexport * from \"./bytes.js\";\nexport * from \"./list.js\";\nexport * from \"./string.js\";\nexport * from \"./standard_schema.js\";\nexport * from \"./structured.js\";\nexport * from \"./transform.js\";\nexport * from \"./json.js\";\nexport * from \"./xml.js\";\n"],"mappings":""}

package/dist/output_parsers/index.d.cts

@@ -3,8 +3,9 @@ import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParse
 import { BytesOutputParser } from "./bytes.cjs";
 import { CommaSeparatedListOutputParser, CustomListOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser } from "./list.cjs";
 import { StringOutputParser } from "./string.cjs";
+import { StandardSchemaOutputParser } from "./standard_schema.cjs";
 import { AsymmetricStructuredOutputParser, AsymmetricStructuredOutputParserFields, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParser, JsonMarkdownStructuredOutputParserInput, StructuredOutputParser } from "./structured.cjs";
 import { parseJsonMarkdown, parsePartialJson } from "../utils/json.cjs";
 import { JsonOutputParser } from "./json.cjs";
 import { Content, XMLOutputParser, XMLOutputParserFields, XMLResult, XML_FORMAT_INSTRUCTIONS, parseXMLMarkdown } from "./xml.cjs";
-export { AsymmetricStructuredOutputParser, AsymmetricStructuredOutputParserFields, BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput, BaseLLMOutputParser, BaseOutputParser, BaseTransformOutputParser, BytesOutputParser, CommaSeparatedListOutputParser, Content, CustomListOutputParser, FormatInstructionsOptions, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParser, JsonMarkdownStructuredOutputParserInput, JsonOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser, OutputParserException, StringOutputParser, StructuredOutputParser, XMLOutputParser, XMLOutputParserFields, XMLResult, XML_FORMAT_INSTRUCTIONS, parseJsonMarkdown, parsePartialJson, parseXMLMarkdown };
+export { AsymmetricStructuredOutputParser, AsymmetricStructuredOutputParserFields, BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput, BaseLLMOutputParser, BaseOutputParser, BaseTransformOutputParser, BytesOutputParser, CommaSeparatedListOutputParser, Content, CustomListOutputParser, FormatInstructionsOptions, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParser, JsonMarkdownStructuredOutputParserInput, JsonOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser, OutputParserException, StandardSchemaOutputParser, StringOutputParser, StructuredOutputParser, XMLOutputParser, XMLOutputParserFields, XMLResult, XML_FORMAT_INSTRUCTIONS, parseJsonMarkdown, parsePartialJson, parseXMLMarkdown };

package/dist/output_parsers/index.d.ts

@@ -3,8 +3,9 @@ import { BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParse
 import { BytesOutputParser } from "./bytes.js";
 import { CommaSeparatedListOutputParser, CustomListOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser } from "./list.js";
 import { StringOutputParser } from "./string.js";
+import { StandardSchemaOutputParser } from "./standard_schema.js";
 import { AsymmetricStructuredOutputParser, AsymmetricStructuredOutputParserFields, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParser, JsonMarkdownStructuredOutputParserInput, StructuredOutputParser } from "./structured.js";
 import { parseJsonMarkdown, parsePartialJson } from "../utils/json.js";
 import { JsonOutputParser } from "./json.js";
 import { Content, XMLOutputParser, XMLOutputParserFields, XMLResult, XML_FORMAT_INSTRUCTIONS, parseXMLMarkdown } from "./xml.js";
-export { AsymmetricStructuredOutputParser, AsymmetricStructuredOutputParserFields, BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput, BaseLLMOutputParser, BaseOutputParser, BaseTransformOutputParser, BytesOutputParser, CommaSeparatedListOutputParser, Content, CustomListOutputParser, FormatInstructionsOptions, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParser, JsonMarkdownStructuredOutputParserInput, JsonOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser, OutputParserException, StringOutputParser, StructuredOutputParser, XMLOutputParser, XMLOutputParserFields, XMLResult, XML_FORMAT_INSTRUCTIONS, parseJsonMarkdown, parsePartialJson, parseXMLMarkdown };
+export { AsymmetricStructuredOutputParser, AsymmetricStructuredOutputParserFields, BaseCumulativeTransformOutputParser, BaseCumulativeTransformOutputParserInput, BaseLLMOutputParser, BaseOutputParser, BaseTransformOutputParser, BytesOutputParser, CommaSeparatedListOutputParser, Content, CustomListOutputParser, FormatInstructionsOptions, JsonMarkdownFormatInstructionsOptions, JsonMarkdownStructuredOutputParser, JsonMarkdownStructuredOutputParserInput, JsonOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser, OutputParserException, StandardSchemaOutputParser, StringOutputParser, StructuredOutputParser, XMLOutputParser, XMLOutputParserFields, XMLResult, XML_FORMAT_INSTRUCTIONS, parseJsonMarkdown, parsePartialJson, parseXMLMarkdown };

package/dist/output_parsers/index.js

@@ -1,17 +1,16 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { parseJsonMarkdown, parsePartialJson } from "../utils/json.js";
 import { BaseLLMOutputParser, BaseOutputParser, OutputParserException } from "./base.js";
 import { BaseCumulativeTransformOutputParser, BaseTransformOutputParser } from "./transform.js";
-import { JsonOutputParser } from "./json.js";
 import { BytesOutputParser } from "./bytes.js";
 import { CommaSeparatedListOutputParser, CustomListOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser } from "./list.js";
 import { StringOutputParser } from "./string.js";
+import { JsonOutputParser } from "./json.js";
+import { StandardSchemaOutputParser } from "./standard_schema.js";
 import { AsymmetricStructuredOutputParser, JsonMarkdownStructuredOutputParser, StructuredOutputParser } from "./structured.js";
 import { XMLOutputParser, XML_FORMAT_INSTRUCTIONS, parseXMLMarkdown } from "./xml.js";
-
 //#region src/output_parsers/index.ts
-var output_parsers_exports = {};
-__export(output_parsers_exports, {
+var output_parsers_exports = /* @__PURE__ */ __exportAll({
 	AsymmetricStructuredOutputParser: () => AsymmetricStructuredOutputParser,
 	BaseCumulativeTransformOutputParser: () => BaseCumulativeTransformOutputParser,
 	BaseLLMOutputParser: () => BaseLLMOutputParser,
@@ -26,6 +25,7 @@ __export(output_parsers_exports, {
 	MarkdownListOutputParser: () => MarkdownListOutputParser,
 	NumberedListOutputParser: () => NumberedListOutputParser,
 	OutputParserException: () => OutputParserException,
+	StandardSchemaOutputParser: () => StandardSchemaOutputParser,
 	StringOutputParser: () => StringOutputParser,
 	StructuredOutputParser: () => StructuredOutputParser,
 	XMLOutputParser: () => XMLOutputParser,
@@ -34,7 +34,7 @@ __export(output_parsers_exports, {
 	parsePartialJson: () => parsePartialJson,
 	parseXMLMarkdown: () => parseXMLMarkdown
 });
-
 //#endregion
-export { AsymmetricStructuredOutputParser, BaseCumulativeTransformOutputParser, BaseLLMOutputParser, BaseOutputParser, BaseTransformOutputParser, BytesOutputParser, CommaSeparatedListOutputParser, CustomListOutputParser, JsonMarkdownStructuredOutputParser, JsonOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser, OutputParserException, StringOutputParser, StructuredOutputParser, XMLOutputParser, XML_FORMAT_INSTRUCTIONS, output_parsers_exports, parseJsonMarkdown, parsePartialJson, parseXMLMarkdown };
+export { AsymmetricStructuredOutputParser, BaseCumulativeTransformOutputParser, BaseLLMOutputParser, BaseOutputParser, BaseTransformOutputParser, BytesOutputParser, CommaSeparatedListOutputParser, CustomListOutputParser, JsonMarkdownStructuredOutputParser, JsonOutputParser, ListOutputParser, MarkdownListOutputParser, NumberedListOutputParser, OutputParserException, StandardSchemaOutputParser, StringOutputParser, StructuredOutputParser, XMLOutputParser, XML_FORMAT_INSTRUCTIONS, output_parsers_exports, parseJsonMarkdown, parsePartialJson, parseXMLMarkdown };
+
 //# sourceMappingURL=index.js.map

package/dist/output_parsers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/output_parsers/index.ts"],"sourcesContent":["export * from \"./base.js\";\nexport * from \"./bytes.js\";\nexport * from \"./list.js\";\nexport * from \"./string.js\";\nexport * from \"./structured.js\";\nexport * from \"./transform.js\";\nexport * from \"./json.js\";\nexport * from \"./xml.js\";\n"],"mappings":""}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/output_parsers/index.ts"],"sourcesContent":["export * from \"./base.js\";\nexport * from \"./bytes.js\";\nexport * from \"./list.js\";\nexport * from \"./string.js\";\nexport * from \"./standard_schema.js\";\nexport * from \"./structured.js\";\nexport * from \"./transform.js\";\nexport * from \"./json.js\";\nexport * from \"./xml.js\";\n"],"mappings":""}

package/dist/output_parsers/json.cjs

@@ -1,8 +1,7 @@
-const require_json = require('../utils/json.cjs');
-const require_duplex = require('../utils/fast-json-patch/src/duplex.cjs');
-const require_transform = require('./transform.cjs');
-require('../utils/json_patch.cjs');
-
+const require_json = require("../utils/json.cjs");
+const require_duplex = require("../utils/fast-json-patch/src/duplex.cjs");
+const require_transform = require("./transform.cjs");
+require("../utils/json_patch.cjs");
 //#region src/output_parsers/json.ts
 /**
 * Class for parsing the output of an LLM into a JSON object.
@@ -19,7 +18,7 @@ var JsonOutputParser = class extends require_transform.BaseCumulativeTransformOu
 		return second;
 	}
 	_diff(prev, next) {
-		if (!next) return void 0;
+		if (!next) return;
 		if (!prev) return [{
 			op: "replace",
 			path: "",
@@ -36,8 +35,18 @@ var JsonOutputParser = class extends require_transform.BaseCumulativeTransformOu
 	getFormatInstructions() {
 		return "";
 	}
+	/**
+	* Extracts text content from a message for JSON parsing.
+	* Uses the message's `.text` accessor which properly handles both
+	* string content and ContentBlock[] arrays (extracting text from text blocks).
+	* @param message The message to extract text from
+	* @returns The text content of the message
+	*/
+	_baseMessageToString(message) {
+		return message.text;
+	}
 };
-
 //#endregion
 exports.JsonOutputParser = JsonOutputParser;
+
 //# sourceMappingURL=json.cjs.map

package/dist/output_parsers/json.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"json.cjs","names":["BaseCumulativeTransformOutputParser","first: T","second: T","prev: unknown | undefined","next: unknown","compare","generations: ChatGeneration[] | Generation[]","parseJsonMarkdown","text: string"],"sources":["../../src/output_parsers/json.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation, compare } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport class JsonOutputParser<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends Record<string, any> = Record<string, any>\n> extends BaseCumulativeTransformOutputParser<T> {\n  static lc_name() {\n    return \"JsonOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /** @internal */\n  override _concatOutputChunks<T>(first: T, second: T): T {\n    if (this.diff) {\n      return super._concatOutputChunks(first, second);\n    }\n    return second;\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): Operation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    if (!prev) {\n      return [{ op: \"replace\", path: \"\", value: next }];\n    }\n    return compare(prev, next);\n  }\n\n  // This should actually return Partial<T>, but there's no way\n  // to specify emitted chunks as instances separate from the main output type.\n  async parsePartialResult(\n    generations: ChatGeneration[] | Generation[]\n  ): Promise<T | undefined> {\n    return parseJsonMarkdown(generations[0].text) as T | undefined;\n  }\n\n  async parse(text: string): Promise<T> {\n    return parseJsonMarkdown(text, JSON.parse) as T;\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\nexport { parsePartialJson, parseJsonMarkdown };\n"],"mappings":";;;;;;;;;AAQA,IAAa,mBAAb,cAGUA,sDAAuC;CAC/C,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,gBAAiB;CAEnD,kBAAkB;;CAGlB,AAAS,oBAAuBC,OAAUC,QAAc;AACtD,MAAI,KAAK,KACP,QAAO,MAAM,oBAAoB,OAAO,OAAO;AAEjD,SAAO;CACR;CAED,AAAU,MACRC,MACAC,MACyB;AACzB,MAAI,CAAC,KACH,QAAO;AAET,MAAI,CAAC,KACH,QAAO,CAAC;GAAE,IAAI;GAAW,MAAM;GAAI,OAAO;EAAM,CAAC;AAEnD,SAAOC,uBAAQ,MAAM,KAAK;CAC3B;CAID,MAAM,mBACJC,aACwB;AACxB,SAAOC,+BAAkB,YAAY,GAAG,KAAK;CAC9C;CAED,MAAM,MAAMC,MAA0B;AACpC,SAAOD,+BAAkB,MAAM,KAAK,MAAM;CAC3C;CAED,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"version":3,"file":"json.cjs","names":["BaseCumulativeTransformOutputParser","compare","parseJsonMarkdown"],"sources":["../../src/output_parsers/json.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation, compare } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\nimport type { BaseMessage } from \"../messages/index.js\";\n\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport class JsonOutputParser<\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends Record<string, any> = Record<string, any>,\n> extends BaseCumulativeTransformOutputParser<T> {\n  static lc_name() {\n    return \"JsonOutputParser\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"output_parsers\"];\n\n  lc_serializable = true;\n\n  /** @internal */\n  override _concatOutputChunks<T>(first: T, second: T): T {\n    if (this.diff) {\n      return super._concatOutputChunks(first, second);\n    }\n    return second;\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): Operation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    if (!prev) {\n      return [{ op: \"replace\", path: \"\", value: next }];\n    }\n    return compare(prev, next);\n  }\n\n  // This should actually return Partial<T>, but there's no way\n  // to specify emitted chunks as instances separate from the main output type.\n  async parsePartialResult(\n    generations: ChatGeneration[] | Generation[]\n  ): Promise<T | undefined> {\n    return parseJsonMarkdown(generations[0].text) as T | undefined;\n  }\n\n  async parse(text: string): Promise<T> {\n    return parseJsonMarkdown(text, JSON.parse) as T;\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n\n  /**\n   * Extracts text content from a message for JSON parsing.\n   * Uses the message's `.text` accessor which properly handles both\n   * string content and ContentBlock[] arrays (extracting text from text blocks).\n   * @param message The message to extract text from\n   * @returns The text content of the message\n   */\n  protected _baseMessageToString(message: BaseMessage): string {\n    return message.text;\n  }\n}\n\nexport { parsePartialJson, parseJsonMarkdown };\n"],"mappings":";;;;;;;;AASA,IAAa,mBAAb,cAGUA,kBAAAA,oCAAuC;CAC/C,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,kBAAkB,iBAAiB;CAEnD,kBAAkB;;CAGlB,oBAAgC,OAAU,QAAc;AACtD,MAAI,KAAK,KACP,QAAO,MAAM,oBAAoB,OAAO,OAAO;AAEjD,SAAO;;CAGT,MACE,MACA,MACyB;AACzB,MAAI,CAAC,KACH;AAEF,MAAI,CAAC,KACH,QAAO,CAAC;GAAE,IAAI;GAAW,MAAM;GAAI,OAAO;GAAM,CAAC;AAEnD,SAAOC,eAAAA,QAAQ,MAAM,KAAK;;CAK5B,MAAM,mBACJ,aACwB;AACxB,SAAOC,aAAAA,kBAAkB,YAAY,GAAG,KAAK;;CAG/C,MAAM,MAAM,MAA0B;AACpC,SAAOA,aAAAA,kBAAkB,MAAM,KAAK,MAAM;;CAG5C,wBAAgC;AAC9B,SAAO;;;;;;;;;CAUT,qBAA+B,SAA8B;AAC3D,SAAO,QAAQ"}

package/dist/output_parsers/json.d.cts

@@ -1,10 +1,10 @@
+import { BaseMessage } from "../messages/base.cjs";
 import { ChatGeneration, Generation } from "../outputs.cjs";
 import { Operation } from "../utils/fast-json-patch/src/core.cjs";
 import { BaseCumulativeTransformOutputParser } from "./transform.cjs";
 import { parseJsonMarkdown, parsePartialJson } from "../utils/json.cjs";
 
 //#region src/output_parsers/json.d.ts
-
 /**
  * Class for parsing the output of an LLM into a JSON object.
  */
@@ -18,6 +18,14 @@ declare class JsonOutputParser<T extends Record<string, any> = Record<string, an
   parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;
   parse(text: string): Promise<T>;
   getFormatInstructions(): string;
+  /**
+   * Extracts text content from a message for JSON parsing.
+   * Uses the message's `.text` accessor which properly handles both
+   * string content and ContentBlock[] arrays (extracting text from text blocks).
+   * @param message The message to extract text from
+   * @returns The text content of the message
+   */
+  protected _baseMessageToString(message: BaseMessage): string;
 }
 //#endregion
 export { JsonOutputParser };

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

@@ -1 +1 @@
-{"version":3,"file":"json.d.cts","names":["BaseCumulativeTransformOutputParser","Operation","ChatGeneration","Generation","parseJsonMarkdown","parsePartialJson","JsonOutputParser","T","Record","Promise"],"sources":["../../src/output_parsers/json.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /** @internal */\n    _concatOutputChunks<T>(first: T, second: T): T;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;\n    parse(text: string): Promise<T>;\n    getFormatInstructions(): string;\n}\nexport { parsePartialJson, parseJsonMarkdown };\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAAgDQ,cAA3BF,gBAA2BE,CAAAA,UAAAA,MAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAAsBA,MAAtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SAAmDR,mCAAnDQ,CAAuFD,CAAvFC,CAAAA,CAAAA;EAAsBA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiED,YAAAA,EAAAA,MAAAA,EAAAA;EAKrGA,eAAAA,EAAAA,OAAAA;EAAWA;EAAIA,mBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAfA,CAAeA,EAAAA,MAAAA,EAAJA,CAAIA,CAAAA,EAAAA,CAAAA;EACcN,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,SAAAA,EAAAA,GAAAA,SAAAA;EAC3BC,kBAAAA,CAAAA,WAAAA,EAAAA,cAAAA,EAAAA,GAAmBC,UAAnBD,EAAAA,CAAAA,EAAkCO,OAAlCP,CAA0CK,CAA1CL,GAAAA,SAAAA,CAAAA;EAAmBC,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EAC9BM,OAD8BN,CACtBI,CADsBJ,CAAAA;EAAuBI,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA"}
+{"version":3,"file":"json.d.cts","names":[],"sources":["../../src/output_parsers/json.ts"],"mappings":";;;;;;;;;;cASa,gBAAA,WAED,MAAA,gBAAsB,MAAA,uBACxB,mCAAA,CAAoC,CAAA;EAAA,OACrC,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EARgC;EAWvB,mBAAA,GAAA,CAAuB,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,GAAI,CAAA;EAAA,UAO5C,KAAA,CACR,IAAA,uBACA,IAAA,YACC,SAAA;EAYG,kBAAA,CACJ,WAAA,EAAa,cAAA,KAAmB,UAAA,KAC/B,OAAA,CAAQ,CAAA;EAIL,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,CAAA;EAInC,qBAAA,CAAA;EATe;;;;;;;EAAA,UAoBL,oBAAA,CAAqB,OAAA,EAAS,WAAA;AAAA"}

package/dist/output_parsers/json.d.ts

@@ -1,10 +1,10 @@
+import { BaseMessage } from "../messages/base.js";
 import { ChatGeneration, Generation } from "../outputs.js";
 import { Operation } from "../utils/fast-json-patch/src/core.js";
 import { BaseCumulativeTransformOutputParser } from "./transform.js";
 import { parseJsonMarkdown, parsePartialJson } from "../utils/json.js";
 
 //#region src/output_parsers/json.d.ts
-
 /**
  * Class for parsing the output of an LLM into a JSON object.
  */
@@ -18,6 +18,14 @@ declare class JsonOutputParser<T extends Record<string, any> = Record<string, an
   parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;
   parse(text: string): Promise<T>;
   getFormatInstructions(): string;
+  /**
+   * Extracts text content from a message for JSON parsing.
+   * Uses the message's `.text` accessor which properly handles both
+   * string content and ContentBlock[] arrays (extracting text from text blocks).
+   * @param message The message to extract text from
+   * @returns The text content of the message
+   */
+  protected _baseMessageToString(message: BaseMessage): string;
 }
 //#endregion
 export { JsonOutputParser };

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

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","names":["BaseCumulativeTransformOutputParser","Operation","ChatGeneration","Generation","parseJsonMarkdown","parsePartialJson","JsonOutputParser","T","Record","Promise"],"sources":["../../src/output_parsers/json.d.ts"],"sourcesContent":["import { BaseCumulativeTransformOutputParser } from \"./transform.js\";\nimport { Operation } from \"../utils/json_patch.js\";\nimport { ChatGeneration, Generation } from \"../outputs.js\";\nimport { parseJsonMarkdown, parsePartialJson } from \"../utils/json.js\";\n/**\n * Class for parsing the output of an LLM into a JSON object.\n */\nexport declare class JsonOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseCumulativeTransformOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    /** @internal */\n    _concatOutputChunks<T>(first: T, second: T): T;\n    protected _diff(prev: unknown | undefined, next: unknown): Operation[] | undefined;\n    parsePartialResult(generations: ChatGeneration[] | Generation[]): Promise<T | undefined>;\n    parse(text: string): Promise<T>;\n    getFormatInstructions(): string;\n}\nexport { parsePartialJson, parseJsonMarkdown };\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAAgDQ,cAA3BF,gBAA2BE,CAAAA,UAAAA,MAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAAsBA,MAAtBA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,SAAmDR,mCAAnDQ,CAAuFD,CAAvFC,CAAAA,CAAAA;EAAsBA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAiED,YAAAA,EAAAA,MAAAA,EAAAA;EAKrGA,eAAAA,EAAAA,OAAAA;EAAWA;EAAIA,mBAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAfA,CAAeA,EAAAA,MAAAA,EAAJA,CAAIA,CAAAA,EAAAA,CAAAA;EACcN,UAAAA,KAAAA,CAAAA,IAAAA,EAAAA,OAAAA,GAAAA,SAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,SAAAA,EAAAA,GAAAA,SAAAA;EAC3BC,kBAAAA,CAAAA,WAAAA,EAAAA,cAAAA,EAAAA,GAAmBC,UAAnBD,EAAAA,CAAAA,EAAkCO,OAAlCP,CAA0CK,CAA1CL,GAAAA,SAAAA,CAAAA;EAAmBC,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EAC9BM,OAD8BN,CACtBI,CADsBJ,CAAAA;EAAuBI,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA"}
+{"version":3,"file":"json.d.ts","names":[],"sources":["../../src/output_parsers/json.ts"],"mappings":";;;;;;;;;;cASa,gBAAA,WAED,MAAA,gBAAsB,MAAA,uBACxB,mCAAA,CAAoC,CAAA;EAAA,OACrC,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EARgC;EAWvB,mBAAA,GAAA,CAAuB,KAAA,EAAO,CAAA,EAAG,MAAA,EAAQ,CAAA,GAAI,CAAA;EAAA,UAO5C,KAAA,CACR,IAAA,uBACA,IAAA,YACC,SAAA;EAYG,kBAAA,CACJ,WAAA,EAAa,cAAA,KAAmB,UAAA,KAC/B,OAAA,CAAQ,CAAA;EAIL,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,CAAA;EAInC,qBAAA,CAAA;EATe;;;;;;;EAAA,UAoBL,oBAAA,CAAqB,OAAA,EAAS,WAAA;AAAA"}