langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

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

@@ -1 +0,0 @@
-{"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"}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.js

@@ -1,40 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
-
-//#region src/output_parsers/expression_type_handlers/object_literal_expression_handler.ts
-/**
-* Handles object literal expressions in the LangChain Expression
-* Language. Extends the NodeHandler class.
-*/
-var ObjectLiteralExpressionHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is an object expression. Returns the node if it
-	* is, otherwise returns false.
-	* @param node The node to check.
-	* @returns The node if it is an object expression, otherwise false.
-	*/
-	async accepts(node) {
-		if (ASTParser.isObjectExpression(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes the object expression node and returns an object of type
-	* ObjectLiteralType. Throws an error if the parent handler is not set.
-	* @param node The object expression node to process.
-	* @returns An object of type ObjectLiteralType.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		const values = [];
-		const { properties } = node;
-		for (const property of properties) if (ASTParser.isPropertyAssignment(property)) values.push(await new PropertyAssignmentHandler(this.parentHandler).handle(property));
-		return {
-			type: "object_literal",
-			values
-		};
-	}
-};
-
-//#endregion
-export { ObjectLiteralExpressionHandler };
-//# sourceMappingURL=object_literal_expression_handler.js.map

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

@@ -1 +0,0 @@
-{"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"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -1,45 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/property_assignment_handler.ts
-/**
-* Handler for `PropertyAssignment` nodes in an AST. Extends the
-* `NodeHandler` base class.
-*/
-var PropertyAssignmentHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a `PropertyAssignment` and returns the node
-	* if true, or false otherwise.
-	* @param node The node to check.
-	* @returns The node if it is a `PropertyAssignment`, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isPropertyAssignment(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a `PropertyAssignment` node. Extracts the key and value of
-	* the property assignment and returns an object of type
-	* `PropertyAssignmentType` with the extracted identifier and value.
-	* @param node The `PropertyAssignment` node to process.
-	* @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		let name;
-		if (require_base.ASTParser.isIdentifier(node.key)) name = node.key.name;
-		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
-		};
-	}
-};
-
-//#endregion
-exports.PropertyAssignmentHandler = PropertyAssignmentHandler;
-//# sourceMappingURL=property_assignment_handler.cjs.map

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

@@ -1 +0,0 @@
-{"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"}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -1,45 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/property_assignment_handler.ts
-/**
-* Handler for `PropertyAssignment` nodes in an AST. Extends the
-* `NodeHandler` base class.
-*/
-var PropertyAssignmentHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a `PropertyAssignment` and returns the node
-	* if true, or false otherwise.
-	* @param node The node to check.
-	* @returns The node if it is a `PropertyAssignment`, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isPropertyAssignment(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a `PropertyAssignment` node. Extracts the key and value of
-	* the property assignment and returns an object of type
-	* `PropertyAssignmentType` with the extracted identifier and value.
-	* @param node The `PropertyAssignment` node to process.
-	* @returns An object of type `PropertyAssignmentType` with the extracted identifier and value.
-	*/
-	async handle(node) {
-		if (!this.parentHandler) throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
-		let name;
-		if (ASTParser.isIdentifier(node.key)) name = node.key.name;
-		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
-		};
-	}
-};
-
-//#endregion
-export { PropertyAssignmentHandler };
-//# sourceMappingURL=property_assignment_handler.js.map

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

@@ -1 +0,0 @@
-{"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"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -1,37 +0,0 @@
-const require_base = require('./base.cjs');
-
-//#region src/output_parsers/expression_type_handlers/string_literal_handler.ts
-/**
-* Handler for string literal nodes in the LangChain Expression Language.
-* Extends the NodeHandler base class.
-*/
-var StringLiteralHandler = class extends require_base.NodeHandler {
-	/**
-	* Checks if a given node is a string literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The ExpressionNode to check.
-	* @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.
-	*/
-	async accepts(node) {
-		if (require_base.ASTParser.isStringLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a string literal node to extract its value. Throws an error
-	* if the handler does not have a parent handler.
-	* @param node The StringLiteral node to process.
-	* @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.
-	*/
-	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
-		};
-	}
-};
-
-//#endregion
-exports.StringLiteralHandler = StringLiteralHandler;
-//# sourceMappingURL=string_literal_handler.cjs.map

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

@@ -1 +0,0 @@
-{"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"}

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -1,37 +0,0 @@
-import { ASTParser, NodeHandler } from "./base.js";
-
-//#region src/output_parsers/expression_type_handlers/string_literal_handler.ts
-/**
-* Handler for string literal nodes in the LangChain Expression Language.
-* Extends the NodeHandler base class.
-*/
-var StringLiteralHandler = class extends NodeHandler {
-	/**
-	* Checks if a given node is a string literal. If it is, the method
-	* returns the node; otherwise, it returns false.
-	* @param node The ExpressionNode to check.
-	* @returns A Promise that resolves to the node if it is a StringLiteral, or false otherwise.
-	*/
-	async accepts(node) {
-		if (ASTParser.isStringLiteral(node)) return node;
-		else return false;
-	}
-	/**
-	* Processes a string literal node to extract its value. Throws an error
-	* if the handler does not have a parent handler.
-	* @param node The StringLiteral node to process.
-	* @returns A Promise that resolves to a StringLiteralType object representing the processed form of the node.
-	*/
-	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
-		};
-	}
-};
-
-//#endregion
-export { StringLiteralHandler };
-//# sourceMappingURL=string_literal_handler.js.map

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

@@ -1 +0,0 @@
-{"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"}

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

@@ -1,95 +0,0 @@
-//#region src/output_parsers/expression_type_handlers/types.d.ts
-/**
- * Represents the different types of arguments that can be used in
- * LangChain.
- */
-type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;
-/**
- * Represents the parsed types in LangChain, which can be either an
- * ArgumentsType or a PropertyAssignmentType.
- */
-type ParsedType = ArgumentsType | PropertyAssignmentType;
-/**
- * Represents an array literal in LangChain. It has a type property set to
- * 'array_literal' and a values property which is an array of
- * ArgumentsType.
- */
-type ArrayLiteralType = {
-  type: "array_literal";
-  values: ArgumentsType[];
-};
-/**
- * Represents a boolean literal in LangChain. It has a type property set
- * to 'boolean_literal' and a value property which is a boolean.
- */
-type BooleanLiteralType = {
-  type: "boolean_literal";
-  value: boolean;
-};
-/**
- * Represents a call expression in LangChain. It has a type property set
- * to 'call_expression', a funcCall property which can be a string or a
- * MemberExpressionType, and an optional args property which is an array
- * of ArgumentsType.
- */
-type CallExpressionType = {
-  type: "call_expression";
-  funcCall: string | MemberExpressionType;
-  args?: ArgumentsType[];
-};
-/**
- * Represents a numeric literal in LangChain. It has a type property set
- * to 'numeric_literal' and a value property which is a number.
- */
-type NumericLiteralType = {
-  type: "numeric_literal";
-  value: number;
-};
-/**
- * Represents an object literal in LangChain. It has a type property set
- * to 'object_literal' and a values property which is an array of
- * PropertyAssignmentType.
- */
-type ObjectLiteralType = {
-  type: "object_literal";
-  values: PropertyAssignmentType[];
-};
-/**
- * Represents a member expression in LangChain. It has a type property set
- * to 'member_expression', an identifier property which is a string, and a
- * property property which is also a string.
- */
-type MemberExpressionType = {
-  type: "member_expression";
-  identifier: string;
-  property: string;
-};
-/**
- * Represents a property assignment in LangChain. It has a type property
- * set to 'property_assignment', an identifier property which is a string,
- * and a value property which is an ArgumentsType.
- */
-type PropertyAssignmentType = {
-  type: "property_assignment";
-  identifier: string;
-  value: ArgumentsType;
-};
-/**
- * Represents a string literal in LangChain. It has a type property set to
- * 'string_literal' and a value property which is a string.
- */
-type StringLiteralType = {
-  type: "string_literal";
-  value: string;
-};
-/**
- * Represents an identifier in LangChain. It has a type property set to
- * 'identifier' and a value property which is a string.
- */
-type IdentifierType = {
-  type: "identifier";
-  value: string;
-};
-//#endregion
-export { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType, IdentifierType, MemberExpressionType, NumericLiteralType, ObjectLiteralType, ParsedType, PropertyAssignmentType, StringLiteralType };
-//# sourceMappingURL=types.d.cts.map

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;AAIA;;;AAA6CE,KAAjCF,aAAAA,GAAgBC,cAAiBC,GAAAA,iBAAAA,GAAoBC,kBAApBD,GAAyCE,gBAAzCF,GAA4DG,iBAA5DH,GAAgFI,kBAAhFJ,GAAqGK,kBAArGL;;;;;AAAqGK,KAKtIC,UAAAA,GAAaR,aALyHO,GAKzGE,sBALyGF;AAAkB;AAKpK;;;;AAA+D,KAMnDH,gBAAAA,GANmD;EAMnDA,IAAAA,EAAAA,eAAgB;EAQhBG,MAAAA,EANAP,aAMkB,EAAA;AAU9B,CAAA;;;;AAGwB;AAMZG,KAnBAI,kBAAAA,GAmBkB;EASlBF,IAAAA,EAAAA,iBAAiB;EASjBK,KAAAA,EAAAA,OAAAA;AAUZ,CAAA;AASA;AAQA;;;;;KAtDYJ,kBAAAA;;qBAEWI;SACZV;;;;;;KAMCG,kBAAAA;;;;;;;;;KASAE,iBAAAA;;UAEAI;;;;;;;KAOAC,oBAAAA;;;;;;;;;;KAUAD,sBAAAA;;;SAGDT;;;;;;KAMCE,iBAAAA;;;;;;;;KAQAD,cAAAA"}

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

@@ -1,95 +0,0 @@
-//#region src/output_parsers/expression_type_handlers/types.d.ts
-/**
- * Represents the different types of arguments that can be used in
- * LangChain.
- */
-type ArgumentsType = IdentifierType | StringLiteralType | NumericLiteralType | ArrayLiteralType | ObjectLiteralType | CallExpressionType | BooleanLiteralType;
-/**
- * Represents the parsed types in LangChain, which can be either an
- * ArgumentsType or a PropertyAssignmentType.
- */
-type ParsedType = ArgumentsType | PropertyAssignmentType;
-/**
- * Represents an array literal in LangChain. It has a type property set to
- * 'array_literal' and a values property which is an array of
- * ArgumentsType.
- */
-type ArrayLiteralType = {
-  type: "array_literal";
-  values: ArgumentsType[];
-};
-/**
- * Represents a boolean literal in LangChain. It has a type property set
- * to 'boolean_literal' and a value property which is a boolean.
- */
-type BooleanLiteralType = {
-  type: "boolean_literal";
-  value: boolean;
-};
-/**
- * Represents a call expression in LangChain. It has a type property set
- * to 'call_expression', a funcCall property which can be a string or a
- * MemberExpressionType, and an optional args property which is an array
- * of ArgumentsType.
- */
-type CallExpressionType = {
-  type: "call_expression";
-  funcCall: string | MemberExpressionType;
-  args?: ArgumentsType[];
-};
-/**
- * Represents a numeric literal in LangChain. It has a type property set
- * to 'numeric_literal' and a value property which is a number.
- */
-type NumericLiteralType = {
-  type: "numeric_literal";
-  value: number;
-};
-/**
- * Represents an object literal in LangChain. It has a type property set
- * to 'object_literal' and a values property which is an array of
- * PropertyAssignmentType.
- */
-type ObjectLiteralType = {
-  type: "object_literal";
-  values: PropertyAssignmentType[];
-};
-/**
- * Represents a member expression in LangChain. It has a type property set
- * to 'member_expression', an identifier property which is a string, and a
- * property property which is also a string.
- */
-type MemberExpressionType = {
-  type: "member_expression";
-  identifier: string;
-  property: string;
-};
-/**
- * Represents a property assignment in LangChain. It has a type property
- * set to 'property_assignment', an identifier property which is a string,
- * and a value property which is an ArgumentsType.
- */
-type PropertyAssignmentType = {
-  type: "property_assignment";
-  identifier: string;
-  value: ArgumentsType;
-};
-/**
- * Represents a string literal in LangChain. It has a type property set to
- * 'string_literal' and a value property which is a string.
- */
-type StringLiteralType = {
-  type: "string_literal";
-  value: string;
-};
-/**
- * Represents an identifier in LangChain. It has a type property set to
- * 'identifier' and a value property which is a string.
- */
-type IdentifierType = {
-  type: "identifier";
-  value: string;
-};
-//#endregion
-export { ArgumentsType, ArrayLiteralType, BooleanLiteralType, CallExpressionType, IdentifierType, MemberExpressionType, NumericLiteralType, ObjectLiteralType, ParsedType, PropertyAssignmentType, StringLiteralType };
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;AAIA;;;AAA6CE,KAAjCF,aAAAA,GAAgBC,cAAiBC,GAAAA,iBAAAA,GAAoBC,kBAApBD,GAAyCE,gBAAzCF,GAA4DG,iBAA5DH,GAAgFI,kBAAhFJ,GAAqGK,kBAArGL;;;;;AAAqGK,KAKtIC,UAAAA,GAAaR,aALyHO,GAKzGE,sBALyGF;AAAkB;AAKpK;;;;AAA+D,KAMnDH,gBAAAA,GANmD;EAMnDA,IAAAA,EAAAA,eAAgB;EAQhBG,MAAAA,EANAP,aAMkB,EAAA;AAU9B,CAAA;;;;AAGwB;AAMZG,KAnBAI,kBAAAA,GAmBkB;EASlBF,IAAAA,EAAAA,iBAAiB;EASjBK,KAAAA,EAAAA,OAAAA;AAUZ,CAAA;AASA;AAQA;;;;;KAtDYJ,kBAAAA;;qBAEWI;SACZV;;;;;;KAMCG,kBAAAA;;;;;;;;;KASAE,iBAAAA;;UAEAI;;;;;;;KAOAC,oBAAAA;;;;;;;;;;KAUAD,sBAAAA;;;SAGDT;;;;;;KAMCE,iBAAAA;;;;;;;;KAQAD,cAAAA"}

package/dist/output_parsers/fix.cjs

@@ -1,92 +0,0 @@
-const require_rolldown_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"));
-
-//#region src/output_parsers/fix.ts
-function isLLMChain(x) {
-	return x.prompt !== void 0 && x.llm !== void 0;
-}
-/**
-* Class that extends the BaseOutputParser to handle situations where the
-* 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 {
-	static lc_name() {
-		return "OutputFixingParser";
-	}
-	lc_namespace = [
-		"langchain",
-		"output_parsers",
-		"fix"
-	];
-	lc_serializable = true;
-	parser;
-	retryChain;
-	/**
-	* Static method to create a new instance of OutputFixingParser using a
-	* given language model, parser, and optional fields.
-	* @param llm The language model to be used.
-	* @param parser The parser to be used.
-	* @param fields Optional fields which may contain a prompt.
-	* @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
-		});
-	}
-	constructor({ parser, retryChain }) {
-		super(...arguments);
-		this.parser = parser;
-		this.retryChain = retryChain;
-	}
-	/**
-	* Method to parse the completion using the parser. If the initial parsing
-	* fails, it uses the retryChain to attempt to fix the output and retry
-	* the parsing process.
-	* @param completion The completion to be parsed.
-	* @param callbacks Optional callbacks to be used during parsing.
-	* @returns The parsed output.
-	*/
-	async parse(completion, callbacks) {
-		try {
-			return await this.parser.parse(completion, callbacks);
-		} catch (e) {
-			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];
-					return this.parser.parse(newCompletion, callbacks);
-				} else {
-					const result = await this.retryChain.invoke(retryInput, { callbacks });
-					return result;
-				}
-			}
-			throw e;
-		}
-	}
-	/**
-	* Method to get the format instructions for the parser.
-	* @returns The format instructions for the parser.
-	*/
-	getFormatInstructions() {
-		return this.parser.getFormatInstructions();
-	}
-};
-
-//#endregion
-exports.OutputFixingParser = OutputFixingParser;
-//# sourceMappingURL=fix.cjs.map

package/dist/output_parsers/fix.cjs.map

@@ -1 +0,0 @@
-{"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"}

package/dist/output_parsers/fix.d.cts

@@ -1,60 +0,0 @@
-import { LLMChain } from "../chains/llm_chain.cjs";
-import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import { Runnable } from "@langchain/core/runnables";
-import { BaseOutputParser, OutputParserException } from "@langchain/core/output_parsers";
-import { BasePromptTemplate } from "@langchain/core/prompts";
-import { Callbacks } from "@langchain/core/callbacks/manager";
-
-//#region src/output_parsers/fix.d.ts
-interface OutputFixingParserRetryInput {
-  instructions: string;
-  completion: string;
-  error: OutputParserException;
-}
-/**
- * Class that extends the BaseOutputParser to handle situations where the
- * initial parsing attempt fails. It contains a retryChain for retrying
- * the parsing process in case of a failure.
- */
-declare class OutputFixingParser<T> extends BaseOutputParser<T> {
-  static lc_name(): string;
-  lc_namespace: string[];
-  lc_serializable: boolean;
-  parser: BaseOutputParser<T>;
-  retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;
-  /**
-   * Static method to create a new instance of OutputFixingParser using a
-   * given language model, parser, and optional fields.
-   * @param llm The language model to be used.
-   * @param parser The parser to be used.
-   * @param fields Optional fields which may contain a prompt.
-   * @returns A new instance of OutputFixingParser.
-   */
-  static fromLLM<T>(llm: BaseLanguageModelInterface, parser: BaseOutputParser<T>, fields?: {
-    prompt?: BasePromptTemplate;
-  }): OutputFixingParser<T>;
-  constructor({
-    parser,
-    retryChain
-  }: {
-    parser: BaseOutputParser<T>;
-    retryChain: LLMChain | Runnable<OutputFixingParserRetryInput, T>;
-  });
-  /**
-   * Method to parse the completion using the parser. If the initial parsing
-   * fails, it uses the retryChain to attempt to fix the output and retry
-   * the parsing process.
-   * @param completion The completion to be parsed.
-   * @param callbacks Optional callbacks to be used during parsing.
-   * @returns The parsed output.
-   */
-  parse(completion: string, callbacks?: Callbacks): Promise<T>;
-  /**
-   * Method to get the format instructions for the parser.
-   * @returns The format instructions for the parser.
-   */
-  getFormatInstructions(): string;
-}
-//#endregion
-export { OutputFixingParser };
-//# sourceMappingURL=fix.d.cts.map

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;UAMUO,4BAAAA;;EAAAA,UAAAA,EAAAA,MAAAA;EAUWC,KAAAA,EAPVL,qBAO4B;;;;;;;AAK2BM,cAL7CD,kBAK6CC,CAAAA,CAAAA,CAAAA,SALfP,gBAKeO,CALEA,CAKFA,CAAAA,CAAAA;EAAC,OAAxCJ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQ,YASRL,EAAAA,MAAAA,EAAAA;EAA0B,eAA2BS,EAAAA,OAAAA;EAAC,MAAlBP,EAVnDA,gBAUmDA,CAVlCO,CAUkCP,CAAAA;EAAgB,UAC9DE,EAVDE,QAUCF,GAVUC,QAUVD,CAVmBG,4BAUnBH,EAViDK,CAUjDL,CAAAA;EAAkB;;;;;;;;EAIiC,OAAEK,OAAAA,CAAAA,CAAAA,CAAAA,CAAAA,GAAAA,EAL3CT,0BAK2CS,EAAAA,MAAAA,EALPP,gBAKOO,CALUA,CAKVA,CAAAA,EAAAA,MAA/B,CAA+BA,EAAAA;IAAvCJ,MAAAA,CAAAA,EAJdD,kBAIcC;EAAQ,CAAA,CAAA,EAH/BG,kBAakCP,CAbfQ,CAaeR,CAAAA;EAAS,WAAWQ,CAAAA;IAAAA,MAAAA;IAAAA;EA7BK,CA6BLA,EAAAA;IAARG,MAAAA,EAXtCV,gBAWsCU,CAXrBH,CAWqBG,CAAAA;IA7BHV,UAAAA,EAmB/BI,QAnB+BJ,GAmBpBG,QAnBoBH,CAmBXK,4BAnBWL,EAmBmBO,CAnBnBP,CAAAA;EAAgB,CAAA;;;;;;;;;wCA6BzBD,YAAYW,QAAQH"}