langchain 0.0.129 → 0.0.131

package/dist/retrievers/self_query/supabase_utils.js

@@ -0,0 +1,172 @@
+import { Comparators, Comparison, Operation, Operators, StructuredQuery, } from "../../chains/query_constructor/ir.js";
+export 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();
+    }
+}
+export function convertObjectFilterToStructuredQuery(objFilter) {
+    return new StructuredQuery("", new Operation(Operators.and, Object.entries(objFilter).map(([column, value]) => new Comparison(Comparators.eq, column, value))));
+}

package/dist/retrievers/self_query/utils.cjs

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFilterEmpty = exports.isObject = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
+exports.isString = exports.isFloat = exports.isInt = exports.isFilterEmpty = exports.isObject = void 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isObject(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
 }
 exports.isObject = isObject;
-function isFilterEmpty(filter) {
+function isFilterEmpty(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+filter) {
     if (!filter)
         return true;
     // for Milvus
@@ -19,3 +21,17 @@ function isFilterEmpty(filter) {
     return isObject(filter) && Object.keys(filter).length === 0;
 }
 exports.isFilterEmpty = isFilterEmpty;
+function isInt(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
+}
+exports.isInt = isInt;
+function isFloat(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
+}
+exports.isFloat = isFloat;
+function isString(value) {
+    return typeof value === "string" && Number.isNaN(parseFloat(value));
+}
+exports.isString = isString;

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

@@ -1,2 +1,5 @@
 export declare function isObject(obj: any): obj is object;
 export declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;
+export declare function isInt(value: unknown): boolean;
+export declare function isFloat(value: unknown): boolean;
+export declare function isString(value: unknown): boolean;

package/dist/retrievers/self_query/utils.js

@@ -1,8 +1,10 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isObject(obj) {
     return obj && typeof obj === "object" && !Array.isArray(obj);
 }
-export function isFilterEmpty(filter) {
+export function isFilterEmpty(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+filter) {
     if (!filter)
         return true;
     // for Milvus
@@ -14,3 +16,14 @@ export function isFilterEmpty(filter) {
     }
     return isObject(filter) && Object.keys(filter).length === 0;
 }
+export function isInt(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
+}
+export function isFloat(value) {
+    const numberValue = parseFloat(value);
+    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
+}
+export function isString(value) {
+    return typeof value === "string" && Number.isNaN(parseFloat(value));
+}

package/dist/retrievers/self_query/weaviate.cjs

@@ -4,17 +4,6 @@ exports.WeaviateTranslator = 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 isInt(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
-}
-function isFloat(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
-}
-function isString(value) {
-    return typeof value === "string" && Number.isNaN(parseFloat(value));
-}
 class WeaviateTranslator extends base_js_1.BaseTranslator {
     constructor() {
         super(...arguments);
@@ -74,21 +63,21 @@ class WeaviateTranslator extends base_js_1.BaseTranslator {
         };
     }
     visitComparison(comparison) {
-        if (isString(comparison.value)) {
+        if ((0, utils_js_1.isString)(comparison.value)) {
             return {
                 path: [comparison.attribute],
                 operator: this.formatFunction(comparison.comparator),
                 valueText: comparison.value,
             };
         }
-        if (isInt(comparison.value)) {
+        if ((0, utils_js_1.isInt)(comparison.value)) {
             return {
                 path: [comparison.attribute],
                 operator: this.formatFunction(comparison.comparator),
                 valueInt: parseInt(comparison.value, 10),
             };
         }
-        if (isFloat(comparison.value)) {
+        if ((0, utils_js_1.isFloat)(comparison.value)) {
             return {
                 path: [comparison.attribute],
                 operator: this.formatFunction(comparison.comparator),

package/dist/retrievers/self_query/weaviate.js

@@ -1,17 +1,6 @@
 import { Comparators, Operators, } from "../../chains/query_constructor/ir.js";
 import { BaseTranslator } from "./base.js";
-import { isFilterEmpty } from "./utils.js";
-function isInt(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 === 0;
-}
-function isFloat(value) {
-    const numberValue = parseFloat(value);
-    return !Number.isNaN(numberValue) && numberValue % 1 !== 0;
-}
-function isString(value) {
-    return typeof value === "string" && Number.isNaN(parseFloat(value));
-}
+import { isFilterEmpty, isString, isInt, isFloat } from "./utils.js";
 export class WeaviateTranslator extends BaseTranslator {
     constructor() {
         super(...arguments);

package/dist/retrievers/supabase.cjs

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

package/dist/retrievers/supabase.d.ts

@@ -33,6 +33,7 @@ export interface SupabaseHybridSearchParams {
     keywordK: number;
 }
 export declare class SupabaseHybridSearch extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     similarityK: number;
     query: string;

package/dist/retrievers/supabase.js

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

package/dist/retrievers/time_weighted.cjs

@@ -9,6 +9,9 @@ exports.BUFFER_IDX = "buffer_idx";
  * ref: https://github.com/hwchase17/langchain/blob/master/langchain/retrievers/time_weighted_retriever.py
  */
 class TimeWeightedVectorStoreRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "TimeWeightedVectorStoreRetriever";
+    }
     get lc_namespace() {
         return ["langchain", "retrievers", "time_weighted"];
     }

package/dist/retrievers/time_weighted.d.ts

@@ -18,6 +18,7 @@ export declare const BUFFER_IDX = "buffer_idx";
  * ref: https://github.com/hwchase17/langchain/blob/master/langchain/retrievers/time_weighted_retriever.py
  */
 export declare class TimeWeightedVectorStoreRetriever extends BaseRetriever {
+    static lc_name(): string;
     get lc_namespace(): string[];
     /**
      * The vectorstore to store documents and determine salience.

package/dist/retrievers/time_weighted.js

@@ -6,6 +6,9 @@ export const BUFFER_IDX = "buffer_idx";
  * ref: https://github.com/hwchase17/langchain/blob/master/langchain/retrievers/time_weighted_retriever.py
  */
 export class TimeWeightedVectorStoreRetriever extends BaseRetriever {
+    static lc_name() {
+        return "TimeWeightedVectorStoreRetriever";
+    }
     get lc_namespace() {
         return ["langchain", "retrievers", "time_weighted"];
     }

package/dist/retrievers/vespa.cjs

@@ -4,6 +4,9 @@ exports.VespaRetriever = void 0;
 const document_js_1 = require("../document.cjs");
 const base_js_1 = require("./remote/base.cjs");
 class VespaRetriever extends base_js_1.RemoteRetriever {
+    static lc_name() {
+        return "VespaRetriever";
+    }
     constructor(fields) {
         super(fields);
         Object.defineProperty(this, "lc_namespace", {

package/dist/retrievers/vespa.d.ts

@@ -11,6 +11,7 @@ export interface VespaRetrieverParams extends RemoteRetrieverParams {
     content_field: string;
 }
 export declare class VespaRetriever extends RemoteRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     query_body: object;
     content_field: string;

package/dist/retrievers/vespa.js

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

package/dist/retrievers/zep.cjs

@@ -5,6 +5,9 @@ const zep_js_1 = require("@getzep/zep-js");
 const retriever_js_1 = require("../schema/retriever.cjs");
 const document_js_1 = require("../document.cjs");
 class ZepRetriever extends retriever_js_1.BaseRetriever {
+    static lc_name() {
+        return "ZepRetriever";
+    }
     get lc_secrets() {
         return {
             apiKey: "ZEP_API_KEY",

package/dist/retrievers/zep.d.ts

@@ -8,6 +8,7 @@ export interface ZepRetrieverConfig extends BaseRetrieverInput {
     apiKey?: string;
 }
 export declare class ZepRetriever extends BaseRetriever {
+    static lc_name(): string;
     lc_namespace: string[];
     get lc_secrets(): {
         [key: string]: string;

package/dist/retrievers/zep.js

@@ -2,6 +2,9 @@ import { NotFoundError, ZepClient, } from "@getzep/zep-js";
 import { BaseRetriever } from "../schema/retriever.js";
 import { Document } from "../document.js";
 export class ZepRetriever extends BaseRetriever {
+    static lc_name() {
+        return "ZepRetriever";
+    }
     get lc_secrets() {
         return {
             apiKey: "ZEP_API_KEY",

package/dist/schema/index.cjs

@@ -128,12 +128,18 @@ class BaseMessageChunk extends BaseMessage {
 }
 exports.BaseMessageChunk = BaseMessageChunk;
 class HumanMessage extends BaseMessage {
+    static lc_name() {
+        return "HumanMessage";
+    }
     _getType() {
         return "human";
     }
 }
 exports.HumanMessage = HumanMessage;
 class HumanMessageChunk extends BaseMessageChunk {
+    static lc_name() {
+        return "HumanMessageChunk";
+    }
     _getType() {
         return "human";
     }
@@ -146,12 +152,18 @@ class HumanMessageChunk extends BaseMessageChunk {
 }
 exports.HumanMessageChunk = HumanMessageChunk;
 class AIMessage extends BaseMessage {
+    static lc_name() {
+        return "AIMessage";
+    }
     _getType() {
         return "ai";
     }
 }
 exports.AIMessage = AIMessage;
 class AIMessageChunk extends BaseMessageChunk {
+    static lc_name() {
+        return "AIMessageChunk";
+    }
     _getType() {
         return "ai";
     }
@@ -164,12 +176,18 @@ class AIMessageChunk extends BaseMessageChunk {
 }
 exports.AIMessageChunk = AIMessageChunk;
 class SystemMessage extends BaseMessage {
+    static lc_name() {
+        return "SystemMessage";
+    }
     _getType() {
         return "system";
     }
 }
 exports.SystemMessage = SystemMessage;
 class SystemMessageChunk extends BaseMessageChunk {
+    static lc_name() {
+        return "SystemMessageChunk";
+    }
     _getType() {
         return "system";
     }
@@ -202,12 +220,15 @@ exports.AIChatMessage = AIMessage;
  */
 exports.SystemChatMessage = SystemMessage;
 class FunctionMessage extends BaseMessage {
+    static lc_name() {
+        return "FunctionMessage";
+    }
     constructor(fields, 
     /** @deprecated */
     name) {
         if (typeof fields === "string") {
-            // eslint-disable-next-line no-param-reassign
-            fields = { content: fields, name };
+            // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion
+            fields = { content: fields, name: name };
         }
         super(fields);
     }
@@ -217,6 +238,9 @@ class FunctionMessage extends BaseMessage {
 }
 exports.FunctionMessage = FunctionMessage;
 class FunctionMessageChunk extends BaseMessageChunk {
+    static lc_name() {
+        return "FunctionMessageChunk";
+    }
     _getType() {
         return "function";
     }
@@ -230,6 +254,9 @@ class FunctionMessageChunk extends BaseMessageChunk {
 }
 exports.FunctionMessageChunk = FunctionMessageChunk;
 class ChatMessage extends BaseMessage {
+    static lc_name() {
+        return "ChatMessage";
+    }
     constructor(fields, role) {
         if (typeof fields === "string") {
             // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion
@@ -253,6 +280,9 @@ class ChatMessage extends BaseMessage {
 }
 exports.ChatMessage = ChatMessage;
 class ChatMessageChunk extends BaseMessageChunk {
+    static lc_name() {
+        return "ChatMessageChunk";
+    }
     constructor(fields, role) {
         if (typeof fields === "string") {
             // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-non-null-assertion

package/dist/schema/index.d.ts

@@ -71,6 +71,9 @@ export interface BaseMessageFields {
 export interface ChatMessageFieldsWithRole extends BaseMessageFields {
     role: string;
 }
+export interface FunctionMessageFieldsWithName extends BaseMessageFields {
+    name: string;
+}
 export declare abstract class BaseMessage extends Serializable implements BaseMessageFields {
     lc_namespace: string[];
     lc_serializable: boolean;
@@ -97,23 +100,29 @@ export declare abstract class BaseMessageChunk extends BaseMessage {
     static _mergeAdditionalKwargs(left: NonNullable<BaseMessageFields["additional_kwargs"]>, right: NonNullable<BaseMessageFields["additional_kwargs"]>): NonNullable<BaseMessageFields["additional_kwargs"]>;
 }
 export declare class HumanMessage extends BaseMessage {
+    static lc_name(): string;
     _getType(): MessageType;
 }
 export declare class HumanMessageChunk extends BaseMessageChunk {
+    static lc_name(): string;
     _getType(): MessageType;
     concat(chunk: HumanMessageChunk): HumanMessageChunk;
 }
 export declare class AIMessage extends BaseMessage {
+    static lc_name(): string;
     _getType(): MessageType;
 }
 export declare class AIMessageChunk extends BaseMessageChunk {
+    static lc_name(): string;
     _getType(): MessageType;
     concat(chunk: AIMessageChunk): AIMessageChunk;
 }
 export declare class SystemMessage extends BaseMessage {
+    static lc_name(): string;
     _getType(): MessageType;
 }
 export declare class SystemMessageChunk extends BaseMessageChunk {
+    static lc_name(): string;
     _getType(): MessageType;
     concat(chunk: SystemMessageChunk): SystemMessageChunk;
 }
@@ -138,16 +147,20 @@ export declare const AIChatMessage: typeof AIMessage;
  */
 export declare const SystemChatMessage: typeof SystemMessage;
 export declare class FunctionMessage extends BaseMessage {
+    static lc_name(): string;
+    constructor(fields: FunctionMessageFieldsWithName);
     constructor(fields: string | BaseMessageFields, 
     /** @deprecated */
     name: string);
     _getType(): MessageType;
 }
 export declare class FunctionMessageChunk extends BaseMessageChunk {
+    static lc_name(): string;
     _getType(): MessageType;
     concat(chunk: FunctionMessageChunk): FunctionMessageChunk;
 }
 export declare class ChatMessage extends BaseMessage implements ChatMessageFieldsWithRole {
+    static lc_name(): string;
     role: string;
     constructor(content: string, role: string);
     constructor(fields: ChatMessageFieldsWithRole);
@@ -155,6 +168,7 @@ export declare class ChatMessage extends BaseMessage implements ChatMessageField
     static isInstance(message: BaseMessage): message is ChatMessage;
 }
 export declare class ChatMessageChunk extends BaseMessageChunk {
+    static lc_name(): string;
     role: string;
     constructor(content: string, role: string);
     constructor(fields: ChatMessageFieldsWithRole);