@langchain/classic 1.0.17 → 1.0.18

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

@@ -1 +1 @@
-{"version":3,"file":"identifier_handler.js","names":["node: ExpressionNode","node: Identifier"],"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,QAAQA,MAAqD;AACjE,MAAI,UAAU,aAAa,KAAK,CAC9B,QAAO;MAEP,QAAO;CAEV;;;;;;;;;;CAWD,MAAM,OAAOC,MAA2C;AACtD,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,OAAO,KAAK,KAAK,QAAQ,2BAA2B,KAAK;AAC/D,SAAO;GAAE,MAAM;GAAc,OAAO;EAAM;CAC3C;AACF"}
+{"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: MemberExpression","prop: string","identifier: string"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,cAA6CA,yBAAY;;;;;;;CAOvD,MAAM,QAAQC,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,EAAE,QAAQ,UAAU,GAAG;EAC7B,IAAIC;AACJ,MAAIF,uBAAU,aAAa,SAAS,EAClC,OAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpDA,uBAAU,gBAAgB,SAAS,EAC5C,OAAQ,GAAG,SAAS,OAAO,CAAY,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;EAElB,IAAIG;AACJ,MAAIH,uBAAU,aAAa,OAAO,EAChC,aAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxDA,uBAAU,gBAAgB,OAAO,EAC1C,aAAc,GAAG,OAAO,OAAO,CAAY,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;AAElB,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM;AAGlB,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;EAAM;CACjE;AACF"}
+{"version":3,"file":"member_expression_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,cAA6CA,yBAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAIA,uBAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpDA,uBAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAIA,uBAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxDA,uBAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}

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

@@ -1 +1 @@
-{"version":3,"file":"member_expression_handler.js","names":["node: ExpressionNode","node: MemberExpression","prop: string","identifier: string"],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;;;;;;;CAOvD,MAAM,QAAQA,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,EAAE,QAAQ,UAAU,GAAG;EAC7B,IAAIC;AACJ,MAAI,UAAU,aAAa,SAAS,EAClC,OAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpD,UAAU,gBAAgB,SAAS,EAC5C,OAAQ,GAAG,SAAS,OAAO,CAAY,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;EAElB,IAAIC;AACJ,MAAI,UAAU,aAAa,OAAO,EAChC,aAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxD,UAAU,gBAAgB,OAAO,EAC1C,aAAc,GAAG,OAAO,OAAO,CAAY,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM;AAElB,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM;AAGlB,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;EAAM;CACjE;AACF"}
+{"version":3,"file":"member_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/member_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { MemberExpressionType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  MemberExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles member expressions in the LangChain Expression Language (LCEL).\n * Extends the NodeHandler base class.\n */\nexport class MemberExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a member expression. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns The node if it is a member expression, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<MemberExpression | boolean> {\n    if (ASTParser.isMemberExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a member expression node. It extracts the object and property\n   * from the node, validates their types, and returns an object with the\n   * type of the expression, the identifier, and the property.\n   * @param node The member expression node to process.\n   * @returns An object with the type of the expression, the identifier, and the property.\n   */\n  async handle(node: MemberExpression): Promise<MemberExpressionType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const { object, property } = node;\n    let prop: string;\n    if (ASTParser.isIdentifier(property)) {\n      prop = property.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(property)) {\n      prop = (`${property.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid property key type\");\n    }\n    let identifier: string;\n    if (ASTParser.isIdentifier(object)) {\n      identifier = object.name.replace(/^[\"'](.+(?=[\"']$))[\"']$/, \"$1\");\n    } else if (ASTParser.isStringLiteral(object)) {\n      identifier = (`${object.value}` as string).replace(\n        /^[\"'](.+(?=[\"']$))[\"']$/,\n        \"$1\"\n      );\n    } else {\n      throw new Error(\"Invalid object type\");\n    }\n    if (object.type !== \"Identifier\" && object.type !== \"StringLiteral\") {\n      throw new Error(\"ArrayExpression is not supported\");\n    }\n\n    return { type: \"member_expression\", identifier, property: prop };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;;;;;;;CAOvD,MAAM,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAAuD;AAClE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,EAAE,QAAQ,aAAa;EAC7B,IAAI;AACJ,MAAI,UAAU,aAAa,SAAS,CAClC,QAAO,SAAS,KAAK,QAAQ,2BAA2B,KAAK;WACpD,UAAU,gBAAgB,SAAS,CAC5C,QAAQ,GAAG,SAAS,QAAmB,QACrC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,4BAA4B;EAE9C,IAAI;AACJ,MAAI,UAAU,aAAa,OAAO,CAChC,cAAa,OAAO,KAAK,QAAQ,2BAA2B,KAAK;WACxD,UAAU,gBAAgB,OAAO,CAC1C,cAAc,GAAG,OAAO,QAAmB,QACzC,2BACA,KACD;MAED,OAAM,IAAI,MAAM,sBAAsB;AAExC,MAAI,OAAO,SAAS,gBAAgB,OAAO,SAAS,gBAClD,OAAM,IAAI,MAAM,mCAAmC;AAGrD,SAAO;GAAE,MAAM;GAAqB;GAAY,UAAU;GAAM"}

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

@@ -1 +1 @@
-{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: NumericLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2CA,yBAAY;;;;;;;CAOrD,MAAM,QAAQC,MAAyD;AACrE,MAAIC,uBAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;EAC1B;CACF;AACF"}
+{"version":3,"file":"numeric_literal_handler.cjs","names":["NodeHandler","ASTParser"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2CA,yBAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAIC,uBAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}

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

@@ -1 +1 @@
-{"version":3,"file":"numeric_literal_handler.js","names":["node: ExpressionNode","node: NumericLiteral"],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQA,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;AAGJ,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;EAC1B;CACF;AACF"}
+{"version":3,"file":"numeric_literal_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/numeric_literal_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { NumericLiteralType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  NumericLiteral,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handler for numeric literal nodes in an abstract syntax tree (AST).\n * Extends the NodeHandler class.\n */\nexport class NumericLiteralHandler extends NodeHandler {\n  /**\n   * Checks if a given node is a numeric literal. If it is, the method\n   * returns the node; otherwise, it returns false.\n   * @param node The node to check.\n   * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.\n   */\n  async accepts(node: ExpressionNode): Promise<NumericLiteral | boolean> {\n    if (ASTParser.isNumericLiteral(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes a numeric literal node and returns a NumericLiteralType\n   * object representing it.\n   * @param node The numeric literal node to process.\n   * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.\n   */\n  async handle(node: NumericLiteral): Promise<NumericLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    return {\n      type: \"numeric_literal\",\n      value: Number(node.value),\n    };\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,wBAAb,cAA2C,YAAY;;;;;;;CAOrD,MAAM,QAAQ,MAAyD;AACrE,MAAI,UAAU,iBAAiB,KAAK,CAClC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAmD;AAC9D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;AAEH,SAAO;GACL,MAAM;GACN,OAAO,OAAO,KAAK,MAAM;GAC1B"}

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

@@ -1 +1 @@
-{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: ObjectExpression","values: PropertyAssignmentType[]","PropertyAssignmentHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iCAAb,cAAoDA,yBAAY;;;;;;;CAO9D,MAAM,QAAQC,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAMC,SAAmC,CAAE;EAC3C,MAAM,EAAE,YAAY,GAAG;AACvB,OAAK,MAAM,YAAY,WACrB,KAAIF,uBAAU,qBAAqB,SAAS,EAC1C,OAAO,KACL,MAAM,IAAIG,8DAA0B,KAAK,eAAe,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;EAAQ;CAC1C;AACF"}
+{"version":3,"file":"object_literal_expression_handler.cjs","names":["NodeHandler","ASTParser","PropertyAssignmentHandler"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iCAAb,cAAoDA,yBAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;AACvE,MAAIC,uBAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAIA,uBAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAIC,8DAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}

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

@@ -1 +1 @@
-{"version":3,"file":"object_literal_expression_handler.js","names":["node: ExpressionNode","node: ObjectExpression","values: PropertyAssignmentType[]"],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iCAAb,cAAoD,YAAY;;;;;;;CAO9D,MAAM,QAAQA,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAMC,SAAmC,CAAE;EAC3C,MAAM,EAAE,YAAY,GAAG;AACvB,OAAK,MAAM,YAAY,WACrB,KAAI,UAAU,qBAAqB,SAAS,EAC1C,OAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,eAAe,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;EAAQ;CAC1C;AACF"}
+{"version":3,"file":"object_literal_expression_handler.js","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts"],"sourcesContent":["import { NodeHandler, ASTParser } from \"./base.js\";\nimport { PropertyAssignmentHandler } from \"./property_assignment_handler.js\";\nimport { ObjectLiteralType, PropertyAssignmentType } from \"./types.js\";\nimport type {\n  ExpressionNode,\n  ObjectExpression,\n} from \"../../types/expression-parser.js\";\n\n/**\n * Handles object literal expressions in the LangChain Expression\n * Language. Extends the NodeHandler class.\n */\nexport class ObjectLiteralExpressionHandler extends NodeHandler {\n  /**\n   * Checks if a given node is an object expression. Returns the node if it\n   * is, otherwise returns false.\n   * @param node The node to check.\n   * @returns The node if it is an object expression, otherwise false.\n   */\n  async accepts(node: ExpressionNode): Promise<ObjectExpression | boolean> {\n    if (ASTParser.isObjectExpression(node)) {\n      return node;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * Processes the object expression node and returns an object of type\n   * ObjectLiteralType. Throws an error if the parent handler is not set.\n   * @param node The object expression node to process.\n   * @returns An object of type ObjectLiteralType.\n   */\n  async handle(node: ObjectExpression): Promise<ObjectLiteralType> {\n    if (!this.parentHandler) {\n      throw new Error(\n        \"ArrayLiteralExpressionHandler must have a parent handler\"\n      );\n    }\n    const values: PropertyAssignmentType[] = [];\n    const { properties } = node;\n    for (const property of properties) {\n      if (ASTParser.isPropertyAssignment(property)) {\n        values.push(\n          await new PropertyAssignmentHandler(this.parentHandler).handle(\n            property\n          )\n        );\n      }\n    }\n    return { type: \"object_literal\", values };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,IAAa,iCAAb,cAAoD,YAAY;;;;;;;CAO9D,MAAM,QAAQ,MAA2D;AACvE,MAAI,UAAU,mBAAmB,KAAK,CACpC,QAAO;MAEP,QAAO;;;;;;;;CAUX,MAAM,OAAO,MAAoD;AAC/D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,MAAM,SAAmC,EAAE;EAC3C,MAAM,EAAE,eAAe;AACvB,OAAK,MAAM,YAAY,WACrB,KAAI,UAAU,qBAAqB,SAAS,CAC1C,QAAO,KACL,MAAM,IAAI,0BAA0B,KAAK,cAAc,CAAC,OACtD,SACD,CACF;AAGL,SAAO;GAAE,MAAM;GAAkB;GAAQ"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -30,12 +30,10 @@ var PropertyAssignmentHandler = class extends require_base.NodeHandler {
 		else if (require_base.ASTParser.isStringLiteral(node.key)) name = node.key.value;
 		else throw new Error("Invalid property key type");
 		if (!name) throw new Error("Invalid property key");
-		const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		const value = await this.parentHandler.handle(node.value);
 		return {
 			type: "property_assignment",
-			identifier,
-			value
+			identifier: `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1"),
+			value: await this.parentHandler.handle(node.value)
 		};
 	}
 };

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

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: PropertyAssignment"],"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,yBAAY;;;;;;;CAOzD,MAAM,QAAQC,MAA6D;AACzE,MAAIC,uBAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,IAAI;AACJ,MAAID,uBAAU,aAAa,KAAK,IAAI,EAClC,OAAO,KAAK,IAAI;WACPA,uBAAU,gBAAgB,KAAK,IAAI,EAC5C,OAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM;AAElB,MAAI,CAAC,KACH,OAAM,IAAI,MAAM;EAElB,MAAM,aAAc,GAAG,MAAM,CAAY,QACvC,2BACA,KACD;EACD,MAAM,QAAQ,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;AACzD,SAAO;GAAE,MAAM;GAAuB;GAAY;EAAO;CAC1D;AACF"}
+{"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,yBAAY;;;;;;;CAOzD,MAAM,QAAQ,MAA6D;AACzE,MAAIC,uBAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;;;;;;;;;CAWX,MAAM,OAAO,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR,2DACD;EAEH,IAAI;AACJ,MAAIA,uBAAU,aAAa,KAAK,IAAI,CAClC,QAAO,KAAK,IAAI;WACPA,uBAAU,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"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -30,12 +30,10 @@ var PropertyAssignmentHandler = class extends NodeHandler {
 		else if (ASTParser.isStringLiteral(node.key)) name = node.key.value;
 		else throw new Error("Invalid property key type");
 		if (!name) throw new Error("Invalid property key");
-		const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
-		const value = await this.parentHandler.handle(node.value);
 		return {
 			type: "property_assignment",
-			identifier,
-			value
+			identifier: `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1"),
+			value: await this.parentHandler.handle(node.value)
 		};
 	}
 };

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

@@ -1 +1 @@
-{"version":3,"file":"property_assignment_handler.js","names":["node: ExpressionNode","node: PropertyAssignment"],"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,QAAQA,MAA6D;AACzE,MAAI,UAAU,qBAAqB,KAAK,CACtC,QAAO;MAEP,QAAO;CAEV;;;;;;;;CASD,MAAM,OAAOC,MAA2D;AACtE,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,IAAI;AACJ,MAAI,UAAU,aAAa,KAAK,IAAI,EAClC,OAAO,KAAK,IAAI;WACP,UAAU,gBAAgB,KAAK,IAAI,EAC5C,OAAO,KAAK,IAAI;MAEhB,OAAM,IAAI,MAAM;AAElB,MAAI,CAAC,KACH,OAAM,IAAI,MAAM;EAElB,MAAM,aAAc,GAAG,MAAM,CAAY,QACvC,2BACA,KACD;EACD,MAAM,QAAQ,MAAM,KAAK,cAAc,OAAO,KAAK,MAAM;AACzD,SAAO;GAAE,MAAM;GAAuB;GAAY;EAAO;CAC1D;AACF"}
+{"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"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -24,10 +24,9 @@ var StringLiteralHandler = class extends require_base.NodeHandler {
 	*/
 	async handle(node) {
 		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
 		return {
 			type: "string_literal",
-			value: text
+			value: `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1")
 		};
 	}
 };

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

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.cjs","names":["NodeHandler","node: ExpressionNode","ASTParser","node: StringLiteral"],"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,yBAAY;;;;;;;CAOpD,MAAM,QAAQC,MAAwD;AACpE,MAAIC,uBAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,OAAQ,GAAG,KAAK,OAAO,CAAY,QACvC,2BACA,KACD;AACD,SAAO;GAAE,MAAM;GAAkB,OAAO;EAAM;CAC/C;AACF"}
+{"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,yBAAY;;;;;;;CAOpD,MAAM,QAAQ,MAAwD;AACpE,MAAIC,uBAAU,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"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -24,10 +24,9 @@ var StringLiteralHandler = class extends NodeHandler {
 	*/
 	async handle(node) {
 		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const text = `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
 		return {
 			type: "string_literal",
-			value: text
+			value: `${node.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1")
 		};
 	}
 };

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

@@ -1 +1 @@
-{"version":3,"file":"string_literal_handler.js","names":["node: ExpressionNode","node: StringLiteral"],"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,QAAQA,MAAwD;AACpE,MAAI,UAAU,gBAAgB,KAAK,CACjC,QAAO;MAEP,QAAO;CAEV;;;;;;;CAQD,MAAM,OAAOC,MAAiD;AAC5D,MAAI,CAAC,KAAK,cACR,OAAM,IAAI,MACR;EAGJ,MAAM,OAAQ,GAAG,KAAK,OAAO,CAAY,QACvC,2BACA,KACD;AACD,SAAO;GAAE,MAAM;GAAkB,OAAO;EAAM;CAC/C;AACF"}
+{"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"}

package/dist/output_parsers/expression_type_handlers/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["ArgumentsType","IdentifierType","StringLiteralType","NumericLiteralType","ArrayLiteralType","ObjectLiteralType","CallExpressionType","BooleanLiteralType","ParsedType","PropertyAssignmentType","MemberExpressionType"],"sources":["../../../src/output_parsers/expression_type_handlers/types.d.ts"],"sourcesContent":["/**\n * Represents the different types of arguments that can be used in\n * LangChain.\n */\nexport type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;\n/**\n * Represents the parsed types in LangChain, which can be either an\n * ArgumentsType or a PropertyAssignmentType.\n */\nexport type ParsedType = ArgumentsType | PropertyAssignmentType;\n/**\n * Represents an array literal in LangChain. It has a type property set to\n * 'array_literal' and a values property which is an array of\n * ArgumentsType.\n */\nexport type ArrayLiteralType = {\n    type: \"array_literal\";\n    values: ArgumentsType[];\n};\n/**\n * Represents a boolean literal in LangChain. It has a type property set\n * to 'boolean_literal' and a value property which is a boolean.\n */\nexport type BooleanLiteralType = {\n    type: \"boolean_literal\";\n    value: boolean;\n};\n/**\n * Represents a call expression in LangChain. It has a type property set\n * to 'call_expression', a funcCall property which can be a string or a\n * MemberExpressionType, and an optional args property which is an array\n * of ArgumentsType.\n */\nexport type CallExpressionType = {\n    type: \"call_expression\";\n    funcCall: string | MemberExpressionType;\n    args?: ArgumentsType[];\n};\n/**\n * Represents a numeric literal in LangChain. It has a type property set\n * to 'numeric_literal' and a value property which is a number.\n */\nexport type NumericLiteralType = {\n    type: \"numeric_literal\";\n    value: number;\n};\n/**\n * Represents an object literal in LangChain. It has a type property set\n * to 'object_literal' and a values property which is an array of\n * PropertyAssignmentType.\n */\nexport type ObjectLiteralType = {\n    type: \"object_literal\";\n    values: PropertyAssignmentType[];\n};\n/**\n * Represents a member expression in LangChain. It has a type property set\n * to 'member_expression', an identifier property which is a string, and a\n * property property which is also a string.\n */\nexport type MemberExpressionType = {\n    type: \"member_expression\";\n    identifier: string;\n    property: string;\n};\n/**\n * Represents a property assignment in LangChain. It has a type property\n * set to 'property_assignment', an identifier property which is a string,\n * and a value property which is an ArgumentsType.\n */\nexport type PropertyAssignmentType = {\n    type: \"property_assignment\";\n    identifier: string;\n    value: ArgumentsType;\n};\n/**\n * Represents a string literal in LangChain. It has a type property set to\n * 'string_literal' and a value property which is a string.\n */\nexport type StringLiteralType = {\n    type: \"string_literal\";\n    value: string;\n};\n/**\n * Represents an identifier in LangChain. It has a type property set to\n * 'identifier' and a value property which is a string.\n */\nexport type IdentifierType = {\n    type: \"identifier\";\n    value: string;\n};\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;AAIA;;;AAAiEG,KAArDH,aAAAA,GAAgBC,cAAqCE,GAApBD,iBAAoBC,GAAAA,kBAAAA,GAAqBC,gBAArBD,GAAwCE,iBAAxCF,GAA4DG,kBAA5DH,GAAiFI,kBAAjFJ;;;;;AAAmG,KAKxJK,UAAAA,GAAaR,aAL2I,GAK3HS,sBAL2H;AAKpK;AAMA;AAQA;AAUA;AASA;AASYJ,KApCAD,gBAAAA,GAoCiB;EASjBM,IAAAA,EAAAA,eAAAA;EAUAD,MAAAA,EArDAT,aAqDAS,EAAAA;AASZ,CAAA;AAQA;;;;KAhEYF,kBAAAA;;;;;;;;;;KAUAD,kBAAAA;;qBAEWI;SACZV;;;;;;KAMCG,kBAAAA;;;;;;;;;KASAE,iBAAAA;;UAEAI;;;;;;;KAOAC,oBAAAA;;;;;;;;;;KAUAD,sBAAAA;;;SAGDT;;;;;;KAMCE,iBAAAA;;;;;;;;KAQAD,cAAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/types.ts"],"mappings":";;AAIA;;;KAAY,aAAA,GACR,cAAA,GACA,iBAAA,GACA,kBAAA,GACA,gBAAA,GACA,iBAAA,GACA,kBAAA,GACA,kBAAA;;;;;KAMQ,UAAA,GAAa,aAAA,GAAgB,sBAAA;;;;;;KAO7B,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,aAAA;AAAA;;;;AATV;KAgBY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;AAXF;;;;;;AAAA,KAoBY,kBAAA;EACV,IAAA;EACA,QAAA,WAAmB,oBAAA;EACnB,IAAA,GAAO,aAAA;AAAA;;;;AAHT;KAUY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;;;;KAQU,iBAAA;EACV,IAAA;EACA,MAAA,EAAQ,sBAAA;AAAA;;;AAFV;;;KAUY,oBAAA;EACV,IAAA;EACA,UAAA;EACA,QAAA;AAAA;;AAHF;;;;KAWY,sBAAA;EACV,IAAA;EACA,UAAA;EACA,KAAA,EAAO,aAAA;AAAA;AAHT;;;;AAAA,KAUY,iBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;AAFF;;KASY,cAAA;EACV,IAAA;EACA,KAAA;AAAA"}

package/dist/output_parsers/expression_type_handlers/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["ArgumentsType","IdentifierType","StringLiteralType","NumericLiteralType","ArrayLiteralType","ObjectLiteralType","CallExpressionType","BooleanLiteralType","ParsedType","PropertyAssignmentType","MemberExpressionType"],"sources":["../../../src/output_parsers/expression_type_handlers/types.d.ts"],"sourcesContent":["/**\n * Represents the different types of arguments that can be used in\n * LangChain.\n */\nexport type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;\n/**\n * Represents the parsed types in LangChain, which can be either an\n * ArgumentsType or a PropertyAssignmentType.\n */\nexport type ParsedType = ArgumentsType | PropertyAssignmentType;\n/**\n * Represents an array literal in LangChain. It has a type property set to\n * 'array_literal' and a values property which is an array of\n * ArgumentsType.\n */\nexport type ArrayLiteralType = {\n    type: \"array_literal\";\n    values: ArgumentsType[];\n};\n/**\n * Represents a boolean literal in LangChain. It has a type property set\n * to 'boolean_literal' and a value property which is a boolean.\n */\nexport type BooleanLiteralType = {\n    type: \"boolean_literal\";\n    value: boolean;\n};\n/**\n * Represents a call expression in LangChain. It has a type property set\n * to 'call_expression', a funcCall property which can be a string or a\n * MemberExpressionType, and an optional args property which is an array\n * of ArgumentsType.\n */\nexport type CallExpressionType = {\n    type: \"call_expression\";\n    funcCall: string | MemberExpressionType;\n    args?: ArgumentsType[];\n};\n/**\n * Represents a numeric literal in LangChain. It has a type property set\n * to 'numeric_literal' and a value property which is a number.\n */\nexport type NumericLiteralType = {\n    type: \"numeric_literal\";\n    value: number;\n};\n/**\n * Represents an object literal in LangChain. It has a type property set\n * to 'object_literal' and a values property which is an array of\n * PropertyAssignmentType.\n */\nexport type ObjectLiteralType = {\n    type: \"object_literal\";\n    values: PropertyAssignmentType[];\n};\n/**\n * Represents a member expression in LangChain. It has a type property set\n * to 'member_expression', an identifier property which is a string, and a\n * property property which is also a string.\n */\nexport type MemberExpressionType = {\n    type: \"member_expression\";\n    identifier: string;\n    property: string;\n};\n/**\n * Represents a property assignment in LangChain. It has a type property\n * set to 'property_assignment', an identifier property which is a string,\n * and a value property which is an ArgumentsType.\n */\nexport type PropertyAssignmentType = {\n    type: \"property_assignment\";\n    identifier: string;\n    value: ArgumentsType;\n};\n/**\n * Represents a string literal in LangChain. It has a type property set to\n * 'string_literal' and a value property which is a string.\n */\nexport type StringLiteralType = {\n    type: \"string_literal\";\n    value: string;\n};\n/**\n * Represents an identifier in LangChain. It has a type property set to\n * 'identifier' and a value property which is a string.\n */\nexport type IdentifierType = {\n    type: \"identifier\";\n    value: string;\n};\n//# sourceMappingURL=types.d.ts.map"],"mappings":";;AAIA;;;AAAiEG,KAArDH,aAAAA,GAAgBC,cAAqCE,GAApBD,iBAAoBC,GAAAA,kBAAAA,GAAqBC,gBAArBD,GAAwCE,iBAAxCF,GAA4DG,kBAA5DH,GAAiFI,kBAAjFJ;;;;;AAAmG,KAKxJK,UAAAA,GAAaR,aAL2I,GAK3HS,sBAL2H;AAKpK;AAMA;AAQA;AAUA;AASA;AASYJ,KApCAD,gBAAAA,GAoCiB;EASjBM,IAAAA,EAAAA,eAAAA;EAUAD,MAAAA,EArDAT,aAqDAS,EAAAA;AASZ,CAAA;AAQA;;;;KAhEYF,kBAAAA;;;;;;;;;;KAUAD,kBAAAA;;qBAEWI;SACZV;;;;;;KAMCG,kBAAAA;;;;;;;;;KASAE,iBAAAA;;UAEAI;;;;;;;KAOAC,oBAAAA;;;;;;;;;;KAUAD,sBAAAA;;;SAGDT;;;;;;KAMCE,iBAAAA;;;;;;;;KAQAD,cAAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/output_parsers/expression_type_handlers/types.ts"],"mappings":";;AAIA;;;KAAY,aAAA,GACR,cAAA,GACA,iBAAA,GACA,kBAAA,GACA,gBAAA,GACA,iBAAA,GACA,kBAAA,GACA,kBAAA;;;;;KAMQ,UAAA,GAAa,aAAA,GAAgB,sBAAA;;;;;;KAO7B,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,aAAA;AAAA;;;;AATV;KAgBY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;AAXF;;;;;;AAAA,KAoBY,kBAAA;EACV,IAAA;EACA,QAAA,WAAmB,oBAAA;EACnB,IAAA,GAAO,aAAA;AAAA;;;;AAHT;KAUY,kBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;;;;KAQU,iBAAA;EACV,IAAA;EACA,MAAA,EAAQ,sBAAA;AAAA;;;AAFV;;;KAUY,oBAAA;EACV,IAAA;EACA,UAAA;EACA,QAAA;AAAA;;AAHF;;;;KAWY,sBAAA;EACV,IAAA;EACA,UAAA;EACA,KAAA,EAAO,aAAA;AAAA;AAHT;;;;AAAA,KAUY,iBAAA;EACV,IAAA;EACA,KAAA;AAAA;;;AAFF;;KASY,cAAA;EACV,IAAA;EACA,KAAA;AAAA"}

package/dist/output_parsers/fix.cjs

@@ -1,7 +1,7 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_llm_chain = require('../chains/llm_chain.cjs');
 const require_prompts = require('./prompts.cjs');
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/output_parsers/fix.ts
 function isLLMChain(x) {
@@ -12,7 +12,7 @@ function isLLMChain(x) {
 * initial parsing attempt fails. It contains a retryChain for retrying
 * the parsing process in case of a failure.
 */
-var OutputFixingParser = class OutputFixingParser extends __langchain_core_output_parsers.BaseOutputParser {
+var OutputFixingParser = class OutputFixingParser extends _langchain_core_output_parsers.BaseOutputParser {
 	static lc_name() {
 		return "OutputFixingParser";
 	}
@@ -33,14 +33,12 @@ var OutputFixingParser = class OutputFixingParser extends __langchain_core_outpu
 	* @returns A new instance of OutputFixingParser.
 	*/
 	static fromLLM(llm, parser, fields) {
-		const prompt = fields?.prompt ?? require_prompts.NAIVE_FIX_PROMPT;
-		const chain = new require_llm_chain.LLMChain({
-			llm,
-			prompt
-		});
 		return new OutputFixingParser({
 			parser,
-			retryChain: chain
+			retryChain: new require_llm_chain.LLMChain({
+				llm,
+				prompt: fields?.prompt ?? require_prompts.NAIVE_FIX_PROMPT
+			})
 		});
 	}
 	constructor({ parser, retryChain }) {
@@ -60,20 +58,16 @@ var OutputFixingParser = class OutputFixingParser extends __langchain_core_outpu
 		try {
 			return await this.parser.parse(completion, callbacks);
 		} catch (e) {
-			if (e instanceof __langchain_core_output_parsers.OutputParserException) {
+			if (e instanceof _langchain_core_output_parsers.OutputParserException) {
 				const retryInput = {
 					instructions: this.parser.getFormatInstructions(),
 					completion,
 					error: e
 				};
 				if (isLLMChain(this.retryChain)) {
-					const result = await this.retryChain.call(retryInput, callbacks);
-					const newCompletion = result[this.retryChain.outputKey];
+					const newCompletion = (await this.retryChain.call(retryInput, callbacks))[this.retryChain.outputKey];
 					return this.parser.parse(newCompletion, callbacks);
-				} else {
-					const result = await this.retryChain.invoke(retryInput, { callbacks });
-					return result;
-				}
+				} else return await this.retryChain.invoke(retryInput, { callbacks });
 			}
 			throw e;
 		}

package/dist/output_parsers/fix.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"fix.cjs","names":["x: LLMChain | Runnable<OutputFixingParserRetryInput, T>","BaseOutputParser","llm: BaseLanguageModelInterface","parser: BaseOutputParser<T>","fields?: {\n      prompt?: BasePromptTemplate;\n    }","NAIVE_FIX_PROMPT","LLMChain","completion: string","callbacks?: Callbacks","OutputParserException","newCompletion: string"],"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      // eslint-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,WACPA,GACe;AACf,QACG,EAAe,WAAW,UAAc,EAAe,QAAQ;AAEnE;;;;;;AAOD,IAAa,qBAAb,MAAa,2BAA8BC,iDAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAkB;CAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACLC,KACAC,QACAC,QAGA;EACA,MAAM,SAAS,QAAQ,UAAUC;EACjC,MAAM,QAAQ,IAAIC,2BAAS;GAAE;GAAK;EAAQ;AAC1C,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAAY;EAAO;CAC/D;CAED,YAAY,EACV,QACA,YAID,EAAE;EACD,MAAM,GAAG,UAAU;EACnB,KAAK,SAAS;EACd,KAAK,aAAa;CACnB;;;;;;;;;CAUD,MAAM,MAAMC,YAAoBC,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;EACtD,SAAQ,GAAG;AAEV,OAAI,aAAaC,uDAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;IACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAC/B,MAAM,SAAS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU;KAChE,MAAMC,gBAAwB,OAAO,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;IACnD,OAAM;KACL,MAAM,SAAS,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,UACD,EAAC;AACF,YAAO;IACR;GACF;AACD,SAAM;EACP;CACF;;;;;CAMD,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB;CAC3C;AACF"}
+{"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      // eslint-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,UAAc,EAAe,QAAQ;;;;;;;AASpE,IAAa,qBAAb,MAAa,2BAA8BA,gDAAoB;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,2BAAS;IAAE;IAAK,QADnB,QAAQ,UAAUC;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,sDAAuB;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"}

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

@@ -1 +1 @@
-{"version":3,"file":"fix.d.cts","names":["BaseLanguageModelInterface","Callbacks","BaseOutputParser","OutputParserException","BasePromptTemplate","Runnable","LLMChain","OutputFixingParserRetryInput","OutputFixingParser","T","parser","retryChain","Promise"],"sources":["../../src/output_parsers/fix.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser, OutputParserException } from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\ninterface OutputFixingParserRetryInput {\n    instructions: string;\n    completion: string;\n    error: OutputParserException;\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 declare class OutputFixingParser<T> extends BaseOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\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>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {\n        prompt?: BasePromptTemplate;\n    }): OutputFixingParser<T>;\n    constructor({ parser, retryChain }: {\n        parser: BaseOutputParser<T>;\n        retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\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    parse(completion: string, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Method to get the format instructions for the parser.\n     * @returns The format instructions for the parser.\n     */\n    getFormatInstructions(): string;\n}\nexport {};\n//# sourceMappingURL=fix.d.ts.map"],"mappings":";;;;;;;;UAMUO,4BAAAA;;EAAAA,UAAAA,EAAAA,MAAAA;EAUWC,KAAAA,EAPVL,qBAO4BM;;;;;;;AAKZJ,cALNG,kBAKMH,CAAAA,CAAAA,CAAAA,SALwBH,gBAKxBG,CALyCI,CAKzCJ,CAAAA,CAAAA;EASAL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAqDS,YAAAA,EAAAA,MAAAA,EAAAA;EAAjBP,eAAAA,EAAAA,OAAAA;EAC9CE,MAAAA,EAXLF,gBAWKE,CAXYK,CAWZL,CAAAA;EACUK,UAAAA,EAXXH,QAWWG,GAXAJ,QAWAI,CAXSF,4BAWTE,EAXuCA,CAWvCA,CAAAA;EAAnBD;;;;;;;;EAGuBH,OAAAA,OAAAA,CAAAA,CAAAA,CAAAA,CAAAA,GAAAA,EALJL,0BAKIK,EAAAA,MAAAA,EALgCH,gBAKhCG,CALiDI,CAKjDJ,CAAAA,EAAAA,MAU+BI,CAV/BJ,EAAAA;IAUWJ,MAAAA,CAAAA,EAdzBG,kBAcyBH;EAAoBQ,CAAAA,CAAAA,EAbtDD,kBAasDC,CAbnCA,CAamCA,CAAAA;EAARG,WAAAA,CAAAA;IAAAA,MAAAA;IAAAA;GAAAA,EAAAA;IA7BHV,MAAAA,EAkBnCA,gBAlBmCA,CAkBlBO,CAlBkBP,CAAAA;IAAgB,UAAA,EAmB/CI,QAnB+C,GAmBpCD,QAnBoC,CAmB3BE,4BAnB2B,EAmBGE,CAnBH,CAAA;;;;;;;;;;wCA6BzBR,YAAYW,QAAQH"}
+{"version":3,"file":"fix.d.cts","names":[],"sources":["../../src/output_parsers/fix.ts"],"mappings":";;;;;;;;UAWU,4BAAA;EACR,YAAA;EACA,UAAA;EACA,KAAA,EAAO,qBAAA;AAAA;;;;;;cAgBI,kBAAA,YAA8B,gBAAA,CAAiB,CAAA;EAAA,OACnD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAEzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAFrC;;;;;;;;EAAA,OAYlB,OAAA,GAAA,CACL,GAAA,EAAK,0BAAA,EACL,MAAA,EAAQ,gBAAA,CAAiB,CAAA,GACzB,MAAA;IACE,MAAA,GAAS,kBAAA;EAAA,IACV,kBAAA,CAAA,CAAA;EAOH,WAAA,CAAA;IACE,MAAA;IACA;EAAA;IAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;IACzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAAA;EADtD;;;;;;;;EAgBJ,KAAA,CAAM,UAAA,UAAoB,SAAA,GAAY,SAAA,GAAS,OAAA,CAAA,CAAA;EArDI;;;;EAoFzD,qBAAA,CAAA;AAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"fix.d.ts","names":["BaseLanguageModelInterface","Callbacks","BaseOutputParser","OutputParserException","BasePromptTemplate","Runnable","LLMChain","OutputFixingParserRetryInput","OutputFixingParser","T","parser","retryChain","Promise"],"sources":["../../src/output_parsers/fix.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { BaseOutputParser, OutputParserException } from \"@langchain/core/output_parsers\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\ninterface OutputFixingParserRetryInput {\n    instructions: string;\n    completion: string;\n    error: OutputParserException;\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 declare class OutputFixingParser<T> extends BaseOutputParser<T> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    parser: BaseOutputParser<T>;\n    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\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>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {\n        prompt?: BasePromptTemplate;\n    }): OutputFixingParser<T>;\n    constructor({ parser, retryChain }: {\n        parser: BaseOutputParser<T>;\n        retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;\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    parse(completion: string, callbacks?: Callbacks): Promise<T>;\n    /**\n     * Method to get the format instructions for the parser.\n     * @returns The format instructions for the parser.\n     */\n    getFormatInstructions(): string;\n}\nexport {};\n//# sourceMappingURL=fix.d.ts.map"],"mappings":";;;;;;;;UAMUO,4BAAAA;;EAAAA,UAAAA,EAAAA,MAAAA;EAUWC,KAAAA,EAPVL,qBAO4BM;;;;;;;AAKZJ,cALNG,kBAKMH,CAAAA,CAAAA,CAAAA,SALwBH,gBAKxBG,CALyCI,CAKzCJ,CAAAA,CAAAA;EASAL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAqDS,YAAAA,EAAAA,MAAAA,EAAAA;EAAjBP,eAAAA,EAAAA,OAAAA;EAC9CE,MAAAA,EAXLF,gBAWKE,CAXYK,CAWZL,CAAAA;EACUK,UAAAA,EAXXH,QAWWG,GAXAJ,QAWAI,CAXSF,4BAWTE,EAXuCA,CAWvCA,CAAAA;EAAnBD;;;;;;;;EAGuBH,OAAAA,OAAAA,CAAAA,CAAAA,CAAAA,CAAAA,GAAAA,EALJL,0BAKIK,EAAAA,MAAAA,EALgCH,gBAKhCG,CALiDI,CAKjDJ,CAAAA,EAAAA,MAU+BI,CAV/BJ,EAAAA;IAUWJ,MAAAA,CAAAA,EAdzBG,kBAcyBH;EAAoBQ,CAAAA,CAAAA,EAbtDD,kBAasDC,CAbnCA,CAamCA,CAAAA;EAARG,WAAAA,CAAAA;IAAAA,MAAAA;IAAAA;GAAAA,EAAAA;IA7BHV,MAAAA,EAkBnCA,gBAlBmCA,CAkBlBO,CAlBkBP,CAAAA;IAAgB,UAAA,EAmB/CI,QAnB+C,GAmBpCD,QAnBoC,CAmB3BE,4BAnB2B,EAmBGE,CAnBH,CAAA;;;;;;;;;;wCA6BzBR,YAAYW,QAAQH"}
+{"version":3,"file":"fix.d.ts","names":[],"sources":["../../src/output_parsers/fix.ts"],"mappings":";;;;;;;;UAWU,4BAAA;EACR,YAAA;EACA,UAAA;EACA,KAAA,EAAO,qBAAA;AAAA;;;;;;cAgBI,kBAAA,YAA8B,gBAAA,CAAiB,CAAA;EAAA,OACnD,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;EAEzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAFrC;;;;;;;;EAAA,OAYlB,OAAA,GAAA,CACL,GAAA,EAAK,0BAAA,EACL,MAAA,EAAQ,gBAAA,CAAiB,CAAA,GACzB,MAAA;IACE,MAAA,GAAS,kBAAA;EAAA,IACV,kBAAA,CAAA,CAAA;EAOH,WAAA,CAAA;IACE,MAAA;IACA;EAAA;IAEA,MAAA,EAAQ,gBAAA,CAAiB,CAAA;IACzB,UAAA,EAAY,QAAA,GAAW,QAAA,CAAS,4BAAA,EAA8B,CAAA;EAAA;EADtD;;;;;;;;EAgBJ,KAAA,CAAM,UAAA,UAAoB,SAAA,GAAY,SAAA,GAAS,OAAA,CAAA,CAAA;EArDI;;;;EAoFzD,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/fix.js

@@ -32,14 +32,12 @@ var OutputFixingParser = class OutputFixingParser extends BaseOutputParser {
 	* @returns A new instance of OutputFixingParser.
 	*/
 	static fromLLM(llm, parser, fields) {
-		const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;
-		const chain = new LLMChain({
-			llm,
-			prompt
-		});
 		return new OutputFixingParser({
 			parser,
-			retryChain: chain
+			retryChain: new LLMChain({
+				llm,
+				prompt: fields?.prompt ?? NAIVE_FIX_PROMPT
+			})
 		});
 	}
 	constructor({ parser, retryChain }) {
@@ -66,13 +64,9 @@ var OutputFixingParser = class OutputFixingParser extends BaseOutputParser {
 					error: e
 				};
 				if (isLLMChain(this.retryChain)) {
-					const result = await this.retryChain.call(retryInput, callbacks);
-					const newCompletion = result[this.retryChain.outputKey];
+					const newCompletion = (await this.retryChain.call(retryInput, callbacks))[this.retryChain.outputKey];
 					return this.parser.parse(newCompletion, callbacks);
-				} else {
-					const result = await this.retryChain.invoke(retryInput, { callbacks });
-					return result;
-				}
+				} else return await this.retryChain.invoke(retryInput, { callbacks });
 			}
 			throw e;
 		}

package/dist/output_parsers/fix.js.map

@@ -1 +1 @@
-{"version":3,"file":"fix.js","names":["x: LLMChain | Runnable<OutputFixingParserRetryInput, T>","llm: BaseLanguageModelInterface","parser: BaseOutputParser<T>","fields?: {\n      prompt?: BasePromptTemplate;\n    }","completion: string","callbacks?: Callbacks","newCompletion: string"],"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      // eslint-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,WACPA,GACe;AACf,QACG,EAAe,WAAW,UAAc,EAAe,QAAQ;AAEnE;;;;;;AAOD,IAAa,qBAAb,MAAa,2BAA8B,iBAAoB;CAC7D,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe;EAAC;EAAa;EAAkB;CAAM;CAErD,kBAAkB;CAElB;CAEA;;;;;;;;;CAUA,OAAO,QACLC,KACAC,QACAC,QAGA;EACA,MAAM,SAAS,QAAQ,UAAU;EACjC,MAAM,QAAQ,IAAI,SAAS;GAAE;GAAK;EAAQ;AAC1C,SAAO,IAAI,mBAAsB;GAAE;GAAQ,YAAY;EAAO;CAC/D;CAED,YAAY,EACV,QACA,YAID,EAAE;EACD,MAAM,GAAG,UAAU;EACnB,KAAK,SAAS;EACd,KAAK,aAAa;CACnB;;;;;;;;;CAUD,MAAM,MAAMC,YAAoBC,WAAuB;AACrD,MAAI;AACF,UAAO,MAAM,KAAK,OAAO,MAAM,YAAY,UAAU;EACtD,SAAQ,GAAG;AAEV,OAAI,aAAa,uBAAuB;IACtC,MAAM,aAAa;KACjB,cAAc,KAAK,OAAO,uBAAuB;KACjD;KACA,OAAO;IACR;AAED,QAAI,WAAW,KAAK,WAAW,EAAE;KAC/B,MAAM,SAAS,MAAM,KAAK,WAAW,KAAK,YAAY,UAAU;KAChE,MAAMC,gBAAwB,OAAO,KAAK,WAAW;AACrD,YAAO,KAAK,OAAO,MAAM,eAAe,UAAU;IACnD,OAAM;KACL,MAAM,SAAS,MAAM,KAAK,WAAW,OAAO,YAAY,EACtD,UACD,EAAC;AACF,YAAO;IACR;GACF;AACD,SAAM;EACP;CACF;;;;;CAMD,wBAAwB;AACtB,SAAO,KAAK,OAAO,uBAAuB;CAC3C;AACF"}
+{"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      // eslint-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,UAAc,EAAe,QAAQ;;;;;;;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"}

package/dist/output_parsers/http_response.cjs

@@ -1,17 +1,17 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const __langchain_core_output_parsers = require_rolldown_runtime.__toESM(require("@langchain/core/output_parsers"));
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_output_parsers = require("@langchain/core/output_parsers");
 
 //#region src/output_parsers/http_response.ts
 /**
 * OutputParser that formats chunks emitted from an LLM for different HTTP content types.
 */
-var HttpResponseOutputParser = class extends __langchain_core_output_parsers.BaseTransformOutputParser {
+var HttpResponseOutputParser = class extends _langchain_core_output_parsers.BaseTransformOutputParser {
 	static lc_name() {
 		return "HttpResponseOutputParser";
 	}
 	lc_namespace = ["langchain", "output_parser"];
 	lc_serializable = true;
-	outputParser = new __langchain_core_output_parsers.StringOutputParser();
+	outputParser = new _langchain_core_output_parsers.StringOutputParser();
 	contentType = "text/plain";
 	constructor(fields) {
 		super(fields);
@@ -21,10 +21,7 @@ var HttpResponseOutputParser = class extends __langchain_core_output_parsers.Bas
 	async *_transform(inputGenerator) {
 		for await (const chunk of this.outputParser._transform(inputGenerator)) if (typeof chunk === "string") yield this.parse(chunk);
 		else yield this.parse(JSON.stringify(chunk));
-		if (this.contentType === "text/event-stream") {
-			const encoder = new TextEncoder();
-			yield encoder.encode(`event: end\n\n`);
-		}
+		if (this.contentType === "text/event-stream") yield new TextEncoder().encode(`event: end\n\n`);
 	}
 	/**
 	* Parses a string output from an LLM call. This method is meant to be

package/dist/output_parsers/http_response.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"http_response.cjs","names":["BaseTransformOutputParser","StringOutputParser","fields?: HttpResponseOutputParserInput","inputGenerator: AsyncGenerator<string | BaseMessage>","text: string"],"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,0DAAsC;CAClF,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,aAAa,eAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAIC;CAE9C,cAAkD;CAElD,YAAYC,QAAwC;EAClD,MAAM,OAAO;EACb,KAAK,eAAe,QAAQ,gBAAgB,KAAK;EACjD,KAAK,cAAc,QAAQ,eAAe,KAAK;CAChD;CAED,OAAO,WACLC,gBAC4B;AAC5B,aAAW,MAAM,SAAS,KAAK,aAAa,WAAW,eAAe,CACpE,KAAI,OAAO,UAAU,UACnB,MAAM,KAAK,MAAM,MAAM;OAEvB,MAAM,KAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAG3C,MAAI,KAAK,gBAAgB,qBAAqB;GAC5C,MAAM,UAAU,IAAI;GACpB,MAAM,QAAQ,OAAO,CAAC,cAAc,CAAC,CAAC;EACvC;CACF;;;;;;;;;CAUD,MAAM,MAAMC,MAAmC;EAC7C,MAAM,QAAQ,MAAM,KAAK,aAAa,MAAM,KAAK;EACjD,MAAM,UAAU,IAAI;AACpB,MAAI,KAAK,gBAAgB,oBACvB,QAAO,QAAQ,OAAO,CAAC,mBAAmB,EAAE,KAAK,UAAU,MAAM,CAAC,IAAI,CAAC,CAAC;EAE1E,IAAI;AACJ,MAAI,OAAO,UAAU,UACnB,cAAc;OAEd,cAAc,KAAK,UAAU,MAAM;AAErC,SAAO,QAAQ,OAAO,YAAY;CACnC;CAED,wBAAgC;AAC9B,SAAO;CACR;AACF"}
+{"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,yDAAsC;CAClF,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,aAAa,gBAAgB;CAE7C,kBAAkB;CAElB,eAA0C,IAAIC,mDAAoB;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"}

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

@@ -1 +1 @@
-{"version":3,"file":"http_response.d.cts","names":["BaseMessage","BaseTransformOutputParser","HttpResponseOutputParserInput","HttpResponseOutputParser","Uint8Array","AsyncGenerator","Promise"],"sources":["../../src/output_parsers/http_response.d.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseTransformOutputParser } from \"@langchain/core/output_parsers\";\nexport type HttpResponseOutputParserInput = {\n    outputParser?: BaseTransformOutputParser;\n    contentType?: \"text/plain\" | \"text/event-stream\";\n};\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport declare class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: BaseTransformOutputParser;\n    contentType: \"text/plain\" | \"text/event-stream\";\n    constructor(fields?: HttpResponseOutputParserInput);\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<Uint8Array>;\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    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=http_response.d.ts.map"],"mappings":";;;;KAEYE,6BAAAA;iBACOD;EADPC,WAAAA,CAAAA,EAAAA,YAAAA,GAAAA,mBACOD;AAMnB,CAAA;;;;AAOuDD,cAPlCG,wBAAAA,SAAiCF,yBAOCD,CAPyBI,UAOzBJ,CAAAA,CAAAA;EAAxBK,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsDD,YAAAA,EAAAA,MAAAA,EAAAA;EAAfC,eAAAA,EAAAA,OAAAA;EASrCD,YAAAA,EAZfH,yBAYeG;EAARE,WAAAA,EAAAA,YAAAA,GAAAA,mBAAAA;EAhB6BL,WAAAA,CAAAA,MAAAA,CAAAA,EAM7BC,6BAN6BD;EAAyB,UAAA,CAAA,cAAA,EAOhDI,cAPgD,CAAA,MAAA,GAOxBL,WAPwB,CAAA,CAAA,EAOTK,cAPS,CAOMD,UAPN,CAAA;;;;;;;;;uBAgBtDE,QAAQF"}
+{"version":3,"file":"http_response.d.cts","names":[],"sources":["../../src/output_parsers/http_response.ts"],"mappings":";;;;KAMY,6BAAA;EACV,YAAA,GAAe,yBAAA;EACf,WAAA;AAAA;;;;cAMW,wBAAA,SAAiC,yBAAA,CAA0B,UAAA;EAAA,OAC/D,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,YAAA,EAAc,yBAAA;EAEd,WAAA;EAEA,WAAA,CAAY,MAAA,GAAS,6BAAA;EAMd,UAAA,CACL,cAAA,EAAgB,cAAA,UAAwB,WAAA,IACvC,cAAA,CAAe,UAAA;EAZJ;;;;;;;;EAkCR,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,UAAA;EAenC,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/http_response.d.ts

@@ -1,5 +1,5 @@
-import { BaseTransformOutputParser } from "@langchain/core/output_parsers";
 import { BaseMessage } from "@langchain/core/messages";
+import { BaseTransformOutputParser } from "@langchain/core/output_parsers";
 
 //#region src/output_parsers/http_response.d.ts
 type HttpResponseOutputParserInput = {

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

@@ -1 +1 @@
-{"version":3,"file":"http_response.d.ts","names":["BaseMessage","BaseTransformOutputParser","HttpResponseOutputParserInput","HttpResponseOutputParser","Uint8Array","AsyncGenerator","Promise"],"sources":["../../src/output_parsers/http_response.d.ts"],"sourcesContent":["import { BaseMessage } from \"@langchain/core/messages\";\nimport { BaseTransformOutputParser } from \"@langchain/core/output_parsers\";\nexport type HttpResponseOutputParserInput = {\n    outputParser?: BaseTransformOutputParser;\n    contentType?: \"text/plain\" | \"text/event-stream\";\n};\n/**\n * OutputParser that formats chunks emitted from an LLM for different HTTP content types.\n */\nexport declare class HttpResponseOutputParser extends BaseTransformOutputParser<Uint8Array> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    outputParser: BaseTransformOutputParser;\n    contentType: \"text/plain\" | \"text/event-stream\";\n    constructor(fields?: HttpResponseOutputParserInput);\n    _transform(inputGenerator: AsyncGenerator<string | BaseMessage>): AsyncGenerator<Uint8Array>;\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    parse(text: string): Promise<Uint8Array>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=http_response.d.ts.map"],"mappings":";;;;KAEYE,6BAAAA;iBACOD;EADPC,WAAAA,CAAAA,EAAAA,YAAAA,GAAAA,mBACOD;AAMnB,CAAA;;;;AAOuDD,cAPlCG,wBAAAA,SAAiCF,yBAOCD,CAPyBI,UAOzBJ,CAAAA,CAAAA;EAAxBK,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsDD,YAAAA,EAAAA,MAAAA,EAAAA;EAAfC,eAAAA,EAAAA,OAAAA;EASrCD,YAAAA,EAZfH,yBAYeG;EAARE,WAAAA,EAAAA,YAAAA,GAAAA,mBAAAA;EAhB6BL,WAAAA,CAAAA,MAAAA,CAAAA,EAM7BC,6BAN6BD;EAAyB,UAAA,CAAA,cAAA,EAOhDI,cAPgD,CAAA,MAAA,GAOxBL,WAPwB,CAAA,CAAA,EAOTK,cAPS,CAOMD,UAPN,CAAA;;;;;;;;;uBAgBtDE,QAAQF"}
+{"version":3,"file":"http_response.d.ts","names":[],"sources":["../../src/output_parsers/http_response.ts"],"mappings":";;;;KAMY,6BAAA;EACV,YAAA,GAAe,yBAAA;EACf,WAAA;AAAA;;;;cAMW,wBAAA,SAAiC,yBAAA,CAA0B,UAAA;EAAA,OAC/D,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,YAAA,EAAc,yBAAA;EAEd,WAAA;EAEA,WAAA,CAAY,MAAA,GAAS,6BAAA;EAMd,UAAA,CACL,cAAA,EAAgB,cAAA,UAAwB,WAAA,IACvC,cAAA,CAAe,UAAA;EAZJ;;;;;;;;EAkCR,KAAA,CAAM,IAAA,WAAe,OAAA,CAAQ,UAAA;EAenC,qBAAA,CAAA;AAAA"}

package/dist/output_parsers/http_response.js

@@ -20,10 +20,7 @@ var HttpResponseOutputParser = class extends BaseTransformOutputParser {
 	async *_transform(inputGenerator) {
 		for await (const chunk of this.outputParser._transform(inputGenerator)) if (typeof chunk === "string") yield this.parse(chunk);
 		else yield this.parse(JSON.stringify(chunk));
-		if (this.contentType === "text/event-stream") {
-			const encoder = new TextEncoder();
-			yield encoder.encode(`event: end\n\n`);
-		}
+		if (this.contentType === "text/event-stream") yield new TextEncoder().encode(`event: end\n\n`);
 	}
 	/**
 	* Parses a string output from an LLM call. This method is meant to be