@langchain/core 0.1.58 → 0.1.60

package/dist/structured_query/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base.cjs"), exports);
+__exportStar(require("./functional.cjs"), exports);
+__exportStar(require("./ir.cjs"), exports);
+__exportStar(require("./utils.cjs"), exports);

package/dist/structured_query/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./base.js";
+export * from "./functional.js";
+export * from "./ir.js";
+export * from "./utils.js";

package/dist/structured_query/index.js

@@ -0,0 +1,4 @@
+export * from "./base.js";
+export * from "./functional.js";
+export * from "./ir.js";
+export * from "./utils.js";

package/dist/structured_query/ir.cjs

@@ -0,0 +1,141 @@
+"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",
+    ne: "ne",
+    lt: "lt",
+    gt: "gt",
+    lte: "lte",
+    gte: "gte",
+};
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
+class Visitor {
+}
+exports.Visitor = Visitor;
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
+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;
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
+class FilterDirective extends Expression {
+}
+exports.FilterDirective = FilterDirective;
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
+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 representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
+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 representing a structured query expression. It extends the
+ * Expression class.
+ */
+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/structured_query/ir.d.ts

@@ -0,0 +1,138 @@
+import { VectorStore } from "../vectorstores.js";
+/**
+ * Represents logical AND operator.
+ */
+export type AND = "and";
+/**
+ * Represents logical OR operator.
+ */
+export type OR = "or";
+/**
+ * Represents logical NOT operator.
+ */
+export type NOT = "not";
+/**
+ * Represents a logical operator which can be AND, OR, or NOT.
+ */
+export type Operator = AND | OR | NOT;
+/**
+ * Represents equality comparison operator.
+ */
+export type EQ = "eq";
+/**
+ * Represents inequality comparison operator.
+ */
+export type NE = "ne";
+/**
+ * Represents less than comparison operator.
+ */
+export type LT = "lt";
+/**
+ * Represents greater than comparison operator.
+ */
+export type GT = "gt";
+/**
+ * Represents less than or equal to comparison operator.
+ */
+export type LTE = "lte";
+/**
+ * Represents greater than or equal to comparison operator.
+ */
+export type GTE = "gte";
+/**
+ * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or
+ * GTE.
+ */
+export type Comparator = EQ | NE | LT | GT | LTE | GTE;
+export declare const Operators: {
+    [key: string]: Operator;
+};
+export declare const Comparators: {
+    [key: string]: Comparator;
+};
+/**
+ * Represents the result of visiting an operation or comparison
+ * expression.
+ */
+export type VisitorResult = VisitorOperationResult | VisitorComparisonResult;
+/**
+ * Represents the result of visiting an operation expression.
+ */
+export type VisitorOperationResult = {
+    [operator: string]: VisitorResult[];
+};
+/**
+ * Represents the result of visiting a comparison expression.
+ */
+export type VisitorComparisonResult = {
+    [attr: string]: {
+        [comparator: string]: string | number;
+    };
+};
+/**
+ * Represents the result of visiting a structured query expression.
+ */
+export type VisitorStructuredQueryResult = {
+    filter?: VisitorComparisonResult | VisitorOperationResult;
+};
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
+export declare abstract class Visitor<T extends VectorStore = VectorStore> {
+    VisitOperationOutput: object;
+    VisitComparisonOutput: object;
+    VisitStructuredQueryOutput: {
+        filter?: T["FilterType"];
+    };
+    abstract allowedOperators: Operator[];
+    abstract allowedComparators: Comparator[];
+    abstract visitOperation(operation: Operation): this["VisitOperationOutput"];
+    abstract visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+    abstract visitStructuredQuery(structuredQuery: StructuredQuery): this["VisitStructuredQueryOutput"];
+}
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
+export declare abstract class Expression {
+    abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
+    accept(visitor: Visitor): object;
+}
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
+export declare abstract class FilterDirective extends Expression {
+}
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
+export declare class Comparison extends FilterDirective {
+    comparator: Comparator;
+    attribute: string;
+    value: string | number;
+    exprName: "Comparison";
+    constructor(comparator: Comparator, attribute: string, value: string | number);
+}
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
+export declare class Operation extends FilterDirective {
+    operator: Operator;
+    args?: FilterDirective[] | undefined;
+    exprName: "Operation";
+    constructor(operator: Operator, args?: FilterDirective[] | undefined);
+}
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
+export declare class StructuredQuery extends Expression {
+    query: string;
+    filter?: FilterDirective | undefined;
+    exprName: "StructuredQuery";
+    constructor(query: string, filter?: FilterDirective | undefined);
+}

package/dist/structured_query/ir.js

@@ -0,0 +1,132 @@
+export const Operators = {
+    and: "and",
+    or: "or",
+    not: "not",
+};
+export const Comparators = {
+    eq: "eq",
+    ne: "ne",
+    lt: "lt",
+    gt: "gt",
+    lte: "lte",
+    gte: "gte",
+};
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
+export class Visitor {
+}
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
+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");
+        }
+    }
+}
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
+export class FilterDirective extends Expression {
+}
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
+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"
+        });
+    }
+}
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
+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"
+        });
+    }
+}
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
+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/structured_query/utils.cjs

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castValue = exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isObject(obj) {
+    return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+exports.isObject = isObject;
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
+function isFilterEmpty(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+filter) {
+    if (!filter)
+        return true;
+    // for Milvus
+    if (typeof filter === "string" && filter.length > 0) {
+        return false;
+    }
+    if (typeof filter === "function") {
+        return false;
+    }
+    return isObject(filter) && Object.keys(filter).length === 0;
+}
+exports.isFilterEmpty = isFilterEmpty;
+/**
+ * Checks if the provided value is an integer.
+ */
+function isInt(value) {
+    if (typeof value === "number") {
+        return value % 1 === 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseInt(value, 10);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 === 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
+}
+exports.isInt = isInt;
+/**
+ * Checks if the provided value is a floating-point number.
+ */
+function isFloat(value) {
+    if (typeof value === "number") {
+        return value % 1 !== 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseFloat(value);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 !== 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
+}
+exports.isFloat = isFloat;
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
+function isString(value) {
+    return (typeof value === "string" &&
+        (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
+}
+exports.isString = isString;
+/**
+ * Casts a value that might be string or number to actual string or number.
+ * Since LLM might return back an integer/float as a string, we need to cast
+ * it back to a number, as many vector databases can't handle number as string
+ * values as a comparator.
+ */
+function castValue(input) {
+    let value;
+    if (isString(input)) {
+        value = input;
+    }
+    else if (isInt(input)) {
+        value = parseInt(input, 10);
+    }
+    else if (isFloat(input)) {
+        value = parseFloat(input);
+    }
+    else {
+        throw new Error("Unsupported value type");
+    }
+    return value;
+}
+exports.castValue = castValue;

package/dist/structured_query/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
+export declare function isObject(obj: any): obj is object;
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
+export declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;
+/**
+ * Checks if the provided value is an integer.
+ */
+export declare function isInt(value: unknown): boolean;
+/**
+ * Checks if the provided value is a floating-point number.
+ */
+export declare function isFloat(value: unknown): boolean;
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
+export declare function isString(value: unknown): boolean;
+/**
+ * Casts a value that might be string or number to actual string or number.
+ * Since LLM might return back an integer/float as a string, we need to cast
+ * it back to a number, as many vector databases can't handle number as string
+ * values as a comparator.
+ */
+export declare function castValue(input: unknown): string | number;

package/dist/structured_query/utils.js

@@ -0,0 +1,85 @@
+/**
+ * Checks if the provided argument is an object and not an array.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isObject(obj) {
+    return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+/**
+ * Checks if a provided filter is empty. The filter can be a function, an
+ * object, a string, or undefined.
+ */
+export function isFilterEmpty(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+filter) {
+    if (!filter)
+        return true;
+    // for Milvus
+    if (typeof filter === "string" && filter.length > 0) {
+        return false;
+    }
+    if (typeof filter === "function") {
+        return false;
+    }
+    return isObject(filter) && Object.keys(filter).length === 0;
+}
+/**
+ * Checks if the provided value is an integer.
+ */
+export function isInt(value) {
+    if (typeof value === "number") {
+        return value % 1 === 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseInt(value, 10);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 === 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
+}
+/**
+ * Checks if the provided value is a floating-point number.
+ */
+export function isFloat(value) {
+    if (typeof value === "number") {
+        return value % 1 !== 0;
+    }
+    else if (typeof value === "string") {
+        const numberValue = parseFloat(value);
+        return (!Number.isNaN(numberValue) &&
+            numberValue % 1 !== 0 &&
+            numberValue.toString() === value);
+    }
+    return false;
+}
+/**
+ * Checks if the provided value is a string that cannot be parsed into a
+ * number.
+ */
+export function isString(value) {
+    return (typeof value === "string" &&
+        (Number.isNaN(parseFloat(value)) || parseFloat(value).toString() !== value));
+}
+/**
+ * Casts a value that might be string or number to actual string or number.
+ * Since LLM might return back an integer/float as a string, we need to cast
+ * it back to a number, as many vector databases can't handle number as string
+ * values as a comparator.
+ */
+export function castValue(input) {
+    let value;
+    if (isString(input)) {
+        value = input;
+    }
+    else if (isInt(input)) {
+        value = parseInt(input, 10);
+    }
+    else if (isFloat(input)) {
+        value = parseFloat(input);
+    }
+    else {
+        throw new Error("Unsupported value type");
+    }
+    return value;
+}

package/dist/tools.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
+exports.BaseToolkit = exports.DynamicStructuredTool = exports.DynamicTool = exports.Tool = exports.StructuredTool = exports.ToolInputParsingException = void 0;
 const zod_1 = require("zod");
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./language_models/base.cjs");
@@ -212,3 +212,14 @@ class DynamicStructuredTool extends StructuredTool {
     }
 }
 exports.DynamicStructuredTool = DynamicStructuredTool;
+/**
+ * Abstract base class for toolkits in LangChain. Toolkits are collections
+ * of tools that agents can use. Subclasses must implement the `tools`
+ * property to provide the specific tools for the toolkit.
+ */
+class BaseToolkit {
+    getTools() {
+        return this.tools;
+    }
+}
+exports.BaseToolkit = BaseToolkit;

package/dist/tools.d.ts

@@ -149,3 +149,12 @@ export declare class DynamicStructuredTool<T extends z.ZodObject<any, any, any,
     tags?: string[]): Promise<string>;
     protected _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun, config?: RunnableConfig): Promise<string>;
 }
+/**
+ * Abstract base class for toolkits in LangChain. Toolkits are collections
+ * of tools that agents can use. Subclasses must implement the `tools`
+ * property to provide the specific tools for the toolkit.
+ */
+export declare abstract class BaseToolkit {
+    abstract tools: StructuredToolInterface[];
+    getTools(): StructuredToolInterface[];
+}