@langchain/classic 1.0.34 → 1.0.36

package/dist/output_parsers/expression_type_handlers/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["GRAMMAR"],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CAChC,YAAY,eAAuC;AAA7B,OAAA,gBAAA;;;;;;;;AAwBxB,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAASA,uBAAAA,QAAQ;AAEtC,cAAU,mBAAmB;;AAE/B,UAAO,UAAU;UACX;AACN,SAAM,IAAI,MACR,mGACD;;;;;;;;CASL,OAAO,UAAU,MAAuC;AACtD,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,sBACL,MAC6B;AAC7B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,gBAAgB,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;;;;;;;CAQhE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,aAAa,MAA0C;AAC5D,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,kBAAkB,MAA+C;AACtE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,qBACL,MAC4B;AAC5B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS"}
+{"version":3,"file":"base.cjs","names":["GRAMMAR"],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CAChC,YAAY,eAAuC;AAA7B,OAAA,gBAAA;;;;;;;;AAwBxB,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAASA,uBAAAA,QACN;AACxB,cAAU,mBAAmB;;AAE/B,UAAO,UAAU;UACX;AACN,SAAM,IAAI,MACR,mGACD;;;;;;;;CASL,OAAO,UAAU,MAAuC;AACtD,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,sBACL,MAC6B;AAC7B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,gBAAgB,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;;;;;;;CAQhE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,aAAa,MAA0C;AAC5D,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,kBAAkB,MAA+C;AACtE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,qBACL,MAC4B;AAC5B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS"}

package/dist/output_parsers/expression_type_handlers/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CAChC,YAAY,eAAuC;AAA7B,OAAA,gBAAA;;;;;;;;AAwBxB,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAAS,QAAQ;AAEtC,cAAU,mBAAmB;;AAE/B,UAAO,UAAU;UACX;AACN,SAAM,IAAI,MACR,mGACD;;;;;;;;CASL,OAAO,UAAU,MAAuC;AACtD,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,sBACL,MAC6B;AAC7B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,gBAAgB,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;;;;;;;CAQhE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,aAAa,MAA0C;AAC5D,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,kBAAkB,MAA+C;AACtE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,qBACL,MAC4B;AAC5B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS"}
+{"version":3,"file":"base.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/base.ts"],"sourcesContent":["import { GRAMMAR } from \"./grammar/parser_grammar.js\";\nimport type {\n  ExpressionNode,\n  Program,\n  ExpressionStatement,\n  CallExpression,\n  StringLiteral,\n  NumericLiteral,\n  BooleanLiteral,\n  Identifier,\n  ObjectExpression,\n  ArrayExpression,\n  PropertyAssignment,\n  MemberExpression,\n  ParseFunction,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Abstract class for handling nodes in an expression language. Subclasses\n * must implement the `accepts` and `handle` methods.\n */\nexport abstract class NodeHandler {\n  constructor(protected parentHandler?: NodeHandler) {}\n\n  /**\n   * Determines whether the given node is acceptable.\n   * @param node The node to be checked.\n   * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.\n   */\n  abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;\n\n  /**\n   * Handles the given node. The specifics of how the node is handled are\n   * determined by the subclass implementation.\n   * @param node The node to be handled.\n   * @returns A Promise that resolves to the result of handling the node.\n   */\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  abstract handle(node: ExpressionNode): Promise<any>;\n}\n\n/**\n * Utility class for parsing Abstract Syntax Trees (ASTs). Contains\n * methods for identifying the type of a given node and a method for\n * importing and generating a parser using the Peggy library.\n */\nexport class ASTParser {\n  static astParseInstance: ParseFunction;\n\n  /**\n   * Imports and generates a parser using the Peggy library.\n   * @returns A Promise that resolves to the parser instance.\n   */\n  static async importASTParser() {\n    try {\n      if (!ASTParser.astParseInstance) {\n        const { default: peggy } = await import(\"peggy\");\n        const parser = peggy.generate(GRAMMAR);\n        const { parse } = parser;\n        ASTParser.astParseInstance = parse as ParseFunction;\n      }\n      return ASTParser.astParseInstance;\n    } catch {\n      throw new Error(\n        `Failed to import peggy. Please install peggy (i.e. \"npm install peggy\" or \"pnpm install peggy\").`\n      );\n    }\n  }\n\n  /**\n   * Checks if the given node is a Program node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a Program node.\n   */\n  static isProgram(node: ExpressionNode): node is Program {\n    return node.type === \"Program\";\n  }\n\n  /**\n   * Checks if the given node is an ExpressionStatement node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ExpressionStatement node.\n   */\n  static isExpressionStatement(\n    node: ExpressionNode\n  ): node is ExpressionStatement {\n    return node.type === \"ExpressionStatement\";\n  }\n\n  /**\n   * Checks if the given node is a CallExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a CallExpression node.\n   */\n  static isCallExpression(node: ExpressionNode): node is CallExpression {\n    return node.type === \"CallExpression\";\n  }\n\n  /**\n   * Checks if the given node is a StringLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a StringLiteral node.\n   */\n  static isStringLiteral(node: ExpressionNode): node is StringLiteral {\n    return node.type === \"StringLiteral\" && typeof node.value === \"string\";\n  }\n\n  /**\n   * Checks if the given node is a NumericLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a NumericLiteral node.\n   */\n  static isNumericLiteral(node: ExpressionNode): node is NumericLiteral {\n    return node.type === \"NumericLiteral\" && typeof node.value === \"number\";\n  }\n\n  /**\n   * Checks if the given node is a BooleanLiteral node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a BooleanLiteral node.\n   */\n  static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral {\n    return node.type === \"BooleanLiteral\" && typeof node.value === \"boolean\";\n  }\n\n  /**\n   * Checks if the given node is an Identifier node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an Identifier node.\n   */\n  static isIdentifier(node: ExpressionNode): node is Identifier {\n    return node.type === \"Identifier\";\n  }\n\n  /**\n   * Checks if the given node is an ObjectExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ObjectExpression node.\n   */\n  static isObjectExpression(node: ExpressionNode): node is ObjectExpression {\n    return node.type === \"ObjectExpression\";\n  }\n\n  /**\n   * Checks if the given node is an ArrayExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is an ArrayExpression node.\n   */\n  static isArrayExpression(node: ExpressionNode): node is ArrayExpression {\n    return node.type === \"ArrayExpression\";\n  }\n\n  /**\n   * Checks if the given node is a PropertyAssignment node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a PropertyAssignment node.\n   */\n  static isPropertyAssignment(\n    node: ExpressionNode\n  ): node is PropertyAssignment {\n    return node.type === \"PropertyAssignment\";\n  }\n\n  /**\n   * Checks if the given node is a MemberExpression node.\n   * @param node The node to be checked.\n   * @returns A boolean indicating whether the node is a MemberExpression node.\n   */\n  static isMemberExpression(node: ExpressionNode): node is MemberExpression {\n    return node.type === \"MemberExpression\";\n  }\n}\n"],"mappings":";;;;;;AAqBA,IAAsB,cAAtB,MAAkC;CAChC,YAAY,eAAuC;AAA7B,OAAA,gBAAA;;;;;;;;AAwBxB,IAAa,YAAb,MAAa,UAAU;CACrB,OAAO;;;;;CAMP,aAAa,kBAAkB;AAC7B,MAAI;AACF,OAAI,CAAC,UAAU,kBAAkB;IAC/B,MAAM,EAAE,SAAS,UAAU,MAAM,OAAO;IAExC,MAAM,EAAE,UADO,MAAM,SAAS,QACN;AACxB,cAAU,mBAAmB;;AAE/B,UAAO,UAAU;UACX;AACN,SAAM,IAAI,MACR,mGACD;;;;;;;;CASL,OAAO,UAAU,MAAuC;AACtD,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,sBACL,MAC6B;AAC7B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,gBAAgB,MAA6C;AAClE,SAAO,KAAK,SAAS,mBAAmB,OAAO,KAAK,UAAU;;;;;;;CAQhE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,iBAAiB,MAA8C;AACpE,SAAO,KAAK,SAAS,oBAAoB,OAAO,KAAK,UAAU;;;;;;;CAQjE,OAAO,aAAa,MAA0C;AAC5D,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,kBAAkB,MAA+C;AACtE,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,qBACL,MAC4B;AAC5B,SAAO,KAAK,SAAS;;;;;;;CAQvB,OAAO,mBAAmB,MAAgD;AACxE,SAAO,KAAK,SAAS"}

package/dist/output_parsers/expression_type_handlers/factory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"factory.cjs","names":["ArrayLiteralExpressionHandler","BooleanLiteralHandler","CallExpressionHandler","NumericLiteralHandler","ObjectLiteralExpressionHandler","MemberExpressionHandler","PropertyAssignmentHandler","StringLiteralHandler","IdentifierHandler","NodeHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ArrayLiteralExpressionHandler } from \"./array_literal_expression_handler.js\";\nimport { BooleanLiteralHandler } from \"./boolean_literal_handler.js\";\nimport { CallExpressionHandler } from \"./call_expression_handler.js\";\nimport { NumericLiteralHandler } from \"./numeric_literal_handler.js\";\nimport { ObjectLiteralExpressionHandler } from \"./object_literal_expression_handler.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { StringLiteralHandler } from \"./string_literal_handler.js\";\nimport { IdentifierHandler } from \"./identifier_handler.js\";\nimport { MemberExpressionHandler } from \"./member_expression_handler.js\";\nimport { ParsedType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n} from \"../../types/expression-parser.js\";\n\nconst handlers = [\n  ArrayLiteralExpressionHandler,\n  BooleanLiteralHandler,\n  CallExpressionHandler,\n  NumericLiteralHandler,\n  ObjectLiteralExpressionHandler,\n  MemberExpressionHandler,\n  PropertyAssignmentHandler,\n  StringLiteralHandler,\n  IdentifierHandler,\n];\n\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport class MasterHandler extends NodeHandler {\n  nodeHandlers: NodeHandler[] = [];\n\n  async accepts(node: ExpressionNode): Promise<ExpressionNode | boolean> {\n    throw new Error(`Master handler does not accept any nodes: ${node}`);\n  }\n\n  /**\n   * This method is responsible for handling a node. It iterates over the\n   * collection of node handlers and uses the first handler that accepts the\n   * node to handle it. If no handler accepts the node, the method throws an\n   * error.\n   * @param node The node to be handled.\n   * @returns The result of the node handling, or throws an error if no handler can handle the node.\n   */\n  async handle(node: CallExpression): Promise<ParsedType> {\n    for (const handler of this.nodeHandlers) {\n      const accepts = await handler.accepts(node);\n      if (accepts) {\n        return handler.handle(node);\n      }\n    }\n\n    throw new Error(`No handler found for node: ${node}`);\n  }\n\n  /**\n   * This static method creates an instance of the MasterHandler class and\n   * initializes it with instances of all the node handlers.\n   * @returns An instance of the MasterHandler class.\n   */\n  static createMasterHandler(): MasterHandler {\n    const masterHandler = new MasterHandler();\n    handlers.forEach((Handler) => {\n      const handlerInstance = new Handler(masterHandler);\n      masterHandler.nodeHandlers.push(handlerInstance);\n    });\n    return masterHandler;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAgBA,MAAM,WAAW;CACfA,yCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,0CAAAA;CACAC,kCAAAA;CACAC,oCAAAA;CACAC,+BAAAA;CACAC,2BAAAA;CACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsBC,aAAAA,YAAY;CAC7C,eAA8B,EAAE;CAEhC,MAAM,QAAQ,MAAyD;AACrE,QAAM,IAAI,MAAM,6CAA6C,OAAO;;;;;;;;;;CAWtE,MAAM,OAAO,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,aAEzB,KADgB,MAAM,QAAQ,QAAQ,KAAK,CAEzC,QAAO,QAAQ,OAAO,KAAK;AAI/B,QAAM,IAAI,MAAM,8BAA8B,OAAO;;;;;;;CAQvD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,eAAe;AACzC,WAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,cAAc;AAClD,iBAAc,aAAa,KAAK,gBAAgB;IAChD;AACF,SAAO"}
+{"version":3,"file":"factory.cjs","names":["ArrayLiteralExpressionHandler","BooleanLiteralHandler","CallExpressionHandler","NumericLiteralHandler","ObjectLiteralExpressionHandler","MemberExpressionHandler","PropertyAssignmentHandler","StringLiteralHandler","IdentifierHandler","NodeHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ArrayLiteralExpressionHandler } from \"./array_literal_expression_handler.js\";\nimport { BooleanLiteralHandler } from \"./boolean_literal_handler.js\";\nimport { CallExpressionHandler } from \"./call_expression_handler.js\";\nimport { NumericLiteralHandler } from \"./numeric_literal_handler.js\";\nimport { ObjectLiteralExpressionHandler } from \"./object_literal_expression_handler.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { StringLiteralHandler } from \"./string_literal_handler.js\";\nimport { IdentifierHandler } from \"./identifier_handler.js\";\nimport { MemberExpressionHandler } from \"./member_expression_handler.js\";\nimport { ParsedType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n} from \"../../types/expression-parser.js\";\n\nconst handlers = [\n  ArrayLiteralExpressionHandler,\n  BooleanLiteralHandler,\n  CallExpressionHandler,\n  NumericLiteralHandler,\n  ObjectLiteralExpressionHandler,\n  MemberExpressionHandler,\n  PropertyAssignmentHandler,\n  StringLiteralHandler,\n  IdentifierHandler,\n];\n\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport class MasterHandler extends NodeHandler {\n  nodeHandlers: NodeHandler[] = [];\n\n  async accepts(node: ExpressionNode): Promise<ExpressionNode | boolean> {\n    throw new Error(`Master handler does not accept any nodes: ${node}`);\n  }\n\n  /**\n   * This method is responsible for handling a node. It iterates over the\n   * collection of node handlers and uses the first handler that accepts the\n   * node to handle it. If no handler accepts the node, the method throws an\n   * error.\n   * @param node The node to be handled.\n   * @returns The result of the node handling, or throws an error if no handler can handle the node.\n   */\n  async handle(node: CallExpression): Promise<ParsedType> {\n    for (const handler of this.nodeHandlers) {\n      const accepts = await handler.accepts(node);\n      if (accepts) {\n        return handler.handle(node);\n      }\n    }\n\n    throw new Error(`No handler found for node: ${node}`);\n  }\n\n  /**\n   * This static method creates an instance of the MasterHandler class and\n   * initializes it with instances of all the node handlers.\n   * @returns An instance of the MasterHandler class.\n   */\n  static createMasterHandler(): MasterHandler {\n    const masterHandler = new MasterHandler();\n    handlers.forEach((Handler) => {\n      const handlerInstance = new Handler(masterHandler);\n      masterHandler.nodeHandlers.push(handlerInstance);\n    });\n    return masterHandler;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAgBA,MAAM,WAAW;CACfA,yCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,gCAAAA;CACAC,0CAAAA;CACAC,kCAAAA;CACAC,oCAAAA;CACAC,+BAAAA;CACAC,2BAAAA;CACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsBC,aAAAA,YAAY;CAC7C,eAA8B,EAAE;CAEhC,MAAM,QAAQ,MAAyD;AACrE,QAAM,IAAI,MAAM,6CAA6C,OAAO;;;;;;;;;;CAWtE,MAAM,OAAO,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,aAEzB,KAAI,MADkB,QAAQ,QAAQ,KAAK,CAEzC,QAAO,QAAQ,OAAO,KAAK;AAI/B,QAAM,IAAI,MAAM,8BAA8B,OAAO;;;;;;;CAQvD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,eAAe;AACzC,WAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,cAAc;AAClD,iBAAc,aAAa,KAAK,gBAAgB;IAChD;AACF,SAAO"}

package/dist/output_parsers/expression_type_handlers/factory.js.map

@@ -1 +1 @@
-{"version":3,"file":"factory.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ArrayLiteralExpressionHandler } from \"./array_literal_expression_handler.js\";\nimport { BooleanLiteralHandler } from \"./boolean_literal_handler.js\";\nimport { CallExpressionHandler } from \"./call_expression_handler.js\";\nimport { NumericLiteralHandler } from \"./numeric_literal_handler.js\";\nimport { ObjectLiteralExpressionHandler } from \"./object_literal_expression_handler.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { StringLiteralHandler } from \"./string_literal_handler.js\";\nimport { IdentifierHandler } from \"./identifier_handler.js\";\nimport { MemberExpressionHandler } from \"./member_expression_handler.js\";\nimport { ParsedType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n} from \"../../types/expression-parser.js\";\n\nconst handlers = [\n  ArrayLiteralExpressionHandler,\n  BooleanLiteralHandler,\n  CallExpressionHandler,\n  NumericLiteralHandler,\n  ObjectLiteralExpressionHandler,\n  MemberExpressionHandler,\n  PropertyAssignmentHandler,\n  StringLiteralHandler,\n  IdentifierHandler,\n];\n\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport class MasterHandler extends NodeHandler {\n  nodeHandlers: NodeHandler[] = [];\n\n  async accepts(node: ExpressionNode): Promise<ExpressionNode | boolean> {\n    throw new Error(`Master handler does not accept any nodes: ${node}`);\n  }\n\n  /**\n   * This method is responsible for handling a node. It iterates over the\n   * collection of node handlers and uses the first handler that accepts the\n   * node to handle it. If no handler accepts the node, the method throws an\n   * error.\n   * @param node The node to be handled.\n   * @returns The result of the node handling, or throws an error if no handler can handle the node.\n   */\n  async handle(node: CallExpression): Promise<ParsedType> {\n    for (const handler of this.nodeHandlers) {\n      const accepts = await handler.accepts(node);\n      if (accepts) {\n        return handler.handle(node);\n      }\n    }\n\n    throw new Error(`No handler found for node: ${node}`);\n  }\n\n  /**\n   * This static method creates an instance of the MasterHandler class and\n   * initializes it with instances of all the node handlers.\n   * @returns An instance of the MasterHandler class.\n   */\n  static createMasterHandler(): MasterHandler {\n    const masterHandler = new MasterHandler();\n    handlers.forEach((Handler) => {\n      const handlerInstance = new Handler(masterHandler);\n      masterHandler.nodeHandlers.push(handlerInstance);\n    });\n    return masterHandler;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAgBA,MAAM,WAAW;CACf;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsB,YAAY;CAC7C,eAA8B,EAAE;CAEhC,MAAM,QAAQ,MAAyD;AACrE,QAAM,IAAI,MAAM,6CAA6C,OAAO;;;;;;;;;;CAWtE,MAAM,OAAO,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,aAEzB,KADgB,MAAM,QAAQ,QAAQ,KAAK,CAEzC,QAAO,QAAQ,OAAO,KAAK;AAI/B,QAAM,IAAI,MAAM,8BAA8B,OAAO;;;;;;;CAQvD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,eAAe;AACzC,WAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,cAAc;AAClD,iBAAc,aAAa,KAAK,gBAAgB;IAChD;AACF,SAAO"}
+{"version":3,"file":"factory.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/factory.ts"],"sourcesContent":["import { NodeHandler } from \"./base.js\";\nimport { ArrayLiteralExpressionHandler } from \"./array_literal_expression_handler.js\";\nimport { BooleanLiteralHandler } from \"./boolean_literal_handler.js\";\nimport { CallExpressionHandler } from \"./call_expression_handler.js\";\nimport { NumericLiteralHandler } from \"./numeric_literal_handler.js\";\nimport { ObjectLiteralExpressionHandler } from \"./object_literal_expression_handler.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { StringLiteralHandler } from \"./string_literal_handler.js\";\nimport { IdentifierHandler } from \"./identifier_handler.js\";\nimport { MemberExpressionHandler } from \"./member_expression_handler.js\";\nimport { ParsedType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  CallExpression,\n} from \"../../types/expression-parser.js\";\n\nconst handlers = [\n  ArrayLiteralExpressionHandler,\n  BooleanLiteralHandler,\n  CallExpressionHandler,\n  NumericLiteralHandler,\n  ObjectLiteralExpressionHandler,\n  MemberExpressionHandler,\n  PropertyAssignmentHandler,\n  StringLiteralHandler,\n  IdentifierHandler,\n];\n\n/**\n * The MasterHandler class is responsible for managing a collection of\n * node handlers in the LangChain Expression Language. Each node handler\n * is capable of handling a specific type of node in the expression\n * language. The MasterHandler class uses these node handlers to process\n * nodes in the expression language.\n */\nexport class MasterHandler extends NodeHandler {\n  nodeHandlers: NodeHandler[] = [];\n\n  async accepts(node: ExpressionNode): Promise<ExpressionNode | boolean> {\n    throw new Error(`Master handler does not accept any nodes: ${node}`);\n  }\n\n  /**\n   * This method is responsible for handling a node. It iterates over the\n   * collection of node handlers and uses the first handler that accepts the\n   * node to handle it. If no handler accepts the node, the method throws an\n   * error.\n   * @param node The node to be handled.\n   * @returns The result of the node handling, or throws an error if no handler can handle the node.\n   */\n  async handle(node: CallExpression): Promise<ParsedType> {\n    for (const handler of this.nodeHandlers) {\n      const accepts = await handler.accepts(node);\n      if (accepts) {\n        return handler.handle(node);\n      }\n    }\n\n    throw new Error(`No handler found for node: ${node}`);\n  }\n\n  /**\n   * This static method creates an instance of the MasterHandler class and\n   * initializes it with instances of all the node handlers.\n   * @returns An instance of the MasterHandler class.\n   */\n  static createMasterHandler(): MasterHandler {\n    const masterHandler = new MasterHandler();\n    handlers.forEach((Handler) => {\n      const handlerInstance = new Handler(masterHandler);\n      masterHandler.nodeHandlers.push(handlerInstance);\n    });\n    return masterHandler;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAgBA,MAAM,WAAW;CACf;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;;;;AASD,IAAa,gBAAb,MAAa,sBAAsB,YAAY;CAC7C,eAA8B,EAAE;CAEhC,MAAM,QAAQ,MAAyD;AACrE,QAAM,IAAI,MAAM,6CAA6C,OAAO;;;;;;;;;;CAWtE,MAAM,OAAO,MAA2C;AACtD,OAAK,MAAM,WAAW,KAAK,aAEzB,KAAI,MADkB,QAAQ,QAAQ,KAAK,CAEzC,QAAO,QAAQ,OAAO,KAAK;AAI/B,QAAM,IAAI,MAAM,8BAA8B,OAAO;;;;;;;CAQvD,OAAO,sBAAqC;EAC1C,MAAM,gBAAgB,IAAI,eAAe;AACzC,WAAS,SAAS,YAAY;GAC5B,MAAM,kBAAkB,IAAI,QAAQ,cAAc;AAClD,iBAAc,aAAa,KAAK,gBAAgB;IAChD;AACF,SAAO"}

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuCA,aAAAA,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAIC,aAAAA,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAAK;GACrB"}
+{"version":3,"file":"identifier_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuCA,aAAAA,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAIC,aAAAA,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAClB;GAAE"}

package/dist/output_parsers/expression_type_handlers/identifier_handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuC,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAI,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAAK;GACrB"}
+{"version":3,"file":"identifier_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/identifier_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { IdentifierType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  Identifier,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles identifiers in the LangChain Expression Language. Extends the\n * NodeHandler class.\n */\nexport class IdentifierHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an identifier. If it is, it returns the node;\n   * otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is an identifier, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<Identifier | boolean> {\n    if (ASTParser.isIdentifier(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the identifier node. If the handler does not have a parent\n   * handler, it throws an error. Otherwise, it extracts the name of the\n   * identifier, removes any enclosing quotes, and returns an object of type\n   * IdentifierType with the type set to \"identifier\" and the value set to\n   * the extracted name.\n   * @param node The identifier node to process.\n   * @returns An object of type IdentifierType with the type set to \"identifier\" and the value set to the extracted name.\n   */\n  async handle(node: Identifier): Promise<IdentifierType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = node.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    return { type: \"identifier\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,oBAAb,cAAuC,YAAY;;;;;;;CAOjD,MAAM,QAAQ,MAAqD;AACjE,MAAI,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;;;;;;;;;;;CAaX,MAAM,OAAO,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAGH,SAAO;GAAE,MAAM;GAAc,OADhB,KAAK,KAAK,QAAQ,2BAA2B,KAClB;GAAE"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+CA,aAAAA,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAIC,aAAAA,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACPA,aAAAA,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KACD;GAEiD,OADpC,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}
+{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+CA,aAAAA,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAIC,aAAAA,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAIA,aAAAA,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACPA,aAAAA,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KAG8C;GAAE,OAAA,MAD9B,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+C,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KACD;GAEiD,OADpC,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}
+{"version":3,"file":"property_assignment_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/property_assignment_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  PropertyAssignment,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for `PropertyAssignment` nodes in an AST. Extends the\n * `NodeHandler` base class.\n */\nexport class PropertyAssignmentHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a `PropertyAssignment` and returns the node\n   * if true, or false otherwise.\n   * @param node The node to check.\n   * @returns The node if it is a `PropertyAssignment`, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean> {\n    if (ASTParser.isPropertyAssignment(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a `PropertyAssignment` node. Extracts the key and value of\n   * the property assignment and returns an object of type\n   * `PropertyAssignmentType` with the extracted identifier and value.\n   * @param node The `PropertyAssignment` node to process.\n   * @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.\n   */\n  async handle(node: PropertyAssignment): Promise<PropertyAssignmentType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    let name;\n    if (ASTParser.isIdentifier(node.key)) {\n      name = node.key.name;\n    } else if (ASTParser.isStringLiteral(node.key)) {\n      name = node.key.value;\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    if (!name) {\n      throw new Error(\"Invalid property key\");\n    }\n    const identifier = (`${name}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    const value = await this.parentHandler.handle(node.value);\n    return { type: \"property_assignment\", identifier, value };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,4BAAb,cAA+C,YAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,CAC5C,QAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM,4BAA4B;AAE9C,MAAI,CAAC,KACH,OAAM,IAAI,MAAM,uBAAuB;AAOzC,SAAO;GAAE,MAAM;GAAuB,YALlB,GAAG,OAAkB,QACvC,2BACA,KAG8C;GAAE,OAAA,MAD9B,KAAK,cAAc,OAAO,KAAK,MAAM;GACA"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0CA,aAAAA,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAIC,aAAAA,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KACD;GAC6C"}
+{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0CA,aAAAA,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAIC,aAAAA,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KAE0C;GAAE"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js.map

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0C,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KACD;GAC6C"}
+{"version":3,"file":"string_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/string_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { StringLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  StringLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for string literal nodes in the LangChain Expression Language.\n * Extends the NodeHandler base class.\n */\nexport class StringLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a string literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The ExpressionNode to check.\n   * @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<StringLiteral | boolean> {\n    if (ASTParser.isStringLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a string literal node to extract its value. Throws an error\n   * if the handler does not have a parent handler.\n   * @param node The StringLiteral node to process.\n   * @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.\n   */\n  async handle(node: StringLiteral): Promise<StringLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const text = (`${node.value}` as string).replace(\n      /^[\"'](.+(?=[\"']$))[\"']$/,\n      \"$1\"\n    );\n    return { type: \"string_literal\", value: text };\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,uBAAb,cAA0C,YAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAMH,SAAO;GAAE,MAAM;GAAkB,OAJnB,GAAG,KAAK,QAAmB,QACvC,2BACA,KAE0C;GAAE"}

package/dist/output_parsers/fix.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fix.cjs","names":["BaseOutputParser","LLMChain","NAIVE_FIX_PROMPT","OutputParserException"],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // oxlint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8BA,+BAAAA,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAD7B,IAAIC,kBAAAA,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAUC,gBAAAA;IACS,CAAC;GACmB,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAaC,+BAAAA,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBADS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAHe,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}
+{"version":3,"file":"fix.cjs","names":["BaseOutputParser","LLMChain","NAIVE_FIX_PROMPT","OutputParserException"],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // oxlint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8BA,+BAAAA,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAAY,IADrCC,kBAAAA,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAUC,gBAAAA;IACS,CACkB;GAAE,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAaC,+BAAAA,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBAAwB,MADT,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAAO,MAHc,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}

package/dist/output_parsers/fix.js.map

@@ -1 +1 @@
-{"version":3,"file":"fix.js","names":[],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // oxlint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8B,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAD7B,IAAI,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAU;IACS,CAAC;GACmB,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAa,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBADS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAHe,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}
+{"version":3,"file":"fix.js","names":[],"sources":["../../src/output_parsers/fix.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport {\n  BaseOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport { NAIVE_FIX_PROMPT } from \"./prompts.js\";\n\ninterface OutputFixingParserRetryInput {\n  instructions: string;\n  completion: string;\n  error: OutputParserException;\n}\n\nfunction isLLMChain<T>(\n  x: LLMChain | Runnable<OutputFixingParserRetryInput, T>\n): x is LLMChain {\n  return (\n    (x as LLMChain).prompt !== undefined && (x as LLMChain).llm !== undefined\n  );\n}\n\n/**\n * Class that extends the BaseOutputParser to handle situations where the\n * initial parsing attempt fails. It contains a retryChain for retrying\n * the parsing process in case of a failure.\n */\nexport class OutputFixingParser<T> extends BaseOutputParser<T> {\n  static lc_name() {\n    return \"OutputFixingParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"fix\"];\n\n  lc_serializable = true;\n\n  parser: BaseOutputParser<T>;\n\n  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n\n  /**\n   * Static method to create a new instance of OutputFixingParser using a\n   * given language model, parser, and optional fields.\n   * @param llm The language model to be used.\n   * @param parser The parser to be used.\n   * @param fields Optional fields which may contain a prompt.\n   * @returns A new instance of OutputFixingParser.\n   */\n  static fromLLM<T>(\n    llm: BaseLanguageModelInterface,\n    parser: BaseOutputParser<T>,\n    fields?: {\n      prompt?: BasePromptTemplate;\n    }\n  ) {\n    const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;\n    const chain = new LLMChain({ llm, prompt });\n    return new OutputFixingParser<T>({ parser, retryChain: chain });\n  }\n\n  constructor({\n    parser,\n    retryChain,\n  }: {\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\n  }) {\n    super(...arguments);\n    this.parser = parser;\n    this.retryChain = retryChain;\n  }\n\n  /**\n   * Method to parse the completion using the parser. If the initial parsing\n   * fails, it uses the retryChain to attempt to fix the output and retry\n   * the parsing process.\n   * @param completion The completion to be parsed.\n   * @param callbacks Optional callbacks to be used during parsing.\n   * @returns The parsed output.\n   */\n  async parse(completion: string, callbacks?: Callbacks) {\n    try {\n      return await this.parser.parse(completion, callbacks);\n    } catch (e) {\n      // oxlint-disable-next-line no-instanceof/no-instanceof\n      if (e instanceof OutputParserException) {\n        const retryInput = {\n          instructions: this.parser.getFormatInstructions(),\n          completion,\n          error: e,\n        };\n\n        if (isLLMChain(this.retryChain)) {\n          const result = await this.retryChain.call(retryInput, callbacks);\n          const newCompletion: string = result[this.retryChain.outputKey];\n          return this.parser.parse(newCompletion, callbacks);\n        } else {\n          const result = await this.retryChain.invoke(retryInput, {\n            callbacks,\n          });\n          return result;\n        }\n      }\n      throw e;\n    }\n  }\n\n  /**\n   * Method to get the format instructions for the parser.\n   * @returns The format instructions for the parser.\n   */\n  getFormatInstructions() {\n    return this.parser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;AAiBA,SAAS,WACP,GACe;AACf,QACG,EAAe,WAAW,KAAA,KAAc,EAAe,QAAQ,KAAA;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8B,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACL,KACA,QACA,QAGA;AAGA,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAAY,IADrC,SAAS;IAAE;IAAK,QADnB,QAAQ,UAAU;IACS,CACkB;GAAE,CAAC;;CAGjE,YAAY,EACV,QACA,cAIC;AACD,QAAM,GAAG,UAAU;AACnB,OAAK,SAAS;AACd,OAAK,aAAa;;;;;;;;;;CAWpB,MAAM,MAAM,YAAoB,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;WAC9C,GAAG;AAEV,OAAI,aAAa,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;KACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAE/B,MAAM,iBAAwB,MADT,KAAK,WAAW,KAAK,YAAY,UAAU,EAC3B,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;UAKlD,QAAO,MAHc,KAAK,WAAW,OAAO,YAAY,EACtD,WACD,CAAC;;AAIN,SAAM;;;;;;;CAQV,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB"}

package/dist/output_parsers/http_response.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"http_response.cjs","names":["BaseTransformOutputParser","StringOutputParser"],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;AAcA,IAAa,2BAAb,cAA8CA,+BAAAA,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAIC,+BAAAA,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OADgB,IAAI,aAAa,CACnB,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}
+{"version":3,"file":"http_response.cjs","names":["BaseTransformOutputParser","StringOutputParser"],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;;AAcA,IAAa,2BAAb,cAA8CA,+BAAAA,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAIC,+BAAAA,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OAAM,IADc,aACP,CAAC,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}

package/dist/output_parsers/http_response.js.map

@@ -1 +1 @@
-{"version":3,"file":"http_response.js","names":[],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;AAcA,IAAa,2BAAb,cAA8C,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAI,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OADgB,IAAI,aAAa,CACnB,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}
+{"version":3,"file":"http_response.js","names":[],"sources":["../../src/output_parsers/http_response.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  BaseTransformOutputParser,\n  StringOutputParser,\n} from \"@langchain/core/output_parsers\";\n\nexport type HttpResponseOutputParserInput = {\n  outputParser?: BaseTransformOutputParser;\n  contentType?: \"text/plain\" | \"text/event-stream\";\n};\n\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n  static lc_name() {\n    return \"HttpResponseOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parser\"];\n\n  lc_serializable = true;\n\n  outputParser: BaseTransformOutputParser = new StringOutputParser();\n\n  contentType: \"text/plain\" | \"text/event-stream\" = \"text/plain\";\n\n  constructor(fields?: HttpResponseOutputParserInput) {\n    super(fields);\n    this.outputParser = fields?.outputParser ?? this.outputParser;\n    this.contentType = fields?.contentType ?? this.contentType;\n  }\n\n  async *_transform(\n    inputGenerator: AsyncGenerator<string | BaseMessage>\n  ): AsyncGenerator<Uint8Array> {\n    for await (const chunk of this.outputParser._transform(inputGenerator)) {\n      if (typeof chunk === \"string\") {\n        yield this.parse(chunk);\n      } else {\n        yield this.parse(JSON.stringify(chunk));\n      }\n    }\n    if (this.contentType === \"text/event-stream\") {\n      const encoder = new TextEncoder();\n      yield encoder.encode(`event: end\\n\\n`);\n    }\n  }\n\n  /**\n   * Parses a string output from an LLM call. This method is meant to be\n   * implemented by subclasses to define how a string output from an LLM\n   * should be parsed.\n   * @param text The string output from an LLM call.\n   * @param callbacks Optional callbacks.\n   * @returns A promise of the parsed output.\n   */\n  async parse(text: string): Promise<Uint8Array> {\n    const chunk = await this.outputParser.parse(text);\n    const encoder = new TextEncoder();\n    if (this.contentType === \"text/event-stream\") {\n      return encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`);\n    }\n    let parsedChunk;\n    if (typeof chunk === \"string\") {\n      parsedChunk = chunk;\n    } else {\n      parsedChunk = JSON.stringify(chunk);\n    }\n    return encoder.encode(parsedChunk);\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n"],"mappings":";;;;;AAcA,IAAa,2BAAb,cAA8C,0BAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAI,oBAAoB;CAElE,cAAkD;CAElD,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,eAAe,QAAQ,gBAAgB,KAAK;AACjD,OAAK,cAAc,QAAQ,eAAe,KAAK;;CAGjD,OAAO,WACL,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,SACnB,OAAM,KAAK,MAAM,MAAM;MAEvB,OAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,oBAEvB,OAAM,IADc,aACP,CAAC,OAAO,iBAAiB;;;;;;;;;;CAY1C,MAAM,MAAM,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI,aAAa;AACjC,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,SACnB,eAAc;MAEd,eAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;;CAGpC,wBAAgC;AAC9B,SAAO"}

package/dist/output_parsers/openai_functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.cjs","names":["BaseLLMOutputParser","BaseCumulativeTransformOutputParser","OutputParserException"],"sources":["../../src/output_parsers/openai_functions.ts"],"sourcesContent":["import { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport {\n  compare,\n  type Operation as JSONPatchOperation,\n} from \"@langchain/core/utils/json_patch\";\n\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport {\n  BaseCumulativeTransformOutputParser,\n  type BaseCumulativeTransformOutputParserInput,\n  BaseLLMOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { parsePartialJson } from \"@langchain/core/output_parsers\";\nimport { Optional } from \"../types/type-utils.js\";\n\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<\n  JsonSchema7ObjectType,\n  \"additionalProperties\"\n>;\n\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n  static lc_name() {\n    return \"OutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  argsOnly = true;\n\n  constructor(config?: { argsOnly?: boolean }) {\n    super();\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n  }\n\n  /**\n   * Parses the output and returns a string representation of the function\n   * call or its arguments.\n   * @param generations The output of the LLM to parse.\n   * @returns A string representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<string> {\n    if (\"message\" in generations[0]) {\n      const gen = generations[0] as ChatGeneration;\n      const functionCall = gen.message.additional_kwargs.function_call;\n      if (!functionCall) {\n        throw new Error(\n          `No function_call in message ${JSON.stringify(generations)}`\n        );\n      }\n      if (!functionCall.arguments) {\n        throw new Error(\n          `No arguments in function_call ${JSON.stringify(generations)}`\n        );\n      }\n      if (this.argsOnly) {\n        return functionCall.arguments;\n      }\n      return JSON.stringify(functionCall);\n    } else {\n      throw new Error(\n        `No message in generations ${JSON.stringify(generations)}`\n      );\n    }\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport class JsonOutputFunctionsParser<\n  Output extends object = object,\n> extends BaseCumulativeTransformOutputParser<Output> {\n  static lc_name() {\n    return \"JsonOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser: OutputFunctionsParser;\n\n  argsOnly = true;\n\n  constructor(\n    config?: { argsOnly?: boolean } & BaseCumulativeTransformOutputParserInput\n  ) {\n    super(config);\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n    this.outputParser = new OutputFunctionsParser(config);\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): JSONPatchOperation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    const ops = compare(prev ?? {}, next);\n    return ops;\n  }\n\n  async parsePartialResult(\n    generations: ChatGeneration[]\n  ): Promise<Output | undefined> {\n    const generation = generations[0];\n    if (!generation.message) {\n      return undefined;\n    }\n    const { message } = generation;\n    const functionCall = message.additional_kwargs.function_call;\n    if (!functionCall) {\n      return undefined;\n    }\n    if (this.argsOnly) {\n      return parsePartialJson(functionCall.arguments);\n    }\n\n    return {\n      ...functionCall,\n      arguments: parsePartialJson(functionCall.arguments),\n    } as Output;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<Output> {\n    const result = await this.outputParser.parseResult(generations);\n    if (!result) {\n      throw new Error(\n        `No result from \"OutputFunctionsParser\" ${JSON.stringify(generations)}`\n      );\n    }\n    return this.parse(result);\n  }\n\n  async parse(text: string): Promise<Output> {\n    try {\n      const parsedResult = JSON.parse(text);\n      if (this.argsOnly) {\n        return parsedResult;\n      }\n      parsedResult.arguments = JSON.parse(parsedResult.arguments);\n      return parsedResult;\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport class JsonKeyOutputFunctionsParser<\n  T = object,\n> extends BaseLLMOutputParser<T> {\n  static lc_name() {\n    return \"JsonKeyOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser = new JsonOutputFunctionsParser();\n\n  attrName: string;\n\n  get lc_aliases() {\n    return {\n      attrName: \"key_name\",\n    };\n  }\n\n  constructor(fields: { attrName: string }) {\n    super(fields);\n    this.attrName = fields.attrName;\n  }\n\n  /**\n   * Parses the output and returns a specific attribute of the parsed JSON\n   * object.\n   * @param generations The output of the LLM to parse.\n   * @returns The value of a specific attribute of the parsed JSON object.\n   */\n  async parseResult(generations: Generation[] | ChatGeneration[]): Promise<T> {\n    const result = await this.outputParser.parseResult(generations);\n    return result[this.attrName as keyof typeof result] as T;\n  }\n}\n"],"mappings":";;;;;;;;AA4BA,IAAa,wBAAb,cAA2CA,+BAAAA,oBAA4B;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,WAAW;CAEX,YAAY,QAAiC;AAC3C,SAAO;AACP,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YACJ,aACiB;AACjB,MAAI,aAAa,YAAY,IAAI;GAE/B,MAAM,eADM,YAAY,GACC,QAAQ,kBAAkB;AACnD,OAAI,CAAC,aACH,OAAM,IAAI,MACR,+BAA+B,KAAK,UAAU,YAAY,GAC3D;AAEH,OAAI,CAAC,aAAa,UAChB,OAAM,IAAI,MACR,iCAAiC,KAAK,UAAU,YAAY,GAC7D;AAEH,OAAI,KAAK,SACP,QAAO,aAAa;AAEtB,UAAO,KAAK,UAAU,aAAa;QAEnC,OAAM,IAAI,MACR,6BAA6B,KAAK,UAAU,YAAY,GACzD;;;;;;;AASP,IAAa,4BAAb,cAEUC,+BAAAA,oCAA4C;CACpD,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB;CAEA,WAAW;CAEX,YACE,QACA;AACA,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,eAAe,IAAI,sBAAsB,OAAO;;CAGvD,MACE,MACA,MACkC;AAClC,MAAI,CAAC,KACH;AAGF,UAAA,GAAA,iCAAA,SADoB,QAAQ,EAAE,EAAE,KAAK;;CAIvC,MAAM,mBACJ,aAC6B;EAC7B,MAAM,aAAa,YAAY;AAC/B,MAAI,CAAC,WAAW,QACd;EAEF,MAAM,EAAE,YAAY;EACpB,MAAM,eAAe,QAAQ,kBAAkB;AAC/C,MAAI,CAAC,aACH;AAEF,MAAI,KAAK,SACP,SAAA,GAAA,+BAAA,kBAAwB,aAAa,UAAU;AAGjD,SAAO;GACL,GAAG;GACH,YAAA,GAAA,+BAAA,kBAA4B,aAAa,UAAU;GACpD;;;;;;;;CASH,MAAM,YACJ,aACiB;EACjB,MAAM,SAAS,MAAM,KAAK,aAAa,YAAY,YAAY;AAC/D,MAAI,CAAC,OACH,OAAM,IAAI,MACR,0CAA0C,KAAK,UAAU,YAAY,GACtE;AAEH,SAAO,KAAK,MAAM,OAAO;;CAG3B,MAAM,MAAM,MAA+B;AACzC,MAAI;GACF,MAAM,eAAe,KAAK,MAAM,KAAK;AACrC,OAAI,KAAK,SACP,QAAO;AAET,gBAAa,YAAY,KAAK,MAAM,aAAa,UAAU;AAC3D,UAAO;WACA,GAAG;AACV,SAAM,IAAIC,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,IAC7C;;;CAIL,wBAAgC;AAC9B,SAAO;;;;;;;;AASX,IAAa,+BAAb,cAEUF,+BAAAA,oBAAuB;CAC/B,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,eAAe,IAAI,2BAA2B;CAE9C;CAEA,IAAI,aAAa;AACf,SAAO,EACL,UAAU,YACX;;CAGH,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;;CASzB,MAAM,YAAY,aAA0D;AAE1E,UADe,MAAM,KAAK,aAAa,YAAY,YAAY,EACjD,KAAK"}
+{"version":3,"file":"openai_functions.cjs","names":["BaseLLMOutputParser","BaseCumulativeTransformOutputParser","OutputParserException"],"sources":["../../src/output_parsers/openai_functions.ts"],"sourcesContent":["import { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport {\n  compare,\n  type Operation as JSONPatchOperation,\n} from \"@langchain/core/utils/json_patch\";\n\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport {\n  BaseCumulativeTransformOutputParser,\n  type BaseCumulativeTransformOutputParserInput,\n  BaseLLMOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { parsePartialJson } from \"@langchain/core/output_parsers\";\nimport { Optional } from \"../types/type-utils.js\";\n\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<\n  JsonSchema7ObjectType,\n  \"additionalProperties\"\n>;\n\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n  static lc_name() {\n    return \"OutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  argsOnly = true;\n\n  constructor(config?: { argsOnly?: boolean }) {\n    super();\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n  }\n\n  /**\n   * Parses the output and returns a string representation of the function\n   * call or its arguments.\n   * @param generations The output of the LLM to parse.\n   * @returns A string representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<string> {\n    if (\"message\" in generations[0]) {\n      const gen = generations[0] as ChatGeneration;\n      const functionCall = gen.message.additional_kwargs.function_call;\n      if (!functionCall) {\n        throw new Error(\n          `No function_call in message ${JSON.stringify(generations)}`\n        );\n      }\n      if (!functionCall.arguments) {\n        throw new Error(\n          `No arguments in function_call ${JSON.stringify(generations)}`\n        );\n      }\n      if (this.argsOnly) {\n        return functionCall.arguments;\n      }\n      return JSON.stringify(functionCall);\n    } else {\n      throw new Error(\n        `No message in generations ${JSON.stringify(generations)}`\n      );\n    }\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport class JsonOutputFunctionsParser<\n  Output extends object = object,\n> extends BaseCumulativeTransformOutputParser<Output> {\n  static lc_name() {\n    return \"JsonOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser: OutputFunctionsParser;\n\n  argsOnly = true;\n\n  constructor(\n    config?: { argsOnly?: boolean } & BaseCumulativeTransformOutputParserInput\n  ) {\n    super(config);\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n    this.outputParser = new OutputFunctionsParser(config);\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): JSONPatchOperation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    const ops = compare(prev ?? {}, next);\n    return ops;\n  }\n\n  async parsePartialResult(\n    generations: ChatGeneration[]\n  ): Promise<Output | undefined> {\n    const generation = generations[0];\n    if (!generation.message) {\n      return undefined;\n    }\n    const { message } = generation;\n    const functionCall = message.additional_kwargs.function_call;\n    if (!functionCall) {\n      return undefined;\n    }\n    if (this.argsOnly) {\n      return parsePartialJson(functionCall.arguments);\n    }\n\n    return {\n      ...functionCall,\n      arguments: parsePartialJson(functionCall.arguments),\n    } as Output;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<Output> {\n    const result = await this.outputParser.parseResult(generations);\n    if (!result) {\n      throw new Error(\n        `No result from \"OutputFunctionsParser\" ${JSON.stringify(generations)}`\n      );\n    }\n    return this.parse(result);\n  }\n\n  async parse(text: string): Promise<Output> {\n    try {\n      const parsedResult = JSON.parse(text);\n      if (this.argsOnly) {\n        return parsedResult;\n      }\n      parsedResult.arguments = JSON.parse(parsedResult.arguments);\n      return parsedResult;\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport class JsonKeyOutputFunctionsParser<\n  T = object,\n> extends BaseLLMOutputParser<T> {\n  static lc_name() {\n    return \"JsonKeyOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser = new JsonOutputFunctionsParser();\n\n  attrName: string;\n\n  get lc_aliases() {\n    return {\n      attrName: \"key_name\",\n    };\n  }\n\n  constructor(fields: { attrName: string }) {\n    super(fields);\n    this.attrName = fields.attrName;\n  }\n\n  /**\n   * Parses the output and returns a specific attribute of the parsed JSON\n   * object.\n   * @param generations The output of the LLM to parse.\n   * @returns The value of a specific attribute of the parsed JSON object.\n   */\n  async parseResult(generations: Generation[] | ChatGeneration[]): Promise<T> {\n    const result = await this.outputParser.parseResult(generations);\n    return result[this.attrName as keyof typeof result] as T;\n  }\n}\n"],"mappings":";;;;;;;;AA4BA,IAAa,wBAAb,cAA2CA,+BAAAA,oBAA4B;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,WAAW;CAEX,YAAY,QAAiC;AAC3C,SAAO;AACP,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YACJ,aACiB;AACjB,MAAI,aAAa,YAAY,IAAI;GAE/B,MAAM,eADM,YAAY,GACC,QAAQ,kBAAkB;AACnD,OAAI,CAAC,aACH,OAAM,IAAI,MACR,+BAA+B,KAAK,UAAU,YAAY,GAC3D;AAEH,OAAI,CAAC,aAAa,UAChB,OAAM,IAAI,MACR,iCAAiC,KAAK,UAAU,YAAY,GAC7D;AAEH,OAAI,KAAK,SACP,QAAO,aAAa;AAEtB,UAAO,KAAK,UAAU,aAAa;QAEnC,OAAM,IAAI,MACR,6BAA6B,KAAK,UAAU,YAAY,GACzD;;;;;;;AASP,IAAa,4BAAb,cAEUC,+BAAAA,oCAA4C;CACpD,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB;CAEA,WAAW;CAEX,YACE,QACA;AACA,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,eAAe,IAAI,sBAAsB,OAAO;;CAGvD,MACE,MACA,MACkC;AAClC,MAAI,CAAC,KACH;AAGF,UAAA,GAAA,iCAAA,SADoB,QAAQ,EAAE,EAAE,KACtB;;CAGZ,MAAM,mBACJ,aAC6B;EAC7B,MAAM,aAAa,YAAY;AAC/B,MAAI,CAAC,WAAW,QACd;EAEF,MAAM,EAAE,YAAY;EACpB,MAAM,eAAe,QAAQ,kBAAkB;AAC/C,MAAI,CAAC,aACH;AAEF,MAAI,KAAK,SACP,SAAA,GAAA,+BAAA,kBAAwB,aAAa,UAAU;AAGjD,SAAO;GACL,GAAG;GACH,YAAA,GAAA,+BAAA,kBAA4B,aAAa,UAAU;GACpD;;;;;;;;CASH,MAAM,YACJ,aACiB;EACjB,MAAM,SAAS,MAAM,KAAK,aAAa,YAAY,YAAY;AAC/D,MAAI,CAAC,OACH,OAAM,IAAI,MACR,0CAA0C,KAAK,UAAU,YAAY,GACtE;AAEH,SAAO,KAAK,MAAM,OAAO;;CAG3B,MAAM,MAAM,MAA+B;AACzC,MAAI;GACF,MAAM,eAAe,KAAK,MAAM,KAAK;AACrC,OAAI,KAAK,SACP,QAAO;AAET,gBAAa,YAAY,KAAK,MAAM,aAAa,UAAU;AAC3D,UAAO;WACA,GAAG;AACV,SAAM,IAAIC,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,IAC7C;;;CAIL,wBAAgC;AAC9B,SAAO;;;;;;;;AASX,IAAa,+BAAb,cAEUF,+BAAAA,oBAAuB;CAC/B,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,eAAe,IAAI,2BAA2B;CAE9C;CAEA,IAAI,aAAa;AACf,SAAO,EACL,UAAU,YACX;;CAGH,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;;CASzB,MAAM,YAAY,aAA0D;AAE1E,UAAO,MADc,KAAK,aAAa,YAAY,YAAY,EACjD,KAAK"}

package/dist/output_parsers/openai_functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.js","names":[],"sources":["../../src/output_parsers/openai_functions.ts"],"sourcesContent":["import { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport {\n  compare,\n  type Operation as JSONPatchOperation,\n} from \"@langchain/core/utils/json_patch\";\n\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport {\n  BaseCumulativeTransformOutputParser,\n  type BaseCumulativeTransformOutputParserInput,\n  BaseLLMOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { parsePartialJson } from \"@langchain/core/output_parsers\";\nimport { Optional } from \"../types/type-utils.js\";\n\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<\n  JsonSchema7ObjectType,\n  \"additionalProperties\"\n>;\n\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n  static lc_name() {\n    return \"OutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  argsOnly = true;\n\n  constructor(config?: { argsOnly?: boolean }) {\n    super();\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n  }\n\n  /**\n   * Parses the output and returns a string representation of the function\n   * call or its arguments.\n   * @param generations The output of the LLM to parse.\n   * @returns A string representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<string> {\n    if (\"message\" in generations[0]) {\n      const gen = generations[0] as ChatGeneration;\n      const functionCall = gen.message.additional_kwargs.function_call;\n      if (!functionCall) {\n        throw new Error(\n          `No function_call in message ${JSON.stringify(generations)}`\n        );\n      }\n      if (!functionCall.arguments) {\n        throw new Error(\n          `No arguments in function_call ${JSON.stringify(generations)}`\n        );\n      }\n      if (this.argsOnly) {\n        return functionCall.arguments;\n      }\n      return JSON.stringify(functionCall);\n    } else {\n      throw new Error(\n        `No message in generations ${JSON.stringify(generations)}`\n      );\n    }\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport class JsonOutputFunctionsParser<\n  Output extends object = object,\n> extends BaseCumulativeTransformOutputParser<Output> {\n  static lc_name() {\n    return \"JsonOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser: OutputFunctionsParser;\n\n  argsOnly = true;\n\n  constructor(\n    config?: { argsOnly?: boolean } & BaseCumulativeTransformOutputParserInput\n  ) {\n    super(config);\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n    this.outputParser = new OutputFunctionsParser(config);\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): JSONPatchOperation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    const ops = compare(prev ?? {}, next);\n    return ops;\n  }\n\n  async parsePartialResult(\n    generations: ChatGeneration[]\n  ): Promise<Output | undefined> {\n    const generation = generations[0];\n    if (!generation.message) {\n      return undefined;\n    }\n    const { message } = generation;\n    const functionCall = message.additional_kwargs.function_call;\n    if (!functionCall) {\n      return undefined;\n    }\n    if (this.argsOnly) {\n      return parsePartialJson(functionCall.arguments);\n    }\n\n    return {\n      ...functionCall,\n      arguments: parsePartialJson(functionCall.arguments),\n    } as Output;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<Output> {\n    const result = await this.outputParser.parseResult(generations);\n    if (!result) {\n      throw new Error(\n        `No result from \"OutputFunctionsParser\" ${JSON.stringify(generations)}`\n      );\n    }\n    return this.parse(result);\n  }\n\n  async parse(text: string): Promise<Output> {\n    try {\n      const parsedResult = JSON.parse(text);\n      if (this.argsOnly) {\n        return parsedResult;\n      }\n      parsedResult.arguments = JSON.parse(parsedResult.arguments);\n      return parsedResult;\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport class JsonKeyOutputFunctionsParser<\n  T = object,\n> extends BaseLLMOutputParser<T> {\n  static lc_name() {\n    return \"JsonKeyOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser = new JsonOutputFunctionsParser();\n\n  attrName: string;\n\n  get lc_aliases() {\n    return {\n      attrName: \"key_name\",\n    };\n  }\n\n  constructor(fields: { attrName: string }) {\n    super(fields);\n    this.attrName = fields.attrName;\n  }\n\n  /**\n   * Parses the output and returns a specific attribute of the parsed JSON\n   * object.\n   * @param generations The output of the LLM to parse.\n   * @returns The value of a specific attribute of the parsed JSON object.\n   */\n  async parseResult(generations: Generation[] | ChatGeneration[]): Promise<T> {\n    const result = await this.outputParser.parseResult(generations);\n    return result[this.attrName as keyof typeof result] as T;\n  }\n}\n"],"mappings":";;;;;;;AA4BA,IAAa,wBAAb,cAA2C,oBAA4B;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,WAAW;CAEX,YAAY,QAAiC;AAC3C,SAAO;AACP,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YACJ,aACiB;AACjB,MAAI,aAAa,YAAY,IAAI;GAE/B,MAAM,eADM,YAAY,GACC,QAAQ,kBAAkB;AACnD,OAAI,CAAC,aACH,OAAM,IAAI,MACR,+BAA+B,KAAK,UAAU,YAAY,GAC3D;AAEH,OAAI,CAAC,aAAa,UAChB,OAAM,IAAI,MACR,iCAAiC,KAAK,UAAU,YAAY,GAC7D;AAEH,OAAI,KAAK,SACP,QAAO,aAAa;AAEtB,UAAO,KAAK,UAAU,aAAa;QAEnC,OAAM,IAAI,MACR,6BAA6B,KAAK,UAAU,YAAY,GACzD;;;;;;;AASP,IAAa,4BAAb,cAEU,oCAA4C;CACpD,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB;CAEA,WAAW;CAEX,YACE,QACA;AACA,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,eAAe,IAAI,sBAAsB,OAAO;;CAGvD,MACE,MACA,MACkC;AAClC,MAAI,CAAC,KACH;AAGF,SADY,QAAQ,QAAQ,EAAE,EAAE,KAAK;;CAIvC,MAAM,mBACJ,aAC6B;EAC7B,MAAM,aAAa,YAAY;AAC/B,MAAI,CAAC,WAAW,QACd;EAEF,MAAM,EAAE,YAAY;EACpB,MAAM,eAAe,QAAQ,kBAAkB;AAC/C,MAAI,CAAC,aACH;AAEF,MAAI,KAAK,SACP,QAAO,iBAAiB,aAAa,UAAU;AAGjD,SAAO;GACL,GAAG;GACH,WAAW,iBAAiB,aAAa,UAAU;GACpD;;;;;;;;CASH,MAAM,YACJ,aACiB;EACjB,MAAM,SAAS,MAAM,KAAK,aAAa,YAAY,YAAY;AAC/D,MAAI,CAAC,OACH,OAAM,IAAI,MACR,0CAA0C,KAAK,UAAU,YAAY,GACtE;AAEH,SAAO,KAAK,MAAM,OAAO;;CAG3B,MAAM,MAAM,MAA+B;AACzC,MAAI;GACF,MAAM,eAAe,KAAK,MAAM,KAAK;AACrC,OAAI,KAAK,SACP,QAAO;AAET,gBAAa,YAAY,KAAK,MAAM,aAAa,UAAU;AAC3D,UAAO;WACA,GAAG;AACV,SAAM,IAAI,sBACR,2BAA2B,KAAK,YAAY,IAC7C;;;CAIL,wBAAgC;AAC9B,SAAO;;;;;;;;AASX,IAAa,+BAAb,cAEU,oBAAuB;CAC/B,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,eAAe,IAAI,2BAA2B;CAE9C;CAEA,IAAI,aAAa;AACf,SAAO,EACL,UAAU,YACX;;CAGH,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;;CASzB,MAAM,YAAY,aAA0D;AAE1E,UADe,MAAM,KAAK,aAAa,YAAY,YAAY,EACjD,KAAK"}
+{"version":3,"file":"openai_functions.js","names":[],"sources":["../../src/output_parsers/openai_functions.ts"],"sourcesContent":["import { type JsonSchema7ObjectType } from \"@langchain/core/utils/json_schema\";\nimport {\n  compare,\n  type Operation as JSONPatchOperation,\n} from \"@langchain/core/utils/json_patch\";\n\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport {\n  BaseCumulativeTransformOutputParser,\n  type BaseCumulativeTransformOutputParserInput,\n  BaseLLMOutputParser,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport { parsePartialJson } from \"@langchain/core/output_parsers\";\nimport { Optional } from \"../types/type-utils.js\";\n\n/**\n * Represents optional parameters for a function in a JSON Schema.\n */\nexport type FunctionParameters = Optional<\n  JsonSchema7ObjectType,\n  \"additionalProperties\"\n>;\n\n/**\n * Class for parsing the output of an LLM. Can be configured to return\n * only the arguments of the function call in the output.\n */\nexport class OutputFunctionsParser extends BaseLLMOutputParser<string> {\n  static lc_name() {\n    return \"OutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  argsOnly = true;\n\n  constructor(config?: { argsOnly?: boolean }) {\n    super();\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n  }\n\n  /**\n   * Parses the output and returns a string representation of the function\n   * call or its arguments.\n   * @param generations The output of the LLM to parse.\n   * @returns A string representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<string> {\n    if (\"message\" in generations[0]) {\n      const gen = generations[0] as ChatGeneration;\n      const functionCall = gen.message.additional_kwargs.function_call;\n      if (!functionCall) {\n        throw new Error(\n          `No function_call in message ${JSON.stringify(generations)}`\n        );\n      }\n      if (!functionCall.arguments) {\n        throw new Error(\n          `No arguments in function_call ${JSON.stringify(generations)}`\n        );\n      }\n      if (this.argsOnly) {\n        return functionCall.arguments;\n      }\n      return JSON.stringify(functionCall);\n    } else {\n      throw new Error(\n        `No message in generations ${JSON.stringify(generations)}`\n      );\n    }\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object. Uses an\n * instance of `OutputFunctionsParser` to parse the output.\n */\nexport class JsonOutputFunctionsParser<\n  Output extends object = object,\n> extends BaseCumulativeTransformOutputParser<Output> {\n  static lc_name() {\n    return \"JsonOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser: OutputFunctionsParser;\n\n  argsOnly = true;\n\n  constructor(\n    config?: { argsOnly?: boolean } & BaseCumulativeTransformOutputParserInput\n  ) {\n    super(config);\n    this.argsOnly = config?.argsOnly ?? this.argsOnly;\n    this.outputParser = new OutputFunctionsParser(config);\n  }\n\n  protected _diff(\n    prev: unknown | undefined,\n    next: unknown\n  ): JSONPatchOperation[] | undefined {\n    if (!next) {\n      return undefined;\n    }\n    const ops = compare(prev ?? {}, next);\n    return ops;\n  }\n\n  async parsePartialResult(\n    generations: ChatGeneration[]\n  ): Promise<Output | undefined> {\n    const generation = generations[0];\n    if (!generation.message) {\n      return undefined;\n    }\n    const { message } = generation;\n    const functionCall = message.additional_kwargs.function_call;\n    if (!functionCall) {\n      return undefined;\n    }\n    if (this.argsOnly) {\n      return parsePartialJson(functionCall.arguments);\n    }\n\n    return {\n      ...functionCall,\n      arguments: parsePartialJson(functionCall.arguments),\n    } as Output;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(\n    generations: Generation[] | ChatGeneration[]\n  ): Promise<Output> {\n    const result = await this.outputParser.parseResult(generations);\n    if (!result) {\n      throw new Error(\n        `No result from \"OutputFunctionsParser\" ${JSON.stringify(generations)}`\n      );\n    }\n    return this.parse(result);\n  }\n\n  async parse(text: string): Promise<Output> {\n    try {\n      const parsedResult = JSON.parse(text);\n      if (this.argsOnly) {\n        return parsedResult;\n      }\n      parsedResult.arguments = JSON.parse(parsedResult.arguments);\n      return parsedResult;\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`\n      );\n    }\n  }\n\n  getFormatInstructions(): string {\n    return \"\";\n  }\n}\n\n/**\n * Class for parsing the output of an LLM into a JSON object and returning\n * a specific attribute. Uses an instance of `JsonOutputFunctionsParser`\n * to parse the output.\n */\nexport class JsonKeyOutputFunctionsParser<\n  T = object,\n> extends BaseLLMOutputParser<T> {\n  static lc_name() {\n    return \"JsonKeyOutputFunctionsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_functions\"];\n\n  lc_serializable = true;\n\n  outputParser = new JsonOutputFunctionsParser();\n\n  attrName: string;\n\n  get lc_aliases() {\n    return {\n      attrName: \"key_name\",\n    };\n  }\n\n  constructor(fields: { attrName: string }) {\n    super(fields);\n    this.attrName = fields.attrName;\n  }\n\n  /**\n   * Parses the output and returns a specific attribute of the parsed JSON\n   * object.\n   * @param generations The output of the LLM to parse.\n   * @returns The value of a specific attribute of the parsed JSON object.\n   */\n  async parseResult(generations: Generation[] | ChatGeneration[]): Promise<T> {\n    const result = await this.outputParser.parseResult(generations);\n    return result[this.attrName as keyof typeof result] as T;\n  }\n}\n"],"mappings":";;;;;;;AA4BA,IAAa,wBAAb,cAA2C,oBAA4B;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,WAAW;CAEX,YAAY,QAAiC;AAC3C,SAAO;AACP,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YACJ,aACiB;AACjB,MAAI,aAAa,YAAY,IAAI;GAE/B,MAAM,eADM,YAAY,GACC,QAAQ,kBAAkB;AACnD,OAAI,CAAC,aACH,OAAM,IAAI,MACR,+BAA+B,KAAK,UAAU,YAAY,GAC3D;AAEH,OAAI,CAAC,aAAa,UAChB,OAAM,IAAI,MACR,iCAAiC,KAAK,UAAU,YAAY,GAC7D;AAEH,OAAI,KAAK,SACP,QAAO,aAAa;AAEtB,UAAO,KAAK,UAAU,aAAa;QAEnC,OAAM,IAAI,MACR,6BAA6B,KAAK,UAAU,YAAY,GACzD;;;;;;;AASP,IAAa,4BAAb,cAEU,oCAA4C;CACpD,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB;CAEA,WAAW;CAEX,YACE,QACA;AACA,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;AACzC,OAAK,eAAe,IAAI,sBAAsB,OAAO;;CAGvD,MACE,MACA,MACkC;AAClC,MAAI,CAAC,KACH;AAGF,SADY,QAAQ,QAAQ,EAAE,EAAE,KACtB;;CAGZ,MAAM,mBACJ,aAC6B;EAC7B,MAAM,aAAa,YAAY;AAC/B,MAAI,CAAC,WAAW,QACd;EAEF,MAAM,EAAE,YAAY;EACpB,MAAM,eAAe,QAAQ,kBAAkB;AAC/C,MAAI,CAAC,aACH;AAEF,MAAI,KAAK,SACP,QAAO,iBAAiB,aAAa,UAAU;AAGjD,SAAO;GACL,GAAG;GACH,WAAW,iBAAiB,aAAa,UAAU;GACpD;;;;;;;;CASH,MAAM,YACJ,aACiB;EACjB,MAAM,SAAS,MAAM,KAAK,aAAa,YAAY,YAAY;AAC/D,MAAI,CAAC,OACH,OAAM,IAAI,MACR,0CAA0C,KAAK,UAAU,YAAY,GACtE;AAEH,SAAO,KAAK,MAAM,OAAO;;CAG3B,MAAM,MAAM,MAA+B;AACzC,MAAI;GACF,MAAM,eAAe,KAAK,MAAM,KAAK;AACrC,OAAI,KAAK,SACP,QAAO;AAET,gBAAa,YAAY,KAAK,MAAM,aAAa,UAAU;AAC3D,UAAO;WACA,GAAG;AACV,SAAM,IAAI,sBACR,2BAA2B,KAAK,YAAY,IAC7C;;;CAIL,wBAAgC;AAC9B,SAAO;;;;;;;;AASX,IAAa,+BAAb,cAEU,oBAAuB;CAC/B,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAmB;CAElE,kBAAkB;CAElB,eAAe,IAAI,2BAA2B;CAE9C;CAEA,IAAI,aAAa;AACf,SAAO,EACL,UAAU,YACX;;CAGH,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;;CASzB,MAAM,YAAY,aAA0D;AAE1E,UAAO,MADc,KAAK,aAAa,YAAY,YAAY,EACjD,KAAK"}

package/dist/output_parsers/openai_tools.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openai_tools.cjs","names":["BaseLLMOutputParser"],"sources":["../../src/output_parsers/openai_tools.ts"],"sourcesContent":["import { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport type { ChatGeneration } from \"@langchain/core/outputs\";\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type ParsedToolCall = {\n  id?: string;\n\n  type: string;\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  args: Record<string, any>;\n\n  /** @deprecated Use `type` instead. Will be removed in 0.2.0. */\n  name: string;\n\n  /** @deprecated Use `args` instead. Will be removed in 0.2.0. */\n  arguments: Record<string, any>; // oxlint-disable-line @typescript-eslint/no-explicit-any\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type JsonOutputToolsParserParams = {\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport class JsonOutputToolsParser extends BaseLLMOutputParser<\n  ParsedToolCall[]\n> {\n  static lc_name() {\n    return \"JsonOutputToolsParser\";\n  }\n\n  returnId = false;\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  constructor(fields?: JsonOutputToolsParserParams) {\n    super(fields);\n    this.returnId = fields?.returnId ?? this.returnId;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]> {\n    const toolCalls = generations[0].message.additional_kwargs.tool_calls;\n    if (!toolCalls) {\n      throw new Error(\n        `No tools_call in message ${JSON.stringify(generations)}`\n      );\n    }\n    const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));\n    const parsedToolCalls = [];\n    for (const toolCall of clonedToolCalls) {\n      if (toolCall.function !== undefined) {\n        // @ts-expect-error name and arguemnts are defined by Object.defineProperty\n        const parsedToolCall: ParsedToolCall = {\n          type: toolCall.function.name,\n          args: JSON.parse(toolCall.function.arguments),\n        };\n\n        if (this.returnId) {\n          parsedToolCall.id = toolCall.id;\n        }\n\n        // backward-compatibility with previous\n        // versions of Langchain JS, which uses `name` and `arguments`\n        Object.defineProperty(parsedToolCall, \"name\", {\n          get() {\n            return this.type;\n          },\n        });\n\n        Object.defineProperty(parsedToolCall, \"arguments\", {\n          get() {\n            return this.args;\n          },\n        });\n\n        parsedToolCalls.push(parsedToolCall);\n      }\n    }\n    return parsedToolCalls;\n  }\n}\n\nexport type JsonOutputKeyToolsParserParams = {\n  keyName: string;\n  returnSingle?: boolean;\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {\n  static lc_name() {\n    return \"JsonOutputKeyToolsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  returnId = false;\n\n  /** The type of tool calls to return. */\n  keyName: string;\n\n  /** Whether to return only the first tool call. */\n  returnSingle = false;\n\n  initialParser: JsonOutputToolsParser;\n\n  constructor(params: JsonOutputKeyToolsParserParams) {\n    super(params);\n    this.keyName = params.keyName;\n    this.returnSingle = params.returnSingle ?? this.returnSingle;\n    this.initialParser = new JsonOutputToolsParser(params);\n  }\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  async parseResult(generations: ChatGeneration[]): Promise<any> {\n    const results = await this.initialParser.parseResult(generations);\n    const matchingResults = results.filter(\n      (result) => result.type === this.keyName\n    );\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    let returnedValues: ParsedToolCall[] | Record<string, any>[] =\n      matchingResults;\n    if (!this.returnId) {\n      returnedValues = matchingResults.map((result) => result.args);\n    }\n    if (this.returnSingle) {\n      return returnedValues[0];\n    }\n    return returnedValues;\n  }\n}\n"],"mappings":";;;;;;AAgCA,IAAa,wBAAb,cAA2CA,+BAAAA,oBAEzC;CACA,OAAO,UAAU;AACf,SAAO;;CAGT,WAAW;CAEX,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,YAAY,QAAsC;AAChD,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YAAY,aAA0D;EAC1E,MAAM,YAAY,YAAY,GAAG,QAAQ,kBAAkB;AAC3D,MAAI,CAAC,UACH,OAAM,IAAI,MACR,4BAA4B,KAAK,UAAU,YAAY,GACxD;EAEH,MAAM,kBAAkB,KAAK,MAAM,KAAK,UAAU,UAAU,CAAC;EAC7D,MAAM,kBAAkB,EAAE;AAC1B,OAAK,MAAM,YAAY,gBACrB,KAAI,SAAS,aAAa,KAAA,GAAW;GAEnC,MAAM,iBAAiC;IACrC,MAAM,SAAS,SAAS;IACxB,MAAM,KAAK,MAAM,SAAS,SAAS,UAAU;IAC9C;AAED,OAAI,KAAK,SACP,gBAAe,KAAK,SAAS;AAK/B,UAAO,eAAe,gBAAgB,QAAQ,EAC5C,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,UAAO,eAAe,gBAAgB,aAAa,EACjD,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,mBAAgB,KAAK,eAAe;;AAGxC,SAAO;;;;;;AAeX,IAAa,2BAAb,cAA8CA,+BAAAA,oBAAyB;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,WAAW;;CAGX;;CAGA,eAAe;CAEf;CAEA,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,UAAU,OAAO;AACtB,OAAK,eAAe,OAAO,gBAAgB,KAAK;AAChD,OAAK,gBAAgB,IAAI,sBAAsB,OAAO;;CAIxD,MAAM,YAAY,aAA6C;EAE7D,MAAM,mBADU,MAAM,KAAK,cAAc,YAAY,YAAY,EACjC,QAC7B,WAAW,OAAO,SAAS,KAAK,QAClC;EAED,IAAI,iBACF;AACF,MAAI,CAAC,KAAK,SACR,kBAAiB,gBAAgB,KAAK,WAAW,OAAO,KAAK;AAE/D,MAAI,KAAK,aACP,QAAO,eAAe;AAExB,SAAO"}
+{"version":3,"file":"openai_tools.cjs","names":["BaseLLMOutputParser"],"sources":["../../src/output_parsers/openai_tools.ts"],"sourcesContent":["import { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport type { ChatGeneration } from \"@langchain/core/outputs\";\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type ParsedToolCall = {\n  id?: string;\n\n  type: string;\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  args: Record<string, any>;\n\n  /** @deprecated Use `type` instead. Will be removed in 0.2.0. */\n  name: string;\n\n  /** @deprecated Use `args` instead. Will be removed in 0.2.0. */\n  arguments: Record<string, any>; // oxlint-disable-line @typescript-eslint/no-explicit-any\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type JsonOutputToolsParserParams = {\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport class JsonOutputToolsParser extends BaseLLMOutputParser<\n  ParsedToolCall[]\n> {\n  static lc_name() {\n    return \"JsonOutputToolsParser\";\n  }\n\n  returnId = false;\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  constructor(fields?: JsonOutputToolsParserParams) {\n    super(fields);\n    this.returnId = fields?.returnId ?? this.returnId;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]> {\n    const toolCalls = generations[0].message.additional_kwargs.tool_calls;\n    if (!toolCalls) {\n      throw new Error(\n        `No tools_call in message ${JSON.stringify(generations)}`\n      );\n    }\n    const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));\n    const parsedToolCalls = [];\n    for (const toolCall of clonedToolCalls) {\n      if (toolCall.function !== undefined) {\n        // @ts-expect-error name and arguemnts are defined by Object.defineProperty\n        const parsedToolCall: ParsedToolCall = {\n          type: toolCall.function.name,\n          args: JSON.parse(toolCall.function.arguments),\n        };\n\n        if (this.returnId) {\n          parsedToolCall.id = toolCall.id;\n        }\n\n        // backward-compatibility with previous\n        // versions of Langchain JS, which uses `name` and `arguments`\n        Object.defineProperty(parsedToolCall, \"name\", {\n          get() {\n            return this.type;\n          },\n        });\n\n        Object.defineProperty(parsedToolCall, \"arguments\", {\n          get() {\n            return this.args;\n          },\n        });\n\n        parsedToolCalls.push(parsedToolCall);\n      }\n    }\n    return parsedToolCalls;\n  }\n}\n\nexport type JsonOutputKeyToolsParserParams = {\n  keyName: string;\n  returnSingle?: boolean;\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {\n  static lc_name() {\n    return \"JsonOutputKeyToolsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  returnId = false;\n\n  /** The type of tool calls to return. */\n  keyName: string;\n\n  /** Whether to return only the first tool call. */\n  returnSingle = false;\n\n  initialParser: JsonOutputToolsParser;\n\n  constructor(params: JsonOutputKeyToolsParserParams) {\n    super(params);\n    this.keyName = params.keyName;\n    this.returnSingle = params.returnSingle ?? this.returnSingle;\n    this.initialParser = new JsonOutputToolsParser(params);\n  }\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  async parseResult(generations: ChatGeneration[]): Promise<any> {\n    const results = await this.initialParser.parseResult(generations);\n    const matchingResults = results.filter(\n      (result) => result.type === this.keyName\n    );\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    let returnedValues: ParsedToolCall[] | Record<string, any>[] =\n      matchingResults;\n    if (!this.returnId) {\n      returnedValues = matchingResults.map((result) => result.args);\n    }\n    if (this.returnSingle) {\n      return returnedValues[0];\n    }\n    return returnedValues;\n  }\n}\n"],"mappings":";;;;;;AAgCA,IAAa,wBAAb,cAA2CA,+BAAAA,oBAEzC;CACA,OAAO,UAAU;AACf,SAAO;;CAGT,WAAW;CAEX,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,YAAY,QAAsC;AAChD,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YAAY,aAA0D;EAC1E,MAAM,YAAY,YAAY,GAAG,QAAQ,kBAAkB;AAC3D,MAAI,CAAC,UACH,OAAM,IAAI,MACR,4BAA4B,KAAK,UAAU,YAAY,GACxD;EAEH,MAAM,kBAAkB,KAAK,MAAM,KAAK,UAAU,UAAU,CAAC;EAC7D,MAAM,kBAAkB,EAAE;AAC1B,OAAK,MAAM,YAAY,gBACrB,KAAI,SAAS,aAAa,KAAA,GAAW;GAEnC,MAAM,iBAAiC;IACrC,MAAM,SAAS,SAAS;IACxB,MAAM,KAAK,MAAM,SAAS,SAAS,UAAU;IAC9C;AAED,OAAI,KAAK,SACP,gBAAe,KAAK,SAAS;AAK/B,UAAO,eAAe,gBAAgB,QAAQ,EAC5C,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,UAAO,eAAe,gBAAgB,aAAa,EACjD,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,mBAAgB,KAAK,eAAe;;AAGxC,SAAO;;;;;;AAeX,IAAa,2BAAb,cAA8CA,+BAAAA,oBAAyB;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,WAAW;;CAGX;;CAGA,eAAe;CAEf;CAEA,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,UAAU,OAAO;AACtB,OAAK,eAAe,OAAO,gBAAgB,KAAK;AAChD,OAAK,gBAAgB,IAAI,sBAAsB,OAAO;;CAIxD,MAAM,YAAY,aAA6C;EAE7D,MAAM,mBAAkB,MADF,KAAK,cAAc,YAAY,YAAY,EACjC,QAC7B,WAAW,OAAO,SAAS,KAAK,QAClC;EAED,IAAI,iBACF;AACF,MAAI,CAAC,KAAK,SACR,kBAAiB,gBAAgB,KAAK,WAAW,OAAO,KAAK;AAE/D,MAAI,KAAK,aACP,QAAO,eAAe;AAExB,SAAO"}

package/dist/output_parsers/openai_tools.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai_tools.js","names":[],"sources":["../../src/output_parsers/openai_tools.ts"],"sourcesContent":["import { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport type { ChatGeneration } from \"@langchain/core/outputs\";\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type ParsedToolCall = {\n  id?: string;\n\n  type: string;\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  args: Record<string, any>;\n\n  /** @deprecated Use `type` instead. Will be removed in 0.2.0. */\n  name: string;\n\n  /** @deprecated Use `args` instead. Will be removed in 0.2.0. */\n  arguments: Record<string, any>; // oxlint-disable-line @typescript-eslint/no-explicit-any\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type JsonOutputToolsParserParams = {\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport class JsonOutputToolsParser extends BaseLLMOutputParser<\n  ParsedToolCall[]\n> {\n  static lc_name() {\n    return \"JsonOutputToolsParser\";\n  }\n\n  returnId = false;\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  constructor(fields?: JsonOutputToolsParserParams) {\n    super(fields);\n    this.returnId = fields?.returnId ?? this.returnId;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]> {\n    const toolCalls = generations[0].message.additional_kwargs.tool_calls;\n    if (!toolCalls) {\n      throw new Error(\n        `No tools_call in message ${JSON.stringify(generations)}`\n      );\n    }\n    const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));\n    const parsedToolCalls = [];\n    for (const toolCall of clonedToolCalls) {\n      if (toolCall.function !== undefined) {\n        // @ts-expect-error name and arguemnts are defined by Object.defineProperty\n        const parsedToolCall: ParsedToolCall = {\n          type: toolCall.function.name,\n          args: JSON.parse(toolCall.function.arguments),\n        };\n\n        if (this.returnId) {\n          parsedToolCall.id = toolCall.id;\n        }\n\n        // backward-compatibility with previous\n        // versions of Langchain JS, which uses `name` and `arguments`\n        Object.defineProperty(parsedToolCall, \"name\", {\n          get() {\n            return this.type;\n          },\n        });\n\n        Object.defineProperty(parsedToolCall, \"arguments\", {\n          get() {\n            return this.args;\n          },\n        });\n\n        parsedToolCalls.push(parsedToolCall);\n      }\n    }\n    return parsedToolCalls;\n  }\n}\n\nexport type JsonOutputKeyToolsParserParams = {\n  keyName: string;\n  returnSingle?: boolean;\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {\n  static lc_name() {\n    return \"JsonOutputKeyToolsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  returnId = false;\n\n  /** The type of tool calls to return. */\n  keyName: string;\n\n  /** Whether to return only the first tool call. */\n  returnSingle = false;\n\n  initialParser: JsonOutputToolsParser;\n\n  constructor(params: JsonOutputKeyToolsParserParams) {\n    super(params);\n    this.keyName = params.keyName;\n    this.returnSingle = params.returnSingle ?? this.returnSingle;\n    this.initialParser = new JsonOutputToolsParser(params);\n  }\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  async parseResult(generations: ChatGeneration[]): Promise<any> {\n    const results = await this.initialParser.parseResult(generations);\n    const matchingResults = results.filter(\n      (result) => result.type === this.keyName\n    );\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    let returnedValues: ParsedToolCall[] | Record<string, any>[] =\n      matchingResults;\n    if (!this.returnId) {\n      returnedValues = matchingResults.map((result) => result.args);\n    }\n    if (this.returnSingle) {\n      return returnedValues[0];\n    }\n    return returnedValues;\n  }\n}\n"],"mappings":";;;;;AAgCA,IAAa,wBAAb,cAA2C,oBAEzC;CACA,OAAO,UAAU;AACf,SAAO;;CAGT,WAAW;CAEX,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,YAAY,QAAsC;AAChD,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YAAY,aAA0D;EAC1E,MAAM,YAAY,YAAY,GAAG,QAAQ,kBAAkB;AAC3D,MAAI,CAAC,UACH,OAAM,IAAI,MACR,4BAA4B,KAAK,UAAU,YAAY,GACxD;EAEH,MAAM,kBAAkB,KAAK,MAAM,KAAK,UAAU,UAAU,CAAC;EAC7D,MAAM,kBAAkB,EAAE;AAC1B,OAAK,MAAM,YAAY,gBACrB,KAAI,SAAS,aAAa,KAAA,GAAW;GAEnC,MAAM,iBAAiC;IACrC,MAAM,SAAS,SAAS;IACxB,MAAM,KAAK,MAAM,SAAS,SAAS,UAAU;IAC9C;AAED,OAAI,KAAK,SACP,gBAAe,KAAK,SAAS;AAK/B,UAAO,eAAe,gBAAgB,QAAQ,EAC5C,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,UAAO,eAAe,gBAAgB,aAAa,EACjD,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,mBAAgB,KAAK,eAAe;;AAGxC,SAAO;;;;;;AAeX,IAAa,2BAAb,cAA8C,oBAAyB;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,WAAW;;CAGX;;CAGA,eAAe;CAEf;CAEA,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,UAAU,OAAO;AACtB,OAAK,eAAe,OAAO,gBAAgB,KAAK;AAChD,OAAK,gBAAgB,IAAI,sBAAsB,OAAO;;CAIxD,MAAM,YAAY,aAA6C;EAE7D,MAAM,mBADU,MAAM,KAAK,cAAc,YAAY,YAAY,EACjC,QAC7B,WAAW,OAAO,SAAS,KAAK,QAClC;EAED,IAAI,iBACF;AACF,MAAI,CAAC,KAAK,SACR,kBAAiB,gBAAgB,KAAK,WAAW,OAAO,KAAK;AAE/D,MAAI,KAAK,aACP,QAAO,eAAe;AAExB,SAAO"}
+{"version":3,"file":"openai_tools.js","names":[],"sources":["../../src/output_parsers/openai_tools.ts"],"sourcesContent":["import { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport type { ChatGeneration } from \"@langchain/core/outputs\";\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type ParsedToolCall = {\n  id?: string;\n\n  type: string;\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  args: Record<string, any>;\n\n  /** @deprecated Use `type` instead. Will be removed in 0.2.0. */\n  name: string;\n\n  /** @deprecated Use `args` instead. Will be removed in 0.2.0. */\n  arguments: Record<string, any>; // oxlint-disable-line @typescript-eslint/no-explicit-any\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport type JsonOutputToolsParserParams = {\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\nexport class JsonOutputToolsParser extends BaseLLMOutputParser<\n  ParsedToolCall[]\n> {\n  static lc_name() {\n    return \"JsonOutputToolsParser\";\n  }\n\n  returnId = false;\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  constructor(fields?: JsonOutputToolsParserParams) {\n    super(fields);\n    this.returnId = fields?.returnId ?? this.returnId;\n  }\n\n  /**\n   * Parses the output and returns a JSON object. If `argsOnly` is true,\n   * only the arguments of the function call are returned.\n   * @param generations The output of the LLM to parse.\n   * @returns A JSON object representation of the function call or its arguments.\n   */\n  async parseResult(generations: ChatGeneration[]): Promise<ParsedToolCall[]> {\n    const toolCalls = generations[0].message.additional_kwargs.tool_calls;\n    if (!toolCalls) {\n      throw new Error(\n        `No tools_call in message ${JSON.stringify(generations)}`\n      );\n    }\n    const clonedToolCalls = JSON.parse(JSON.stringify(toolCalls));\n    const parsedToolCalls = [];\n    for (const toolCall of clonedToolCalls) {\n      if (toolCall.function !== undefined) {\n        // @ts-expect-error name and arguemnts are defined by Object.defineProperty\n        const parsedToolCall: ParsedToolCall = {\n          type: toolCall.function.name,\n          args: JSON.parse(toolCall.function.arguments),\n        };\n\n        if (this.returnId) {\n          parsedToolCall.id = toolCall.id;\n        }\n\n        // backward-compatibility with previous\n        // versions of Langchain JS, which uses `name` and `arguments`\n        Object.defineProperty(parsedToolCall, \"name\", {\n          get() {\n            return this.type;\n          },\n        });\n\n        Object.defineProperty(parsedToolCall, \"arguments\", {\n          get() {\n            return this.args;\n          },\n        });\n\n        parsedToolCalls.push(parsedToolCall);\n      }\n    }\n    return parsedToolCalls;\n  }\n}\n\nexport type JsonOutputKeyToolsParserParams = {\n  keyName: string;\n  returnSingle?: boolean;\n  /** Whether to return the tool call id. */\n  returnId?: boolean;\n};\n\n/**\n * @deprecated Import from \"@langchain/core/output_parsers/openai_tools\"\n */\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport class JsonOutputKeyToolsParser extends BaseLLMOutputParser<any> {\n  static lc_name() {\n    return \"JsonOutputKeyToolsParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"openai_tools\"];\n\n  lc_serializable = true;\n\n  returnId = false;\n\n  /** The type of tool calls to return. */\n  keyName: string;\n\n  /** Whether to return only the first tool call. */\n  returnSingle = false;\n\n  initialParser: JsonOutputToolsParser;\n\n  constructor(params: JsonOutputKeyToolsParserParams) {\n    super(params);\n    this.keyName = params.keyName;\n    this.returnSingle = params.returnSingle ?? this.returnSingle;\n    this.initialParser = new JsonOutputToolsParser(params);\n  }\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  async parseResult(generations: ChatGeneration[]): Promise<any> {\n    const results = await this.initialParser.parseResult(generations);\n    const matchingResults = results.filter(\n      (result) => result.type === this.keyName\n    );\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    let returnedValues: ParsedToolCall[] | Record<string, any>[] =\n      matchingResults;\n    if (!this.returnId) {\n      returnedValues = matchingResults.map((result) => result.args);\n    }\n    if (this.returnSingle) {\n      return returnedValues[0];\n    }\n    return returnedValues;\n  }\n}\n"],"mappings":";;;;;AAgCA,IAAa,wBAAb,cAA2C,oBAEzC;CACA,OAAO,UAAU;AACf,SAAO;;CAGT,WAAW;CAEX,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,YAAY,QAAsC;AAChD,QAAM,OAAO;AACb,OAAK,WAAW,QAAQ,YAAY,KAAK;;;;;;;;CAS3C,MAAM,YAAY,aAA0D;EAC1E,MAAM,YAAY,YAAY,GAAG,QAAQ,kBAAkB;AAC3D,MAAI,CAAC,UACH,OAAM,IAAI,MACR,4BAA4B,KAAK,UAAU,YAAY,GACxD;EAEH,MAAM,kBAAkB,KAAK,MAAM,KAAK,UAAU,UAAU,CAAC;EAC7D,MAAM,kBAAkB,EAAE;AAC1B,OAAK,MAAM,YAAY,gBACrB,KAAI,SAAS,aAAa,KAAA,GAAW;GAEnC,MAAM,iBAAiC;IACrC,MAAM,SAAS,SAAS;IACxB,MAAM,KAAK,MAAM,SAAS,SAAS,UAAU;IAC9C;AAED,OAAI,KAAK,SACP,gBAAe,KAAK,SAAS;AAK/B,UAAO,eAAe,gBAAgB,QAAQ,EAC5C,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,UAAO,eAAe,gBAAgB,aAAa,EACjD,MAAM;AACJ,WAAO,KAAK;MAEf,CAAC;AAEF,mBAAgB,KAAK,eAAe;;AAGxC,SAAO;;;;;;AAeX,IAAa,2BAAb,cAA8C,oBAAyB;CACrE,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAe;CAE9D,kBAAkB;CAElB,WAAW;;CAGX;;CAGA,eAAe;CAEf;CAEA,YAAY,QAAwC;AAClD,QAAM,OAAO;AACb,OAAK,UAAU,OAAO;AACtB,OAAK,eAAe,OAAO,gBAAgB,KAAK;AAChD,OAAK,gBAAgB,IAAI,sBAAsB,OAAO;;CAIxD,MAAM,YAAY,aAA6C;EAE7D,MAAM,mBAAkB,MADF,KAAK,cAAc,YAAY,YAAY,EACjC,QAC7B,WAAW,OAAO,SAAS,KAAK,QAClC;EAED,IAAI,iBACF;AACF,MAAI,CAAC,KAAK,SACR,kBAAiB,gBAAgB,KAAK,WAAW,OAAO,KAAK;AAE/D,MAAI,KAAK,aACP,QAAO,eAAe;AAExB,SAAO"}

package/dist/output_parsers/prompts.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.cjs","names":[],"sources":["../../src/output_parsers/prompts.ts"],"sourcesContent":["import { PromptTemplate } from \"@langchain/core/prompts\";\n\nexport const NAIVE_FIX_TEMPLATE = `Instructions:\n--------------\n{instructions}\n--------------\nCompletion:\n--------------\n{completion}\n--------------\n\nAbove, the Completion did not satisfy the constraints given in the Instructions.\nError:\n--------------\n{error}\n--------------\n\nPlease try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;\n\nexport const NAIVE_FIX_PROMPT =\n  /* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);\n"],"mappings":";AAmBA,MAAa,mBACK,mDAAA,eAAe,aAlBC;;;;;;;;;;;;;;;mHAkB+B"}
+{"version":3,"file":"prompts.cjs","names":[],"sources":["../../src/output_parsers/prompts.ts"],"sourcesContent":["import { PromptTemplate } from \"@langchain/core/prompts\";\n\nexport const NAIVE_FIX_TEMPLATE = `Instructions:\n--------------\n{instructions}\n--------------\nCompletion:\n--------------\n{completion}\n--------------\n\nAbove, the Completion did not satisfy the constraints given in the Instructions.\nError:\n--------------\n{error}\n--------------\n\nPlease try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;\n\nexport const NAIVE_FIX_PROMPT =\n  /* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);\n"],"mappings":";AAmBA,MAAa,mBACK,kDAAA,CAAA,eAAe,aAAa;;;;;;;;;;;;;;;mHAAmB"}

package/dist/output_parsers/prompts.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompts.js","names":[],"sources":["../../src/output_parsers/prompts.ts"],"sourcesContent":["import { PromptTemplate } from \"@langchain/core/prompts\";\n\nexport const NAIVE_FIX_TEMPLATE = `Instructions:\n--------------\n{instructions}\n--------------\nCompletion:\n--------------\n{completion}\n--------------\n\nAbove, the Completion did not satisfy the constraints given in the Instructions.\nError:\n--------------\n{error}\n--------------\n\nPlease try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;\n\nexport const NAIVE_FIX_PROMPT =\n  /* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);\n"],"mappings":";AAmBA,MAAa,mBACK,+BAAe,aAlBC;;;;;;;;;;;;;;;mHAkB+B"}
+{"version":3,"file":"prompts.js","names":[],"sources":["../../src/output_parsers/prompts.ts"],"sourcesContent":["import { PromptTemplate } from \"@langchain/core/prompts\";\n\nexport const NAIVE_FIX_TEMPLATE = `Instructions:\n--------------\n{instructions}\n--------------\nCompletion:\n--------------\n{completion}\n--------------\n\nAbove, the Completion did not satisfy the constraints given in the Instructions.\nError:\n--------------\n{error}\n--------------\n\nPlease try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;\n\nexport const NAIVE_FIX_PROMPT =\n  /* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);\n"],"mappings":";AAmBA,MAAa,mBACK,+BAAe,aAAa;;;;;;;;;;;;;;;mHAAmB"}

package/dist/output_parsers/structured.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"structured.cjs","names":["BaseOutputParser","z","OutputParserException"],"sources":["../../src/output_parsers/structured.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport {\n  toJsonSchema,\n  type JsonSchema7Type,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"@langchain/core/utils/json_schema\";\nimport {\n  BaseOutputParser,\n  FormatInstructionsOptions,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport {\n  interopParseAsync,\n  type InferInteropZodOutput,\n  type InteropZodType,\n} from \"@langchain/core/utils/types\";\n\nexport type JsonMarkdownStructuredOutputParserInput = {\n  interpolationDepth?: number;\n};\n\nexport interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {\n  interpolationDepth?: number;\n}\n\nexport class StructuredOutputParser<\n  T extends InteropZodType,\n> extends BaseOutputParser<InferInteropZodOutput<T>> {\n  static lc_name() {\n    return \"StructuredOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"structured\"];\n\n  toJSON() {\n    return this.toJSONNotImplemented();\n  }\n\n  constructor(public schema: T) {\n    super(schema);\n  }\n\n  /**\n   * Creates a new StructuredOutputParser from a Zod schema.\n   * @param schema The Zod schema which the output should match\n   * @returns A new instance of StructuredOutputParser.\n   */\n  static fromZodSchema<T extends InteropZodType>(schema: T) {\n    return new this(schema);\n  }\n\n  /**\n   * Creates a new StructuredOutputParser from a set of names and\n   * descriptions.\n   * @param schemas An object where each key is a name and each value is a description\n   * @returns A new instance of StructuredOutputParser.\n   */\n  static fromNamesAndDescriptions<S extends { [key: string]: string }>(\n    schemas: S\n  ) {\n    const zodSchema = z.object(\n      Object.fromEntries(\n        Object.entries(schemas).map(\n          ([name, description]) =>\n            [name, z.string().describe(description)] as const\n        )\n      )\n    );\n\n    return new this(zodSchema);\n  }\n\n  /**\n   * Returns a markdown code snippet with a JSON object formatted according\n   * to the schema.\n   * @param options Optional. The options for formatting the instructions\n   * @returns A markdown code snippet with a JSON object formatted according to the schema.\n   */\n  getFormatInstructions(): string {\n    return `You must format your output as a JSON value that adheres to a given \"JSON Schema\" instance.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nYour output will be parsed and type-checked according to the provided schema instance, so make sure all fields in your output match the schema exactly and there are no trailing commas!\n\nHere is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:\n\\`\\`\\`json\n${JSON.stringify(toJsonSchema(this.schema))}\n\\`\\`\\`\n`;\n  }\n\n  /**\n   * Parses the given text according to the schema.\n   * @param text The text to parse\n   * @returns The parsed output.\n   */\n  async parse(text: string): Promise<InferInteropZodOutput<T>> {\n    try {\n      const json = text.includes(\"```\")\n        ? text.trim().split(/```(?:json)?/)[1]\n        : text.trim();\n      return await interopParseAsync(this.schema, JSON.parse(json));\n    } catch {\n      try {\n        return await interopParseAsync(this.schema, JSON.parse(text.trim()));\n      } catch (e2) {\n        throw new OutputParserException(\n          `Failed to parse. Text: \"${text}\". Error: ${e2}`,\n          text\n        );\n      }\n    }\n  }\n}\n\n/**\n * A specific type of `StructuredOutputParser` that parses JSON data\n * formatted as a markdown code snippet.\n */\nexport class JsonMarkdownStructuredOutputParser<\n  T extends InteropZodType,\n> extends StructuredOutputParser<T> {\n  static lc_name() {\n    return \"JsonMarkdownStructuredOutputParser\";\n  }\n\n  getFormatInstructions(\n    options?: JsonMarkdownFormatInstructionsOptions\n  ): string {\n    const interpolationDepth = options?.interpolationDepth ?? 1;\n    if (interpolationDepth < 1) {\n      throw new Error(\"f string interpolation depth must be at least 1\");\n    }\n\n    return `Return a markdown code snippet with a JSON object formatted to look like:\\n\\`\\`\\`json\\n${this._schemaToInstruction(\n      toJsonSchema(this.schema)\n    )\n      .replaceAll(\"{\", \"{\".repeat(interpolationDepth))\n      .replaceAll(\"}\", \"}\".repeat(interpolationDepth))}\\n\\`\\`\\``;\n  }\n\n  private _schemaToInstruction(\n    schemaInput: JsonSchema7Type,\n    indent = 2\n  ): string {\n    const schema = schemaInput as Extract<\n      JsonSchema7Type,\n      | JsonSchema7ObjectType\n      | JsonSchema7ArrayType\n      | JsonSchema7StringType\n      | JsonSchema7NumberType\n      | JsonSchema7NullableType\n    >;\n\n    if (\"type\" in schema) {\n      let nullable = false;\n      let type: string;\n      if (Array.isArray(schema.type)) {\n        const nullIdx = schema.type.findIndex((type) => type === \"null\");\n        if (nullIdx !== -1) {\n          nullable = true;\n          schema.type.splice(nullIdx, 1);\n        }\n        type = schema.type.join(\" | \") as string;\n      } else {\n        type = schema.type;\n      }\n\n      if (schema.type === \"object\" && schema.properties) {\n        const description = schema.description\n          ? ` // ${schema.description}`\n          : \"\";\n        const properties = Object.entries(schema.properties)\n          .map(([key, value]) => {\n            const isOptional = schema.required?.includes(key)\n              ? \"\"\n              : \" (optional)\";\n            return `${\" \".repeat(indent)}\"${key}\": ${this._schemaToInstruction(\n              value,\n              indent + 2\n            )}${isOptional}`;\n          })\n          .join(\"\\n\");\n        return `{\\n${properties}\\n${\" \".repeat(indent - 2)}}${description}`;\n      }\n      if (schema.type === \"array\" && schema.items) {\n        const description = schema.description\n          ? ` // ${schema.description}`\n          : \"\";\n        return `array[\\n${\" \".repeat(indent)}${this._schemaToInstruction(\n          schema.items,\n          indent + 2\n        )}\\n${\" \".repeat(indent - 2)}] ${description}`;\n      }\n      const isNullable = nullable ? \" (nullable)\" : \"\";\n      const description = schema.description ? ` // ${schema.description}` : \"\";\n      return `${type}${description}${isNullable}`;\n    }\n\n    if (\"anyOf\" in schema) {\n      return schema.anyOf\n        .map((s) => this._schemaToInstruction(s, indent))\n        .join(`\\n${\" \".repeat(indent - 2)}`);\n    }\n\n    throw new Error(\"unsupported schema type\");\n  }\n\n  static fromZodSchema<T extends InteropZodType>(schema: T) {\n    return new this<T>(schema);\n  }\n\n  static fromNamesAndDescriptions<S extends { [key: string]: string }>(\n    schemas: S\n  ) {\n    const zodSchema = z.object(\n      Object.fromEntries(\n        Object.entries(schemas).map(\n          ([name, description]) =>\n            [name, z.string().describe(description)] as const\n        )\n      )\n    );\n\n    return new this<typeof zodSchema>(zodSchema);\n  }\n}\n\nexport interface AsymmetricStructuredOutputParserFields<\n  T extends InteropZodType,\n> {\n  inputSchema: T;\n}\n\n/**\n * A type of `StructuredOutputParser` that handles asymmetric input and\n * output schemas.\n */\nexport abstract class AsymmetricStructuredOutputParser<\n  T extends InteropZodType,\n  Y = unknown,\n> extends BaseOutputParser<Y> {\n  private structuredInputParser: JsonMarkdownStructuredOutputParser<T>;\n\n  constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>) {\n    super(...arguments);\n    this.structuredInputParser = new JsonMarkdownStructuredOutputParser(\n      inputSchema\n    );\n  }\n\n  /**\n   * Processes the parsed input into the desired output format. Must be\n   * implemented by subclasses.\n   * @param input The parsed input\n   * @returns The processed output.\n   */\n  abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;\n\n  async parse(text: string): Promise<Y> {\n    let parsedInput;\n    try {\n      parsedInput = await this.structuredInputParser.parse(text);\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`,\n        text\n      );\n    }\n\n    return this.outputProcessor(parsedInput);\n  }\n\n  getFormatInstructions(): string {\n    return this.structuredInputParser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;;AA6BA,IAAa,yBAAb,cAEUA,+BAAAA,iBAA2C;CACnD,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAa;CAE5D,SAAS;AACP,SAAO,KAAK,sBAAsB;;CAGpC,YAAY,QAAkB;AAC5B,QAAM,OAAO;AADI,OAAA,SAAA;;;;;;;CASnB,OAAO,cAAwC,QAAW;AACxD,SAAO,IAAI,KAAK,OAAO;;;;;;;;CASzB,OAAO,yBACL,SACA;EACA,MAAM,YAAYC,OAAAA,EAAE,OAClB,OAAO,YACL,OAAO,QAAQ,QAAQ,CAAC,KACrB,CAAC,MAAM,iBACN,CAAC,MAAMA,OAAAA,EAAE,QAAQ,CAAC,SAAS,YAAY,CAAC,CAC3C,CACF,CACF;AAED,SAAO,IAAI,KAAK,UAAU;;;;;;;;CAS5B,wBAAgC;AAC9B,SAAO;;;;;;;;;;;;EAYT,KAAK,WAAA,GAAA,kCAAA,cAAuB,KAAK,OAAO,CAAC,CAAC;;;;;;;;;CAU1C,MAAM,MAAM,MAAiD;AAC3D,MAAI;GACF,MAAM,OAAO,KAAK,SAAS,MAAM,GAC7B,KAAK,MAAM,CAAC,MAAM,eAAe,CAAC,KAClC,KAAK,MAAM;AACf,UAAO,OAAA,GAAA,4BAAA,mBAAwB,KAAK,QAAQ,KAAK,MAAM,KAAK,CAAC;UACvD;AACN,OAAI;AACF,WAAO,OAAA,GAAA,4BAAA,mBAAwB,KAAK,QAAQ,KAAK,MAAM,KAAK,MAAM,CAAC,CAAC;YAC7D,IAAI;AACX,UAAM,IAAIC,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,MAC5C,KACD;;;;;;;;;AAUT,IAAa,qCAAb,cAEU,uBAA0B;CAClC,OAAO,UAAU;AACf,SAAO;;CAGT,sBACE,SACQ;EACR,MAAM,qBAAqB,SAAS,sBAAsB;AAC1D,MAAI,qBAAqB,EACvB,OAAM,IAAI,MAAM,kDAAkD;AAGpE,SAAO,0FAA0F,KAAK,sBAAA,GAAA,kCAAA,cACvF,KAAK,OAAO,CAC1B,CACE,WAAW,KAAK,IAAI,OAAO,mBAAmB,CAAC,CAC/C,WAAW,KAAK,IAAI,OAAO,mBAAmB,CAAC,CAAC;;CAGrD,qBACE,aACA,SAAS,GACD;EACR,MAAM,SAAS;AASf,MAAI,UAAU,QAAQ;GACpB,IAAI,WAAW;GACf,IAAI;AACJ,OAAI,MAAM,QAAQ,OAAO,KAAK,EAAE;IAC9B,MAAM,UAAU,OAAO,KAAK,WAAW,SAAS,SAAS,OAAO;AAChE,QAAI,YAAY,IAAI;AAClB,gBAAW;AACX,YAAO,KAAK,OAAO,SAAS,EAAE;;AAEhC,WAAO,OAAO,KAAK,KAAK,MAAM;SAE9B,QAAO,OAAO;AAGhB,OAAI,OAAO,SAAS,YAAY,OAAO,YAAY;IACjD,MAAM,cAAc,OAAO,cACvB,OAAO,OAAO,gBACd;AAYJ,WAAO,MAXY,OAAO,QAAQ,OAAO,WAAW,CACjD,KAAK,CAAC,KAAK,WAAW;KACrB,MAAM,aAAa,OAAO,UAAU,SAAS,IAAI,GAC7C,KACA;AACJ,YAAO,GAAG,IAAI,OAAO,OAAO,CAAC,GAAG,IAAI,KAAK,KAAK,qBAC5C,OACA,SAAS,EACV,GAAG;MACJ,CACD,KAAK,KAAK,CACW,IAAI,IAAI,OAAO,SAAS,EAAE,CAAC,GAAG;;AAExD,OAAI,OAAO,SAAS,WAAW,OAAO,OAAO;IAC3C,MAAM,cAAc,OAAO,cACvB,OAAO,OAAO,gBACd;AACJ,WAAO,WAAW,IAAI,OAAO,OAAO,GAAG,KAAK,qBAC1C,OAAO,OACP,SAAS,EACV,CAAC,IAAI,IAAI,OAAO,SAAS,EAAE,CAAC,IAAI;;GAEnC,MAAM,aAAa,WAAW,gBAAgB;GAC9C,MAAM,cAAc,OAAO,cAAc,OAAO,OAAO,gBAAgB;AACvE,UAAO,GAAG,OAAO,cAAc;;AAGjC,MAAI,WAAW,OACb,QAAO,OAAO,MACX,KAAK,MAAM,KAAK,qBAAqB,GAAG,OAAO,CAAC,CAChD,KAAK,KAAK,IAAI,OAAO,SAAS,EAAE,GAAG;AAGxC,QAAM,IAAI,MAAM,0BAA0B;;CAG5C,OAAO,cAAwC,QAAW;AACxD,SAAO,IAAI,KAAQ,OAAO;;CAG5B,OAAO,yBACL,SACA;EACA,MAAM,YAAYD,OAAAA,EAAE,OAClB,OAAO,YACL,OAAO,QAAQ,QAAQ,CAAC,KACrB,CAAC,MAAM,iBACN,CAAC,MAAMA,OAAAA,EAAE,QAAQ,CAAC,SAAS,YAAY,CAAC,CAC3C,CACF,CACF;AAED,SAAO,IAAI,KAAuB,UAAU;;;;;;;AAchD,IAAsB,mCAAtB,cAGUD,+BAAAA,iBAAoB;CAC5B;CAEA,YAAY,EAAE,eAA0D;AACtE,QAAM,GAAG,UAAU;AACnB,OAAK,wBAAwB,IAAI,mCAC/B,YACD;;CAWH,MAAM,MAAM,MAA0B;EACpC,IAAI;AACJ,MAAI;AACF,iBAAc,MAAM,KAAK,sBAAsB,MAAM,KAAK;WACnD,GAAG;AACV,SAAM,IAAIE,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,KAC5C,KACD;;AAGH,SAAO,KAAK,gBAAgB,YAAY;;CAG1C,wBAAgC;AAC9B,SAAO,KAAK,sBAAsB,uBAAuB"}
+{"version":3,"file":"structured.cjs","names":["BaseOutputParser","z","OutputParserException"],"sources":["../../src/output_parsers/structured.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport {\n  toJsonSchema,\n  type JsonSchema7Type,\n  type JsonSchema7ArrayType,\n  type JsonSchema7ObjectType,\n  type JsonSchema7StringType,\n  type JsonSchema7NumberType,\n  type JsonSchema7NullableType,\n} from \"@langchain/core/utils/json_schema\";\nimport {\n  BaseOutputParser,\n  FormatInstructionsOptions,\n  OutputParserException,\n} from \"@langchain/core/output_parsers\";\nimport {\n  interopParseAsync,\n  type InferInteropZodOutput,\n  type InteropZodType,\n} from \"@langchain/core/utils/types\";\n\nexport type JsonMarkdownStructuredOutputParserInput = {\n  interpolationDepth?: number;\n};\n\nexport interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {\n  interpolationDepth?: number;\n}\n\nexport class StructuredOutputParser<\n  T extends InteropZodType,\n> extends BaseOutputParser<InferInteropZodOutput<T>> {\n  static lc_name() {\n    return \"StructuredOutputParser\";\n  }\n\n  lc_namespace = [\"langchain\", \"output_parsers\", \"structured\"];\n\n  toJSON() {\n    return this.toJSONNotImplemented();\n  }\n\n  constructor(public schema: T) {\n    super(schema);\n  }\n\n  /**\n   * Creates a new StructuredOutputParser from a Zod schema.\n   * @param schema The Zod schema which the output should match\n   * @returns A new instance of StructuredOutputParser.\n   */\n  static fromZodSchema<T extends InteropZodType>(schema: T) {\n    return new this(schema);\n  }\n\n  /**\n   * Creates a new StructuredOutputParser from a set of names and\n   * descriptions.\n   * @param schemas An object where each key is a name and each value is a description\n   * @returns A new instance of StructuredOutputParser.\n   */\n  static fromNamesAndDescriptions<S extends { [key: string]: string }>(\n    schemas: S\n  ) {\n    const zodSchema = z.object(\n      Object.fromEntries(\n        Object.entries(schemas).map(\n          ([name, description]) =>\n            [name, z.string().describe(description)] as const\n        )\n      )\n    );\n\n    return new this(zodSchema);\n  }\n\n  /**\n   * Returns a markdown code snippet with a JSON object formatted according\n   * to the schema.\n   * @param options Optional. The options for formatting the instructions\n   * @returns A markdown code snippet with a JSON object formatted according to the schema.\n   */\n  getFormatInstructions(): string {\n    return `You must format your output as a JSON value that adheres to a given \"JSON Schema\" instance.\n\n\"JSON Schema\" is a declarative language that allows you to annotate and validate JSON documents.\n\nFor example, the example \"JSON Schema\" instance {{\"properties\": {{\"foo\": {{\"description\": \"a list of test words\", \"type\": \"array\", \"items\": {{\"type\": \"string\"}}}}}}, \"required\": [\"foo\"]}}}}\nwould match an object with one required property, \"foo\". The \"type\" property specifies \"foo\" must be an \"array\", and the \"description\" property semantically describes it as \"a list of test words\". The items within \"foo\" must be strings.\nThus, the object {{\"foo\": [\"bar\", \"baz\"]}} is a well-formatted instance of this example \"JSON Schema\". The object {{\"properties\": {{\"foo\": [\"bar\", \"baz\"]}}}} is not well-formatted.\n\nYour output will be parsed and type-checked according to the provided schema instance, so make sure all fields in your output match the schema exactly and there are no trailing commas!\n\nHere is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:\n\\`\\`\\`json\n${JSON.stringify(toJsonSchema(this.schema))}\n\\`\\`\\`\n`;\n  }\n\n  /**\n   * Parses the given text according to the schema.\n   * @param text The text to parse\n   * @returns The parsed output.\n   */\n  async parse(text: string): Promise<InferInteropZodOutput<T>> {\n    try {\n      const json = text.includes(\"```\")\n        ? text.trim().split(/```(?:json)?/)[1]\n        : text.trim();\n      return await interopParseAsync(this.schema, JSON.parse(json));\n    } catch {\n      try {\n        return await interopParseAsync(this.schema, JSON.parse(text.trim()));\n      } catch (e2) {\n        throw new OutputParserException(\n          `Failed to parse. Text: \"${text}\". Error: ${e2}`,\n          text\n        );\n      }\n    }\n  }\n}\n\n/**\n * A specific type of `StructuredOutputParser` that parses JSON data\n * formatted as a markdown code snippet.\n */\nexport class JsonMarkdownStructuredOutputParser<\n  T extends InteropZodType,\n> extends StructuredOutputParser<T> {\n  static lc_name() {\n    return \"JsonMarkdownStructuredOutputParser\";\n  }\n\n  getFormatInstructions(\n    options?: JsonMarkdownFormatInstructionsOptions\n  ): string {\n    const interpolationDepth = options?.interpolationDepth ?? 1;\n    if (interpolationDepth < 1) {\n      throw new Error(\"f string interpolation depth must be at least 1\");\n    }\n\n    return `Return a markdown code snippet with a JSON object formatted to look like:\\n\\`\\`\\`json\\n${this._schemaToInstruction(\n      toJsonSchema(this.schema)\n    )\n      .replaceAll(\"{\", \"{\".repeat(interpolationDepth))\n      .replaceAll(\"}\", \"}\".repeat(interpolationDepth))}\\n\\`\\`\\``;\n  }\n\n  private _schemaToInstruction(\n    schemaInput: JsonSchema7Type,\n    indent = 2\n  ): string {\n    const schema = schemaInput as Extract<\n      JsonSchema7Type,\n      | JsonSchema7ObjectType\n      | JsonSchema7ArrayType\n      | JsonSchema7StringType\n      | JsonSchema7NumberType\n      | JsonSchema7NullableType\n    >;\n\n    if (\"type\" in schema) {\n      let nullable = false;\n      let type: string;\n      if (Array.isArray(schema.type)) {\n        const nullIdx = schema.type.findIndex((type) => type === \"null\");\n        if (nullIdx !== -1) {\n          nullable = true;\n          schema.type.splice(nullIdx, 1);\n        }\n        type = schema.type.join(\" | \") as string;\n      } else {\n        type = schema.type;\n      }\n\n      if (schema.type === \"object\" && schema.properties) {\n        const description = schema.description\n          ? ` // ${schema.description}`\n          : \"\";\n        const properties = Object.entries(schema.properties)\n          .map(([key, value]) => {\n            const isOptional = schema.required?.includes(key)\n              ? \"\"\n              : \" (optional)\";\n            return `${\" \".repeat(indent)}\"${key}\": ${this._schemaToInstruction(\n              value,\n              indent + 2\n            )}${isOptional}`;\n          })\n          .join(\"\\n\");\n        return `{\\n${properties}\\n${\" \".repeat(indent - 2)}}${description}`;\n      }\n      if (schema.type === \"array\" && schema.items) {\n        const description = schema.description\n          ? ` // ${schema.description}`\n          : \"\";\n        return `array[\\n${\" \".repeat(indent)}${this._schemaToInstruction(\n          schema.items,\n          indent + 2\n        )}\\n${\" \".repeat(indent - 2)}] ${description}`;\n      }\n      const isNullable = nullable ? \" (nullable)\" : \"\";\n      const description = schema.description ? ` // ${schema.description}` : \"\";\n      return `${type}${description}${isNullable}`;\n    }\n\n    if (\"anyOf\" in schema) {\n      return schema.anyOf\n        .map((s) => this._schemaToInstruction(s, indent))\n        .join(`\\n${\" \".repeat(indent - 2)}`);\n    }\n\n    throw new Error(\"unsupported schema type\");\n  }\n\n  static fromZodSchema<T extends InteropZodType>(schema: T) {\n    return new this<T>(schema);\n  }\n\n  static fromNamesAndDescriptions<S extends { [key: string]: string }>(\n    schemas: S\n  ) {\n    const zodSchema = z.object(\n      Object.fromEntries(\n        Object.entries(schemas).map(\n          ([name, description]) =>\n            [name, z.string().describe(description)] as const\n        )\n      )\n    );\n\n    return new this<typeof zodSchema>(zodSchema);\n  }\n}\n\nexport interface AsymmetricStructuredOutputParserFields<\n  T extends InteropZodType,\n> {\n  inputSchema: T;\n}\n\n/**\n * A type of `StructuredOutputParser` that handles asymmetric input and\n * output schemas.\n */\nexport abstract class AsymmetricStructuredOutputParser<\n  T extends InteropZodType,\n  Y = unknown,\n> extends BaseOutputParser<Y> {\n  private structuredInputParser: JsonMarkdownStructuredOutputParser<T>;\n\n  constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>) {\n    super(...arguments);\n    this.structuredInputParser = new JsonMarkdownStructuredOutputParser(\n      inputSchema\n    );\n  }\n\n  /**\n   * Processes the parsed input into the desired output format. Must be\n   * implemented by subclasses.\n   * @param input The parsed input\n   * @returns The processed output.\n   */\n  abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;\n\n  async parse(text: string): Promise<Y> {\n    let parsedInput;\n    try {\n      parsedInput = await this.structuredInputParser.parse(text);\n    } catch (e) {\n      throw new OutputParserException(\n        `Failed to parse. Text: \"${text}\". Error: ${e}`,\n        text\n      );\n    }\n\n    return this.outputProcessor(parsedInput);\n  }\n\n  getFormatInstructions(): string {\n    return this.structuredInputParser.getFormatInstructions();\n  }\n}\n"],"mappings":";;;;;;AA6BA,IAAa,yBAAb,cAEUA,+BAAAA,iBAA2C;CACnD,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe;EAAC;EAAa;EAAkB;EAAa;CAE5D,SAAS;AACP,SAAO,KAAK,sBAAsB;;CAGpC,YAAY,QAAkB;AAC5B,QAAM,OAAO;AADI,OAAA,SAAA;;;;;;;CASnB,OAAO,cAAwC,QAAW;AACxD,SAAO,IAAI,KAAK,OAAO;;;;;;;;CASzB,OAAO,yBACL,SACA;EACA,MAAM,YAAYC,OAAAA,EAAE,OAClB,OAAO,YACL,OAAO,QAAQ,QAAQ,CAAC,KACrB,CAAC,MAAM,iBACN,CAAC,MAAMA,OAAAA,EAAE,QAAQ,CAAC,SAAS,YAAY,CAAC,CAC3C,CACF,CACF;AAED,SAAO,IAAI,KAAK,UAAU;;;;;;;;CAS5B,wBAAgC;AAC9B,SAAO;;;;;;;;;;;;EAYT,KAAK,WAAA,GAAA,kCAAA,cAAuB,KAAK,OAAO,CAAC,CAAC;;;;;;;;;CAU1C,MAAM,MAAM,MAAiD;AAC3D,MAAI;GACF,MAAM,OAAO,KAAK,SAAS,MAAM,GAC7B,KAAK,MAAM,CAAC,MAAM,eAAe,CAAC,KAClC,KAAK,MAAM;AACf,UAAO,OAAA,GAAA,4BAAA,mBAAwB,KAAK,QAAQ,KAAK,MAAM,KAAK,CAAC;UACvD;AACN,OAAI;AACF,WAAO,OAAA,GAAA,4BAAA,mBAAwB,KAAK,QAAQ,KAAK,MAAM,KAAK,MAAM,CAAC,CAAC;YAC7D,IAAI;AACX,UAAM,IAAIC,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,MAC5C,KACD;;;;;;;;;AAUT,IAAa,qCAAb,cAEU,uBAA0B;CAClC,OAAO,UAAU;AACf,SAAO;;CAGT,sBACE,SACQ;EACR,MAAM,qBAAqB,SAAS,sBAAsB;AAC1D,MAAI,qBAAqB,EACvB,OAAM,IAAI,MAAM,kDAAkD;AAGpE,SAAO,0FAA0F,KAAK,sBAAA,GAAA,kCAAA,cACvF,KAAK,OAAO,CAC1B,CACE,WAAW,KAAK,IAAI,OAAO,mBAAmB,CAAC,CAC/C,WAAW,KAAK,IAAI,OAAO,mBAAmB,CAAC,CAAC;;CAGrD,qBACE,aACA,SAAS,GACD;EACR,MAAM,SAAS;AASf,MAAI,UAAU,QAAQ;GACpB,IAAI,WAAW;GACf,IAAI;AACJ,OAAI,MAAM,QAAQ,OAAO,KAAK,EAAE;IAC9B,MAAM,UAAU,OAAO,KAAK,WAAW,SAAS,SAAS,OAAO;AAChE,QAAI,YAAY,IAAI;AAClB,gBAAW;AACX,YAAO,KAAK,OAAO,SAAS,EAAE;;AAEhC,WAAO,OAAO,KAAK,KAAK,MAAM;SAE9B,QAAO,OAAO;AAGhB,OAAI,OAAO,SAAS,YAAY,OAAO,YAAY;IACjD,MAAM,cAAc,OAAO,cACvB,OAAO,OAAO,gBACd;AAYJ,WAAO,MAXY,OAAO,QAAQ,OAAO,WAAW,CACjD,KAAK,CAAC,KAAK,WAAW;KACrB,MAAM,aAAa,OAAO,UAAU,SAAS,IAAI,GAC7C,KACA;AACJ,YAAO,GAAG,IAAI,OAAO,OAAO,CAAC,GAAG,IAAI,KAAK,KAAK,qBAC5C,OACA,SAAS,EACV,GAAG;MACJ,CACD,KAAK,KACe,CAAC,IAAI,IAAI,OAAO,SAAS,EAAE,CAAC,GAAG;;AAExD,OAAI,OAAO,SAAS,WAAW,OAAO,OAAO;IAC3C,MAAM,cAAc,OAAO,cACvB,OAAO,OAAO,gBACd;AACJ,WAAO,WAAW,IAAI,OAAO,OAAO,GAAG,KAAK,qBAC1C,OAAO,OACP,SAAS,EACV,CAAC,IAAI,IAAI,OAAO,SAAS,EAAE,CAAC,IAAI;;GAEnC,MAAM,aAAa,WAAW,gBAAgB;GAC9C,MAAM,cAAc,OAAO,cAAc,OAAO,OAAO,gBAAgB;AACvE,UAAO,GAAG,OAAO,cAAc;;AAGjC,MAAI,WAAW,OACb,QAAO,OAAO,MACX,KAAK,MAAM,KAAK,qBAAqB,GAAG,OAAO,CAAC,CAChD,KAAK,KAAK,IAAI,OAAO,SAAS,EAAE,GAAG;AAGxC,QAAM,IAAI,MAAM,0BAA0B;;CAG5C,OAAO,cAAwC,QAAW;AACxD,SAAO,IAAI,KAAQ,OAAO;;CAG5B,OAAO,yBACL,SACA;EACA,MAAM,YAAYD,OAAAA,EAAE,OAClB,OAAO,YACL,OAAO,QAAQ,QAAQ,CAAC,KACrB,CAAC,MAAM,iBACN,CAAC,MAAMA,OAAAA,EAAE,QAAQ,CAAC,SAAS,YAAY,CAAC,CAC3C,CACF,CACF;AAED,SAAO,IAAI,KAAuB,UAAU;;;;;;;AAchD,IAAsB,mCAAtB,cAGUD,+BAAAA,iBAAoB;CAC5B;CAEA,YAAY,EAAE,eAA0D;AACtE,QAAM,GAAG,UAAU;AACnB,OAAK,wBAAwB,IAAI,mCAC/B,YACD;;CAWH,MAAM,MAAM,MAA0B;EACpC,IAAI;AACJ,MAAI;AACF,iBAAc,MAAM,KAAK,sBAAsB,MAAM,KAAK;WACnD,GAAG;AACV,SAAM,IAAIE,+BAAAA,sBACR,2BAA2B,KAAK,YAAY,KAC5C,KACD;;AAGH,SAAO,KAAK,gBAAgB,YAAY;;CAG1C,wBAAgC;AAC9B,SAAO,KAAK,sBAAsB,uBAAuB"}