langchain 0.0.194 → 0.0.196

package/dist/retrievers/chaindesk.cjs

@@ -19,7 +19,7 @@ class ChaindeskRetriever extends retriever_js_1.BaseRetriever {
     static lc_name() {
         return "ChaindeskRetriever";
     }
-    constructor({ datastoreId, apiKey, topK, ...rest }) {
+    constructor({ datastoreId, apiKey, topK, filter, ...rest }) {
         super();
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -45,6 +45,12 @@ class ChaindeskRetriever extends retriever_js_1.BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
             configurable: true,
@@ -55,6 +61,7 @@ class ChaindeskRetriever extends retriever_js_1.BaseRetriever {
         this.datastoreId = datastoreId;
         this.apiKey = apiKey;
         this.topK = topK;
+        this.filter = filter;
     }
     async getRelevantDocuments(query) {
         const r = await this.caller.call(fetch, `https://app.chaindesk.ai/api/datastores/${this.datastoreId}/query`, {
@@ -62,6 +69,7 @@ class ChaindeskRetriever extends retriever_js_1.BaseRetriever {
             body: JSON.stringify({
                 query,
                 ...(this.topK ? { topK: this.topK } : {}),
+                ...(this.filter ? { filters: this.filter } : {}),
             }),
             headers: {
                 "Content-Type": "application/json",

package/dist/retrievers/chaindesk.d.ts

@@ -4,6 +4,7 @@ import { AsyncCaller, type AsyncCallerParams } from "../util/async_caller.js";
 export interface ChaindeskRetrieverArgs extends AsyncCallerParams, BaseRetrieverInput {
     datastoreId: string;
     topK?: number;
+    filter?: Record<string, unknown>;
     apiKey?: string;
 }
 /**
@@ -23,7 +24,8 @@ export declare class ChaindeskRetriever extends BaseRetriever {
     caller: AsyncCaller;
     datastoreId: string;
     topK?: number;
+    filter?: Record<string, unknown>;
     apiKey?: string;
-    constructor({ datastoreId, apiKey, topK, ...rest }: ChaindeskRetrieverArgs);
+    constructor({ datastoreId, apiKey, topK, filter, ...rest }: ChaindeskRetrieverArgs);
     getRelevantDocuments(query: string): Promise<Document[]>;
 }

package/dist/retrievers/chaindesk.js

@@ -16,7 +16,7 @@ export class ChaindeskRetriever extends BaseRetriever {
     static lc_name() {
         return "ChaindeskRetriever";
     }
-    constructor({ datastoreId, apiKey, topK, ...rest }) {
+    constructor({ datastoreId, apiKey, topK, filter, ...rest }) {
         super();
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -42,6 +42,12 @@ export class ChaindeskRetriever extends BaseRetriever {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "filter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
             configurable: true,
@@ -52,6 +58,7 @@ export class ChaindeskRetriever extends BaseRetriever {
         this.datastoreId = datastoreId;
         this.apiKey = apiKey;
         this.topK = topK;
+        this.filter = filter;
     }
     async getRelevantDocuments(query) {
         const r = await this.caller.call(fetch, `https://app.chaindesk.ai/api/datastores/${this.datastoreId}/query`, {
@@ -59,6 +66,7 @@ export class ChaindeskRetriever extends BaseRetriever {
             body: JSON.stringify({
                 query,
                 ...(this.topK ? { topK: this.topK } : {}),
+                ...(this.filter ? { filters: this.filter } : {}),
             }),
             headers: {
                 "Content-Type": "application/json",

package/dist/retrievers/self_query/vectara.cjs

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectaraTranslator = void 0;
+const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
+const base_js_1 = require("./base.cjs");
+const utils_js_1 = require("./utils.cjs");
+function processValue(value) {
+    /** Convert a value to a string and add single quotes if it is a string. */
+    if (typeof value === "string") {
+        return `'${value}'`;
+    }
+    else {
+        return String(value);
+    }
+}
+class VectaraTranslator extends base_js_1.BaseTranslator {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "allowedOperators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [ir_js_1.Operators.and, ir_js_1.Operators.or]
+        });
+        Object.defineProperty(this, "allowedComparators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                ir_js_1.Comparators.eq,
+                ir_js_1.Comparators.ne,
+                ir_js_1.Comparators.lt,
+                ir_js_1.Comparators.lte,
+                ir_js_1.Comparators.gt,
+                ir_js_1.Comparators.gte,
+            ]
+        });
+    }
+    formatFunction(func) {
+        if (func in ir_js_1.Comparators) {
+            if (this.allowedComparators.length > 0 &&
+                this.allowedComparators.indexOf(func) === -1) {
+                throw new Error(`Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(", ")}`);
+            }
+        }
+        else if (func in ir_js_1.Operators) {
+            if (this.allowedOperators.length > 0 &&
+                this.allowedOperators.indexOf(func) === -1) {
+                throw new Error(`Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(", ")}`);
+            }
+        }
+        else {
+            throw new Error("Unknown comparator or operator");
+        }
+        const mapDict = {
+            and: " and ",
+            or: " or ",
+            eq: "=",
+            ne: "!=",
+            lt: "<",
+            lte: "<=",
+            gt: ">",
+            gte: ">=",
+        };
+        return mapDict[func];
+    }
+    /**
+     * Visits an operation and returns a VectaraOperationResult. The
+     * operation's arguments are visited and the operator is formatted.
+     * @param operation The operation to visit.
+     * @returns A VectaraOperationResult.
+     */
+    visitOperation(operation) {
+        const args = operation.args?.map((arg) => arg.accept(this));
+        const operator = this.formatFunction(operation.operator);
+        return `( ${args.join(operator)} )`;
+    }
+    /**
+     * Visits a comparison and returns a VectaraComparisonResult. The
+     * comparison's value is checked for type and the comparator is formatted.
+     * Throws an error if the value type is not supported.
+     * @param comparison The comparison to visit.
+     * @returns A VectaraComparisonResult.
+     */
+    visitComparison(comparison) {
+        const comparator = this.formatFunction(comparison.comparator);
+        return `( doc.${comparison.attribute} ${comparator} ${processValue(comparison.value)} )`;
+    }
+    /**
+     * Visits a structured query and returns a VectaraStructuredQueryResult.
+     * If the query has a filter, it is visited.
+     * @param query The structured query to visit.
+     * @returns A VectaraStructuredQueryResult.
+     */
+    visitStructuredQuery(query) {
+        let nextArg = {};
+        if (query.filter) {
+            nextArg = {
+                filter: { filter: query.filter.accept(this) },
+            };
+        }
+        return nextArg;
+    }
+    mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
+        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) && (0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+            return undefined;
+        }
+        if ((0, utils_js_1.isFilterEmpty)(defaultFilter) || mergeType === "replace") {
+            if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+                return undefined;
+            }
+            return generatedFilter;
+        }
+        if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+            if (forceDefaultFilter) {
+                return defaultFilter;
+            }
+            if (mergeType === "and") {
+                return undefined;
+            }
+            return defaultFilter;
+        }
+        if (mergeType === "and") {
+            return {
+                filter: `${defaultFilter} and ${generatedFilter}`,
+            };
+        }
+        else if (mergeType === "or") {
+            return {
+                filter: `${defaultFilter} or ${generatedFilter}`,
+            };
+        }
+        else {
+            throw new Error("Unknown merge type");
+        }
+    }
+}
+exports.VectaraTranslator = VectaraTranslator;

package/dist/retrievers/self_query/vectara.d.ts

@@ -0,0 +1,41 @@
+import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "../../chains/query_constructor/ir.js";
+import { VectaraFilter, VectaraStore } from "../../vectorstores/vectara.js";
+import { BaseTranslator } from "./base.js";
+export type VectaraVisitorResult = VectaraOperationResult | VectaraComparisonResult | VectaraVisitorStructuredQueryResult;
+export type VectaraOperationResult = String;
+export type VectaraComparisonResult = String;
+export type VectaraVisitorStructuredQueryResult = {
+    filter?: {
+        filter?: VectaraOperationResult | VectaraComparisonResult;
+    };
+};
+export declare class VectaraTranslator<T extends VectaraStore> extends BaseTranslator<T> {
+    VisitOperationOutput: VectaraOperationResult;
+    VisitComparisonOutput: VectaraComparisonResult;
+    allowedOperators: Operator[];
+    allowedComparators: Comparator[];
+    formatFunction(func: Operator | Comparator): string;
+    /**
+     * Visits an operation and returns a VectaraOperationResult. The
+     * operation's arguments are visited and the operator is formatted.
+     * @param operation The operation to visit.
+     * @returns A VectaraOperationResult.
+     */
+    visitOperation(operation: Operation): this["VisitOperationOutput"];
+    /**
+     * Visits a comparison and returns a VectaraComparisonResult. The
+     * comparison's value is checked for type and the comparator is formatted.
+     * Throws an error if the value type is not supported.
+     * @param comparison The comparison to visit.
+     * @returns A VectaraComparisonResult.
+     */
+    visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
+    /**
+     * Visits a structured query and returns a VectaraStructuredQueryResult.
+     * If the query has a filter, it is visited.
+     * @param query The structured query to visit.
+     * @returns A VectaraStructuredQueryResult.
+     */
+    visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
+    mergeFilters(defaultFilter: VectaraFilter | undefined, generatedFilter: VectaraFilter | undefined, mergeType?: string, forceDefaultFilter?: boolean): VectaraFilter | undefined;
+}

package/dist/retrievers/self_query/vectara.js

@@ -0,0 +1,134 @@
+import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
+import { BaseTranslator } from "./base.js";
+import { isFilterEmpty } from "./utils.js";
+function processValue(value) {
+    /** Convert a value to a string and add single quotes if it is a string. */
+    if (typeof value === "string") {
+        return `'${value}'`;
+    }
+    else {
+        return String(value);
+    }
+}
+export class VectaraTranslator extends BaseTranslator {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "allowedOperators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [Operators.and, Operators.or]
+        });
+        Object.defineProperty(this, "allowedComparators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                Comparators.eq,
+                Comparators.ne,
+                Comparators.lt,
+                Comparators.lte,
+                Comparators.gt,
+                Comparators.gte,
+            ]
+        });
+    }
+    formatFunction(func) {
+        if (func in Comparators) {
+            if (this.allowedComparators.length > 0 &&
+                this.allowedComparators.indexOf(func) === -1) {
+                throw new Error(`Comparator ${func} not allowed. Allowed operators: ${this.allowedComparators.join(", ")}`);
+            }
+        }
+        else if (func in Operators) {
+            if (this.allowedOperators.length > 0 &&
+                this.allowedOperators.indexOf(func) === -1) {
+                throw new Error(`Operator ${func} not allowed. Allowed operators: ${this.allowedOperators.join(", ")}`);
+            }
+        }
+        else {
+            throw new Error("Unknown comparator or operator");
+        }
+        const mapDict = {
+            and: " and ",
+            or: " or ",
+            eq: "=",
+            ne: "!=",
+            lt: "<",
+            lte: "<=",
+            gt: ">",
+            gte: ">=",
+        };
+        return mapDict[func];
+    }
+    /**
+     * Visits an operation and returns a VectaraOperationResult. The
+     * operation's arguments are visited and the operator is formatted.
+     * @param operation The operation to visit.
+     * @returns A VectaraOperationResult.
+     */
+    visitOperation(operation) {
+        const args = operation.args?.map((arg) => arg.accept(this));
+        const operator = this.formatFunction(operation.operator);
+        return `( ${args.join(operator)} )`;
+    }
+    /**
+     * Visits a comparison and returns a VectaraComparisonResult. The
+     * comparison's value is checked for type and the comparator is formatted.
+     * Throws an error if the value type is not supported.
+     * @param comparison The comparison to visit.
+     * @returns A VectaraComparisonResult.
+     */
+    visitComparison(comparison) {
+        const comparator = this.formatFunction(comparison.comparator);
+        return `( doc.${comparison.attribute} ${comparator} ${processValue(comparison.value)} )`;
+    }
+    /**
+     * Visits a structured query and returns a VectaraStructuredQueryResult.
+     * If the query has a filter, it is visited.
+     * @param query The structured query to visit.
+     * @returns A VectaraStructuredQueryResult.
+     */
+    visitStructuredQuery(query) {
+        let nextArg = {};
+        if (query.filter) {
+            nextArg = {
+                filter: { filter: query.filter.accept(this) },
+            };
+        }
+        return nextArg;
+    }
+    mergeFilters(defaultFilter, generatedFilter, mergeType = "and", forceDefaultFilter = false) {
+        if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {
+            return undefined;
+        }
+        if (isFilterEmpty(defaultFilter) || mergeType === "replace") {
+            if (isFilterEmpty(generatedFilter)) {
+                return undefined;
+            }
+            return generatedFilter;
+        }
+        if (isFilterEmpty(generatedFilter)) {
+            if (forceDefaultFilter) {
+                return defaultFilter;
+            }
+            if (mergeType === "and") {
+                return undefined;
+            }
+            return defaultFilter;
+        }
+        if (mergeType === "and") {
+            return {
+                filter: `${defaultFilter} and ${generatedFilter}`,
+            };
+        }
+        else if (mergeType === "or") {
+            return {
+                filter: `${defaultFilter} or ${generatedFilter}`,
+            };
+        }
+        else {
+            throw new Error("Unknown merge type");
+        }
+    }
+}

package/dist/{util/@cfworker/json-schema → runnables}/index.cjs

@@ -14,4 +14,4 @@ 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("./src/index.cjs"), exports);
+__exportStar(require("langchain-core/runnables"), exports);

package/dist/runnables/index.d.ts

@@ -0,0 +1 @@
+export * from "langchain-core/runnables";

package/dist/runnables/index.js

@@ -0,0 +1 @@
+export * from "langchain-core/runnables";

package/dist/schema/document.cjs

@@ -1,44 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MappingDocumentTransformer = exports.BaseDocumentTransformer = void 0;
-const index_js_1 = require("./runnable/index.cjs");
-/**
- * Abstract base class for document transformation systems.
- *
- * A document transformation system takes an array of Documents and returns an
- * array of transformed Documents. These arrays do not necessarily have to have
- * the same length.
- *
- * One example of this is a text splitter that splits a large document into
- * many smaller documents.
- */
-class BaseDocumentTransformer extends index_js_1.Runnable {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "document_transformers"]
-        });
-    }
-    /**
-     * Method to invoke the document transformation. This method calls the
-     * transformDocuments method with the provided input.
-     * @param input The input documents to be transformed.
-     * @param _options Optional configuration object to customize the behavior of callbacks.
-     * @returns A Promise that resolves to the transformed documents.
-     */
-    invoke(input, _options) {
-        return this.transformDocuments(input);
-    }
-}
-exports.BaseDocumentTransformer = BaseDocumentTransformer;
+const document_1 = require("langchain-core/schema/document");
+Object.defineProperty(exports, "BaseDocumentTransformer", { enumerable: true, get: function () { return document_1.BaseDocumentTransformer; } });
 /**
  * Class for document transformers that return exactly one transformed document
  * for each input document.
  */
-class MappingDocumentTransformer extends BaseDocumentTransformer {
+class MappingDocumentTransformer extends document_1.BaseDocumentTransformer {
     async transformDocuments(documents) {
         const newDocuments = [];
         for (const document of documents) {

package/dist/schema/document.d.ts

@@ -1,33 +1,6 @@
-import { BaseCallbackConfig } from "../callbacks/manager.js";
+import { BaseDocumentTransformer } from "langchain-core/schema/document";
 import { Document } from "../document.js";
-import { Runnable } from "./runnable/index.js";
-/**
- * Abstract base class for document transformation systems.
- *
- * A document transformation system takes an array of Documents and returns an
- * array of transformed Documents. These arrays do not necessarily have to have
- * the same length.
- *
- * One example of this is a text splitter that splits a large document into
- * many smaller documents.
- */
-export declare abstract class BaseDocumentTransformer<RunInput extends Document[] = Document[], RunOutput extends Document[] = Document[]> extends Runnable<RunInput, RunOutput> {
-    lc_namespace: string[];
-    /**
-     * Transform a list of documents.
-     * @param documents A sequence of documents to be transformed.
-     * @returns A list of transformed documents.
-     */
-    abstract transformDocuments(documents: RunInput): Promise<RunOutput>;
-    /**
-     * Method to invoke the document transformation. This method calls the
-     * transformDocuments method with the provided input.
-     * @param input The input documents to be transformed.
-     * @param _options Optional configuration object to customize the behavior of callbacks.
-     * @returns A Promise that resolves to the transformed documents.
-     */
-    invoke(input: RunInput, _options?: Partial<BaseCallbackConfig>): Promise<RunOutput>;
-}
+export { BaseDocumentTransformer };
 /**
  * Class for document transformers that return exactly one transformed document
  * for each input document.

package/dist/schema/document.js

@@ -1,35 +1,5 @@
-import { Runnable } from "./runnable/index.js";
-/**
- * Abstract base class for document transformation systems.
- *
- * A document transformation system takes an array of Documents and returns an
- * array of transformed Documents. These arrays do not necessarily have to have
- * the same length.
- *
- * One example of this is a text splitter that splits a large document into
- * many smaller documents.
- */
-export class BaseDocumentTransformer extends Runnable {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "document_transformers"]
-        });
-    }
-    /**
-     * Method to invoke the document transformation. This method calls the
-     * transformDocuments method with the provided input.
-     * @param input The input documents to be transformed.
-     * @param _options Optional configuration object to customize the behavior of callbacks.
-     * @returns A Promise that resolves to the transformed documents.
-     */
-    invoke(input, _options) {
-        return this.transformDocuments(input);
-    }
-}
+import { BaseDocumentTransformer } from "langchain-core/schema/document";
+export { BaseDocumentTransformer };
 /**
  * Class for document transformers that return exactly one transformed document
  * for each input document.