langchain 0.0.76 → 0.0.77

package/dist/output_parsers/expression.d.ts

@@ -0,0 +1,25 @@
+import { ParsedType } from "./expression_type_handlers/types.js";
+import { BaseOutputParser } from "../schema/output_parser.js";
+/**
+ * okay so we need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+export declare class ExpressionParser extends BaseOutputParser<ParsedType> {
+    parse(text: string): Promise<ParsedType>;
+    getFormatInstructions(): string;
+}
+export * from "./expression_type_handlers/types.js";
+export { MasterHandler } from "./expression_type_handlers/factory.js";

package/dist/output_parsers/expression.js

@@ -0,0 +1,49 @@
+import { MasterHandler } from "./expression_type_handlers/factory.js";
+import { BaseOutputParser } from "../schema/output_parser.js";
+import { ASTParser } from "./expression_type_handlers/base.js";
+/**
+ * okay so we need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+export class ExpressionParser extends BaseOutputParser {
+    async parse(text) {
+        const parse = await ASTParser.importASTParser();
+        try {
+            const program = parse(text);
+            if (program.body.length > 1) {
+                throw new Error(`Expected 1 statement, got ${program.body.length}`);
+            }
+            const [node] = program.body;
+            if (!ASTParser.isExpressionStatement(node)) {
+                throw new Error(`Expected ExpressionStatement, got ${node.type}`);
+            }
+            const { expression: expressionStatement } = node;
+            if (!ASTParser.isCallExpression(expressionStatement)) {
+                throw new Error("Expected CallExpression");
+            }
+            const masterHandler = MasterHandler.createMasterHandler();
+            return await masterHandler.handle(expressionStatement);
+        }
+        catch (err) {
+            throw new Error(`Error parsing ${err}: ${text}`);
+        }
+    }
+    getFormatInstructions() {
+        return "";
+    }
+}
+export * from "./expression_type_handlers/types.js";
+export { MasterHandler } from "./expression_type_handlers/factory.js";

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayLiteralExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class ArrayLiteralExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isArrayExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "array_literal",
+            values: await Promise.all(node.elements.map((innerNode) => 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.parentHandler.handle(innerNode))),
+        };
+    }
+}
+exports.ArrayLiteralExpressionHandler = ArrayLiteralExpressionHandler;

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

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { ArrayLiteralType } from "./types.js";
+export declare class ArrayLiteralExpressionHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.ArrayExpression | boolean>;
+    handle(node: ESTree.ArrayExpression): Promise<ArrayLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.js

@@ -0,0 +1,22 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class ArrayLiteralExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isArrayExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "array_literal",
+            values: await Promise.all(node.elements.map((innerNode) => 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.parentHandler.handle(innerNode))),
+        };
+    }
+}

package/dist/output_parsers/expression_type_handlers/base.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTParser = exports.NodeHandler = void 0;
+class NodeHandler {
+    constructor(parentHandler) {
+        Object.defineProperty(this, "parentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parentHandler
+        });
+    }
+}
+exports.NodeHandler = NodeHandler;
+class ASTParser {
+    static async importASTParser() {
+        try {
+            if (!ASTParser.astParseInstance) {
+                const meriyah = await import("meriyah");
+                ASTParser.astParseInstance =
+                    meriyah.parseScript;
+            }
+            return ASTParser.astParseInstance;
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error("Failed to import meriyah. Please install meriyah (i.e. npm install meriyah).");
+        }
+    }
+    static isProgram(node) {
+        return node.type === "Program";
+    }
+    static isExpressionStatement(node) {
+        return node.type === "ExpressionStatement";
+    }
+    static isCallExpression(node) {
+        return node.type === "CallExpression";
+    }
+    static isLiteral(node) {
+        return node.type === "Literal";
+    }
+    static isStringLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "string";
+    }
+    static isNumericLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "number";
+    }
+    static isBooleanLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "boolean";
+    }
+    static isIdentifier(node) {
+        return node.type === "Identifier";
+    }
+    static isObjectExpression(node) {
+        return node.type === "ObjectExpression";
+    }
+    static isArrayExpression(node) {
+        return node.type === "ArrayExpression";
+    }
+    static isProperty(node) {
+        return node.type === "Property";
+    }
+    static isMemberExpression(node) {
+        return node.type === "MemberExpression";
+    }
+}
+exports.ASTParser = ASTParser;

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

@@ -0,0 +1,23 @@
+import type meriyahT from "meriyah";
+export declare abstract class NodeHandler {
+    protected parentHandler?: NodeHandler | undefined;
+    constructor(parentHandler?: NodeHandler | undefined);
+    abstract accepts(node: meriyahT.ESTree.Node): Promise<meriyahT.ESTree.Node | boolean>;
+    abstract handle(node: meriyahT.ESTree.Node): Promise<any>;
+}
+export declare class ASTParser {
+    static astParseInstance: typeof meriyahT.parseScript;
+    static importASTParser(): Promise<typeof meriyahT.parseScript>;
+    static isProgram(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Program;
+    static isExpressionStatement(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.ExpressionStatement;
+    static isCallExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.CallExpression;
+    static isLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isStringLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isNumericLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isBooleanLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isIdentifier(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Identifier;
+    static isObjectExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.ObjectExpression;
+    static isArrayExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.ArrayExpression;
+    static isProperty(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Property;
+    static isMemberExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.MemberExpression;
+}

package/dist/output_parsers/expression_type_handlers/base.js

@@ -0,0 +1,62 @@
+export class NodeHandler {
+    constructor(parentHandler) {
+        Object.defineProperty(this, "parentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parentHandler
+        });
+    }
+}
+export class ASTParser {
+    static async importASTParser() {
+        try {
+            if (!ASTParser.astParseInstance) {
+                const meriyah = await import("meriyah");
+                ASTParser.astParseInstance =
+                    meriyah.parseScript;
+            }
+            return ASTParser.astParseInstance;
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error("Failed to import meriyah. Please install meriyah (i.e. npm install meriyah).");
+        }
+    }
+    static isProgram(node) {
+        return node.type === "Program";
+    }
+    static isExpressionStatement(node) {
+        return node.type === "ExpressionStatement";
+    }
+    static isCallExpression(node) {
+        return node.type === "CallExpression";
+    }
+    static isLiteral(node) {
+        return node.type === "Literal";
+    }
+    static isStringLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "string";
+    }
+    static isNumericLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "number";
+    }
+    static isBooleanLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "boolean";
+    }
+    static isIdentifier(node) {
+        return node.type === "Identifier";
+    }
+    static isObjectExpression(node) {
+        return node.type === "ObjectExpression";
+    }
+    static isArrayExpression(node) {
+        return node.type === "ArrayExpression";
+    }
+    static isProperty(node) {
+        return node.type === "Property";
+    }
+    static isMemberExpression(node) {
+        return node.type === "MemberExpression";
+    }
+}

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanLiteralHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class BooleanLiteralHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isBooleanLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "boolean_literal",
+            value: node.value,
+        };
+    }
+}
+exports.BooleanLiteralHandler = BooleanLiteralHandler;

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

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { BooleanLiteralType } from "./types.js";
+export declare class BooleanLiteralHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.Literal | boolean>;
+    handle(node: ESTree.Literal): Promise<BooleanLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.js

@@ -0,0 +1,20 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class BooleanLiteralHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isBooleanLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "boolean_literal",
+            value: node.value,
+        };
+    }
+}

package/dist/output_parsers/expression_type_handlers/call_expression_handler.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class CallExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isCallExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        function checkCallExpressionArgumentType(arg) {
+            return [
+                base_js_1.ASTParser.isStringLiteral,
+                base_js_1.ASTParser.isNumericLiteral,
+                base_js_1.ASTParser.isBooleanLiteral,
+                base_js_1.ASTParser.isArrayExpression,
+                base_js_1.ASTParser.isObjectExpression,
+                base_js_1.ASTParser.isCallExpression,
+                base_js_1.ASTParser.isIdentifier,
+            ].reduce((acc, func) => acc || func(arg), false);
+        }
+        if (this.parentHandler === undefined) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { callee } = node;
+        let funcCall;
+        if (base_js_1.ASTParser.isIdentifier(callee)) {
+            funcCall = callee.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (base_js_1.ASTParser.isMemberExpression(callee)) {
+            funcCall = (await this.parentHandler.handle(callee));
+        }
+        else {
+            throw new Error("Unknown expression type");
+        }
+        const args = await Promise.all(node.arguments.map((arg) => {
+            if (!checkCallExpressionArgumentType(arg)) {
+                throw new Error("Unknown argument type");
+            }
+            if (!this.parentHandler) {
+                throw new Error("CallExpressionHandler must have a parent handler");
+            }
+            return this.parentHandler.handle(arg);
+        }));
+        return { type: "call_expression", funcCall, args };
+    }
+}
+exports.CallExpressionHandler = CallExpressionHandler;

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

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { CallExpressionType } from "./types.js";
+export declare class CallExpressionHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.CallExpression | boolean>;
+    handle(node: ESTree.CallExpression): Promise<CallExpressionType>;
+}

package/dist/output_parsers/expression_type_handlers/call_expression_handler.js

@@ -0,0 +1,48 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class CallExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isCallExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        function checkCallExpressionArgumentType(arg) {
+            return [
+                ASTParser.isStringLiteral,
+                ASTParser.isNumericLiteral,
+                ASTParser.isBooleanLiteral,
+                ASTParser.isArrayExpression,
+                ASTParser.isObjectExpression,
+                ASTParser.isCallExpression,
+                ASTParser.isIdentifier,
+            ].reduce((acc, func) => acc || func(arg), false);
+        }
+        if (this.parentHandler === undefined) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { callee } = node;
+        let funcCall;
+        if (ASTParser.isIdentifier(callee)) {
+            funcCall = callee.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (ASTParser.isMemberExpression(callee)) {
+            funcCall = (await this.parentHandler.handle(callee));
+        }
+        else {
+            throw new Error("Unknown expression type");
+        }
+        const args = await Promise.all(node.arguments.map((arg) => {
+            if (!checkCallExpressionArgumentType(arg)) {
+                throw new Error("Unknown argument type");
+            }
+            if (!this.parentHandler) {
+                throw new Error("CallExpressionHandler must have a parent handler");
+            }
+            return this.parentHandler.handle(arg);
+        }));
+        return { type: "call_expression", funcCall, args };
+    }
+}

package/dist/output_parsers/expression_type_handlers/factory.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MasterHandler = void 0;
+const base_js_1 = require("./base.cjs");
+const array_literal_expression_handler_js_1 = require("./array_literal_expression_handler.cjs");
+const boolean_literal_handler_js_1 = require("./boolean_literal_handler.cjs");
+const call_expression_handler_js_1 = require("./call_expression_handler.cjs");
+const numeric_literal_handler_js_1 = require("./numeric_literal_handler.cjs");
+const object_literal_expression_handler_js_1 = require("./object_literal_expression_handler.cjs");
+const property_assignment_handler_js_1 = require("./property_assignment_handler.cjs");
+const string_literal_handler_js_1 = require("./string_literal_handler.cjs");
+const identifier_handler_js_1 = require("./identifier_handler.cjs");
+const member_expression_handler_js_1 = require("./member_expression_handler.cjs");
+const handlers = [
+    array_literal_expression_handler_js_1.ArrayLiteralExpressionHandler,
+    boolean_literal_handler_js_1.BooleanLiteralHandler,
+    call_expression_handler_js_1.CallExpressionHandler,
+    numeric_literal_handler_js_1.NumericLiteralHandler,
+    object_literal_expression_handler_js_1.ObjectLiteralExpressionHandler,
+    member_expression_handler_js_1.MemberExpressionHandler,
+    property_assignment_handler_js_1.PropertyAssignmentHandler,
+    string_literal_handler_js_1.StringLiteralHandler,
+    identifier_handler_js_1.IdentifierHandler,
+];
+class MasterHandler extends base_js_1.NodeHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nodeHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async accepts(node) {
+        throw new Error(`Master handler does not accept any nodes: ${node}`);
+    }
+    async handle(node) {
+        for (const handler of this.nodeHandlers) {
+            const accepts = await handler.accepts(node);
+            if (accepts) {
+                return handler.handle(node);
+            }
+        }
+        throw new Error(`No handler found for node: ${node}`);
+    }
+    static createMasterHandler() {
+        const masterHandler = new MasterHandler();
+        handlers.forEach((Handler) => {
+            const handlerInstance = new Handler(masterHandler);
+            masterHandler.nodeHandlers.push(handlerInstance);
+        });
+        return masterHandler;
+    }
+}
+exports.MasterHandler = MasterHandler;

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

@@ -0,0 +1,9 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { ParsedType } from "./types.js";
+export declare class MasterHandler extends NodeHandler {
+    nodeHandlers: NodeHandler[];
+    accepts(node: ESTree.Node): Promise<ESTree.Node | boolean>;
+    handle(node: ESTree.CallExpression): Promise<ParsedType>;
+    static createMasterHandler(): MasterHandler;
+}

package/dist/output_parsers/expression_type_handlers/factory.js

@@ -0,0 +1,52 @@
+import { NodeHandler } from "./base.js";
+import { ArrayLiteralExpressionHandler } from "./array_literal_expression_handler.js";
+import { BooleanLiteralHandler } from "./boolean_literal_handler.js";
+import { CallExpressionHandler } from "./call_expression_handler.js";
+import { NumericLiteralHandler } from "./numeric_literal_handler.js";
+import { ObjectLiteralExpressionHandler } from "./object_literal_expression_handler.js";
+import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
+import { StringLiteralHandler } from "./string_literal_handler.js";
+import { IdentifierHandler } from "./identifier_handler.js";
+import { MemberExpressionHandler } from "./member_expression_handler.js";
+const handlers = [
+    ArrayLiteralExpressionHandler,
+    BooleanLiteralHandler,
+    CallExpressionHandler,
+    NumericLiteralHandler,
+    ObjectLiteralExpressionHandler,
+    MemberExpressionHandler,
+    PropertyAssignmentHandler,
+    StringLiteralHandler,
+    IdentifierHandler,
+];
+export class MasterHandler extends NodeHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nodeHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async accepts(node) {
+        throw new Error(`Master handler does not accept any nodes: ${node}`);
+    }
+    async handle(node) {
+        for (const handler of this.nodeHandlers) {
+            const accepts = await handler.accepts(node);
+            if (accepts) {
+                return handler.handle(node);
+            }
+        }
+        throw new Error(`No handler found for node: ${node}`);
+    }
+    static createMasterHandler() {
+        const masterHandler = new MasterHandler();
+        handlers.forEach((Handler) => {
+            const handlerInstance = new Handler(masterHandler);
+            masterHandler.nodeHandlers.push(handlerInstance);
+        });
+        return masterHandler;
+    }
+}

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class IdentifierHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isIdentifier(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = node.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "identifier", value: text };
+    }
+}
+exports.IdentifierHandler = IdentifierHandler;

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

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { IdentifierType } from "./types.js";
+export declare class IdentifierHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.Identifier | boolean>;
+    handle(node: ESTree.Identifier): Promise<IdentifierType>;
+}

package/dist/output_parsers/expression_type_handlers/identifier_handler.js

@@ -0,0 +1,18 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class IdentifierHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isIdentifier(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = node.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "identifier", value: text };
+    }
+}