langchain 0.0.76 → 0.0.78

package/dist/chains/query_constructor/index.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { QueryTransformer } from "./parser.js";
+import { Comparators, Operators, StructuredQuery, } from "./ir.js";
+import { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, } from "./prompt.js";
+import { interpolateFString } from "../../prompts/template.js";
+import { LLMChain } from "../llm_chain.js";
+import { FewShotPromptTemplate } from "../../prompts/few_shot.js";
+import { AsymmetricStructuredOutputParser } from "../../output_parsers/structured.js";
+export { QueryTransformer };
+export { DEFAULT_EXAMPLES, DEFAULT_PREFIX, DEFAULT_SCHEMA, DEFAULT_SUFFIX, EXAMPLE_PROMPT, };
+const queryInputSchema = /* #__PURE__ */ z.object({
+    query: /* #__PURE__ */ z
+        .string()
+        .describe("text string to compare to document contents"),
+    filter: /* #__PURE__ */ z
+        .string()
+        .optional()
+        .describe("logical condition statement for filtering documents"),
+});
+export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser {
+    constructor(parserFunction) {
+        super(queryInputSchema);
+        Object.defineProperty(this, "parserFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parserFunction
+        });
+    }
+    async outputProcessor(input) {
+        return this.parserFunction(input.query, input.filter);
+    }
+    static fromComponents(allowedComparators = [], allowedOperators = []) {
+        const queryTransformer = new QueryTransformer(allowedComparators, allowedOperators);
+        return new StructuredQueryOutputParser(async (query, filter) => {
+            let myQuery = query;
+            if (myQuery.length === 0) {
+                myQuery = " ";
+            }
+            if (filter === "NO_FILTER" || filter === undefined) {
+                return new StructuredQuery(query);
+            }
+            else {
+                const parsedFilter = await queryTransformer.parse(filter);
+                return new StructuredQuery(query, parsedFilter);
+            }
+        });
+    }
+}
+export function formatAttributeInfo(info) {
+    const infoObj = info.reduce((acc, attr) => {
+        acc[attr.name] = {
+            type: attr.type,
+            description: attr.description,
+        };
+        return acc;
+    }, {});
+    return JSON.stringify(infoObj, null, 2)
+        .replaceAll("{", "{{")
+        .replaceAll("}", "}}");
+}
+const defaultExample = DEFAULT_EXAMPLES.map((EXAMPLE) => EXAMPLE);
+function _getPrompt(documentContents, attributeInfo, allowedComparators, allowedOperators, examples = defaultExample) {
+    const myAllowedComparators = allowedComparators ?? Object.values(Comparators);
+    const myAllowedOperators = allowedOperators ?? Object.values(Operators);
+    const attributeJSON = formatAttributeInfo(attributeInfo);
+    const schema = interpolateFString(DEFAULT_SCHEMA, {
+        allowed_comparators: myAllowedComparators.join(" | "),
+        allowed_operators: myAllowedOperators.join(" | "),
+    });
+    const prefix = interpolateFString(DEFAULT_PREFIX, {
+        schema,
+    });
+    const suffix = interpolateFString(DEFAULT_SUFFIX, {
+        i: examples.length + 1,
+        content: documentContents,
+        attributes: attributeJSON,
+    });
+    const outputParser = StructuredQueryOutputParser.fromComponents(allowedComparators, allowedOperators);
+    return new FewShotPromptTemplate({
+        examples,
+        examplePrompt: EXAMPLE_PROMPT,
+        inputVariables: ["query"],
+        suffix,
+        prefix,
+        outputParser,
+    });
+}
+export function loadQueryContstructorChain(opts) {
+    const prompt = _getPrompt(opts.documentContents, opts.attributeInfo, opts.allowedComparators, opts.allowedOperators, opts.examples);
+    return new LLMChain({
+        llm: opts.llm,
+        prompt,
+    });
+}

package/dist/chains/query_constructor/ir.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructuredQuery = exports.Operation = exports.Comparison = exports.FilterDirective = exports.Expression = exports.Visitor = exports.Comparators = exports.Operators = void 0;
+exports.Operators = {
+    and: "and",
+    or: "or",
+    not: "not",
+};
+exports.Comparators = {
+    eq: "eq",
+    lt: "lt",
+    gt: "gt",
+    lte: "lte",
+    gte: "gte",
+};
+class Visitor {
+}
+exports.Visitor = Visitor;
+class Expression {
+    accept(visitor) {
+        if (this.exprName === "Operation") {
+            return visitor.visitOperation(this);
+        }
+        else if (this.exprName === "Comparison") {
+            return visitor.visitComparison(this);
+        }
+        else if (this.exprName === "StructuredQuery") {
+            return visitor.visitStructuredQuery(this);
+        }
+        else {
+            throw new Error("Unknown Expression type");
+        }
+    }
+}
+exports.Expression = Expression;
+class FilterDirective extends Expression {
+}
+exports.FilterDirective = FilterDirective;
+class Comparison extends FilterDirective {
+    constructor(comparator, attribute, value) {
+        super();
+        Object.defineProperty(this, "comparator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: comparator
+        });
+        Object.defineProperty(this, "attribute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: attribute
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: value
+        });
+        Object.defineProperty(this, "exprName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Comparison"
+        });
+    }
+}
+exports.Comparison = Comparison;
+class Operation extends FilterDirective {
+    constructor(operator, args) {
+        super();
+        Object.defineProperty(this, "operator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: operator
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: args
+        });
+        Object.defineProperty(this, "exprName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Operation"
+        });
+    }
+}
+exports.Operation = Operation;
+class StructuredQuery extends Expression {
+    constructor(query, filter) {
+        super();
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: query
+        });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: filter
+        });
+        Object.defineProperty(this, "exprName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "StructuredQuery"
+        });
+    }
+}
+exports.StructuredQuery = StructuredQuery;

package/dist/chains/query_constructor/ir.d.ts

@@ -0,0 +1,60 @@
+export type AND = "and";
+export type OR = "or";
+export type NOT = "not";
+export type Operator = AND | OR | NOT;
+export type EQ = "eq";
+export type LT = "lt";
+export type GT = "gt";
+export type LTE = "lte";
+export type GTE = "gte";
+export type Comparator = EQ | LT | GT | LTE | GTE;
+export declare const Operators: {
+    [key: string]: Operator;
+};
+export declare const Comparators: {
+    [key: string]: Comparator;
+};
+export type VisitorResult = VisitorOperationResult | VisitorComparisonResult | VisitorStructuredQueryResult;
+export type VisitorOperationResult = {
+    [operator: string]: VisitorResult[];
+};
+export type VisitorComparisonResult = {
+    [attr: string]: {
+        [comparator: string]: string | number;
+    };
+};
+export type VisitorStructuredQueryResult = {
+    filter?: VisitorStructuredQueryResult | VisitorComparisonResult | VisitorOperationResult;
+};
+export declare abstract class Visitor {
+    abstract allowedOperators: Operator[];
+    abstract allowedComparators: Comparator[];
+    abstract visitOperation(operation: Operation): VisitorOperationResult;
+    abstract visitComparison(comparison: Comparison): VisitorComparisonResult;
+    abstract visitStructuredQuery(structuredQuery: StructuredQuery): VisitorStructuredQueryResult;
+}
+export declare abstract class Expression {
+    abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
+    accept(visitor: Visitor): VisitorOperationResult | VisitorComparisonResult | VisitorStructuredQueryResult;
+}
+export declare abstract class FilterDirective extends Expression {
+}
+export declare class Comparison extends FilterDirective {
+    comparator: Comparator;
+    attribute: string;
+    value: string | number;
+    exprName: "Comparison";
+    constructor(comparator: Comparator, attribute: string, value: string | number);
+}
+export declare class Operation extends FilterDirective {
+    operator: Operator;
+    args?: FilterDirective[] | undefined;
+    exprName: "Operation";
+    constructor(operator: Operator, args?: FilterDirective[] | undefined);
+}
+export declare class StructuredQuery extends Expression {
+    query: string;
+    filter?: FilterDirective | undefined;
+    exprName: "StructuredQuery";
+    constructor(query: string, filter?: FilterDirective | undefined);
+}

package/dist/chains/query_constructor/ir.js

@@ -0,0 +1,107 @@
+export const Operators = {
+    and: "and",
+    or: "or",
+    not: "not",
+};
+export const Comparators = {
+    eq: "eq",
+    lt: "lt",
+    gt: "gt",
+    lte: "lte",
+    gte: "gte",
+};
+export class Visitor {
+}
+export class Expression {
+    accept(visitor) {
+        if (this.exprName === "Operation") {
+            return visitor.visitOperation(this);
+        }
+        else if (this.exprName === "Comparison") {
+            return visitor.visitComparison(this);
+        }
+        else if (this.exprName === "StructuredQuery") {
+            return visitor.visitStructuredQuery(this);
+        }
+        else {
+            throw new Error("Unknown Expression type");
+        }
+    }
+}
+export class FilterDirective extends Expression {
+}
+export class Comparison extends FilterDirective {
+    constructor(comparator, attribute, value) {
+        super();
+        Object.defineProperty(this, "comparator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: comparator
+        });
+        Object.defineProperty(this, "attribute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: attribute
+        });
+        Object.defineProperty(this, "value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: value
+        });
+        Object.defineProperty(this, "exprName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Comparison"
+        });
+    }
+}
+export class Operation extends FilterDirective {
+    constructor(operator, args) {
+        super();
+        Object.defineProperty(this, "operator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: operator
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: args
+        });
+        Object.defineProperty(this, "exprName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "Operation"
+        });
+    }
+}
+export class StructuredQuery extends Expression {
+    constructor(query, filter) {
+        super();
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: query
+        });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: filter
+        });
+        Object.defineProperty(this, "exprName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "StructuredQuery"
+        });
+    }
+}

package/dist/chains/query_constructor/parser.cjs

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTransformer = void 0;
+const ir_js_1 = require("./ir.cjs");
+const expression_js_1 = require("../../output_parsers/expression.cjs");
+class QueryTransformer {
+    constructor(allowedComparators = [], allowedOperators = []) {
+        Object.defineProperty(this, "allowedComparators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: allowedComparators
+        });
+        Object.defineProperty(this, "allowedOperators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: allowedOperators
+        });
+    }
+    matchFunctionName(funcName) {
+        if (funcName in ir_js_1.Comparators) {
+            if (this.allowedComparators.length > 0) {
+                if (this.allowedComparators.includes(funcName)) {
+                    return funcName;
+                }
+                else {
+                    throw new Error("Received comparator not allowed");
+                }
+            }
+            else {
+                return funcName;
+            }
+        }
+        if (funcName in ir_js_1.Operators) {
+            if (this.allowedOperators.length > 0) {
+                if (this.allowedOperators.includes(funcName)) {
+                    return funcName;
+                }
+                else {
+                    throw new Error("Received operator not allowed");
+                }
+            }
+            else {
+                return funcName;
+            }
+        }
+        throw new Error("Unknown function name");
+    }
+    transform(parsed) {
+        const traverse = (node) => {
+            switch (node.type) {
+                case "call_expression": {
+                    if (typeof node.funcCall !== "string") {
+                        throw new Error("Property access expression and element access expression not supported");
+                    }
+                    const funcName = this.matchFunctionName(node.funcCall);
+                    if (funcName in ir_js_1.Operators) {
+                        return new ir_js_1.Operation(funcName, node.args?.map((arg) => traverse(arg)));
+                    }
+                    if (funcName in ir_js_1.Comparators) {
+                        if (node.args && node.args.length === 2) {
+                            return new ir_js_1.Comparison(funcName, traverse(node.args[0]), traverse(node.args[1]));
+                        }
+                        throw new Error("Comparator must have exactly 2 arguments");
+                    }
+                    throw new Error("Function name neither operator nor comparator");
+                }
+                case "string_literal": {
+                    return node.value;
+                }
+                case "numeric_literal": {
+                    return node.value;
+                }
+                case "array_literal": {
+                    return node.values.map((value) => traverse(value));
+                }
+                case "object_literal": {
+                    return node.values.reduce((acc, value) => {
+                        acc[value.identifier] = traverse(value.value);
+                        return acc;
+                    }, {});
+                }
+                case "boolean_literal": {
+                    return node.value;
+                }
+                default: {
+                    throw new Error("Unknown node type");
+                }
+            }
+        };
+        return traverse(parsed);
+    }
+    async parse(expression) {
+        const expressionParser = new expression_js_1.ExpressionParser();
+        const parsed = (await expressionParser.parse(expression));
+        if (!parsed) {
+            throw new Error("Could not parse expression");
+        }
+        return this.transform(parsed);
+    }
+}
+exports.QueryTransformer = QueryTransformer;

package/dist/chains/query_constructor/parser.d.ts

@@ -0,0 +1,12 @@
+import { Comparator, Comparison, Operation, Operator } from "./ir.js";
+export type TraverseType = boolean | Operation | Comparison | string | number | {
+    [key: string]: TraverseType;
+} | TraverseType[];
+export declare class QueryTransformer {
+    allowedComparators: Comparator[];
+    allowedOperators: Operator[];
+    constructor(allowedComparators?: Comparator[], allowedOperators?: Operator[]);
+    private matchFunctionName;
+    private transform;
+    parse(expression: string): Promise<Operation | Comparison>;
+}

package/dist/chains/query_constructor/parser.js

@@ -0,0 +1,99 @@
+import { Comparators, Comparison, Operation, Operators, } from "./ir.js";
+import { ExpressionParser, } from "../../output_parsers/expression.js";
+export class QueryTransformer {
+    constructor(allowedComparators = [], allowedOperators = []) {
+        Object.defineProperty(this, "allowedComparators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: allowedComparators
+        });
+        Object.defineProperty(this, "allowedOperators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: allowedOperators
+        });
+    }
+    matchFunctionName(funcName) {
+        if (funcName in Comparators) {
+            if (this.allowedComparators.length > 0) {
+                if (this.allowedComparators.includes(funcName)) {
+                    return funcName;
+                }
+                else {
+                    throw new Error("Received comparator not allowed");
+                }
+            }
+            else {
+                return funcName;
+            }
+        }
+        if (funcName in Operators) {
+            if (this.allowedOperators.length > 0) {
+                if (this.allowedOperators.includes(funcName)) {
+                    return funcName;
+                }
+                else {
+                    throw new Error("Received operator not allowed");
+                }
+            }
+            else {
+                return funcName;
+            }
+        }
+        throw new Error("Unknown function name");
+    }
+    transform(parsed) {
+        const traverse = (node) => {
+            switch (node.type) {
+                case "call_expression": {
+                    if (typeof node.funcCall !== "string") {
+                        throw new Error("Property access expression and element access expression not supported");
+                    }
+                    const funcName = this.matchFunctionName(node.funcCall);
+                    if (funcName in Operators) {
+                        return new Operation(funcName, node.args?.map((arg) => traverse(arg)));
+                    }
+                    if (funcName in Comparators) {
+                        if (node.args && node.args.length === 2) {
+                            return new Comparison(funcName, traverse(node.args[0]), traverse(node.args[1]));
+                        }
+                        throw new Error("Comparator must have exactly 2 arguments");
+                    }
+                    throw new Error("Function name neither operator nor comparator");
+                }
+                case "string_literal": {
+                    return node.value;
+                }
+                case "numeric_literal": {
+                    return node.value;
+                }
+                case "array_literal": {
+                    return node.values.map((value) => traverse(value));
+                }
+                case "object_literal": {
+                    return node.values.reduce((acc, value) => {
+                        acc[value.identifier] = traverse(value.value);
+                        return acc;
+                    }, {});
+                }
+                case "boolean_literal": {
+                    return node.value;
+                }
+                default: {
+                    throw new Error("Unknown node type");
+                }
+            }
+        };
+        return traverse(parsed);
+    }
+    async parse(expression) {
+        const expressionParser = new ExpressionParser();
+        const parsed = (await expressionParser.parse(expression));
+        if (!parsed) {
+            throw new Error("Could not parse expression");
+        }
+        return this.transform(parsed);
+    }
+}