langchain 0.0.131 → 0.0.132

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

@@ -1,6 +1,24 @@
 import { NodeHandler } from "./base.js";
 import { ArrayLiteralType } from "./types.js";
+/**
+ * Handles array expressions in the LangChain Expression Language (LCEL).
+ * It extends the NodeHandler base class, providing functionality to
+ * accept and handle array expressions.
+ */
 export declare class ArrayLiteralExpressionHandler extends NodeHandler {
+    /**
+     * Checks if the given node is an array expression. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The ExpressionNode to check.
+     * @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.
+     */
     accepts(node: ExpressionNode): Promise<ArrayExpression | boolean>;
+    /**
+     * Handles the given array expression node. If the handler doesn't have a
+     * parent handler, it throws an error. Otherwise, it returns an object
+     * representing the array literal.
+     * @param node The ArrayExpression node to handle.
+     * @returns A Promise that resolves to an object representing the array literal.
+     */
     handle(node: ArrayExpression): Promise<ArrayLiteralType>;
 }

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.js

@@ -1,5 +1,16 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handles array expressions in the LangChain Expression Language (LCEL).
+ * It extends the NodeHandler base class, providing functionality to
+ * accept and handle array expressions.
+ */
 export class ArrayLiteralExpressionHandler extends NodeHandler {
+    /**
+     * Checks if the given node is an array expression. If it is, the method
+     * returns the node; otherwise, it returns false.
+     * @param node The ExpressionNode to check.
+     * @returns A Promise that resolves to either the ArrayExpression node if the node is an array expression, or false otherwise.
+     */
     async accepts(node) {
         if (ASTParser.isArrayExpression(node)) {
             return node;
@@ -8,6 +19,13 @@ export class ArrayLiteralExpressionHandler extends NodeHandler {
             return false;
         }
     }
+    /**
+     * Handles the given array expression node. If the handler doesn't have a
+     * parent handler, it throws an error. Otherwise, it returns an object
+     * representing the array literal.
+     * @param node The ArrayExpression node to handle.
+     * @returns A Promise that resolves to an object representing the array literal.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

package/dist/output_parsers/expression_type_handlers/base.cjs

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ASTParser = exports.NodeHandler = void 0;
 const parser_grammar_js_1 = require("./grammar/parser_grammar.cjs");
+/**
+ * Abstract class for handling nodes in an expression language. Subclasses
+ * must implement the `accepts` and `handle` methods.
+ */
 class NodeHandler {
     constructor(parentHandler) {
         Object.defineProperty(this, "parentHandler", {
@@ -13,7 +17,16 @@ class NodeHandler {
     }
 }
 exports.NodeHandler = NodeHandler;
+/**
+ * Utility class for parsing Abstract Syntax Trees (ASTs). Contains
+ * methods for identifying the type of a given node and a method for
+ * importing and generating a parser using the Peggy library.
+ */
 class ASTParser {
+    /**
+     * Imports and generates a parser using the Peggy library.
+     * @returns A Promise that resolves to the parser instance.
+     */
     static async importASTParser() {
         try {
             if (!ASTParser.astParseInstance) {
@@ -28,36 +41,91 @@ class ASTParser {
             throw new Error(`Failed to import peggy. Please install peggy (i.e. "npm install peggy" or "yarn add peggy").`);
         }
     }
+    /**
+     * Checks if the given node is a Program node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a Program node.
+     */
     static isProgram(node) {
         return node.type === "Program";
     }
+    /**
+     * Checks if the given node is an ExpressionStatement node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ExpressionStatement node.
+     */
     static isExpressionStatement(node) {
         return node.type === "ExpressionStatement";
     }
+    /**
+     * Checks if the given node is a CallExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a CallExpression node.
+     */
     static isCallExpression(node) {
         return node.type === "CallExpression";
     }
+    /**
+     * Checks if the given node is a StringLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a StringLiteral node.
+     */
     static isStringLiteral(node) {
         return node.type === "StringLiteral" && typeof node.value === "string";
     }
+    /**
+     * Checks if the given node is a NumericLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a NumericLiteral node.
+     */
     static isNumericLiteral(node) {
         return node.type === "NumericLiteral" && typeof node.value === "number";
     }
+    /**
+     * Checks if the given node is a BooleanLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a BooleanLiteral node.
+     */
     static isBooleanLiteral(node) {
         return node.type === "BooleanLiteral" && typeof node.value === "boolean";
     }
+    /**
+     * Checks if the given node is an Identifier node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an Identifier node.
+     */
     static isIdentifier(node) {
         return node.type === "Identifier";
     }
+    /**
+     * Checks if the given node is an ObjectExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ObjectExpression node.
+     */
     static isObjectExpression(node) {
         return node.type === "ObjectExpression";
     }
+    /**
+     * Checks if the given node is an ArrayExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ArrayExpression node.
+     */
     static isArrayExpression(node) {
         return node.type === "ArrayExpression";
     }
+    /**
+     * Checks if the given node is a PropertyAssignment node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a PropertyAssignment node.
+     */
     static isPropertyAssignment(node) {
         return node.type === "PropertyAssignment";
     }
+    /**
+     * Checks if the given node is a MemberExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a MemberExpression node.
+     */
     static isMemberExpression(node) {
         return node.type === "MemberExpression";
     }

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

@@ -1,21 +1,100 @@
+/**
+ * Abstract class for handling nodes in an expression language. Subclasses
+ * must implement the `accepts` and `handle` methods.
+ */
 export declare abstract class NodeHandler {
     protected parentHandler?: NodeHandler | undefined;
     constructor(parentHandler?: NodeHandler | undefined);
+    /**
+     * Determines whether the given node is acceptable.
+     * @param node The node to be checked.
+     * @returns A Promise that resolves to either the node itself or a boolean indicating whether the node is acceptable.
+     */
     abstract accepts(node: ExpressionNode): Promise<ExpressionNode | boolean>;
+    /**
+     * Handles the given node. The specifics of how the node is handled are
+     * determined by the subclass implementation.
+     * @param node The node to be handled.
+     * @returns A Promise that resolves to the result of handling the node.
+     */
     abstract handle(node: ExpressionNode): Promise<any>;
 }
+/**
+ * Utility class for parsing Abstract Syntax Trees (ASTs). Contains
+ * methods for identifying the type of a given node and a method for
+ * importing and generating a parser using the Peggy library.
+ */
 export declare class ASTParser {
     static astParseInstance: ParseFunction;
+    /**
+     * Imports and generates a parser using the Peggy library.
+     * @returns A Promise that resolves to the parser instance.
+     */
     static importASTParser(): Promise<ParseFunction>;
+    /**
+     * Checks if the given node is a Program node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a Program node.
+     */
     static isProgram(node: ExpressionNode): node is Program;
+    /**
+     * Checks if the given node is an ExpressionStatement node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ExpressionStatement node.
+     */
     static isExpressionStatement(node: ExpressionNode): node is ExpressionStatement;
+    /**
+     * Checks if the given node is a CallExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a CallExpression node.
+     */
     static isCallExpression(node: ExpressionNode): node is CallExpression;
+    /**
+     * Checks if the given node is a StringLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a StringLiteral node.
+     */
     static isStringLiteral(node: ExpressionNode): node is StringLiteral;
+    /**
+     * Checks if the given node is a NumericLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a NumericLiteral node.
+     */
     static isNumericLiteral(node: ExpressionNode): node is NumericLiteral;
+    /**
+     * Checks if the given node is a BooleanLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a BooleanLiteral node.
+     */
     static isBooleanLiteral(node: ExpressionNode): node is BooleanLiteral;
+    /**
+     * Checks if the given node is an Identifier node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an Identifier node.
+     */
     static isIdentifier(node: ExpressionNode): node is Identifier;
+    /**
+     * Checks if the given node is an ObjectExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ObjectExpression node.
+     */
     static isObjectExpression(node: ExpressionNode): node is ObjectExpression;
+    /**
+     * Checks if the given node is an ArrayExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ArrayExpression node.
+     */
     static isArrayExpression(node: ExpressionNode): node is ArrayExpression;
+    /**
+     * Checks if the given node is a PropertyAssignment node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a PropertyAssignment node.
+     */
     static isPropertyAssignment(node: ExpressionNode): node is PropertyAssignment;
+    /**
+     * Checks if the given node is a MemberExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a MemberExpression node.
+     */
     static isMemberExpression(node: ExpressionNode): node is MemberExpression;
 }

package/dist/output_parsers/expression_type_handlers/base.js

@@ -1,4 +1,8 @@
 import { GRAMMAR } from "./grammar/parser_grammar.js";
+/**
+ * Abstract class for handling nodes in an expression language. Subclasses
+ * must implement the `accepts` and `handle` methods.
+ */
 export class NodeHandler {
     constructor(parentHandler) {
         Object.defineProperty(this, "parentHandler", {
@@ -9,7 +13,16 @@ export class NodeHandler {
         });
     }
 }
+/**
+ * Utility class for parsing Abstract Syntax Trees (ASTs). Contains
+ * methods for identifying the type of a given node and a method for
+ * importing and generating a parser using the Peggy library.
+ */
 export class ASTParser {
+    /**
+     * Imports and generates a parser using the Peggy library.
+     * @returns A Promise that resolves to the parser instance.
+     */
     static async importASTParser() {
         try {
             if (!ASTParser.astParseInstance) {
@@ -24,36 +37,91 @@ export class ASTParser {
             throw new Error(`Failed to import peggy. Please install peggy (i.e. "npm install peggy" or "yarn add peggy").`);
         }
     }
+    /**
+     * Checks if the given node is a Program node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a Program node.
+     */
     static isProgram(node) {
         return node.type === "Program";
     }
+    /**
+     * Checks if the given node is an ExpressionStatement node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ExpressionStatement node.
+     */
     static isExpressionStatement(node) {
         return node.type === "ExpressionStatement";
     }
+    /**
+     * Checks if the given node is a CallExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a CallExpression node.
+     */
     static isCallExpression(node) {
         return node.type === "CallExpression";
     }
+    /**
+     * Checks if the given node is a StringLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a StringLiteral node.
+     */
     static isStringLiteral(node) {
         return node.type === "StringLiteral" && typeof node.value === "string";
     }
+    /**
+     * Checks if the given node is a NumericLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a NumericLiteral node.
+     */
     static isNumericLiteral(node) {
         return node.type === "NumericLiteral" && typeof node.value === "number";
     }
+    /**
+     * Checks if the given node is a BooleanLiteral node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a BooleanLiteral node.
+     */
     static isBooleanLiteral(node) {
         return node.type === "BooleanLiteral" && typeof node.value === "boolean";
     }
+    /**
+     * Checks if the given node is an Identifier node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an Identifier node.
+     */
     static isIdentifier(node) {
         return node.type === "Identifier";
     }
+    /**
+     * Checks if the given node is an ObjectExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ObjectExpression node.
+     */
     static isObjectExpression(node) {
         return node.type === "ObjectExpression";
     }
+    /**
+     * Checks if the given node is an ArrayExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is an ArrayExpression node.
+     */
     static isArrayExpression(node) {
         return node.type === "ArrayExpression";
     }
+    /**
+     * Checks if the given node is a PropertyAssignment node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a PropertyAssignment node.
+     */
     static isPropertyAssignment(node) {
         return node.type === "PropertyAssignment";
     }
+    /**
+     * Checks if the given node is a MemberExpression node.
+     * @param node The node to be checked.
+     * @returns A boolean indicating whether the node is a MemberExpression node.
+     */
     static isMemberExpression(node) {
         return node.type === "MemberExpression";
     }

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.cjs

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BooleanLiteralHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handler for boolean literal nodes in the abstract syntax tree (AST).
+ * Extends the NodeHandler class.
+ */
 class BooleanLiteralHandler extends base_js_1.NodeHandler {
+    /**
+     * Checks if a given node is a boolean literal. 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 boolean literal, or false otherwise.
+     */
     async accepts(node) {
         if (base_js_1.ASTParser.isBooleanLiteral(node)) {
             return node;
@@ -11,6 +21,14 @@ class BooleanLiteralHandler extends base_js_1.NodeHandler {
             return false;
         }
     }
+    /**
+     * Handles the boolean literal node. Throws an error if there is no parent
+     * handler. If there is a parent handler, it returns an object of type
+     * BooleanLiteralType which includes the type of the node
+     * ("boolean_literal") and the value of the boolean literal.
+     * @param node The boolean literal node to handle.
+     * @returns An object of type BooleanLiteralType representing the handled node.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

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

@@ -1,6 +1,24 @@
 import { NodeHandler } from "./base.js";
 import { BooleanLiteralType } from "./types.js";
+/**
+ * Handler for boolean literal nodes in the abstract syntax tree (AST).
+ * Extends the NodeHandler class.
+ */
 export declare class BooleanLiteralHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a boolean literal. 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 boolean literal, or false otherwise.
+     */
     accepts(node: ExpressionNode): Promise<BooleanLiteral | boolean>;
+    /**
+     * Handles the boolean literal node. Throws an error if there is no parent
+     * handler. If there is a parent handler, it returns an object of type
+     * BooleanLiteralType which includes the type of the node
+     * ("boolean_literal") and the value of the boolean literal.
+     * @param node The boolean literal node to handle.
+     * @returns An object of type BooleanLiteralType representing the handled node.
+     */
     handle(node: BooleanLiteral): Promise<BooleanLiteralType>;
 }

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.js

@@ -1,5 +1,15 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handler for boolean literal nodes in the abstract syntax tree (AST).
+ * Extends the NodeHandler class.
+ */
 export class BooleanLiteralHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a boolean literal. 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 boolean literal, or false otherwise.
+     */
     async accepts(node) {
         if (ASTParser.isBooleanLiteral(node)) {
             return node;
@@ -8,6 +18,14 @@ export class BooleanLiteralHandler extends NodeHandler {
             return false;
         }
     }
+    /**
+     * Handles the boolean literal node. Throws an error if there is no parent
+     * handler. If there is a parent handler, it returns an object of type
+     * BooleanLiteralType which includes the type of the node
+     * ("boolean_literal") and the value of the boolean literal.
+     * @param node The boolean literal node to handle.
+     * @returns An object of type BooleanLiteralType representing the handled node.
+     */
     async handle(node) {
         if (!this.parentHandler) {
             throw new Error("ArrayLiteralExpressionHandler must have a parent handler");

package/dist/output_parsers/expression_type_handlers/call_expression_handler.cjs

@@ -2,7 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallExpressionHandler = void 0;
 const base_js_1 = require("./base.cjs");
+/**
+ * Handles call expressions in the AST parsed by the `ASTParser`. This
+ * class is part of the LangChain Expression Language (LCEL), a
+ * declarative way to compose chains together in LangChain.
+ */
 class CallExpressionHandler extends base_js_1.NodeHandler {
+    /**
+     * Checks if a given node is a call expression. If it is, it returns the
+     * node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is a call expression, or false otherwise.
+     */
     async accepts(node) {
         if (base_js_1.ASTParser.isCallExpression(node)) {
             return node;
@@ -11,6 +22,17 @@ class CallExpressionHandler extends base_js_1.NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes a call expression node. It checks the type of the callee (the
+     * function being called) and the arguments passed to it. If the callee is
+     * an identifier, it extracts the function name. If the callee is a member
+     * expression, it delegates handling to the parent handler. It also checks
+     * the types of the arguments and delegates their handling to the parent
+     * handler. The method returns an object representing the call expression,
+     * including the function call and its arguments.
+     * @param node The call expression node to process.
+     * @returns An object representing the call expression, including the function call and its arguments.
+     */
     async handle(node) {
         function checkCallExpressionArgumentType(arg) {
             return [

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

@@ -1,6 +1,28 @@
 import { NodeHandler } from "./base.js";
 import { CallExpressionType } from "./types.js";
+/**
+ * Handles call expressions in the AST parsed by the `ASTParser`. This
+ * class is part of the LangChain Expression Language (LCEL), a
+ * declarative way to compose chains together in LangChain.
+ */
 export declare class CallExpressionHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a call expression. If it is, it returns the
+     * node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is a call expression, or false otherwise.
+     */
     accepts(node: ExpressionNode): Promise<CallExpression | boolean>;
+    /**
+     * Processes a call expression node. It checks the type of the callee (the
+     * function being called) and the arguments passed to it. If the callee is
+     * an identifier, it extracts the function name. If the callee is a member
+     * expression, it delegates handling to the parent handler. It also checks
+     * the types of the arguments and delegates their handling to the parent
+     * handler. The method returns an object representing the call expression,
+     * including the function call and its arguments.
+     * @param node The call expression node to process.
+     * @returns An object representing the call expression, including the function call and its arguments.
+     */
     handle(node: CallExpression): Promise<CallExpressionType>;
 }

package/dist/output_parsers/expression_type_handlers/call_expression_handler.js

@@ -1,5 +1,16 @@
 import { NodeHandler, ASTParser } from "./base.js";
+/**
+ * Handles call expressions in the AST parsed by the `ASTParser`. This
+ * class is part of the LangChain Expression Language (LCEL), a
+ * declarative way to compose chains together in LangChain.
+ */
 export class CallExpressionHandler extends NodeHandler {
+    /**
+     * Checks if a given node is a call expression. If it is, it returns the
+     * node; otherwise, it returns false.
+     * @param node The node to check.
+     * @returns The node if it is a call expression, or false otherwise.
+     */
     async accepts(node) {
         if (ASTParser.isCallExpression(node)) {
             return node;
@@ -8,6 +19,17 @@ export class CallExpressionHandler extends NodeHandler {
             return false;
         }
     }
+    /**
+     * Processes a call expression node. It checks the type of the callee (the
+     * function being called) and the arguments passed to it. If the callee is
+     * an identifier, it extracts the function name. If the callee is a member
+     * expression, it delegates handling to the parent handler. It also checks
+     * the types of the arguments and delegates their handling to the parent
+     * handler. The method returns an object representing the call expression,
+     * including the function call and its arguments.
+     * @param node The call expression node to process.
+     * @returns An object representing the call expression, including the function call and its arguments.
+     */
     async handle(node) {
         function checkCallExpressionArgumentType(arg) {
             return [

package/dist/output_parsers/expression_type_handlers/factory.cjs

@@ -22,6 +22,13 @@ const handlers = [
     string_literal_handler_js_1.StringLiteralHandler,
     identifier_handler_js_1.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.
+ */
 class MasterHandler extends base_js_1.NodeHandler {
     constructor() {
         super(...arguments);
@@ -35,6 +42,14 @@ class MasterHandler extends base_js_1.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);
@@ -44,6 +59,11 @@ class MasterHandler extends base_js_1.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/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;
 }