langchain 0.0.130 → 0.0.132

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

@@ -1,8 +1,28 @@
 import { NodeHandler } from "./base.js";
 import { ParsedType } from "./types.js";
+/**
+ * The MasterHandler class is responsible for managing a collection of
+ * node handlers in the LangChain Expression Language. Each node handler
+ * is capable of handling a specific type of node in the expression
+ * language. The MasterHandler class uses these node handlers to process
+ * nodes in the expression language.
+ */
 export declare class MasterHandler extends NodeHandler {
     nodeHandlers: NodeHandler[];
     accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
+    /**
+     * This method is responsible for handling a node. It iterates over the
+     * collection of node handlers and uses the first handler that accepts the
+     * node to handle it. If no handler accepts the node, the method throws an
+     * error.
+     * @param node The node to be handled.
+     * @returns The result of the node handling, or throws an error if no handler can handle the node.
+     */
     handle(node: CallExpression): Promise<ParsedType>;
+    /**
+     * This static method creates an instance of the MasterHandler class and
+     * initializes it with instances of all the node handlers.
+     * @returns An instance of the MasterHandler class.
+     */
     static createMasterHandler(): MasterHandler;
 }

package/dist/output_parsers/expression_type_handlers/factory.js

@@ -19,6 +19,13 @@ const handlers = [
     StringLiteralHandler,
     IdentifierHandler,
 ];
+/**
+ * The MasterHandler class is responsible for managing a collection of
+ * node handlers in the LangChain Expression Language. Each node handler
+ * is capable of handling a specific type of node in the expression
+ * language. The MasterHandler class uses these node handlers to process
+ * nodes in the expression language.
+ */
 export class MasterHandler extends NodeHandler {
     constructor() {
         super(...arguments);
@@ -32,6 +39,14 @@ export class MasterHandler extends NodeHandler {
     async accepts(node) {
         throw new Error(`Master handler does not accept any nodes: ${node}`);
     }
+    /**
+     * This method is responsible for handling a node. It iterates over the
+     * collection of node handlers and uses the first handler that accepts the
+     * node to handle it. If no handler accepts the node, the method throws an
+     * error.
+     * @param node The node to be handled.
+     * @returns The result of the node handling, or throws an error if no handler can handle the node.
+     */
     async handle(node) {
         for (const handler of this.nodeHandlers) {
             const accepts = await handler.accepts(node);
@@ -41,6 +56,11 @@ export class MasterHandler extends NodeHandler {
         }
         throw new Error(`No handler found for node: ${node}`);
     }
+    /**
+     * This static method creates an instance of the MasterHandler class and
+     * initializes it with instances of all the node handlers.
+     * @returns An instance of the MasterHandler class.
+     */
     static createMasterHandler() {
         const masterHandler = new MasterHandler();
         handlers.forEach((Handler) => {

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdentifierHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handles identifiers in the LangChain Expression Language. Extends the
+ * NodeHandler class.
+ */
 class IdentifierHandler extends base_js_1.NodeHandler {
+    /**
+     * Checks if a given node is an identifier. If it is, it returns the node;
+     * otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is an identifier, or false otherwise.
+     */
     async accepts(node) {
         if (base_js_1.ASTParser.isIdentifier(node)) {
             return node;
@@ -11,6 +21,15 @@ class IdentifierHandler extends base_js_1.NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes the identifier node. If the handler does not have a parent
+     * handler, it throws an error. Otherwise, it extracts the name of the
+     * identifier, removes any enclosing quotes, and returns an object of type
+     * IdentifierType with the type set to "identifier" and the value set to
+     * the extracted name.
+     * @param node The identifier node to process.
+     * @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

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

@@ -1,6 +1,25 @@
 import { NodeHandler } from "./base.js";
 import { IdentifierType } from "./types.js";
+/**
+ * Handles identifiers in the LangChain Expression Language. Extends the
+ * NodeHandler class.
+ */
 export declare class IdentifierHandler extends NodeHandler {
+    /**
+     * Checks if a given node is an identifier. If it is, it returns the node;
+     * otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is an identifier, or false otherwise.
+     */
     accepts(node: ExpressionNode): Promise<Identifier | boolean>;
+    /**
+     * Processes the identifier node. If the handler does not have a parent
+     * handler, it throws an error. Otherwise, it extracts the name of the
+     * identifier, removes any enclosing quotes, and returns an object of type
+     * IdentifierType with the type set to "identifier" and the value set to
+     * the extracted name.
+     * @param node The identifier node to process.
+     * @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
+     */
     handle(node: Identifier): Promise<IdentifierType>;
 }

package/dist/output_parsers/expression_type_handlers/identifier_handler.js

@@ -1,5 +1,15 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handles identifiers in the LangChain Expression Language. Extends the
+ * NodeHandler class.
+ */
 export class IdentifierHandler extends NodeHandler {
+    /**
+     * Checks if a given node is an identifier. If it is, it returns the node;
+     * otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is an identifier, or false otherwise.
+     */
     async accepts(node) {
         if (ASTParser.isIdentifier(node)) {
             return node;
@@ -8,6 +18,15 @@ export class IdentifierHandler extends NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes the identifier node. If the handler does not have a parent
+     * handler, it throws an error. Otherwise, it extracts the name of the
+     * identifier, removes any enclosing quotes, and returns an object of type
+     * IdentifierType with the type set to "identifier" and the value set to
+     * the extracted name.
+     * @param node The identifier node to process.
+     * @returns An object of type IdentifierType with the type set to "identifier" and the value set to the extracted name.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

package/dist/output_parsers/expression_type_handlers/member_expression_handler.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemberExpressionHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handles member expressions in the LangChain Expression Language (LCEL).
+ * Extends the NodeHandler base class.
+ */
 class MemberExpressionHandler extends base_js_1.NodeHandler {
+    /**
+     * Checks if a given node is a member expression. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is a member expression, or false otherwise.
+     */
     async accepts(node) {
         if (base_js_1.ASTParser.isMemberExpression(node)) {
             return node;
@@ -11,6 +21,13 @@ class MemberExpressionHandler extends base_js_1.NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes a member expression node. It extracts the object and property
+     * from the node, validates their types, and returns an object with the
+     * type of the expression, the identifier, and the property.
+     * @param node The member expression node to process.
+     * @returns An object with the type of the expression, the identifier, and the property.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

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

@@ -1,6 +1,23 @@
 import { NodeHandler } from "./base.js";
 import { MemberExpressionType } from "./types.js";
+/**
+ * Handles member expressions in the LangChain Expression Language (LCEL).
+ * Extends the NodeHandler base class.
+ */
 export declare class MemberExpressionHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a member expression. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is a member expression, or false otherwise.
+     */
     accepts(node: ExpressionNode): Promise<MemberExpression | boolean>;
+    /**
+     * Processes a member expression node. It extracts the object and property
+     * from the node, validates their types, and returns an object with the
+     * type of the expression, the identifier, and the property.
+     * @param node The member expression node to process.
+     * @returns An object with the type of the expression, the identifier, and the property.
+     */
     handle(node: MemberExpression): Promise<MemberExpressionType>;
 }

package/dist/output_parsers/expression_type_handlers/member_expression_handler.js

@@ -1,5 +1,15 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handles member expressions in the LangChain Expression Language (LCEL).
+ * Extends the NodeHandler base class.
+ */
 export class MemberExpressionHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a member expression. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is a member expression, or false otherwise.
+     */
     async accepts(node) {
         if (ASTParser.isMemberExpression(node)) {
             return node;
@@ -8,6 +18,13 @@ export class MemberExpressionHandler extends NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes a member expression node. It extracts the object and property
+     * from the node, validates their types, and returns an object with the
+     * type of the expression, the identifier, and the property.
+     * @param node The member expression node to process.
+     * @returns An object with the type of the expression, the identifier, and the property.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NumericLiteralHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handler for numeric literal nodes in an abstract syntax tree (AST).
+ * Extends the NodeHandler class.
+ */
 class NumericLiteralHandler extends base_js_1.NodeHandler {
+    /**
+     * Checks if a given node is a numeric literal. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.
+     */
     async accepts(node) {
         if (base_js_1.ASTParser.isNumericLiteral(node)) {
             return node;
@@ -11,6 +21,12 @@ class NumericLiteralHandler extends base_js_1.NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes a numeric literal node and returns a NumericLiteralType
+     * object representing it.
+     * @param node The numeric literal node to process.
+     * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

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

@@ -1,6 +1,22 @@
 import { NodeHandler } from "./base.js";
 import { NumericLiteralType } from "./types.js";
+/**
+ * Handler for numeric literal nodes in an abstract syntax tree (AST).
+ * Extends the NodeHandler class.
+ */
 export declare class NumericLiteralHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a numeric literal. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.
+     */
     accepts(node: ExpressionNode): Promise<NumericLiteral | boolean>;
+    /**
+     * Processes a numeric literal node and returns a NumericLiteralType
+     * object representing it.
+     * @param node The numeric literal node to process.
+     * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.
+     */
     handle(node: NumericLiteral): Promise<NumericLiteralType>;
 }

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.js

@@ -1,5 +1,15 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handler for numeric literal nodes in an abstract syntax tree (AST).
+ * Extends the NodeHandler class.
+ */
 export class NumericLiteralHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a numeric literal. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns A Promise that resolves to the node if it is a numeric literal, or false otherwise.
+     */
     async accepts(node) {
         if (ASTParser.isNumericLiteral(node)) {
             return node;
@@ -8,6 +18,12 @@ export class NumericLiteralHandler extends NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes a numeric literal node and returns a NumericLiteralType
+     * object representing it.
+     * @param node The numeric literal node to process.
+     * @returns A Promise that resolves to a NumericLiteralType object representing the numeric literal node.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.cjs

@@ -3,7 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectLiteralExpressionHandler = void 0;
 const base_js_1 = require("./base.cjs");
 const property_assignment_handler_js_1 = require("./property_assignment_handler.cjs");
+/**
+ * Handles object literal expressions in the LangChain Expression
+ * Language. Extends the NodeHandler class.
+ */
 class ObjectLiteralExpressionHandler extends base_js_1.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 (base_js_1.ASTParser.isObjectExpression(node)) {
             return node;
@@ -12,6 +22,12 @@ class ObjectLiteralExpressionHandler extends base_js_1.NodeHandler {
             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");

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

@@ -1,6 +1,22 @@
 import { NodeHandler } from "./base.js";
 import { ObjectLiteralType } from "./types.js";
+/**
+ * Handles object literal expressions in the LangChain Expression
+ * Language. Extends the NodeHandler class.
+ */
 export declare class ObjectLiteralExpressionHandler 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.
+     */
     accepts(node: ExpressionNode): Promise<ObjectExpression | boolean>;
+    /**
+     * 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.
+     */
     handle(node: ObjectExpression): Promise<ObjectLiteralType>;
 }

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.js

@@ -1,6 +1,16 @@
 import { NodeHandler, ASTParser } from "./base.js";
 import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
+/**
+ * Handles object literal expressions in the LangChain Expression
+ * Language. Extends the NodeHandler class.
+ */
 export class ObjectLiteralExpressionHandler 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;
@@ -9,6 +19,12 @@ export class ObjectLiteralExpressionHandler extends NodeHandler {
             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");

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PropertyAssignmentHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handler for `PropertyAssignment` nodes in an AST. Extends the
+ * `NodeHandler` base class.
+ */
 class PropertyAssignmentHandler extends base_js_1.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 (base_js_1.ASTParser.isPropertyAssignment(node)) {
             return node;
@@ -11,6 +21,13 @@ class PropertyAssignmentHandler extends base_js_1.NodeHandler {
             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");

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

@@ -1,6 +1,23 @@
 import { NodeHandler } from "./base.js";
 import { PropertyAssignmentType } from "./types.js";
+/**
+ * Handler for `PropertyAssignment` nodes in an AST. Extends the
+ * `NodeHandler` base class.
+ */
 export declare class PropertyAssignmentHandler 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.
+     */
     accepts(node: ExpressionNode): Promise<PropertyAssignment | boolean>;
+    /**
+     * 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.
+     */
     handle(node: PropertyAssignment): Promise<PropertyAssignmentType>;
 }

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.js

@@ -1,5 +1,15 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handler for `PropertyAssignment` nodes in an AST. Extends the
+ * `NodeHandler` base class.
+ */
 export class PropertyAssignmentHandler 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;
@@ -8,6 +18,13 @@ export class PropertyAssignmentHandler extends NodeHandler {
             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");

package/dist/output_parsers/expression_type_handlers/string_literal_handler.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringLiteralHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handler for string literal nodes in the LangChain Expression Language.
+ * Extends the NodeHandler base class.
+ */
 class StringLiteralHandler extends base_js_1.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 (base_js_1.ASTParser.isStringLiteral(node)) {
             return node;
@@ -11,6 +21,12 @@ class StringLiteralHandler extends base_js_1.NodeHandler {
             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");

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

@@ -1,6 +1,22 @@
 import { NodeHandler } from "./base.js";
 import { StringLiteralType } from "./types.js";
+/**
+ * Handler for string literal nodes in the LangChain Expression Language.
+ * Extends the NodeHandler base class.
+ */
 export declare class StringLiteralHandler 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.
+     */
     accepts(node: ExpressionNode): Promise<StringLiteral | boolean>;
+    /**
+     * 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.
+     */
     handle(node: StringLiteral): Promise<StringLiteralType>;
 }

package/dist/output_parsers/expression_type_handlers/string_literal_handler.js

@@ -1,5 +1,15 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handler for string literal nodes in the LangChain Expression Language.
+ * Extends the NodeHandler base class.
+ */
 export class StringLiteralHandler 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;
@@ -8,6 +18,12 @@ export class StringLiteralHandler extends NodeHandler {
             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");