langchain 0.0.129 → 0.0.131

package/dist/prompts/pipeline.d.ts

@@ -10,6 +10,7 @@ export type PipelinePromptTemplateInput<PromptTemplateType extends BasePromptTem
     finalPrompt: PromptTemplateType;
 };
 export declare class PipelinePromptTemplate<PromptTemplateType extends BasePromptTemplate> extends BasePromptTemplate {
+    static lc_name(): string;
     pipelinePrompts: PipelinePromptParams<PromptTemplateType>[];
     finalPrompt: PromptTemplateType;
     constructor(input: PipelinePromptTemplateInput<PromptTemplateType>);

package/dist/prompts/pipeline.js

@@ -1,6 +1,9 @@
 import { BasePromptTemplate } from "./base.js";
 import { ChatPromptTemplate } from "./chat.js";
 export class PipelinePromptTemplate extends BasePromptTemplate {
+    static lc_name() {
+        return "PipelinePromptTemplate";
+    }
     constructor(input) {
         super({ ...input, inputVariables: [] });
         Object.defineProperty(this, "pipelinePrompts", {

package/dist/prompts/prompt.cjs

@@ -21,6 +21,9 @@ const template_js_1 = require("./template.cjs");
  * ```
  */
 class PromptTemplate extends base_js_1.BaseStringPromptTemplate {
+    static lc_name() {
+        return "PromptTemplate";
+    }
     constructor(input) {
         super(input);
         Object.defineProperty(this, "template", {

package/dist/prompts/prompt.d.ts

@@ -40,6 +40,7 @@ export interface PromptTemplateInput<RunInput extends InputValues = any, Partial
  * ```
  */
 export declare class PromptTemplate<RunInput extends InputValues = any, PartialVariableName extends string = any> extends BaseStringPromptTemplate<RunInput, PartialVariableName> implements PromptTemplateInput<RunInput, PartialVariableName> {
+    static lc_name(): string;
     template: string;
     templateFormat: TemplateFormat;
     validateTemplate: boolean;

package/dist/prompts/prompt.js

@@ -18,6 +18,9 @@ import { checkValidTemplate, parseTemplate, renderTemplate, } from "./template.j
  * ```
  */
 export class PromptTemplate extends BaseStringPromptTemplate {
+    static lc_name() {
+        return "PromptTemplate";
+    }
     constructor(input) {
         super(input);
         Object.defineProperty(this, "template", {

package/dist/retrievers/amazon_kendra.cjs

@@ -5,6 +5,9 @@ const client_kendra_1 = require("@aws-sdk/client-kendra");
 const retriever_js_1 = require("../schema/retriever.cjs");
 const document_js_1 = require("../document.cjs");
 class AmazonKendraRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "AmazonKendraRetriever";
+    }
     constructor({ indexId, topK = 10, clientOptions, attributeFilter, region, }) {
         super();
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/amazon_kendra.d.ts

@@ -9,6 +9,7 @@ export interface AmazonKendraRetrieverArgs {
     clientOptions?: KendraClientConfig;
 }
 export declare class AmazonKendraRetriever extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     indexId: string;
     topK: number;

package/dist/retrievers/amazon_kendra.js

@@ -2,6 +2,9 @@ import { KendraClient, QueryCommand, RetrieveCommand, } from "@aws-sdk/client-ke
 import { BaseRetriever } from "../schema/retriever.js";
 import { Document } from "../document.js";
 export class AmazonKendraRetriever extends BaseRetriever {
+    static lc_name() {
+        return "AmazonKendraRetriever";
+    }
     constructor({ indexId, topK = 10, clientOptions, attributeFilter, region, }) {
         super();
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/contextual_compression.cjs

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextualCompressionRetriever = void 0;
 const retriever_js_1 = require("../schema/retriever.cjs");
 class ContextualCompressionRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "ContextualCompressionRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/contextual_compression.d.ts

@@ -7,6 +7,7 @@ export interface ContextualCompressionRetrieverArgs extends BaseRetrieverInput {
     baseRetriever: BaseRetriever;
 }
 export declare class ContextualCompressionRetriever extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     baseCompressor: BaseDocumentCompressor;
     baseRetriever: BaseRetriever;

package/dist/retrievers/contextual_compression.js

@@ -1,5 +1,8 @@
 import { BaseRetriever } from "../schema/retriever.js";
 export class ContextualCompressionRetriever extends BaseRetriever {
+    static lc_name() {
+        return "ContextualCompressionRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/databerry.cjs

@@ -5,6 +5,9 @@ const retriever_js_1 = require("../schema/retriever.cjs");
 const document_js_1 = require("../document.cjs");
 const async_caller_js_1 = require("../util/async_caller.cjs");
 class DataberryRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "DataberryRetriever";
+    }
     get lc_secrets() {
         return { apiKey: "DATABERRY_API_KEY" };
     }

package/dist/retrievers/databerry.d.ts

@@ -7,6 +7,7 @@ export interface DataberryRetrieverArgs extends AsyncCallerParams, BaseRetriever
     apiKey?: string;
 }
 export declare class DataberryRetriever extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     get lc_secrets(): {
         apiKey: string;

package/dist/retrievers/databerry.js

@@ -2,6 +2,9 @@ import { BaseRetriever } from "../schema/retriever.js";
 import { Document } from "../document.js";
 import { AsyncCaller } from "../util/async_caller.js";
 export class DataberryRetriever extends BaseRetriever {
+    static lc_name() {
+        return "DataberryRetriever";
+    }
     get lc_secrets() {
         return { apiKey: "DATABERRY_API_KEY" };
     }

package/dist/retrievers/hyde.cjs

@@ -5,6 +5,9 @@ const base_js_1 = require("../prompts/base.cjs");
 const prompt_js_1 = require("../prompts/prompt.cjs");
 const base_js_2 = require("../vectorstores/base.cjs");
 class HydeRetriever extends base_js_2.VectorStoreRetriever {
+    static lc_name() {
+        return "HydeRetriever";
+    }
     get lc_namespace() {
         return ["langchain", "retrievers", "hyde"];
     }

package/dist/retrievers/hyde.d.ts

@@ -9,6 +9,7 @@ export type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverIn
     promptTemplate?: BasePromptTemplate | PromptKey;
 };
 export declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {
+    static lc_name(): string;
     get lc_namespace(): string[];
     llm: BaseLanguageModel;
     promptTemplate?: BasePromptTemplate;

package/dist/retrievers/hyde.js

@@ -2,6 +2,9 @@ import { StringPromptValue } from "../prompts/base.js";
 import { PromptTemplate } from "../prompts/prompt.js";
 import { VectorStoreRetriever, } from "../vectorstores/base.js";
 export class HydeRetriever extends VectorStoreRetriever {
+    static lc_name() {
+        return "HydeRetriever";
+    }
     get lc_namespace() {
         return ["langchain", "retrievers", "hyde"];
     }

package/dist/retrievers/metal.cjs

@@ -4,6 +4,9 @@ exports.MetalRetriever = void 0;
 const retriever_js_1 = require("../schema/retriever.cjs");
 const document_js_1 = require("../document.cjs");
 class MetalRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "MetalRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/metal.d.ts

@@ -5,6 +5,7 @@ export interface MetalRetrieverFields extends BaseRetrieverInput {
     client: Metal;
 }
 export declare class MetalRetriever extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     private client;
     constructor(fields: MetalRetrieverFields);

package/dist/retrievers/metal.js

@@ -1,6 +1,9 @@
 import { BaseRetriever } from "../schema/retriever.js";
 import { Document } from "../document.js";
 export class MetalRetriever extends BaseRetriever {
+    static lc_name() {
+        return "MetalRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/parent_document.cjs

@@ -28,6 +28,9 @@ const uuid = __importStar(require("uuid"));
 const retriever_js_1 = require("../schema/retriever.cjs");
 const document_js_1 = require("../document.cjs");
 class ParentDocumentRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "ParentDocumentRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/parent_document.d.ts

@@ -11,6 +11,7 @@ export interface ParentDocumentRetrieverFields extends BaseRetrieverInput {
     idKey?: string;
 }
 export declare class ParentDocumentRetriever extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     protected vectorstore: VectorStore;
     protected docstore: Docstore;

package/dist/retrievers/parent_document.js

@@ -2,6 +2,9 @@ import * as uuid from "uuid";
 import { BaseRetriever } from "../schema/retriever.js";
 import { Document } from "../document.js";
 export class ParentDocumentRetriever extends BaseRetriever {
+    static lc_name() {
+        return "ParentDocumentRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/self_query/index.cjs

@@ -9,6 +9,9 @@ const base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "BaseTranslator", { enumerable: true, get: function () { return base_js_1.BaseTranslator; } });
 Object.defineProperty(exports, "BasicTranslator", { enumerable: true, get: function () { return base_js_1.BasicTranslator; } });
 class SelfQueryRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "SelfQueryRetriever";
+    }
     get lc_namespace() {
         return ["langchain", "retrievers", "self_query"];
     }

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

@@ -20,6 +20,7 @@ export interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetri
     };
 }
 export declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {
+    static lc_name(): string;
     get lc_namespace(): string[];
     vectorStore: T;
     llmChain: LLMChain;

package/dist/retrievers/self_query/index.js

@@ -4,6 +4,9 @@ import { FunctionalTranslator } from "./functional.js";
 import { BaseTranslator, BasicTranslator } from "./base.js";
 export { BaseTranslator, BasicTranslator, FunctionalTranslator };
 export class SelfQueryRetriever extends BaseRetriever {
+    static lc_name() {
+        return "SelfQueryRetriever";
+    }
     get lc_namespace() {
         return ["langchain", "retrievers", "self_query"];
     }

package/dist/retrievers/self_query/supabase.cjs

@@ -4,6 +4,7 @@ exports.SupabaseTranslator = 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");
+const supabase_utils_js_1 = require("./supabase_utils.cjs");
 class SupabaseTranslator extends base_js_1.BaseTranslator {
     constructor() {
         super(...arguments);
@@ -57,12 +58,15 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
     }
     buildColumnName(attr, value, includeType = true) {
         let column = "";
-        if (typeof value === "string") {
+        if ((0, utils_js_1.isString)(value)) {
             column = `metadata->>${attr}`;
         }
-        else if (typeof value === "number") {
+        else if ((0, utils_js_1.isInt)(value)) {
             column = `metadata->${attr}${includeType ? "::int" : ""}`;
         }
+        else if ((0, utils_js_1.isFloat)(value)) {
+            column = `metadata->${attr}${includeType ? "::float" : ""}`;
+        }
         else {
             throw new Error("Data type not supported");
         }
@@ -146,9 +150,6 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
         return { filter: filterFunction ?? {} };
     }
     mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-        if (mergeType === "or") {
-            throw new Error("Supabase self-query filter does not support merging two filters with the OR operator");
-        }
         if ((0, utils_js_1.isFilterEmpty)(defaultFilter) && (0, utils_js_1.isFilterEmpty)(generatedFilter)) {
             return undefined;
         }
@@ -164,8 +165,28 @@ class SupabaseTranslator extends base_js_1.BaseTranslator {
             }
             return defaultFilter;
         }
-        if (mergeType === "and") {
-            return (rpc) => generatedFilter(defaultFilter(rpc));
+        let myDefaultFilter = defaultFilter;
+        if ((0, utils_js_1.isObject)(defaultFilter)) {
+            const { filter } = this.visitStructuredQuery((0, supabase_utils_js_1.convertObjectFilterToStructuredQuery)(defaultFilter));
+            // just in case the built filter is empty somehow
+            if ((0, utils_js_1.isFilterEmpty)(filter)) {
+                if ((0, utils_js_1.isFilterEmpty)(generatedFilter)) {
+                    return undefined;
+                }
+                return generatedFilter;
+            }
+            myDefaultFilter = filter;
+        }
+        // After this point, myDefaultFilter will always be SupabaseFilterRPCCall
+        if (mergeType === "or") {
+            return (rpc) => {
+                const defaultFlattenedParams = supabase_utils_js_1.ProxyParamsDuplicator.getFlattenedParams(rpc, myDefaultFilter);
+                const generatedFlattenedParams = supabase_utils_js_1.ProxyParamsDuplicator.getFlattenedParams(rpc, generatedFilter);
+                return rpc.or(`${defaultFlattenedParams},${generatedFlattenedParams}`);
+            };
+        }
+        else if (mergeType === "and") {
+            return (rpc) => generatedFilter(myDefaultFilter(rpc));
         }
         else {
             throw new Error("Unknown merge type");

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

@@ -1,5 +1,5 @@
 import { Comparator, Comparison, Operation, Operator, StructuredQuery } from "../../chains/query_constructor/ir.js";
-import { SupabaseFilterRPCCall, SupabaseVectorStore } from "../../vectorstores/supabase.js";
+import type { SupabaseFilterRPCCall, SupabaseMetadata, SupabaseVectorStore } from "../../vectorstores/supabase.js";
 import { BaseTranslator } from "./base.js";
 type ValueType = {
     eq: string | number;
@@ -22,6 +22,6 @@ export declare class SupabaseTranslator<T extends SupabaseVectorStore> extends B
     visitComparisonAsString(comparison: Comparison): string;
     visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
     visitStructuredQuery(query: StructuredQuery): this["VisitStructuredQueryOutput"];
-    mergeFilters(defaultFilter: SupabaseFilterRPCCall | undefined, generatedFilter: SupabaseFilterRPCCall | undefined, mergeType?: string): SupabaseFilterRPCCall | undefined;
+    mergeFilters(defaultFilter: SupabaseFilterRPCCall | SupabaseMetadata | undefined, generatedFilter: SupabaseFilterRPCCall | undefined, mergeType?: string): SupabaseFilterRPCCall | SupabaseMetadata | undefined;
 }
 export {};

package/dist/retrievers/self_query/supabase.js

@@ -1,6 +1,7 @@
 import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
 import { BaseTranslator } from "./base.js";
-import { isFilterEmpty } from "./utils.js";
+import { isFilterEmpty, isFloat, isInt, isObject, isString } from "./utils.js";
+import { ProxyParamsDuplicator, convertObjectFilterToStructuredQuery, } from "./supabase_utils.js";
 export class SupabaseTranslator extends BaseTranslator {
     constructor() {
         super(...arguments);
@@ -54,12 +55,15 @@ export class SupabaseTranslator extends BaseTranslator {
     }
     buildColumnName(attr, value, includeType = true) {
         let column = "";
-        if (typeof value === "string") {
+        if (isString(value)) {
             column = `metadata->>${attr}`;
         }
-        else if (typeof value === "number") {
+        else if (isInt(value)) {
             column = `metadata->${attr}${includeType ? "::int" : ""}`;
         }
+        else if (isFloat(value)) {
+            column = `metadata->${attr}${includeType ? "::float" : ""}`;
+        }
         else {
             throw new Error("Data type not supported");
         }
@@ -143,9 +147,6 @@ export class SupabaseTranslator extends BaseTranslator {
         return { filter: filterFunction ?? {} };
     }
     mergeFilters(defaultFilter, generatedFilter, mergeType = "and") {
-        if (mergeType === "or") {
-            throw new Error("Supabase self-query filter does not support merging two filters with the OR operator");
-        }
         if (isFilterEmpty(defaultFilter) && isFilterEmpty(generatedFilter)) {
             return undefined;
         }
@@ -161,8 +162,28 @@ export class SupabaseTranslator extends BaseTranslator {
             }
             return defaultFilter;
         }
-        if (mergeType === "and") {
-            return (rpc) => generatedFilter(defaultFilter(rpc));
+        let myDefaultFilter = defaultFilter;
+        if (isObject(defaultFilter)) {
+            const { filter } = this.visitStructuredQuery(convertObjectFilterToStructuredQuery(defaultFilter));
+            // just in case the built filter is empty somehow
+            if (isFilterEmpty(filter)) {
+                if (isFilterEmpty(generatedFilter)) {
+                    return undefined;
+                }
+                return generatedFilter;
+            }
+            myDefaultFilter = filter;
+        }
+        // After this point, myDefaultFilter will always be SupabaseFilterRPCCall
+        if (mergeType === "or") {
+            return (rpc) => {
+                const defaultFlattenedParams = ProxyParamsDuplicator.getFlattenedParams(rpc, myDefaultFilter);
+                const generatedFlattenedParams = ProxyParamsDuplicator.getFlattenedParams(rpc, generatedFilter);
+                return rpc.or(`${defaultFlattenedParams},${generatedFlattenedParams}`);
+            };
+        }
+        else if (mergeType === "and") {
+            return (rpc) => generatedFilter(myDefaultFilter(rpc));
         }
         else {
             throw new Error("Unknown merge type");

package/dist/retrievers/self_query/supabase_utils.cjs

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertObjectFilterToStructuredQuery = exports.ProxyParamsDuplicator = void 0;
+const ir_js_1 = require("../../chains/query_constructor/ir.cjs");
+class ProxyParamsDuplicator {
+    constructor() {
+        Object.defineProperty(this, "duplicationAllowedOps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [
+                "eq",
+                "neq",
+                "lt",
+                "lte",
+                "gt",
+                "gte",
+                "like",
+                "ilike",
+                "or",
+                "in",
+                "contains",
+                "match",
+                "not",
+                "textSearch",
+                "filter",
+            ]
+        });
+        Object.defineProperty(this, "values", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    buildProxyHandler() {
+        const proxyHandler = {
+            get: (target, prop, receiver) => {
+                if (typeof target[prop] === "function") {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return (...args) => {
+                        if (this.duplicationAllowedOps.includes(String(prop))) {
+                            switch (String(prop)) {
+                                case "or":
+                                    // args[0]: filters, args[1]: { foreignTable }
+                                    this.addOrClause(args[0], args[1]);
+                                    break;
+                                case "filter":
+                                    // args[0]: column, args[1]: operator, args[2]: value
+                                    this.addFilterClause(args[0], args[1], args[2]);
+                                    break;
+                                case "in":
+                                    // args[0]: column, args[1]: values
+                                    this.addInClause(args[0], args[1]);
+                                    break;
+                                case "contains":
+                                    // args[0]: column, args[1]: value
+                                    this.addContainsClause(args[0], args[1]);
+                                    break;
+                                case "textSearch":
+                                    // args[0]: column, args[1]: query, args[2]: { config, type }
+                                    this.addTextSearchClause(args[0], args[1], args[2]);
+                                    break;
+                                case "match":
+                                    // args[0]: query
+                                    this.addMatchClause(args[0]);
+                                    break;
+                                case "not":
+                                    // args[0]: column, args[1]: operator, args[2]: value
+                                    this.addNotClause(args[0], args[1], args[2]);
+                                    break;
+                                default:
+                                    // args[0]: column, args[1]: value
+                                    this.addDefaultOpClause(prop, args[0], args[1]);
+                            }
+                            return new Proxy(target, proxyHandler);
+                        }
+                        else {
+                            throw new Error("Filter operation not supported for 'or' mergeFiltersOperator");
+                        }
+                    };
+                }
+                else {
+                    return Reflect.get(target, prop, receiver);
+                }
+            },
+        };
+        return proxyHandler;
+    }
+    removeType(value) {
+        let cleanedValue = value;
+        if (cleanedValue.includes("::float")) {
+            cleanedValue = cleanedValue.replace("::float", "");
+        }
+        if (cleanedValue.includes("::int")) {
+            cleanedValue = cleanedValue.replace("::int", "");
+        }
+        return cleanedValue;
+    }
+    addDefaultOpClause(prop, column, value) {
+        this.values.push([this.removeType(column), `${String(prop)}.${value}`]);
+    }
+    addOrClause(filters, { foreignTable } = {}) {
+        const key = foreignTable ? `${foreignTable}.or` : "or";
+        this.values.push([this.removeType(key), `(${filters})`]);
+    }
+    addFilterClause(column, operator, value) {
+        this.values.push([this.removeType(column), `${operator}.${value}`]);
+    }
+    addInClause(column, values) {
+        const cleanedValues = values
+            .map((s) => {
+            if (typeof s === "string" && /[,()]/.test(s))
+                return `"${s}"`;
+            else
+                return `${s}`;
+        })
+            .join(",");
+        this.values.push([this.removeType(column), `in.(${cleanedValues})`]);
+    }
+    addContainsClause(column, value) {
+        if (typeof value === "string") {
+            this.values.push([this.removeType(column), `cs.${value}`]);
+        }
+        else if (Array.isArray(value)) {
+            this.values.push([this.removeType(column), `cs.{${value.join(",")}}`]);
+        }
+        else {
+            this.values.push([
+                this.removeType(column),
+                `cs.${JSON.stringify(value)}`,
+            ]);
+        }
+    }
+    addTextSearchClause(column, query, { config, type, } = {}) {
+        let typePart = "";
+        if (type === "plain") {
+            typePart = "pl";
+        }
+        else if (type === "phrase") {
+            typePart = "ph";
+        }
+        else if (type === "websearch") {
+            typePart = "w";
+        }
+        const configPart = config === undefined ? "" : `(${config})`;
+        this.values.push([
+            this.removeType(column),
+            `${typePart}fts${configPart}.${query}`,
+        ]);
+    }
+    addNotClause(column, operator, value) {
+        this.values.push([column, `not.${operator}.${value}`]);
+    }
+    addMatchClause(query) {
+        Object.entries(query).forEach(([column, value]) => {
+            this.values.push([column, `eq.${value}`]);
+        });
+    }
+    flattenedParams() {
+        const mapped = this.values.map(([k, v]) => `${k}.${v}`);
+        if (mapped.length === 1)
+            return mapped[0];
+        return `and(${mapped.join(",")})`;
+    }
+    static getFlattenedParams(rpc, filter) {
+        const proxiedDuplicator = new ProxyParamsDuplicator();
+        const proxiedRpc = new Proxy(rpc, proxiedDuplicator.buildProxyHandler());
+        void filter(proxiedRpc);
+        return proxiedDuplicator.flattenedParams();
+    }
+}
+exports.ProxyParamsDuplicator = ProxyParamsDuplicator;
+function convertObjectFilterToStructuredQuery(objFilter) {
+    return new ir_js_1.StructuredQuery("", new ir_js_1.Operation(ir_js_1.Operators.and, Object.entries(objFilter).map(([column, value]) => new ir_js_1.Comparison(ir_js_1.Comparators.eq, column, value))));
+}
+exports.convertObjectFilterToStructuredQuery = convertObjectFilterToStructuredQuery;

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

@@ -0,0 +1,24 @@
+import { StructuredQuery } from "../../chains/query_constructor/ir.js";
+import type { SupabaseFilter, SupabaseFilterRPCCall, SupabaseMetadata } from "../../vectorstores/supabase.js";
+export declare class ProxyParamsDuplicator {
+    duplicationAllowedOps: string[];
+    values: [string, string][];
+    buildProxyHandler(): ProxyHandler<SupabaseFilter>;
+    removeType(value: string): string;
+    addDefaultOpClause(prop: string, column: string, value: unknown): void;
+    addOrClause(filters: string, { foreignTable }?: {
+        foreignTable?: string;
+    }): void;
+    addFilterClause(column: string, operator: string, value: unknown): void;
+    addInClause(column: string, values: unknown[]): void;
+    addContainsClause(column: string, value: unknown): void;
+    addTextSearchClause(column: string, query: string[], { config, type, }?: {
+        config?: string;
+        type?: "plain" | "phrase" | "websearch";
+    }): void;
+    addNotClause(column: string, operator: string, value: unknown): void;
+    addMatchClause(query: Record<string, unknown>): void;
+    flattenedParams(): string;
+    static getFlattenedParams(rpc: SupabaseFilter, filter: SupabaseFilterRPCCall): string;
+}
+export declare function convertObjectFilterToStructuredQuery(objFilter: SupabaseMetadata): StructuredQuery;