@langchain/classic 1.0.5 → 1.0.6-dev-1765432861398

package/dist/output_parsers/structured.d.cts

@@ -1,6 +1,6 @@
-import { serializable_d_exports } from "../load/serializable.cjs";
 import { BaseOutputParser, FormatInstructionsOptions } from "@langchain/core/output_parsers";
 import { InferInteropZodOutput, InteropZodType } from "@langchain/core/utils/types";
+import * as _langchain_core_load_serializable0 from "@langchain/core/load/serializable";
 import { z } from "zod/v3";
 
 //#region src/output_parsers/structured.d.ts
@@ -14,7 +14,7 @@ declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutpu
   schema: T;
   static lc_name(): string;
   lc_namespace: string[];
-  toJSON(): serializable_d_exports.SerializedNotImplemented;
+  toJSON(): _langchain_core_load_serializable0.SerializedNotImplemented;
   constructor(schema: T);
   /**
    * Creates a new StructuredOutputParser from a Zod schema.

package/dist/output_parsers/structured.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.cts","names":["z","BaseOutputParser","FormatInstructionsOptions","InferInteropZodOutput","InteropZodType","JsonMarkdownStructuredOutputParserInput","JsonMarkdownFormatInstructionsOptions","StructuredOutputParser","T","S","_langchain_core_load_serializable0","SerializedNotImplemented","ZodString","ZodTypeAny","ZodObject","Promise","JsonMarkdownStructuredOutputParser","AsymmetricStructuredOutputParserFields","AsymmetricStructuredOutputParser","Y","inputSchema"],"sources":["../../src/output_parsers/structured.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseOutputParser, FormatInstructionsOptions } from \"@langchain/core/output_parsers\";\nimport { type InferInteropZodOutput, type InteropZodType } from \"@langchain/core/utils/types\";\nexport type JsonMarkdownStructuredOutputParserInput = {\n    interpolationDepth?: number;\n};\nexport interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {\n    interpolationDepth?: number;\n}\nexport declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutputParser<InferInteropZodOutput<T>> {\n    schema: T;\n    static lc_name(): string;\n    lc_namespace: string[];\n    toJSON(): import(\"@langchain/core/load/serializable\").SerializedNotImplemented;\n    constructor(schema: T);\n    /**\n     * Creates a new StructuredOutputParser from a Zod schema.\n     * @param schema The Zod schema which the output should match\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromZodSchema<T extends InteropZodType>(schema: T): StructuredOutputParser<T>;\n    /**\n     * Creates a new StructuredOutputParser from a set of names and\n     * descriptions.\n     * @param schemas An object where each key is a name and each value is a description\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): StructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n    /**\n     * Returns a markdown code snippet with a JSON object formatted according\n     * to the schema.\n     * @param options Optional. The options for formatting the instructions\n     * @returns A markdown code snippet with a JSON object formatted according to the schema.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Parses the given text according to the schema.\n     * @param text The text to parse\n     * @returns The parsed output.\n     */\n    parse(text: string): Promise<InferInteropZodOutput<T>>;\n}\n/**\n * A specific type of `StructuredOutputParser` that parses JSON data\n * formatted as a markdown code snippet.\n */\nexport declare class JsonMarkdownStructuredOutputParser<T extends InteropZodType> extends StructuredOutputParser<T> {\n    static lc_name(): string;\n    getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;\n    private _schemaToInstruction;\n    static fromZodSchema<T extends InteropZodType>(schema: T): JsonMarkdownStructuredOutputParser<T>;\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n}\nexport interface AsymmetricStructuredOutputParserFields<T extends InteropZodType> {\n    inputSchema: T;\n}\n/**\n * A type of `StructuredOutputParser` that handles asymmetric input and\n * output schemas.\n */\nexport declare abstract class AsymmetricStructuredOutputParser<T extends InteropZodType, Y = unknown> extends BaseOutputParser<Y> {\n    private structuredInputParser;\n    constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>);\n    /**\n     * Processes the parsed input into the desired output format. Must be\n     * implemented by subclasses.\n     * @param input The parsed input\n     * @returns The processed output.\n     */\n    abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;\n    parse(text: string): Promise<Y>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=structured.d.ts.map"],"mappings":";;;;;;KAGYK,uCAAAA;;;AAAAA,UAGKC,qCAAAA,SAA8CJ,yBAHZ,CAAA;EAGlCI,kBAAAA,CAAAA,EAAAA,MAAAA;AAGjB;AAAsDF,cAAjCG,sBAAiCH,CAAAA,UAAAA,cAAAA,CAAAA,SAAwBH,gBAAxBG,CAAyCD,qBAAzCC,CAA+DI,CAA/DJ,CAAAA,CAAAA,CAAAA;EAA+DI,MAAAA,EACzGA,CADyGA;EAAtBL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACnFK,YAAAA,EAAAA,MAAAA,EAAAA;EAACE,MAAAA,CAAAA,CAAAA,EAAAA,kCAAAA,CAG6CC,wBAAAA;EAClCH,WAAAA,CAAAA,MAAAA,EAAAA,CAAAA;EAMWJ;;;;;EAUZQ,OAAAA,aAAAA,CAAAA,UAVYR,cAUZQ,CAAAA,CAAAA,MAAAA,EAVoCJ,CAUpCI,CAAAA,EAVwCL,sBAUxCK,CAV+DJ,CAU/DI,CAAAA;EACLC;;;;;;EAtB4DZ,OAAAA,wBAAAA,CAAAA,UAAAA;IAAgB,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EA6CzEe,CAAAA,CAAAA,CAAAA,OAAAA,EAzBLP,CAyBKO,CAAAA,EAzBDT,sBAyBmC,CAzBZP,CAAAA,CAAEc,SAyBUL,CAAAA;IAAWL,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAxB7CJ,CAAAA,CAAEY,SAwB2CR;EAA+CI,CAAAA,EAAAA,OAAAA,EAvBjGR,CAAAA,CAAEa,UAuB+FL,EAAAA;IAE7EF,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAEDF,CAAAA,EAAAA;IAAwBI,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAuCA,CAAAA,CAAAA,CAAAA;EAAnCQ;;;;;;EAJ2BT,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB;AAehH;AAOA;;;EAEkBa,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9BOL,OA8BPK,CA9BejB,qBA8BfiB,CA9BqCZ,CA8BrCY,CAAAA,CAAAA;;;;;;AAO6CL,cA/B1CC,kCA+B0CD,CAAAA,UA/BGX,cA+BHW,CAAAA,SA/B2BR,sBA+B3BQ,CA/BkDP,CA+BlDO,CAAAA,CAAAA;EAC9BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAARJ,qBAAAA,CAAAA,OAAAA,CAAAA,EA9BWT,qCA8BXS,CAAAA,EAAAA,MAAAA;EAVqFd,QAAAA,oBAAAA;EAAgB,OAAA,aAAA,CAAA,UAlB3FG,cAkB2F,CAAA,CAAA,MAAA,EAlBnEI,CAkBmE,CAAA,EAlB/DQ,kCAkB+D,CAlB5BR,CAkB4B,CAAA;;;cAf9GC,IAAIO,mCAAmChB,CAAAA,CAAEc;iBACpCd,CAAAA,CAAEY;cACPZ,CAAAA,CAAEa;;;;;;UAMDI,iDAAiDb;eACjDI;;;;;;uBAMaU,2CAA2Cd,qCAAqCH,iBAAiBkB;;;;KAE9FF,uCAAuCT;;;;;;;kCAOpCL,sBAAsBK,KAAKO,QAAQI;uBAC9CJ,QAAQI"}

package/dist/output_parsers/structured.d.ts

@@ -1,4 +1,4 @@
-import { serializable_d_exports } from "../load/serializable.js";
+import * as _langchain_core_load_serializable0 from "@langchain/core/load/serializable";
 import { BaseOutputParser, FormatInstructionsOptions } from "@langchain/core/output_parsers";
 import { InferInteropZodOutput, InteropZodType } from "@langchain/core/utils/types";
 import { z } from "zod/v3";
@@ -14,7 +14,7 @@ declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutpu
   schema: T;
   static lc_name(): string;
   lc_namespace: string[];
-  toJSON(): serializable_d_exports.SerializedNotImplemented;
+  toJSON(): _langchain_core_load_serializable0.SerializedNotImplemented;
   constructor(schema: T);
   /**
    * Creates a new StructuredOutputParser from a Zod schema.

package/dist/output_parsers/structured.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured.d.ts","names":["z","BaseOutputParser","FormatInstructionsOptions","InferInteropZodOutput","InteropZodType","JsonMarkdownStructuredOutputParserInput","JsonMarkdownFormatInstructionsOptions","StructuredOutputParser","T","S","_langchain_core_load_serializable0","SerializedNotImplemented","ZodString","ZodTypeAny","ZodObject","Promise","JsonMarkdownStructuredOutputParser","AsymmetricStructuredOutputParserFields","AsymmetricStructuredOutputParser","Y","inputSchema"],"sources":["../../src/output_parsers/structured.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { BaseOutputParser, FormatInstructionsOptions } from \"@langchain/core/output_parsers\";\nimport { type InferInteropZodOutput, type InteropZodType } from \"@langchain/core/utils/types\";\nexport type JsonMarkdownStructuredOutputParserInput = {\n    interpolationDepth?: number;\n};\nexport interface JsonMarkdownFormatInstructionsOptions extends FormatInstructionsOptions {\n    interpolationDepth?: number;\n}\nexport declare class StructuredOutputParser<T extends InteropZodType> extends BaseOutputParser<InferInteropZodOutput<T>> {\n    schema: T;\n    static lc_name(): string;\n    lc_namespace: string[];\n    toJSON(): import(\"@langchain/core/load/serializable\").SerializedNotImplemented;\n    constructor(schema: T);\n    /**\n     * Creates a new StructuredOutputParser from a Zod schema.\n     * @param schema The Zod schema which the output should match\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromZodSchema<T extends InteropZodType>(schema: T): StructuredOutputParser<T>;\n    /**\n     * Creates a new StructuredOutputParser from a set of names and\n     * descriptions.\n     * @param schemas An object where each key is a name and each value is a description\n     * @returns A new instance of StructuredOutputParser.\n     */\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): StructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n    /**\n     * Returns a markdown code snippet with a JSON object formatted according\n     * to the schema.\n     * @param options Optional. The options for formatting the instructions\n     * @returns A markdown code snippet with a JSON object formatted according to the schema.\n     */\n    getFormatInstructions(): string;\n    /**\n     * Parses the given text according to the schema.\n     * @param text The text to parse\n     * @returns The parsed output.\n     */\n    parse(text: string): Promise<InferInteropZodOutput<T>>;\n}\n/**\n * A specific type of `StructuredOutputParser` that parses JSON data\n * formatted as a markdown code snippet.\n */\nexport declare class JsonMarkdownStructuredOutputParser<T extends InteropZodType> extends StructuredOutputParser<T> {\n    static lc_name(): string;\n    getFormatInstructions(options?: JsonMarkdownFormatInstructionsOptions): string;\n    private _schemaToInstruction;\n    static fromZodSchema<T extends InteropZodType>(schema: T): JsonMarkdownStructuredOutputParser<T>;\n    static fromNamesAndDescriptions<S extends {\n        [key: string]: string;\n    }>(schemas: S): JsonMarkdownStructuredOutputParser<z.ZodObject<{\n        [k: string]: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        [x: string]: string;\n    }, {\n        [x: string]: string;\n    }>>;\n}\nexport interface AsymmetricStructuredOutputParserFields<T extends InteropZodType> {\n    inputSchema: T;\n}\n/**\n * A type of `StructuredOutputParser` that handles asymmetric input and\n * output schemas.\n */\nexport declare abstract class AsymmetricStructuredOutputParser<T extends InteropZodType, Y = unknown> extends BaseOutputParser<Y> {\n    private structuredInputParser;\n    constructor({ inputSchema }: AsymmetricStructuredOutputParserFields<T>);\n    /**\n     * Processes the parsed input into the desired output format. Must be\n     * implemented by subclasses.\n     * @param input The parsed input\n     * @returns The processed output.\n     */\n    abstract outputProcessor(input: InferInteropZodOutput<T>): Promise<Y>;\n    parse(text: string): Promise<Y>;\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=structured.d.ts.map"],"mappings":";;;;;;KAGYK,uCAAAA;;;AAAAA,UAGKC,qCAAAA,SAA8CJ,yBAHZ,CAAA;EAGlCI,kBAAAA,CAAAA,EAAAA,MAAAA;AAGjB;AAAsDF,cAAjCG,sBAAiCH,CAAAA,UAAAA,cAAAA,CAAAA,SAAwBH,gBAAxBG,CAAyCD,qBAAzCC,CAA+DI,CAA/DJ,CAAAA,CAAAA,CAAAA;EAA+DI,MAAAA,EACzGA,CADyGA;EAAtBL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EACnFK,YAAAA,EAAAA,MAAAA,EAAAA;EAACE,MAAAA,CAAAA,CAAAA,EAAAA,kCAAAA,CAG6CC,wBAAAA;EAClCH,WAAAA,CAAAA,MAAAA,EAAAA,CAAAA;EAMWJ;;;;;EAUZQ,OAAAA,aAAAA,CAAAA,UAVYR,cAUZQ,CAAAA,CAAAA,MAAAA,EAVoCJ,CAUpCI,CAAAA,EAVwCL,sBAUxCK,CAV+DJ,CAU/DI,CAAAA;EACLC;;;;;;EAtB4DZ,OAAAA,wBAAAA,CAAAA,UAAAA;IAAgB,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EA6CzEe,CAAAA,CAAAA,CAAAA,OAAAA,EAzBLP,CAyBKO,CAAAA,EAzBDT,sBAyBmC,CAzBZP,CAAAA,CAAEc,SAyBUL,CAAAA;IAAWL,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAxB7CJ,CAAAA,CAAEY,SAwB2CR;EAA+CI,CAAAA,EAAAA,OAAAA,EAvBjGR,CAAAA,CAAEa,UAuB+FL,EAAAA;IAE7EF,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAEDF,CAAAA,EAAAA;IAAwBI,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EAAuCA,CAAAA,CAAAA,CAAAA;EAAnCQ;;;;;;EAJ2BT,qBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB;AAehH;AAOA;;;EAEkBa,KAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EA9BOL,OA8BPK,CA9BejB,qBA8BfiB,CA9BqCZ,CA8BrCY,CAAAA,CAAAA;;;;;;AAO6CL,cA/B1CC,kCA+B0CD,CAAAA,UA/BGX,cA+BHW,CAAAA,SA/B2BR,sBA+B3BQ,CA/BkDP,CA+BlDO,CAAAA,CAAAA;EAC9BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAARJ,qBAAAA,CAAAA,OAAAA,CAAAA,EA9BWT,qCA8BXS,CAAAA,EAAAA,MAAAA;EAVqFd,QAAAA,oBAAAA;EAAgB,OAAA,aAAA,CAAA,UAlB3FG,cAkB2F,CAAA,CAAA,MAAA,EAlBnEI,CAkBmE,CAAA,EAlB/DQ,kCAkB+D,CAlB5BR,CAkB4B,CAAA;;;cAf9GC,IAAIO,mCAAmChB,CAAAA,CAAEc;iBACpCd,CAAAA,CAAEY;cACPZ,CAAAA,CAAEa;;;;;;UAMDI,iDAAiDb;eACjDI;;;;;;uBAMaU,2CAA2Cd,qCAAqCH,iBAAiBkB;;;;KAE9FF,uCAAuCT;;;;;;;kCAOpCL,sBAAsBK,KAAKO,QAAQI;uBAC9CJ,QAAQI"}

package/dist/retrievers/contextual_compression.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual_compression.d.cts","names":["BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","DocumentInterface","CallbackManagerForRetrieverRun","BaseDocumentCompressor","ContextualCompressionRetrieverArgs","ContextualCompressionRetriever","Promise"],"sources":["../../src/retrievers/contextual_compression.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseDocumentCompressor } from \"./document_compressors/index.js\";\n/**\n * Interface for the arguments required to construct a\n * ContextualCompressionRetriever. It extends the BaseRetrieverInput\n * interface with two additional fields: baseCompressor and baseRetriever.\n */\nexport interface ContextualCompressionRetrieverArgs extends BaseRetrieverInput {\n    baseCompressor: BaseDocumentCompressor;\n    baseRetriever: BaseRetrieverInterface;\n}\n/**\n * A retriever that wraps a base retriever and compresses the results. It\n * retrieves relevant documents based on a given query and then compresses\n * these documents using a specified document compressor.\n * @example\n * ```typescript\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: new LLMChainExtractor(),\n *   baseRetriever: new HNSWLib().asRetriever(),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer?\",\n * );\n * ```\n */\nexport declare class ContextualCompressionRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    baseCompressor: BaseDocumentCompressor;\n    baseRetriever: BaseRetrieverInterface;\n    constructor(fields: ContextualCompressionRetrieverArgs);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=contextual_compression.d.ts.map"],"mappings":";;;;;;;;;AASA;;;AAA4DC,UAA3CK,kCAAAA,SAA2CL,kBAAAA,CAAAA;EAAkB,cAAA,EAC1DI,sBAD0D;EAmBzDE,aAAAA,EAjBFL,sBAiBgC;;;;;;;;AAAsB;;;;;;;;;cAApDK,8BAAAA,SAAuCP,aAAAA;;;kBAGxCK;iBACDH;sBACKI;oDAC8BF,iCAAiCI,QAAQL"}

package/dist/retrievers/contextual_compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual_compression.d.ts","names":["BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","DocumentInterface","CallbackManagerForRetrieverRun","BaseDocumentCompressor","ContextualCompressionRetrieverArgs","ContextualCompressionRetriever","Promise"],"sources":["../../src/retrievers/contextual_compression.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { BaseDocumentCompressor } from \"./document_compressors/index.js\";\n/**\n * Interface for the arguments required to construct a\n * ContextualCompressionRetriever. It extends the BaseRetrieverInput\n * interface with two additional fields: baseCompressor and baseRetriever.\n */\nexport interface ContextualCompressionRetrieverArgs extends BaseRetrieverInput {\n    baseCompressor: BaseDocumentCompressor;\n    baseRetriever: BaseRetrieverInterface;\n}\n/**\n * A retriever that wraps a base retriever and compresses the results. It\n * retrieves relevant documents based on a given query and then compresses\n * these documents using a specified document compressor.\n * @example\n * ```typescript\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: new LLMChainExtractor(),\n *   baseRetriever: new HNSWLib().asRetriever(),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer?\",\n * );\n * ```\n */\nexport declare class ContextualCompressionRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    baseCompressor: BaseDocumentCompressor;\n    baseRetriever: BaseRetrieverInterface;\n    constructor(fields: ContextualCompressionRetrieverArgs);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=contextual_compression.d.ts.map"],"mappings":";;;;;;;;;AASA;;;AAA4DC,UAA3CK,kCAAAA,SAA2CL,kBAAAA,CAAAA;EAAkB,cAAA,EAC1DI,sBAD0D;EAmBzDE,aAAAA,EAjBFL,sBAiBgC;;;;;;;;AAAsB;;;;;;;;;cAApDK,8BAAAA,SAAuCP,aAAAA;;;kBAGxCK;iBACDH;sBACKI;oDAC8BF,iCAAiCI,QAAQL"}

package/dist/retrievers/document_compressors/chain_extract.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain_extract.d.cts","names":["BaseLanguageModelInterface","DocumentInterface","PromptTemplate","LLMChain","BaseDocumentCompressor","LLMChainExtractorArgs","Record","LLMChainExtractor","llmChain","getInput","Promise"],"sources":["../../../src/retrievers/document_compressors/chain_extract.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { type DocumentInterface } from \"@langchain/core/documents\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the arguments required to create an instance of\n * LLMChainExtractor.\n */\nexport interface LLMChainExtractorArgs {\n    llmChain: LLMChain;\n    getInput: (query: string, doc: DocumentInterface) => Record<string, unknown>;\n}\n/**\n * A class that uses an LLM chain to extract relevant parts of documents.\n * It extends the BaseDocumentCompressor class.\n */\nexport declare class LLMChainExtractor extends BaseDocumentCompressor {\n    llmChain: LLMChain;\n    getInput: (query: string, doc: DocumentInterface) => Record<string, unknown>;\n    constructor({ llmChain, getInput }: LLMChainExtractorArgs);\n    /**\n     * Compresses a list of documents based on the output of an LLM chain.\n     * @param documents The list of documents to be compressed.\n     * @param query The query to be used for document compression.\n     * @returns A list of compressed documents.\n     */\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n    /**\n     * Creates a new instance of LLMChainExtractor from a given LLM, prompt\n     * template, and getInput function.\n     * @param llm The BaseLanguageModel instance used for document extraction.\n     * @param prompt The PromptTemplate instance used for document extraction.\n     * @param getInput A function used for constructing the chain input from the query and a Document.\n     * @returns A new instance of LLMChainExtractor.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, prompt?: PromptTemplate, getInput?: (query: string, doc: DocumentInterface) => Record<string, unknown>): LLMChainExtractor;\n}\n//# sourceMappingURL=chain_extract.d.ts.map"],"mappings":";;;;;;;;;;AASA;;AAEmCC,UAFlBI,qBAAAA,CAEkBJ;EAAsBK,QAAAA,EAD3CH,QAC2CG;EAAM,QAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAAA,EAA5BL,iBAA4B,EAAA,GAANK,MAAM,CAAA,MAAA,EAAA,OAAA,CAAA;AAM/D;;;;;AAG4BG,cAHPF,iBAAAA,SAA0BH,sBAAAA,CAGnBK;EAAYJ,QAAAA,EAF1BF,QAE0BE;EAOPJ,QAAAA,EAAAA,CAAAA,KAAAA,EAAAA,MAAAA,EAAAA,GAAAA,EAREA,iBAQFA,EAAAA,GARwBK,MAQxBL,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAA6CA,WAAAA,CAAAA;IAAAA,QAAAA;IAAAA;EAAAA,CAAAA,EAPtCI,qBAOsCJ;EAARS;;;;;;EAVvBN,iBAAAA,CAAAA,SAAAA,EAUdH,iBAVcG,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAUuBM,OAVvBN,CAU+BH,iBAV/BG,EAAAA,CAAAA;EAAsB;;;;;;;;sBAmB7CJ,qCAAqCE,gDAAgDD,sBAAsBK,0BAA0BC"}

package/dist/retrievers/document_compressors/chain_extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain_extract.d.ts","names":["BaseLanguageModelInterface","DocumentInterface","PromptTemplate","LLMChain","BaseDocumentCompressor","LLMChainExtractorArgs","Record","LLMChainExtractor","llmChain","getInput","Promise"],"sources":["../../../src/retrievers/document_compressors/chain_extract.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { type DocumentInterface } from \"@langchain/core/documents\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the arguments required to create an instance of\n * LLMChainExtractor.\n */\nexport interface LLMChainExtractorArgs {\n    llmChain: LLMChain;\n    getInput: (query: string, doc: DocumentInterface) => Record<string, unknown>;\n}\n/**\n * A class that uses an LLM chain to extract relevant parts of documents.\n * It extends the BaseDocumentCompressor class.\n */\nexport declare class LLMChainExtractor extends BaseDocumentCompressor {\n    llmChain: LLMChain;\n    getInput: (query: string, doc: DocumentInterface) => Record<string, unknown>;\n    constructor({ llmChain, getInput }: LLMChainExtractorArgs);\n    /**\n     * Compresses a list of documents based on the output of an LLM chain.\n     * @param documents The list of documents to be compressed.\n     * @param query The query to be used for document compression.\n     * @returns A list of compressed documents.\n     */\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n    /**\n     * Creates a new instance of LLMChainExtractor from a given LLM, prompt\n     * template, and getInput function.\n     * @param llm The BaseLanguageModel instance used for document extraction.\n     * @param prompt The PromptTemplate instance used for document extraction.\n     * @param getInput A function used for constructing the chain input from the query and a Document.\n     * @returns A new instance of LLMChainExtractor.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, prompt?: PromptTemplate, getInput?: (query: string, doc: DocumentInterface) => Record<string, unknown>): LLMChainExtractor;\n}\n//# sourceMappingURL=chain_extract.d.ts.map"],"mappings":";;;;;;;;;;AASA;;AAEmCC,UAFlBI,qBAAAA,CAEkBJ;EAAsBK,QAAAA,EAD3CH,QAC2CG;EAAM,QAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAAA,EAA5BL,iBAA4B,EAAA,GAANK,MAAM,CAAA,MAAA,EAAA,OAAA,CAAA;AAM/D;;;;;AAG4BG,cAHPF,iBAAAA,SAA0BH,sBAAAA,CAGnBK;EAAYJ,QAAAA,EAF1BF,QAE0BE;EAOPJ,QAAAA,EAAAA,CAAAA,KAAAA,EAAAA,MAAAA,EAAAA,GAAAA,EAREA,iBAQFA,EAAAA,GARwBK,MAQxBL,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAA6CA,WAAAA,CAAAA;IAAAA,QAAAA;IAAAA;EAAAA,CAAAA,EAPtCI,qBAOsCJ;EAARS;;;;;;EAVvBN,iBAAAA,CAAAA,SAAAA,EAUdH,iBAVcG,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAUuBM,OAVvBN,CAU+BH,iBAV/BG,EAAAA,CAAAA;EAAsB;;;;;;;;sBAmB7CJ,qCAAqCE,gDAAgDD,sBAAsBK,0BAA0BC"}

package/dist/retrievers/document_compressors/embeddings_filter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings_filter.d.cts","names":["EmbeddingsInterface","DocumentInterface","cosineSimilarity","BaseDocumentCompressor","EmbeddingsFilterParams","EmbeddingsFilter","Promise"],"sources":["../../../src/retrievers/document_compressors/embeddings_filter.d.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { cosineSimilarity } from \"@langchain/core/utils/math\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the parameters of the `EmbeddingsFilter` class.\n */\nexport interface EmbeddingsFilterParams {\n    embeddings: EmbeddingsInterface;\n    similarityFn?: (x: number[][], y: number[][]) => number[][];\n    similarityThreshold?: number;\n    k?: number;\n}\n/**\n * Class that represents a document compressor that uses embeddings to\n * drop documents unrelated to the query.\n * @example\n * ```typescript\n * const embeddingsFilter = new EmbeddingsFilter({\n *   embeddings: new OpenAIEmbeddings(),\n *   similarityThreshold: 0.8,\n *   k: 5,\n * });\n * const retrievedDocs = await embeddingsFilter.filterDocuments(\n *   getDocuments(),\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class EmbeddingsFilter extends BaseDocumentCompressor {\n    /**\n     * Embeddings to use for embedding document contents and queries.\n     */\n    embeddings: EmbeddingsInterface;\n    /**\n     * Similarity function for comparing documents.\n     */\n    similarityFn: typeof cosineSimilarity;\n    /**\n     * Threshold for determining when two documents are similar enough\n     * to be considered redundant. Must be specified if `k` is not set.\n     */\n    similarityThreshold?: number;\n    /**\n     * The number of relevant documents to return. Can be explicitly set to undefined, in which case\n     * similarity_threshold` must be specified. Defaults to 20\n     */\n    k?: number | undefined;\n    constructor(params: EmbeddingsFilterParams);\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=embeddings_filter.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAuBqBK,UAvBJD,sBAAAA,CAuBoB;EAIrBJ,UAAAA,EA1BAA,mBA0BAA;EAISE,YAAAA,CAAAA,EAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,GAAAA,MAAAA,EAAAA,EAAAA;EAWDE,mBAAAA,CAAAA,EAAAA,MAAAA;EACSH,CAAAA,CAAAA,EAAAA,MAAAA;;;;AApBmC;;;;;;;;;;;;;;;cAA/CI,gBAAAA,SAAyBF,sBAAAA;;;;cAI9BH;;;;uBAISE;;;;;;;;;;;sBAWDE;+BACSH,qCAAqCK,QAAQL"}

package/dist/retrievers/document_compressors/embeddings_filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings_filter.d.ts","names":["EmbeddingsInterface","DocumentInterface","cosineSimilarity","BaseDocumentCompressor","EmbeddingsFilterParams","EmbeddingsFilter","Promise"],"sources":["../../../src/retrievers/document_compressors/embeddings_filter.d.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { cosineSimilarity } from \"@langchain/core/utils/math\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the parameters of the `EmbeddingsFilter` class.\n */\nexport interface EmbeddingsFilterParams {\n    embeddings: EmbeddingsInterface;\n    similarityFn?: (x: number[][], y: number[][]) => number[][];\n    similarityThreshold?: number;\n    k?: number;\n}\n/**\n * Class that represents a document compressor that uses embeddings to\n * drop documents unrelated to the query.\n * @example\n * ```typescript\n * const embeddingsFilter = new EmbeddingsFilter({\n *   embeddings: new OpenAIEmbeddings(),\n *   similarityThreshold: 0.8,\n *   k: 5,\n * });\n * const retrievedDocs = await embeddingsFilter.filterDocuments(\n *   getDocuments(),\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class EmbeddingsFilter extends BaseDocumentCompressor {\n    /**\n     * Embeddings to use for embedding document contents and queries.\n     */\n    embeddings: EmbeddingsInterface;\n    /**\n     * Similarity function for comparing documents.\n     */\n    similarityFn: typeof cosineSimilarity;\n    /**\n     * Threshold for determining when two documents are similar enough\n     * to be considered redundant. Must be specified if `k` is not set.\n     */\n    similarityThreshold?: number;\n    /**\n     * The number of relevant documents to return. Can be explicitly set to undefined, in which case\n     * similarity_threshold` must be specified. Defaults to 20\n     */\n    k?: number | undefined;\n    constructor(params: EmbeddingsFilterParams);\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=embeddings_filter.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAuBqBK,UAvBJD,sBAAAA,CAuBoB;EAIrBJ,UAAAA,EA1BAA,mBA0BAA;EAISE,YAAAA,CAAAA,EAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,GAAAA,MAAAA,EAAAA,EAAAA;EAWDE,mBAAAA,CAAAA,EAAAA,MAAAA;EACSH,CAAAA,CAAAA,EAAAA,MAAAA;;;;AApBmC;;;;;;;;;;;;;;;cAA/CI,gBAAAA,SAAyBF,sBAAAA;;;;cAI9BH;;;;uBAISE;;;;;;;;;;;sBAWDE;+BACSH,qCAAqCK,QAAQL"}

package/dist/retrievers/document_compressors/index.d.cts

@@ -17,7 +17,6 @@ declare abstract class BaseDocumentCompressor {
    * @returns A Promise that resolves with an array of compressed `Document` objects.
    */
   abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;
 }
 /**

package/dist/retrievers/document_compressors/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["DocumentInterface","BaseDocumentTransformer","Callbacks","BaseDocumentCompressor","Promise","DocumentCompressorPipeline"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import type { DocumentInterface } from \"@langchain/core/documents\";\nimport { BaseDocumentTransformer } from \"@langchain/core/documents\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n/**\n * Document compressor that uses a pipeline of Transformers.\n * @example\n * ```typescript\n * const compressorPipeline = new DocumentCompressorPipeline({\n *   transformers: [\n *     new RecursiveCharacterTextSplitter({\n *       chunkSize: 200,\n *       chunkOverlap: 0,\n *     }),\n *     new EmbeddingsFilter({\n *       embeddings: new OpenAIEmbeddings(),\n *       similarityThreshold: 0.8,\n *       k: 5,\n *     }),\n *   ],\n * });\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: compressorPipeline,\n *   baseRetriever: new TavilySearchAPIRetriever({\n *     includeRawContent: true,\n *   }),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class DocumentCompressorPipeline extends BaseDocumentCompressor {\n    transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    constructor(fields: {\n        transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    });\n    compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;AAMA;;AAU0FE,uBAV5DC,sBAAAA,CAU4DD;EAAoBF;;;AACtC;AA+BxE;;;;;EAKiCA,SAAAA,iBAAAA,CAAAA,SAAAA,EArCSA,iBAqCTA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,SAAAA,CAAAA,EArCyDE,SAqCzDF,CAAAA,EArCqEI,OAqCrEJ,CArC6EA,iBAqC7EA,EAAAA,CAAAA;EAAgDE,OAAAA,wBAAAA,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,IApC/BC,sBAoC+BD;;;;AALH;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzDG,0BAAAA,SAAmCF,sBAAAA;iBACrCF,0BAA0BE;;mBAEtBF,0BAA0BE;;+BAEhBH,gDAAgDE,YAAYE,QAAQJ"}

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

@@ -17,7 +17,6 @@ declare abstract class BaseDocumentCompressor {
    * @returns A Promise that resolves with an array of compressed `Document` objects.
    */
   abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;
 }
 /**

package/dist/retrievers/document_compressors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["DocumentInterface","BaseDocumentTransformer","Callbacks","BaseDocumentCompressor","Promise","DocumentCompressorPipeline"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import type { DocumentInterface } from \"@langchain/core/documents\";\nimport { BaseDocumentTransformer } from \"@langchain/core/documents\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n/**\n * Document compressor that uses a pipeline of Transformers.\n * @example\n * ```typescript\n * const compressorPipeline = new DocumentCompressorPipeline({\n *   transformers: [\n *     new RecursiveCharacterTextSplitter({\n *       chunkSize: 200,\n *       chunkOverlap: 0,\n *     }),\n *     new EmbeddingsFilter({\n *       embeddings: new OpenAIEmbeddings(),\n *       similarityThreshold: 0.8,\n *       k: 5,\n *     }),\n *   ],\n * });\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: compressorPipeline,\n *   baseRetriever: new TavilySearchAPIRetriever({\n *     includeRawContent: true,\n *   }),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class DocumentCompressorPipeline extends BaseDocumentCompressor {\n    transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    constructor(fields: {\n        transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    });\n    compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;AAMA;;AAU0FE,uBAV5DC,sBAAAA,CAU4DD;EAAoBF;;;AACtC;AA+BxE;;;;;EAKiCA,SAAAA,iBAAAA,CAAAA,SAAAA,EArCSA,iBAqCTA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,SAAAA,CAAAA,EArCyDE,SAqCzDF,CAAAA,EArCqEI,OAqCrEJ,CArC6EA,iBAqC7EA,EAAAA,CAAAA;EAAgDE,OAAAA,wBAAAA,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,IApC/BC,sBAoC+BD;;;;AALH;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzDG,0BAAAA,SAAmCF,sBAAAA;iBACrCF,0BAA0BE;;mBAEtBF,0BAA0BE;;+BAEhBH,gDAAgDE,YAAYE,QAAQJ"}

package/dist/retrievers/ensemble.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble.d.cts","names":["BaseRetriever","BaseRetrieverInput","Document","DocumentInterface","CallbackManagerForRetrieverRun","EnsembleRetrieverInput","EnsembleRetriever","Record","Promise"],"sources":["../../src/retrievers/ensemble.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nexport interface EnsembleRetrieverInput extends BaseRetrieverInput {\n    /** A list of retrievers to ensemble. */\n    retrievers: BaseRetriever[];\n    /**\n     * A list of weights corresponding to the retrievers. Defaults to equal\n     * weighting for all retrievers.\n     */\n    weights?: number[];\n    /**\n     * A constant added to the rank, controlling the balance between the importance\n     * of high-ranked items and the consideration given to lower-ranked items.\n     * Default is 60.\n     */\n    c?: number;\n}\n/**\n * Ensemble retriever that aggregates and orders the results of\n * multiple retrievers by using weighted Reciprocal Rank Fusion.\n */\nexport declare class EnsembleRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    retrievers: BaseRetriever[];\n    weights: number[];\n    c: number;\n    constructor(args: EnsembleRetrieverInput);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _rankFusion(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _weightedReciprocalRank(docList: DocumentInterface[][]): Promise<Document<Record<string, any>>[]>;\n    private _uniqueUnion;\n}\n//# sourceMappingURL=ensemble.d.ts.map"],"mappings":";;;;;UAGiBK,sBAAAA,SAA+BJ;;EAA/BI,UAAAA,EAEDL,aAFuB,EAAA;EAmBlBM;;;;EAOmFC,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAATL;;;;;EAClBM,CAAAA,CAAAA,EAAAA,MAAAA;;;;;;AARjB,cAAvCF,iBAAAA,SAA0BN,aAAAA,CAAa;;;cAG5CA;;;oBAGMK;oDACgCD,iCAAiCI,QAAQN,SAASK;0CAC5DH,iCAAiCI,QAAQN,SAASK;mCACzDJ,wBAAwBK,QAAQN,SAASK"}

package/dist/retrievers/ensemble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensemble.d.ts","names":["BaseRetriever","BaseRetrieverInput","Document","DocumentInterface","CallbackManagerForRetrieverRun","EnsembleRetrieverInput","EnsembleRetriever","Record","Promise"],"sources":["../../src/retrievers/ensemble.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nexport interface EnsembleRetrieverInput extends BaseRetrieverInput {\n    /** A list of retrievers to ensemble. */\n    retrievers: BaseRetriever[];\n    /**\n     * A list of weights corresponding to the retrievers. Defaults to equal\n     * weighting for all retrievers.\n     */\n    weights?: number[];\n    /**\n     * A constant added to the rank, controlling the balance between the importance\n     * of high-ranked items and the consideration given to lower-ranked items.\n     * Default is 60.\n     */\n    c?: number;\n}\n/**\n * Ensemble retriever that aggregates and orders the results of\n * multiple retrievers by using weighted Reciprocal Rank Fusion.\n */\nexport declare class EnsembleRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    retrievers: BaseRetriever[];\n    weights: number[];\n    c: number;\n    constructor(args: EnsembleRetrieverInput);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _rankFusion(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _weightedReciprocalRank(docList: DocumentInterface[][]): Promise<Document<Record<string, any>>[]>;\n    private _uniqueUnion;\n}\n//# sourceMappingURL=ensemble.d.ts.map"],"mappings":";;;;;UAGiBK,sBAAAA,SAA+BJ;;EAA/BI,UAAAA,EAEDL,aAFuB,EAAA;EAmBlBM;;;;EAOmFC,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAATL;;;;;EAClBM,CAAAA,CAAAA,EAAAA,MAAAA;;;;;;AARjB,cAAvCF,iBAAAA,SAA0BN,aAAAA,CAAa;;;cAG5CA;;;oBAGMK;oDACgCD,iCAAiCI,QAAQN,SAASK;0CAC5DH,iCAAiCI,QAAQN,SAASK;mCACzDJ,wBAAwBK,QAAQN,SAASK"}

package/dist/retrievers/hyde.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyde.d.cts","names":["BaseLanguageModelInterface","Document","BasePromptTemplate","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","CallbackManagerForRetrieverRun","PromptKey","HydeRetrieverOptions","V","HydeRetriever","Promise","getPromptTemplateFromKey"],"sources":["../../src/retrievers/hyde.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * A string that corresponds to a specific prompt template.\n */\nexport type PromptKey = \"websearch\" | \"scifact\" | \"arguana\" | \"trec-covid\" | \"fiqa\" | \"dbpedia-entity\" | \"trec-news\" | \"mr-tydi\";\n/**\n * Options for the HydeRetriever class, which includes a BaseLanguageModel\n * instance, a VectorStore instance, and an optional promptTemplate which\n * can either be a BasePromptTemplate instance or a PromptKey.\n */\nexport type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverInput<V> & {\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate | PromptKey;\n};\n/**\n * A class for retrieving relevant documents based on a given query. It\n * extends the VectorStoreRetriever class and uses a BaseLanguageModel to\n * generate a hypothetical answer to the query, which is then used to\n * retrieve relevant documents.\n * @example\n * ```typescript\n * const retriever = new HydeRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   k: 1,\n * });\n * await vectorStore.addDocuments(\n *   [\n *     \"My name is John.\",\n *     \"My name is Bob.\",\n *     \"My favourite food is pizza.\",\n *     \"My favourite food is pasta.\",\n *   ].map((pageContent) => new Document({ pageContent })),\n * );\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate;\n    constructor(fields: HydeRetrieverOptions<V>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\n/**\n * Returns a BasePromptTemplate instance based on a given PromptKey.\n */\nexport declare function getPromptTemplateFromKey(key: PromptKey): BasePromptTemplate;\n//# sourceMappingURL=hyde.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAMYQ,KANAD,SAAAA,GAMAC,WAAoBC,GAAAA,SAAA,GAAA,SAAA,GAAA,YAAA,GAAA,MAAA,GAAA,gBAAA,GAAA,WAAA,GAAA,SAAA;;;;;;AAEUF,KAF9BC,oBAE8BD,CAAAA,UAFCJ,WAEDI,CAAAA,GAFgBF,yBAEhBE,CAF0CE,CAE1CF,CAAAA,GAAAA;EAAS,GAAA,EAD1CP,0BAC0C;EA2B9BU,cAAAA,CAAAA,EA3BAR,kBA2Ba,GA3BQK,SA2BR;CAAWJ;;;;;;;;;;;AAAuD;AAWpG;;;;;;;;;;;;;;cAXqBO,wBAAwBP,cAAcA,qBAAqBC,qBAAqBK;;;OAG5FT;mBACYE;sBACGM,qBAAqBC;oDACSH,iCAAiCK,QAAQV;;;;;iBAKvEW,wBAAAA,MAA8BL,YAAYL"}

package/dist/retrievers/hyde.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyde.d.ts","names":["BaseLanguageModelInterface","Document","BasePromptTemplate","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","CallbackManagerForRetrieverRun","PromptKey","HydeRetrieverOptions","V","HydeRetriever","Promise","getPromptTemplateFromKey"],"sources":["../../src/retrievers/hyde.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * A string that corresponds to a specific prompt template.\n */\nexport type PromptKey = \"websearch\" | \"scifact\" | \"arguana\" | \"trec-covid\" | \"fiqa\" | \"dbpedia-entity\" | \"trec-news\" | \"mr-tydi\";\n/**\n * Options for the HydeRetriever class, which includes a BaseLanguageModel\n * instance, a VectorStore instance, and an optional promptTemplate which\n * can either be a BasePromptTemplate instance or a PromptKey.\n */\nexport type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverInput<V> & {\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate | PromptKey;\n};\n/**\n * A class for retrieving relevant documents based on a given query. It\n * extends the VectorStoreRetriever class and uses a BaseLanguageModel to\n * generate a hypothetical answer to the query, which is then used to\n * retrieve relevant documents.\n * @example\n * ```typescript\n * const retriever = new HydeRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   k: 1,\n * });\n * await vectorStore.addDocuments(\n *   [\n *     \"My name is John.\",\n *     \"My name is Bob.\",\n *     \"My favourite food is pizza.\",\n *     \"My favourite food is pasta.\",\n *   ].map((pageContent) => new Document({ pageContent })),\n * );\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate;\n    constructor(fields: HydeRetrieverOptions<V>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\n/**\n * Returns a BasePromptTemplate instance based on a given PromptKey.\n */\nexport declare function getPromptTemplateFromKey(key: PromptKey): BasePromptTemplate;\n//# sourceMappingURL=hyde.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAMYQ,KANAD,SAAAA,GAMAC,WAAoBC,GAAAA,SAAA,GAAA,SAAA,GAAA,YAAA,GAAA,MAAA,GAAA,gBAAA,GAAA,WAAA,GAAA,SAAA;;;;;;AAEUF,KAF9BC,oBAE8BD,CAAAA,UAFCJ,WAEDI,CAAAA,GAFgBF,yBAEhBE,CAF0CE,CAE1CF,CAAAA,GAAAA;EAAS,GAAA,EAD1CP,0BAC0C;EA2B9BU,cAAAA,CAAAA,EA3BAR,kBA2Ba,GA3BQK,SA2BR;CAAWJ;;;;;;;;;;;AAAuD;AAWpG;;;;;;;;;;;;;;cAXqBO,wBAAwBP,cAAcA,qBAAqBC,qBAAqBK;;;OAG5FT;mBACYE;sBACGM,qBAAqBC;oDACSH,iCAAiCK,QAAQV;;;;;iBAKvEW,wBAAAA,MAA8BL,YAAYL"}

package/dist/retrievers/matryoshka_retriever.d.cts

@@ -7,7 +7,6 @@ import { Embeddings } from "@langchain/core/embeddings";
 /**
  * Type for options when adding a document to the VectorStore.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AddDocumentOptions = Record<string, any>;
 interface MatryoshkaRetrieverFields {
   /**

package/dist/retrievers/matryoshka_retriever.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matryoshka_retriever.d.cts","names":["DocumentInterface","Embeddings","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","AddDocumentOptions","Record","MatryoshkaRetrieverFields","MatryoshkaRetriever","Store","Promise"],"sources":["../../src/retrievers/matryoshka_retriever.d.ts"],"sourcesContent":["import { DocumentInterface } from \"@langchain/core/documents\";\nimport { Embeddings } from \"@langchain/core/embeddings\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\n/**\n * Type for options when adding a document to the VectorStore.\n */\ntype AddDocumentOptions = Record<string, any>;\nexport interface MatryoshkaRetrieverFields {\n    /**\n     * The number of documents to retrieve from the small store.\n     * @default 50\n     */\n    smallK?: number;\n    /**\n     * The number of documents to retrieve from the large store.\n     * @default 8\n     */\n    largeK?: number;\n    /**\n     * The metadata key to store the larger embeddings.\n     * @default \"lc_large_embedding\"\n     */\n    largeEmbeddingKey?: string;\n    /**\n     * The embedding model to use when generating the large\n     * embeddings.\n     */\n    largeEmbeddingModel: Embeddings;\n    /**\n     * The type of search to perform using the large embeddings.\n     * @default \"cosine\"\n     */\n    searchType?: \"cosine\" | \"innerProduct\" | \"euclidean\";\n}\n/**\n * A retriever that uses two sets of embeddings to perform adaptive retrieval. Based\n * off of the \"Matryoshka embeddings: faster OpenAI vector search using Adaptive Retrieval\"\n * blog post {@link https://supabase.com/blog/matryoshka-embeddings}.\n *\n *\n * This class performs \"Adaptive Retrieval\" for searching text embeddings efficiently using the\n * Matryoshka Representation Learning (MRL) technique. It retrieves documents similar to a query\n * embedding in two steps:\n *\n * First-pass: Uses a lower dimensional sub-vector from the MRL embedding for an initial, fast,\n * but less accurate search.\n *\n * Second-pass: Re-ranks the top results from the first pass using the full, high-dimensional\n * embedding for higher accuracy.\n *\n *\n * This code implements MRL embeddings for efficient vector search by combining faster,\n * lower-dimensional initial search with accurate, high-dimensional re-ranking.\n */\nexport declare class MatryoshkaRetriever<Store extends VectorStore = VectorStore> extends VectorStoreRetriever<Store> {\n    smallK: number;\n    largeK: number;\n    largeEmbeddingKey: string;\n    largeEmbeddingModel: Embeddings;\n    searchType: \"cosine\" | \"innerProduct\" | \"euclidean\";\n    constructor(fields: MatryoshkaRetrieverFields & VectorStoreRetrieverInput<Store>);\n    /**\n     * Ranks documents based on their similarity to a query embedding using larger embeddings.\n     *\n     * This method takes a query embedding and a list of documents (smallResults) as input. Each document\n     * in the smallResults array has previously been associated with a large embedding stored in its metadata.\n     * Depending on the `searchType` (cosine, innerProduct, or euclidean), it calculates the similarity scores\n     * between the query embedding and each document's large embedding. It then ranks the documents based on\n     * these similarity scores, from the most similar to the least similar.\n     *\n     * The method returns a promise that resolves to an array of the top `largeK` documents, where `largeK`\n     * is a class property defining the number of documents to return. This subset of documents is determined\n     * by sorting the entire list of documents based on their similarity scores and then selecting the top\n     * `largeK` documents.\n     *\n     * @param {number[]} embeddedQuery The embedding of the query, represented as an array of numbers.\n     * @param {DocumentInterface[]} smallResults An array of documents, each with metadata that includes a large embedding for similarity comparison.\n     * @returns {Promise<DocumentInterface[]>} A promise that resolves to an array of the top `largeK` ranked documents based on their similarity to the query embedding.\n     */\n    private _rankByLargeEmbeddings;\n    _getRelevantDocuments(query: string): Promise<DocumentInterface[]>;\n    /**\n     * Override the default `addDocuments` method to embed the documents twice,\n     * once using the larger embeddings model, and then again using the default\n     * embedding model linked to the vector store.\n     *\n     * @param {DocumentInterface[]} documents - An array of documents to add to the vector store.\n     * @param {AddDocumentOptions} options - An optional object containing additional options for adding documents.\n     * @returns {Promise<string[] | void>} A promise that resolves to an array of the document IDs that were added to the vector store.\n     */\n    addDocuments: (documents: DocumentInterface<Record<string, any>>[], options?: AddDocumentOptions | undefined) => Promise<void | string[]>;\n}\nexport {};\n//# sourceMappingURL=matryoshka_retriever.d.ts.map"],"mappings":";;;;;;;;AAE4G;AAK5G,KADKK,kBAAAA,GAAqBC,MACgB,CAAA,MAAA,EAAA,GAoBjBL,CAAAA;AA2BJO,UA/CJD,yBAAAA,CA+CuB;EAAeL;;;;EAM/BK,MAAAA,CAAAA,EAAAA,MAAAA;EAAsDE;;;;EA8B9BH,MAAAA,CAAAA,EAAAA,MAAAA;EAAlBN;;;;EApCgF,iBAAA,CAAA,EAAA,MAAA;;;;;uBA3BrFC;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BJO,kCAAkCN,cAAcA,qBAAqBC,qBAAqBM;;;;uBAItFR;;sBAEDM,4BAA4BH,0BAA0BK;;;;;;;;;;;;;;;;;;;;wCAoBpCC,QAAQV;;;;;;;;;;4BAUpBA,kBAAkBM,kCAAkCD,mCAAmCK"}

package/dist/retrievers/matryoshka_retriever.d.ts

@@ -7,7 +7,6 @@ import { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from "@l
 /**
  * Type for options when adding a document to the VectorStore.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AddDocumentOptions = Record<string, any>;
 interface MatryoshkaRetrieverFields {
   /**

package/dist/retrievers/matryoshka_retriever.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matryoshka_retriever.d.ts","names":["DocumentInterface","Embeddings","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","AddDocumentOptions","Record","MatryoshkaRetrieverFields","MatryoshkaRetriever","Store","Promise"],"sources":["../../src/retrievers/matryoshka_retriever.d.ts"],"sourcesContent":["import { DocumentInterface } from \"@langchain/core/documents\";\nimport { Embeddings } from \"@langchain/core/embeddings\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\n/**\n * Type for options when adding a document to the VectorStore.\n */\ntype AddDocumentOptions = Record<string, any>;\nexport interface MatryoshkaRetrieverFields {\n    /**\n     * The number of documents to retrieve from the small store.\n     * @default 50\n     */\n    smallK?: number;\n    /**\n     * The number of documents to retrieve from the large store.\n     * @default 8\n     */\n    largeK?: number;\n    /**\n     * The metadata key to store the larger embeddings.\n     * @default \"lc_large_embedding\"\n     */\n    largeEmbeddingKey?: string;\n    /**\n     * The embedding model to use when generating the large\n     * embeddings.\n     */\n    largeEmbeddingModel: Embeddings;\n    /**\n     * The type of search to perform using the large embeddings.\n     * @default \"cosine\"\n     */\n    searchType?: \"cosine\" | \"innerProduct\" | \"euclidean\";\n}\n/**\n * A retriever that uses two sets of embeddings to perform adaptive retrieval. Based\n * off of the \"Matryoshka embeddings: faster OpenAI vector search using Adaptive Retrieval\"\n * blog post {@link https://supabase.com/blog/matryoshka-embeddings}.\n *\n *\n * This class performs \"Adaptive Retrieval\" for searching text embeddings efficiently using the\n * Matryoshka Representation Learning (MRL) technique. It retrieves documents similar to a query\n * embedding in two steps:\n *\n * First-pass: Uses a lower dimensional sub-vector from the MRL embedding for an initial, fast,\n * but less accurate search.\n *\n * Second-pass: Re-ranks the top results from the first pass using the full, high-dimensional\n * embedding for higher accuracy.\n *\n *\n * This code implements MRL embeddings for efficient vector search by combining faster,\n * lower-dimensional initial search with accurate, high-dimensional re-ranking.\n */\nexport declare class MatryoshkaRetriever<Store extends VectorStore = VectorStore> extends VectorStoreRetriever<Store> {\n    smallK: number;\n    largeK: number;\n    largeEmbeddingKey: string;\n    largeEmbeddingModel: Embeddings;\n    searchType: \"cosine\" | \"innerProduct\" | \"euclidean\";\n    constructor(fields: MatryoshkaRetrieverFields & VectorStoreRetrieverInput<Store>);\n    /**\n     * Ranks documents based on their similarity to a query embedding using larger embeddings.\n     *\n     * This method takes a query embedding and a list of documents (smallResults) as input. Each document\n     * in the smallResults array has previously been associated with a large embedding stored in its metadata.\n     * Depending on the `searchType` (cosine, innerProduct, or euclidean), it calculates the similarity scores\n     * between the query embedding and each document's large embedding. It then ranks the documents based on\n     * these similarity scores, from the most similar to the least similar.\n     *\n     * The method returns a promise that resolves to an array of the top `largeK` documents, where `largeK`\n     * is a class property defining the number of documents to return. This subset of documents is determined\n     * by sorting the entire list of documents based on their similarity scores and then selecting the top\n     * `largeK` documents.\n     *\n     * @param {number[]} embeddedQuery The embedding of the query, represented as an array of numbers.\n     * @param {DocumentInterface[]} smallResults An array of documents, each with metadata that includes a large embedding for similarity comparison.\n     * @returns {Promise<DocumentInterface[]>} A promise that resolves to an array of the top `largeK` ranked documents based on their similarity to the query embedding.\n     */\n    private _rankByLargeEmbeddings;\n    _getRelevantDocuments(query: string): Promise<DocumentInterface[]>;\n    /**\n     * Override the default `addDocuments` method to embed the documents twice,\n     * once using the larger embeddings model, and then again using the default\n     * embedding model linked to the vector store.\n     *\n     * @param {DocumentInterface[]} documents - An array of documents to add to the vector store.\n     * @param {AddDocumentOptions} options - An optional object containing additional options for adding documents.\n     * @returns {Promise<string[] | void>} A promise that resolves to an array of the document IDs that were added to the vector store.\n     */\n    addDocuments: (documents: DocumentInterface<Record<string, any>>[], options?: AddDocumentOptions | undefined) => Promise<void | string[]>;\n}\nexport {};\n//# sourceMappingURL=matryoshka_retriever.d.ts.map"],"mappings":";;;;;;;;AAE4G;AAK5G,KADKK,kBAAAA,GAAqBC,MACgB,CAAA,MAAA,EAAA,GAoBjBL,CAAAA;AA2BJO,UA/CJD,yBAAAA,CA+CuB;EAAeL;;;;EAM/BK,MAAAA,CAAAA,EAAAA,MAAAA;EAAsDE;;;;EA8B9BH,MAAAA,CAAAA,EAAAA,MAAAA;EAAlBN;;;;EApCgF,iBAAA,CAAA,EAAA,MAAA;;;;;uBA3BrFC;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BJO,kCAAkCN,cAAcA,qBAAqBC,qBAAqBM;;;;uBAItFR;;sBAEDM,4BAA4BH,0BAA0BK;;;;;;;;;;;;;;;;;;;;wCAoBpCC,QAAQV;;;;;;;;;;4BAUpBA,kBAAkBM,kCAAkCD,mCAAmCK"}

package/dist/retrievers/multi_query.d.cts

@@ -10,7 +10,6 @@ import { Document } from "@langchain/core/documents";
 interface LineList {
   lines: string[];
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MultiDocs = Document<Record<string, any>>[];
 interface MultiQueryRetrieverInput extends BaseRetrieverInput {
   retriever: BaseRetrieverInterface;
@@ -50,7 +49,6 @@ declare class MultiQueryRetriever extends BaseRetriever {
   }): MultiQueryRetriever;
   private _generateQueries;
   private _retrieveDocuments;
-  // Deduplicate the documents that were returned in multiple retrievals
   private _uniqueUnion;
   _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
 }

package/dist/retrievers/multi_query.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_query.d.cts","names":["BaseLanguageModelInterface","BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","Document","BasePromptTemplate","CallbackManagerForRetrieverRun","LLMChain","BaseDocumentCompressor","LineList","MultiDocs","Record","MultiQueryRetrieverInput","MultiQueryRetriever","Omit","Promise"],"sources":["../../src/retrievers/multi_query.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\ninterface LineList {\n    lines: string[];\n}\nexport type MultiDocs = Document<Record<string, any>>[];\nexport interface MultiQueryRetrieverInput extends BaseRetrieverInput {\n    retriever: BaseRetrieverInterface;\n    /** @deprecated Pass a custom prompt into `.fromLLM` instead. */\n    llmChain: LLMChain<LineList>;\n    queryCount?: number;\n    parserKey?: string;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: MultiDocs) => MultiDocs;\n}\n/**\n * @example\n * ```typescript\n * const retriever = new MultiQueryRetriever.fromLLM({\n *   llm: new ChatAnthropic({}),\n *   retriever: new MemoryVectorStore().asRetriever(),\n *   verbose: true,\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What are mitochondria made of?\",\n * );\n * ```\n */\nexport declare class MultiQueryRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    private retriever;\n    private llmChain;\n    private queryCount;\n    private parserKey;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: MultiQueryRetrieverInput[\"documentCompressorFilteringFn\"];\n    constructor(fields: MultiQueryRetrieverInput);\n    static fromLLM(fields: Omit<MultiQueryRetrieverInput, \"llmChain\"> & {\n        llm: BaseLanguageModelInterface;\n        prompt?: BasePromptTemplate;\n    }): MultiQueryRetriever;\n    private _generateQueries;\n    private _retrieveDocuments;\n    private _uniqueUnion;\n    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\nexport {};\n//# sourceMappingURL=multi_query.d.ts.map"],"mappings":";;;;;;;;;UAOUS,QAAAA;;AADoE;AAIlEC,KAAAA,SAAAA,GAAYN,QAASO,CAAAA,MAATP,CAAAA,MAAQ,EAAA,GAAA,CAAA,CAAA,EAAA;AACfQ,UAAAA,wBAAAA,SAAiCV,kBAAT,CAAA;EAC1BC,SAAAA,EAAAA,sBAAAA;EAEQM;EAATF,QAAAA,EAAAA,QAAAA,CAASE,QAATF,CAAAA;EAGWC,UAAAA,CAAAA,EAAAA,MAAAA;EACkBE,SAAAA,CAAAA,EAAAA,MAAAA;EAAcA,kBAAAA,CAAAA,EADhCF,sBACgCE,GAAAA,SAAAA;EAPPR,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAOPQ,SAPOR,EAAAA,GAOOQ,SAPPR;AAAkB;AAsBpE;;;;;;;;;;;;;AAA8D,cAAzCW,mBAAAA,SAA4BZ,aAAAA,CAAa;;;;;;;sBAOtCO;kCACYI;sBACZA;yBACGE,KAAKF;SACnBZ;aACIK;MACTQ;;;;uDAIiDP,iCAAiCS,QAAQX"}

package/dist/retrievers/multi_query.d.ts

@@ -10,7 +10,6 @@ import { BaseRetriever, BaseRetrieverInput, BaseRetrieverInterface } from "@lang
 interface LineList {
   lines: string[];
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MultiDocs = Document<Record<string, any>>[];
 interface MultiQueryRetrieverInput extends BaseRetrieverInput {
   retriever: BaseRetrieverInterface;
@@ -50,7 +49,6 @@ declare class MultiQueryRetriever extends BaseRetriever {
   }): MultiQueryRetriever;
   private _generateQueries;
   private _retrieveDocuments;
-  // Deduplicate the documents that were returned in multiple retrievals
   private _uniqueUnion;
   _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
 }

package/dist/retrievers/multi_query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_query.d.ts","names":["BaseLanguageModelInterface","BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","Document","BasePromptTemplate","CallbackManagerForRetrieverRun","LLMChain","BaseDocumentCompressor","LineList","MultiDocs","Record","MultiQueryRetrieverInput","MultiQueryRetriever","Omit","Promise"],"sources":["../../src/retrievers/multi_query.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\ninterface LineList {\n    lines: string[];\n}\nexport type MultiDocs = Document<Record<string, any>>[];\nexport interface MultiQueryRetrieverInput extends BaseRetrieverInput {\n    retriever: BaseRetrieverInterface;\n    /** @deprecated Pass a custom prompt into `.fromLLM` instead. */\n    llmChain: LLMChain<LineList>;\n    queryCount?: number;\n    parserKey?: string;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: MultiDocs) => MultiDocs;\n}\n/**\n * @example\n * ```typescript\n * const retriever = new MultiQueryRetriever.fromLLM({\n *   llm: new ChatAnthropic({}),\n *   retriever: new MemoryVectorStore().asRetriever(),\n *   verbose: true,\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What are mitochondria made of?\",\n * );\n * ```\n */\nexport declare class MultiQueryRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    private retriever;\n    private llmChain;\n    private queryCount;\n    private parserKey;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: MultiQueryRetrieverInput[\"documentCompressorFilteringFn\"];\n    constructor(fields: MultiQueryRetrieverInput);\n    static fromLLM(fields: Omit<MultiQueryRetrieverInput, \"llmChain\"> & {\n        llm: BaseLanguageModelInterface;\n        prompt?: BasePromptTemplate;\n    }): MultiQueryRetriever;\n    private _generateQueries;\n    private _retrieveDocuments;\n    private _uniqueUnion;\n    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\nexport {};\n//# sourceMappingURL=multi_query.d.ts.map"],"mappings":";;;;;;;;;UAOUS,QAAAA;;AADoE;AAIlEC,KAAAA,SAAAA,GAAYN,QAASO,CAAAA,MAATP,CAAAA,MAAQ,EAAA,GAAA,CAAA,CAAA,EAAA;AACfQ,UAAAA,wBAAAA,SAAiCV,kBAAT,CAAA;EAC1BC,SAAAA,EAAAA,sBAAAA;EAEQM;EAATF,QAAAA,EAAAA,QAAAA,CAASE,QAATF,CAAAA;EAGWC,UAAAA,CAAAA,EAAAA,MAAAA;EACkBE,SAAAA,CAAAA,EAAAA,MAAAA;EAAcA,kBAAAA,CAAAA,EADhCF,sBACgCE,GAAAA,SAAAA;EAPPR,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAOPQ,SAPOR,EAAAA,GAOOQ,SAPPR;AAAkB;AAsBpE;;;;;;;;;;;;;AAA8D,cAAzCW,mBAAAA,SAA4BZ,aAAAA,CAAa;;;;;;;sBAOtCO;kCACYI;sBACZA;yBACGE,KAAKF;SACnBZ;aACIK;MACTQ;;;;uDAIiDP,iCAAiCS,QAAQX"}

package/dist/retrievers/multi_vector.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_vector.d.cts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","Document","BaseStore","BaseStoreInterface","MultiVectorRetrieverInput","Uint8Array","MultiVectorRetriever","Promise"],"sources":["../../src/retrievers/multi_vector.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseStore, type BaseStoreInterface } from \"@langchain/core/stores\";\n/**\n * Arguments for the MultiVectorRetriever class.\n */\nexport interface MultiVectorRetrieverInput extends BaseRetrieverInput {\n    vectorstore: VectorStoreInterface;\n    /** @deprecated Prefer `byteStore`. */\n    docstore?: BaseStoreInterface<string, Document>;\n    byteStore?: BaseStore<string, Uint8Array>;\n    idKey?: string;\n    childK?: number;\n    parentK?: number;\n}\n/**\n * A retriever that retrieves documents from a vector store and a document\n * store. It uses the vector store to find relevant documents based on a\n * query, and then retrieves the full documents from the document store.\n * @example\n * ```typescript\n * const retriever = new MultiVectorRetriever({\n *   vectorstore: new FaissStore(),\n *   byteStore: new InMemoryStore<Unit8Array>(),\n *   idKey: \"doc_id\",\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const retrieverResult = await retriever.invoke(\"justice breyer\");\n * console.log(retrieverResult[0].pageContent.length);\n * ```\n */\nexport declare class MultiVectorRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    docstore: BaseStoreInterface<string, Document>;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    constructor(args: MultiVectorRetrieverInput);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n}\n//# sourceMappingURL=multi_vector.d.ts.map"],"mappings":";;;;;;;;;AAOA;AACiBE,UADAI,yBAAAA,SAAkCL,kBAClCC,CAAAA;EAEyBC,WAAAA,EAFzBD,oBAEyBC;EAA3BE;EACmBE,QAAAA,CAAAA,EADnBF,kBACmBE,CAAAA,MAAAA,EADQJ,QACRI,CAAAA;EAAlBH,SAAAA,CAAAA,EAAAA,SAAAA,CAAAA,MAAAA,EAAkBG,UAAlBH,CAAAA;EAJmCH,KAAAA,CAAAA,EAAAA,MAAAA;EAAkB,MAAA,CAAA,EAAA,MAAA;EA2BhDO,OAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;AAA0C;;;;;;;;;;;;cAA1CA,oBAAAA,SAA6BR,aAAAA;;;eAGjCE;YACHG,2BAA2BF;;;;oBAInBG;wCACoBG,QAAQN"}

package/dist/retrievers/multi_vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_vector.d.ts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","Document","BaseStore","BaseStoreInterface","MultiVectorRetrieverInput","Uint8Array","MultiVectorRetriever","Promise"],"sources":["../../src/retrievers/multi_vector.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseStore, type BaseStoreInterface } from \"@langchain/core/stores\";\n/**\n * Arguments for the MultiVectorRetriever class.\n */\nexport interface MultiVectorRetrieverInput extends BaseRetrieverInput {\n    vectorstore: VectorStoreInterface;\n    /** @deprecated Prefer `byteStore`. */\n    docstore?: BaseStoreInterface<string, Document>;\n    byteStore?: BaseStore<string, Uint8Array>;\n    idKey?: string;\n    childK?: number;\n    parentK?: number;\n}\n/**\n * A retriever that retrieves documents from a vector store and a document\n * store. It uses the vector store to find relevant documents based on a\n * query, and then retrieves the full documents from the document store.\n * @example\n * ```typescript\n * const retriever = new MultiVectorRetriever({\n *   vectorstore: new FaissStore(),\n *   byteStore: new InMemoryStore<Unit8Array>(),\n *   idKey: \"doc_id\",\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const retrieverResult = await retriever.invoke(\"justice breyer\");\n * console.log(retrieverResult[0].pageContent.length);\n * ```\n */\nexport declare class MultiVectorRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    docstore: BaseStoreInterface<string, Document>;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    constructor(args: MultiVectorRetrieverInput);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n}\n//# sourceMappingURL=multi_vector.d.ts.map"],"mappings":";;;;;;;;;AAOA;AACiBE,UADAI,yBAAAA,SAAkCL,kBAClCC,CAAAA;EAEyBC,WAAAA,EAFzBD,oBAEyBC;EAA3BE;EACmBE,QAAAA,CAAAA,EADnBF,kBACmBE,CAAAA,MAAAA,EADQJ,QACRI,CAAAA;EAAlBH,SAAAA,CAAAA,EAAAA,SAAAA,CAAAA,MAAAA,EAAkBG,UAAlBH,CAAAA;EAJmCH,KAAAA,CAAAA,EAAAA,MAAAA;EAAkB,MAAA,CAAA,EAAA,MAAA;EA2BhDO,OAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;AAA0C;;;;;;;;;;;;cAA1CA,oBAAAA,SAA6BR,aAAAA;;;eAGjCE;YACHG,2BAA2BF;;;;oBAInBG;wCACoBG,QAAQN"}

package/dist/retrievers/parent_document.d.cts

@@ -5,7 +5,6 @@ import { Document } from "@langchain/core/documents";
 import { TextSplitter, TextSplitterChunkHeaderOptions } from "@langchain/textsplitters";
 
 //#region src/retrievers/parent_document.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type SubDocs = Document<Record<string, any>>[];
 /**
  * Interface for the fields required to initialize a

package/dist/retrievers/parent_document.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent_document.d.cts","names":["VectorStoreInterface","VectorStoreRetrieverInterface","Document","TextSplitter","TextSplitterChunkHeaderOptions","BaseDocumentCompressor","MultiVectorRetriever","MultiVectorRetrieverInput","SubDocs","Record","ParentDocumentRetrieverFields","ParentDocumentRetriever","Promise"],"sources":["../../src/retrievers/parent_document.d.ts"],"sourcesContent":["import { type VectorStoreInterface, type VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { TextSplitter, TextSplitterChunkHeaderOptions } from \"@langchain/textsplitters\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\nimport { MultiVectorRetriever, type MultiVectorRetrieverInput } from \"./multi_vector.js\";\nexport type SubDocs = Document<Record<string, any>>[];\n/**\n * Interface for the fields required to initialize a\n * ParentDocumentRetriever instance.\n */\nexport type ParentDocumentRetrieverFields = MultiVectorRetrieverInput & {\n    childSplitter: TextSplitter;\n    parentSplitter?: TextSplitter;\n    /**\n     * A custom retriever to use when retrieving instead of\n     * the `.similaritySearch` method of the vectorstore.\n     */\n    childDocumentRetriever?: VectorStoreRetrieverInterface<VectorStoreInterface>;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: SubDocs) => SubDocs;\n};\n/**\n * A type of document retriever that splits input documents into smaller chunks\n * while separately storing and preserving the original documents.\n * The small chunks are embedded, then on retrieval, the original\n * \"parent\" documents are retrieved.\n *\n * This strikes a balance between better targeted retrieval with small documents\n * and the more context-rich larger documents.\n * @example\n * ```typescript\n * const retriever = new ParentDocumentRetriever({\n *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   byteStore: new InMemoryStore<Uint8Array>(),\n *   parentSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 500,\n *   }),\n *   childSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 50,\n *   }),\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const parentDocuments = await getDocuments();\n * await retriever.addDocuments(parentDocuments);\n * const retrievedDocs = await retriever.invoke(\"justice breyer\");\n * ```\n */\nexport declare class ParentDocumentRetriever extends MultiVectorRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    protected childSplitter: TextSplitter;\n    protected parentSplitter?: TextSplitter;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    childDocumentRetriever: VectorStoreRetrieverInterface<VectorStoreInterface> | undefined;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: ParentDocumentRetrieverFields[\"documentCompressorFilteringFn\"];\n    constructor(fields: ParentDocumentRetrieverFields);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n    _storeDocuments(parentDoc: Record<string, Document>, childDocs: Document[], addToDocstore: boolean): Promise<void>;\n    /**\n     * Adds documents to the docstore and vectorstores.\n     * If a retriever is provided, it will be used to add documents instead of the vectorstore.\n     * @param docs The documents to add\n     * @param config.ids Optional list of ids for documents. If provided should be the same\n     *   length as the list of documents. Can provided if parent documents\n     *   are already in the document store and you don't want to re-add\n     *   to the docstore. If not provided, random UUIDs will be used as ids.\n     * @param config.addToDocstore Boolean of whether to add documents to docstore.\n     * This can be false if and only if `ids` are provided. You may want\n     *   to set this to False if the documents are already in the docstore\n     *   and you don't want to re-add them.\n     * @param config.chunkHeaderOptions Object with options for adding Contextual chunk headers\n     */\n    addDocuments(docs: Document[], config?: {\n        ids?: string[];\n        addToDocstore?: boolean;\n        childDocChunkHeaderOptions?: TextSplitterChunkHeaderOptions;\n    }): Promise<void>;\n}\n//# sourceMappingURL=parent_document.d.ts.map"],"mappings":";;;;;;;KAKYQ,OAAAA,GAAUN,SAASO;;AAA/B;AAKA;;AACmBN,KADPO,6BAAAA,GAAgCH,yBACzBJ,GAAAA;EACEA,aAAAA,EADFA,YACEA;EAKsCH,cAAAA,CAAAA,EALtCG,YAKsCH;EAA9BC;;;;EAEiC,sBAAA,CAAA,EAFjCA,6BAEiC,CAFHD,oBAEG,CAAA;EAgCzCW,kBAAAA,CAAAA,EAjCIN,sBAiCmB,GAAA,SAAA;EAG3BL,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAnC0BQ,OAmC1BR,EAAAA,GAnCsCQ,OAmCtCR;CACYG;;;;;;;;;;;;;;;;;AAJ4C;;;;;;;;;;;;;;cAApDQ,uBAAAA,SAAgCL,oBAAAA;;;eAGpCN;2BACYG;6BACEA;;;;0BAIHF,8BAA8BD;sBAClCK;kCACYK;sBACZA;wCACkBE,QAAQV;6BACnBO,eAAeP,sBAAsBA,qCAAqCU;;;;;;;;;;;;;;;qBAelFV;;;iCAGcE;MAC7BQ"}

package/dist/retrievers/parent_document.d.ts

@@ -5,7 +5,6 @@ import { TextSplitter, TextSplitterChunkHeaderOptions } from "@langchain/textspl
 import { VectorStoreInterface, VectorStoreRetrieverInterface } from "@langchain/core/vectorstores";
 
 //#region src/retrievers/parent_document.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type SubDocs = Document<Record<string, any>>[];
 /**
  * Interface for the fields required to initialize a

package/dist/retrievers/parent_document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent_document.d.ts","names":["VectorStoreInterface","VectorStoreRetrieverInterface","Document","TextSplitter","TextSplitterChunkHeaderOptions","BaseDocumentCompressor","MultiVectorRetriever","MultiVectorRetrieverInput","SubDocs","Record","ParentDocumentRetrieverFields","ParentDocumentRetriever","Promise"],"sources":["../../src/retrievers/parent_document.d.ts"],"sourcesContent":["import { type VectorStoreInterface, type VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { TextSplitter, TextSplitterChunkHeaderOptions } from \"@langchain/textsplitters\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\nimport { MultiVectorRetriever, type MultiVectorRetrieverInput } from \"./multi_vector.js\";\nexport type SubDocs = Document<Record<string, any>>[];\n/**\n * Interface for the fields required to initialize a\n * ParentDocumentRetriever instance.\n */\nexport type ParentDocumentRetrieverFields = MultiVectorRetrieverInput & {\n    childSplitter: TextSplitter;\n    parentSplitter?: TextSplitter;\n    /**\n     * A custom retriever to use when retrieving instead of\n     * the `.similaritySearch` method of the vectorstore.\n     */\n    childDocumentRetriever?: VectorStoreRetrieverInterface<VectorStoreInterface>;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: SubDocs) => SubDocs;\n};\n/**\n * A type of document retriever that splits input documents into smaller chunks\n * while separately storing and preserving the original documents.\n * The small chunks are embedded, then on retrieval, the original\n * \"parent\" documents are retrieved.\n *\n * This strikes a balance between better targeted retrieval with small documents\n * and the more context-rich larger documents.\n * @example\n * ```typescript\n * const retriever = new ParentDocumentRetriever({\n *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   byteStore: new InMemoryStore<Uint8Array>(),\n *   parentSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 500,\n *   }),\n *   childSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 50,\n *   }),\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const parentDocuments = await getDocuments();\n * await retriever.addDocuments(parentDocuments);\n * const retrievedDocs = await retriever.invoke(\"justice breyer\");\n * ```\n */\nexport declare class ParentDocumentRetriever extends MultiVectorRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    protected childSplitter: TextSplitter;\n    protected parentSplitter?: TextSplitter;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    childDocumentRetriever: VectorStoreRetrieverInterface<VectorStoreInterface> | undefined;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: ParentDocumentRetrieverFields[\"documentCompressorFilteringFn\"];\n    constructor(fields: ParentDocumentRetrieverFields);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n    _storeDocuments(parentDoc: Record<string, Document>, childDocs: Document[], addToDocstore: boolean): Promise<void>;\n    /**\n     * Adds documents to the docstore and vectorstores.\n     * If a retriever is provided, it will be used to add documents instead of the vectorstore.\n     * @param docs The documents to add\n     * @param config.ids Optional list of ids for documents. If provided should be the same\n     *   length as the list of documents. Can provided if parent documents\n     *   are already in the document store and you don't want to re-add\n     *   to the docstore. If not provided, random UUIDs will be used as ids.\n     * @param config.addToDocstore Boolean of whether to add documents to docstore.\n     * This can be false if and only if `ids` are provided. You may want\n     *   to set this to False if the documents are already in the docstore\n     *   and you don't want to re-add them.\n     * @param config.chunkHeaderOptions Object with options for adding Contextual chunk headers\n     */\n    addDocuments(docs: Document[], config?: {\n        ids?: string[];\n        addToDocstore?: boolean;\n        childDocChunkHeaderOptions?: TextSplitterChunkHeaderOptions;\n    }): Promise<void>;\n}\n//# sourceMappingURL=parent_document.d.ts.map"],"mappings":";;;;;;;KAKYQ,OAAAA,GAAUN,SAASO;;AAA/B;AAKA;;AACmBN,KADPO,6BAAAA,GAAgCH,yBACzBJ,GAAAA;EACEA,aAAAA,EADFA,YACEA;EAKsCH,cAAAA,CAAAA,EALtCG,YAKsCH;EAA9BC;;;;EAEiC,sBAAA,CAAA,EAFjCA,6BAEiC,CAFHD,oBAEG,CAAA;EAgCzCW,kBAAAA,CAAAA,EAjCIN,sBAiCmB,GAAA,SAAA;EAG3BL,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAnC0BQ,OAmC1BR,EAAAA,GAnCsCQ,OAmCtCR;CACYG;;;;;;;;;;;;;;;;;AAJ4C;;;;;;;;;;;;;;cAApDQ,uBAAAA,SAAgCL,oBAAAA;;;eAGpCN;2BACYG;6BACEA;;;;0BAIHF,8BAA8BD;sBAClCK;kCACYK;sBACZA;wCACkBE,QAAQV;6BACnBO,eAAeP,sBAAsBA,qCAAqCU;;;;;;;;;;;;;;;qBAelFV;;;iCAGcE;MAC7BQ"}

package/dist/retrievers/score_threshold.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score_threshold.d.cts","names":["Document","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","ScoreThresholdRetrieverInput","V","Omit","ScoreThresholdRetriever","Promise"],"sources":["../../src/retrievers/score_threshold.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nexport type ScoreThresholdRetrieverInput<V extends VectorStore> = Omit<VectorStoreRetrieverInput<V>, \"k\"> & {\n    maxK?: number;\n    kIncrement?: number;\n    minSimilarityScore: number;\n};\nexport declare class ScoreThresholdRetriever<V extends VectorStore> extends VectorStoreRetriever<V> {\n    minSimilarityScore: number;\n    kIncrement: number;\n    maxK: number;\n    constructor(input: ScoreThresholdRetrieverInput<V>);\n    invoke(query: string): Promise<Document[]>;\n    static fromVectorStore<V extends VectorStore>(vectorStore: V, options: Omit<ScoreThresholdRetrieverInput<V>, \"vectorStore\">): ScoreThresholdRetriever<V>;\n}\n//# sourceMappingURL=score_threshold.d.ts.map"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAAuCH,kBAAAA,EAAAA,MAAAA;CAA8CI;AAA1BF,cAKlDI,uBALkDJ,CAAAA,UAKhBF,WALgBE,CAAAA,SAKKD,oBALLC,CAK0BE,CAL1BF,CAAAA,CAAAA;EAALG,kBAAAA,EAAAA,MAAAA;EAAI,UAAA,EAAA,MAAA;EAKjDC,IAAAA,EAAAA,MAAAA;EAAkCN,WAAAA,CAAAA,KAAAA,EAIhCG,4BAJgCH,CAIHI,CAJGJ,CAAAA;EAA0CI,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAKtEG,OALsEH,CAK9DL,QAL8DK,EAAAA,CAAAA;EAI7CA,OAAAA,eAAAA,CAAAA,UAEfJ,WAFeI,CAAAA,CAAAA,WAAAA,EAEWA,CAFXA,EAAAA,OAAAA,EAEuBC,IAFvBD,CAE4BD,4BAF5BC,CAEyDA,CAFzDA,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAE8EE,uBAF9EF,CAEsGA,CAFtGA,CAAAA"}

package/dist/retrievers/score_threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"score_threshold.d.ts","names":["Document","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","ScoreThresholdRetrieverInput","V","Omit","ScoreThresholdRetriever","Promise"],"sources":["../../src/retrievers/score_threshold.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nexport type ScoreThresholdRetrieverInput<V extends VectorStore> = Omit<VectorStoreRetrieverInput<V>, \"k\"> & {\n    maxK?: number;\n    kIncrement?: number;\n    minSimilarityScore: number;\n};\nexport declare class ScoreThresholdRetriever<V extends VectorStore> extends VectorStoreRetriever<V> {\n    minSimilarityScore: number;\n    kIncrement: number;\n    maxK: number;\n    constructor(input: ScoreThresholdRetrieverInput<V>);\n    invoke(query: string): Promise<Document[]>;\n    static fromVectorStore<V extends VectorStore>(vectorStore: V, options: Omit<ScoreThresholdRetrieverInput<V>, \"vectorStore\">): ScoreThresholdRetriever<V>;\n}\n//# sourceMappingURL=score_threshold.d.ts.map"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAAuCH,kBAAAA,EAAAA,MAAAA;CAA8CI;AAA1BF,cAKlDI,uBALkDJ,CAAAA,UAKhBF,WALgBE,CAAAA,SAKKD,oBALLC,CAK0BE,CAL1BF,CAAAA,CAAAA;EAALG,kBAAAA,EAAAA,MAAAA;EAAI,UAAA,EAAA,MAAA;EAKjDC,IAAAA,EAAAA,MAAAA;EAAkCN,WAAAA,CAAAA,KAAAA,EAIhCG,4BAJgCH,CAIHI,CAJGJ,CAAAA;EAA0CI,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAKtEG,OALsEH,CAK9DL,QAL8DK,EAAAA,CAAAA;EAI7CA,OAAAA,eAAAA,CAAAA,UAEfJ,WAFeI,CAAAA,CAAAA,WAAAA,EAEWA,CAFXA,EAAAA,OAAAA,EAEuBC,IAFvBD,CAE4BD,4BAF5BC,CAEyDA,CAFzDA,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAE8EE,uBAF9EF,CAEsGA,CAFtGA,CAAAA"}

package/dist/retrievers/self_query/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["RunnableInterface","BaseRetriever","BaseRetrieverInput","Document","VectorStore","BaseTranslator","StructuredQuery","CallbackManagerForRetrieverRun","QueryConstructorRunnableOptions","BasicTranslator","FunctionalTranslator","SelfQueryRetrieverArgs","T","SelfQueryRetriever","Record","Promise","Omit"],"sources":["../../../src/retrievers/self_query/index.d.ts"],"sourcesContent":["import { RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { VectorStore } from \"@langchain/core/vectorstores\";\nimport { BaseTranslator, StructuredQuery } from \"@langchain/core/structured_query\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { QueryConstructorRunnableOptions } from \"../../chains/query_constructor/index.js\";\nexport { BaseTranslator } from \"@langchain/core/structured_query\";\nexport { BasicTranslator, FunctionalTranslator, } from \"@langchain/core/structured_query\";\n/**\n * Interface for the arguments required to create a SelfQueryRetriever\n * instance. It extends the BaseRetrieverInput interface.\n */\nexport interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetrieverInput {\n    vectorStore: T;\n    structuredQueryTranslator: BaseTranslator<T>;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    useOriginalQuery?: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n}\n/**\n * Class for question answering over an index. It retrieves relevant\n * documents based on a query. It extends the BaseRetriever class and\n * implements the SelfQueryRetrieverArgs interface.\n * @example\n * ```typescript\n * const selfQueryRetriever = SelfQueryRetriever.fromLLM({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   vectorStore: await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings()),\n *   documentContents: \"Brief summary of a movie\",\n *   attributeInfo: attributeInfo,\n *   structuredQueryTranslator: new FunctionalTranslator(),\n * });\n * const relevantDocuments = await selfQueryRetriever.invoke(\n *   \"Which movies are directed by Greta Gerwig?\",\n * );\n * ```\n */\nexport declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    vectorStore: T;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    structuredQueryTranslator: BaseTranslator<T>;\n    useOriginalQuery: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n    constructor(options: SelfQueryRetrieverArgs<T>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, unknown>>[]>;\n    /**\n     * Static method to create a new SelfQueryRetriever instance from a\n     * BaseLanguageModel and a VectorStore. It first loads a query constructor\n     * chain using the loadQueryConstructorChain function, then creates a new\n     * SelfQueryRetriever instance with the loaded chain and the provided\n     * options.\n     * @param options The options used to create the SelfQueryRetriever instance. It includes the QueryConstructorChainOptions and all the SelfQueryRetrieverArgs except 'llmChain'.\n     * @returns A new instance of SelfQueryRetriever.\n     */\n    static fromLLM<T extends VectorStore>(options: QueryConstructorRunnableOptions & Omit<SelfQueryRetrieverArgs<T>, \"queryConstructor\">): SelfQueryRetriever<T>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;AAaA;;;;AAE+BK,UAFdM,sBAEcN,CAAAA,UAFmBD,WAEnBC,CAAAA,SAFwCH,kBAExCG,CAAAA;EAGxBC,WAAAA,EAJUM,CAIVN;EAFeN,yBAAAA,EADSK,gBACTL,CADwBY,CACxBZ,CAAAA;EAOLY,gBAAAA,EAPKZ,iBAOLY,CAAAA;IAVsDV,KAAAA,EAAAA,MAAAA;EAAkB,CAAA,EAKlFI,eALkF,CAAA;EAiCpEO,OAAAA,CAAAA,EAAAA,OAAAA;EAA6BT,gBAAAA,CAAAA,EAAAA,OAAAA;EAAqEQ,YAAAA,CAAAA,EAAAA;IAGtGA,CAAAA,CAAAA,EAAAA,MAAAA;IAGVN,MAAAA,CAAAA,EA7BUM,CA6BVN,CAAAA,YAAAA,CAAAA;IAFeN,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAIwBY,kBAAAA,CAAAA,EAAAA,OAAAA;EAAfP,CAAAA;;;;;;;;;;;;;;;;;AARuF;;;cAAjGQ,6BAA6BT,qBAAqBH,aAAAA,YAAyBU,uBAAuBC;;;eAGtGA;oBACKZ;;KAEfM;;6BAEwBD,iBAAeO;;;;aAI7BA;;;;uBAIQD,uBAAuBC;oDACML,iCAAiCQ,QAAQZ,SAASW;;;;;;;;;;2BAU3EV,sBAAsBI,kCAAkCQ,KAAKL,uBAAuBC,0BAA0BC,mBAAmBD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["RunnableInterface","BaseRetriever","BaseRetrieverInput","Document","VectorStore","BaseTranslator","StructuredQuery","CallbackManagerForRetrieverRun","QueryConstructorRunnableOptions","BasicTranslator","FunctionalTranslator","SelfQueryRetrieverArgs","T","SelfQueryRetriever","Record","Promise","Omit"],"sources":["../../../src/retrievers/self_query/index.d.ts"],"sourcesContent":["import { RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { VectorStore } from \"@langchain/core/vectorstores\";\nimport { BaseTranslator, StructuredQuery } from \"@langchain/core/structured_query\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { QueryConstructorRunnableOptions } from \"../../chains/query_constructor/index.js\";\nexport { BaseTranslator } from \"@langchain/core/structured_query\";\nexport { BasicTranslator, FunctionalTranslator, } from \"@langchain/core/structured_query\";\n/**\n * Interface for the arguments required to create a SelfQueryRetriever\n * instance. It extends the BaseRetrieverInput interface.\n */\nexport interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetrieverInput {\n    vectorStore: T;\n    structuredQueryTranslator: BaseTranslator<T>;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    useOriginalQuery?: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n}\n/**\n * Class for question answering over an index. It retrieves relevant\n * documents based on a query. It extends the BaseRetriever class and\n * implements the SelfQueryRetrieverArgs interface.\n * @example\n * ```typescript\n * const selfQueryRetriever = SelfQueryRetriever.fromLLM({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   vectorStore: await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings()),\n *   documentContents: \"Brief summary of a movie\",\n *   attributeInfo: attributeInfo,\n *   structuredQueryTranslator: new FunctionalTranslator(),\n * });\n * const relevantDocuments = await selfQueryRetriever.invoke(\n *   \"Which movies are directed by Greta Gerwig?\",\n * );\n * ```\n */\nexport declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    vectorStore: T;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    structuredQueryTranslator: BaseTranslator<T>;\n    useOriginalQuery: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n    constructor(options: SelfQueryRetrieverArgs<T>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, unknown>>[]>;\n    /**\n     * Static method to create a new SelfQueryRetriever instance from a\n     * BaseLanguageModel and a VectorStore. It first loads a query constructor\n     * chain using the loadQueryConstructorChain function, then creates a new\n     * SelfQueryRetriever instance with the loaded chain and the provided\n     * options.\n     * @param options The options used to create the SelfQueryRetriever instance. It includes the QueryConstructorChainOptions and all the SelfQueryRetrieverArgs except 'llmChain'.\n     * @returns A new instance of SelfQueryRetriever.\n     */\n    static fromLLM<T extends VectorStore>(options: QueryConstructorRunnableOptions & Omit<SelfQueryRetrieverArgs<T>, \"queryConstructor\">): SelfQueryRetriever<T>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;AAaA;;;;AAE+BK,UAFdM,sBAEcN,CAAAA,UAFmBD,WAEnBC,CAAAA,SAFwCH,kBAExCG,CAAAA;EAGxBC,WAAAA,EAJUM,CAIVN;EAFeN,yBAAAA,EADSK,gBACTL,CADwBY,CACxBZ,CAAAA;EAOLY,gBAAAA,EAPKZ,iBAOLY,CAAAA;IAVsDV,KAAAA,EAAAA,MAAAA;EAAkB,CAAA,EAKlFI,eALkF,CAAA;EAiCpEO,OAAAA,CAAAA,EAAAA,OAAAA;EAA6BT,gBAAAA,CAAAA,EAAAA,OAAAA;EAAqEQ,YAAAA,CAAAA,EAAAA;IAGtGA,CAAAA,CAAAA,EAAAA,MAAAA;IAGVN,MAAAA,CAAAA,EA7BUM,CA6BVN,CAAAA,YAAAA,CAAAA;IAFeN,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAIwBY,kBAAAA,CAAAA,EAAAA,OAAAA;EAAfP,CAAAA;;;;;;;;;;;;;;;;;AARuF;;;cAAjGQ,6BAA6BT,qBAAqBH,aAAAA,YAAyBU,uBAAuBC;;;eAGtGA;oBACKZ;;KAEfM;;6BAEwBD,iBAAeO;;;;aAI7BA;;;;uBAIQD,uBAAuBC;oDACML,iCAAiCQ,QAAQZ,SAASW;;;;;;;;;;2BAU3EV,sBAAsBI,kCAAkCQ,KAAKL,uBAAuBC,0BAA0BC,mBAAmBD"}

package/dist/retrievers/time_weighted.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time_weighted.d.cts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","DocumentInterface","CallbackManagerForRetrieverRun","TimeWeightedVectorStoreRetrieverFields","LAST_ACCESSED_AT_KEY","BUFFER_IDX","TimeWeightedVectorStoreRetriever","Promise"],"sources":["../../src/retrievers/time_weighted.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * Interface for the fields required to initialize a\n * TimeWeightedVectorStoreRetriever instance.\n */\nexport interface TimeWeightedVectorStoreRetrieverFields extends BaseRetrieverInput {\n    vectorStore: VectorStoreInterface;\n    searchKwargs?: number;\n    memoryStream?: DocumentInterface[];\n    decayRate?: number;\n    k?: number;\n    otherScoreKeys?: string[];\n    defaultSalience?: number;\n}\nexport declare const LAST_ACCESSED_AT_KEY = \"last_accessed_at\";\nexport declare const BUFFER_IDX = \"buffer_idx\";\n/**\n * TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.\n * ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py\n * @example\n * ```typescript\n * const retriever = new TimeWeightedVectorStoreRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   memoryStream: [],\n *   searchKwargs: 2,\n * });\n * await retriever.addDocuments([\n *   { pageContent: \"My name is John.\", metadata: {} },\n *   { pageContent: \"My favourite food is pizza.\", metadata: {} },\n *\n * ]);\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class TimeWeightedVectorStoreRetriever extends BaseRetriever {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    /**\n     * The vectorstore to store documents and determine salience.\n     */\n    private vectorStore;\n    /**\n     * The number of top K most relevant documents to consider when searching.\n     */\n    private searchKwargs;\n    /**\n     * The memory_stream of documents to search through.\n     */\n    private memoryStream;\n    /**\n     * The exponential decay factor used as (1.0-decay_rate)**(hrs_passed).\n     */\n    private decayRate;\n    /**\n     * The maximum number of documents to retrieve in a given call.\n     */\n    private k;\n    /**\n     * Other keys in the metadata to factor into the score, e.g. 'importance'.\n     */\n    private otherScoreKeys;\n    /**\n     * The salience to assign memories not retrieved from the vector store.\n     */\n    private defaultSalience;\n    /**\n     * Constructor to initialize the required fields\n     * @param fields - The fields required for initializing the TimeWeightedVectorStoreRetriever\n     */\n    constructor(fields: TimeWeightedVectorStoreRetrieverFields);\n    /**\n     * Get the memory stream of documents.\n     * @returns The memory stream of documents.\n     */\n    getMemoryStream(): DocumentInterface[];\n    /**\n     * Set the memory stream of documents.\n     * @param memoryStream The new memory stream of documents.\n     */\n    setMemoryStream(memoryStream: DocumentInterface[]): void;\n    /**\n     * Get relevant documents based on time-weighted relevance\n     * @param query - The query to search for\n     * @returns The relevant documents\n     */\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<DocumentInterface[]>;\n    /**\n     * NOTE: When adding documents to a vector store, use addDocuments\n     * via retriever instead of directly to the vector store.\n     * This is because it is necessary to process the document\n     * in prepareDocuments.\n     *\n     * @param docs - The documents to add to vector store in the retriever\n     */\n    addDocuments(docs: DocumentInterface[]): Promise<void>;\n    /**\n     * Get memory documents and their scores\n     * @returns An object containing memory documents and their scores\n     */\n    private getMemoryDocsAndScores;\n    private getSalientDocuments;\n    /**\n     * Compute the final result set of documents based on the combined scores\n     * @param docsAndScores - An object containing documents and their scores\n     * @param now - The current timestamp\n     * @returns The final set of documents\n     */\n    private computeResults;\n    /**\n     * Prepare documents with necessary metadata before saving\n     * @param docs - The documents to prepare\n     * @param now - The current timestamp\n     * @returns The prepared documents\n     */\n    private prepareDocuments;\n    /**\n     * Calculate the combined score based on vector relevance and other factors\n     * @param doc - The document to calculate the score for\n     * @param vectorRelevance - The relevance score from the vector store\n     * @param nowMsec - The current timestamp in milliseconds\n     * @returns The combined score for the document\n     */\n    private getCombinedScore;\n    /**\n     * Calculate the hours passed between two time points\n     * @param time - The current time in seconds\n     * @param refTime - The reference time in seconds\n     * @returns The number of hours passed between the two time points\n     */\n    private getHoursPassed;\n}\n//# sourceMappingURL=time_weighted.d.ts.map"],"mappings":";;;;;;;;;AAQA;;AAGmBG,UAHFE,sCAAAA,SAA+CJ,kBAG7CE,CAAAA;EAH6CF,WAAAA,EAC/CC,oBAD+CD;EAAkB,YAAA,CAAA,EAAA,MAAA;EAS7DK,YAAAA,CAAAA,EANFH,iBAMsB,EAAA;EACpBI,SAAAA,CAAAA,EAAAA,MAAU;EAqBVC,CAAAA,CAAAA,EAAAA,MAAAA;EAmCGH,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAKDF,eAAAA,CAAAA,EAAAA,MAAAA;;AAW+BC,cAzEjCE,oBAAAA,GAyEiCF,kBAAAA;AAAyCD,cAxE1EI,UAAAA,GAwE0EJ,YAAAA;;;;;AAnDpB;;;;;;;;;;;;;;;;cAAtDK,gCAAAA,SAAyCR,aAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmCtCK;;;;;qBAKDF;;;;;gCAKWA;;;;;;oDAMoBC,iCAAiCK,QAAQN;;;;;;;;;qBASxEA,sBAAsBM"}

package/dist/retrievers/time_weighted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time_weighted.d.ts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","DocumentInterface","CallbackManagerForRetrieverRun","TimeWeightedVectorStoreRetrieverFields","LAST_ACCESSED_AT_KEY","BUFFER_IDX","TimeWeightedVectorStoreRetriever","Promise"],"sources":["../../src/retrievers/time_weighted.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * Interface for the fields required to initialize a\n * TimeWeightedVectorStoreRetriever instance.\n */\nexport interface TimeWeightedVectorStoreRetrieverFields extends BaseRetrieverInput {\n    vectorStore: VectorStoreInterface;\n    searchKwargs?: number;\n    memoryStream?: DocumentInterface[];\n    decayRate?: number;\n    k?: number;\n    otherScoreKeys?: string[];\n    defaultSalience?: number;\n}\nexport declare const LAST_ACCESSED_AT_KEY = \"last_accessed_at\";\nexport declare const BUFFER_IDX = \"buffer_idx\";\n/**\n * TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.\n * ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py\n * @example\n * ```typescript\n * const retriever = new TimeWeightedVectorStoreRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   memoryStream: [],\n *   searchKwargs: 2,\n * });\n * await retriever.addDocuments([\n *   { pageContent: \"My name is John.\", metadata: {} },\n *   { pageContent: \"My favourite food is pizza.\", metadata: {} },\n *\n * ]);\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class TimeWeightedVectorStoreRetriever extends BaseRetriever {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    /**\n     * The vectorstore to store documents and determine salience.\n     */\n    private vectorStore;\n    /**\n     * The number of top K most relevant documents to consider when searching.\n     */\n    private searchKwargs;\n    /**\n     * The memory_stream of documents to search through.\n     */\n    private memoryStream;\n    /**\n     * The exponential decay factor used as (1.0-decay_rate)**(hrs_passed).\n     */\n    private decayRate;\n    /**\n     * The maximum number of documents to retrieve in a given call.\n     */\n    private k;\n    /**\n     * Other keys in the metadata to factor into the score, e.g. 'importance'.\n     */\n    private otherScoreKeys;\n    /**\n     * The salience to assign memories not retrieved from the vector store.\n     */\n    private defaultSalience;\n    /**\n     * Constructor to initialize the required fields\n     * @param fields - The fields required for initializing the TimeWeightedVectorStoreRetriever\n     */\n    constructor(fields: TimeWeightedVectorStoreRetrieverFields);\n    /**\n     * Get the memory stream of documents.\n     * @returns The memory stream of documents.\n     */\n    getMemoryStream(): DocumentInterface[];\n    /**\n     * Set the memory stream of documents.\n     * @param memoryStream The new memory stream of documents.\n     */\n    setMemoryStream(memoryStream: DocumentInterface[]): void;\n    /**\n     * Get relevant documents based on time-weighted relevance\n     * @param query - The query to search for\n     * @returns The relevant documents\n     */\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<DocumentInterface[]>;\n    /**\n     * NOTE: When adding documents to a vector store, use addDocuments\n     * via retriever instead of directly to the vector store.\n     * This is because it is necessary to process the document\n     * in prepareDocuments.\n     *\n     * @param docs - The documents to add to vector store in the retriever\n     */\n    addDocuments(docs: DocumentInterface[]): Promise<void>;\n    /**\n     * Get memory documents and their scores\n     * @returns An object containing memory documents and their scores\n     */\n    private getMemoryDocsAndScores;\n    private getSalientDocuments;\n    /**\n     * Compute the final result set of documents based on the combined scores\n     * @param docsAndScores - An object containing documents and their scores\n     * @param now - The current timestamp\n     * @returns The final set of documents\n     */\n    private computeResults;\n    /**\n     * Prepare documents with necessary metadata before saving\n     * @param docs - The documents to prepare\n     * @param now - The current timestamp\n     * @returns The prepared documents\n     */\n    private prepareDocuments;\n    /**\n     * Calculate the combined score based on vector relevance and other factors\n     * @param doc - The document to calculate the score for\n     * @param vectorRelevance - The relevance score from the vector store\n     * @param nowMsec - The current timestamp in milliseconds\n     * @returns The combined score for the document\n     */\n    private getCombinedScore;\n    /**\n     * Calculate the hours passed between two time points\n     * @param time - The current time in seconds\n     * @param refTime - The reference time in seconds\n     * @returns The number of hours passed between the two time points\n     */\n    private getHoursPassed;\n}\n//# sourceMappingURL=time_weighted.d.ts.map"],"mappings":";;;;;;;;;AAQA;;AAGmBG,UAHFE,sCAAAA,SAA+CJ,kBAG7CE,CAAAA;EAH6CF,WAAAA,EAC/CC,oBAD+CD;EAAkB,YAAA,CAAA,EAAA,MAAA;EAS7DK,YAAAA,CAAAA,EANFH,iBAMsB,EAAA;EACpBI,SAAAA,CAAAA,EAAAA,MAAU;EAqBVC,CAAAA,CAAAA,EAAAA,MAAAA;EAmCGH,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAKDF,eAAAA,CAAAA,EAAAA,MAAAA;;AAW+BC,cAzEjCE,oBAAAA,GAyEiCF,kBAAAA;AAAyCD,cAxE1EI,UAAAA,GAwE0EJ,YAAAA;;;;;AAnDpB;;;;;;;;;;;;;;;;cAAtDK,gCAAAA,SAAyCR,aAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmCtCK;;;;;qBAKDF;;;;;gCAKWA;;;;;;oDAMoBC,iCAAiCK,QAAQN;;;;;;;;;qBASxEA,sBAAsBM"}

package/dist/schema/prompt_template.d.cts

@@ -1,5 +1,5 @@
-import { BasePromptValueInterface } from "../langchain-core/dist/prompt_values.cjs";
 import { BasePromptTemplate } from "@langchain/core/prompts";
+import * as _langchain_core_prompt_values0 from "@langchain/core/prompt_values";
 import { Document } from "@langchain/core/documents";
 
 //#region src/schema/prompt_template.d.ts
@@ -13,7 +13,7 @@ import { Document } from "@langchain/core/documents";
  * @returns {Promise<string>} A Promise that resolves to the formatted document as a string.
  * @throws {Error} If the document is missing required metadata variables specified in the prompt template.
  */
-declare const formatDocument: (document: Document<Record<string, any>>, prompt: BasePromptTemplate<any, BasePromptValueInterface, any>) => Promise<string>;
+declare const formatDocument: (document: Document<Record<string, any>>, prompt: BasePromptTemplate<any, _langchain_core_prompt_values0.BasePromptValueInterface, any>) => Promise<string>;
 //#endregion
 export { formatDocument };
 //# sourceMappingURL=prompt_template.d.cts.map

package/dist/schema/prompt_template.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt_template.d.cts","names":["Document","BasePromptTemplate","formatDocument","Record","_langchain_core_prompt_values0","BasePromptValueInterface","Promise"],"sources":["../../src/schema/prompt_template.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\n/**\n * Formats a document using a given prompt template.\n *\n * @async\n * @param {Document} document - The document to format.\n * @param {BasePromptTemplate} prompt - The prompt template to use for formatting.\n * @returns {Promise<string>} A Promise that resolves to the formatted document as a string.\n * @throws {Error} If the document is missing required metadata variables specified in the prompt template.\n */\nexport declare const formatDocument: (document: Document<Record<string, any>>, prompt: BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>) => Promise<string>;\n//# sourceMappingURL=prompt_template.d.ts.map"],"mappings":";;;;;;;;;AAWA;;;;;;AAAiM,cAA5KE,cAA4K,EAAA,CAAA,QAAA,EAAjJF,QAAiJ,CAAxIG,MAAwI,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA,MAAA,EAA1GF,kBAA0G,CAAA,GAAA,EAAzIG,8BAAAA,CAA+FC,wBAAAA,EAA0C,GAAA,CAAA,EAAA,GAAPC,OAAO,CAAA,MAAA,CAAA"}

package/dist/schema/prompt_template.d.ts

@@ -1,6 +1,6 @@
-import { BasePromptValueInterface } from "../libs/langchain-core/dist/prompt_values.js";
 import { Document } from "@langchain/core/documents";
 import { BasePromptTemplate } from "@langchain/core/prompts";
+import * as _langchain_core_prompt_values0 from "@langchain/core/prompt_values";
 
 //#region src/schema/prompt_template.d.ts
 
@@ -13,7 +13,7 @@ import { BasePromptTemplate } from "@langchain/core/prompts";
  * @returns {Promise<string>} A Promise that resolves to the formatted document as a string.
  * @throws {Error} If the document is missing required metadata variables specified in the prompt template.
  */
-declare const formatDocument: (document: Document<Record<string, any>>, prompt: BasePromptTemplate<any, BasePromptValueInterface, any>) => Promise<string>;
+declare const formatDocument: (document: Document<Record<string, any>>, prompt: BasePromptTemplate<any, _langchain_core_prompt_values0.BasePromptValueInterface, any>) => Promise<string>;
 //#endregion
 export { formatDocument };
 //# sourceMappingURL=prompt_template.d.ts.map

package/dist/schema/prompt_template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt_template.d.ts","names":["Document","BasePromptTemplate","formatDocument","Record","_langchain_core_prompt_values0","BasePromptValueInterface","Promise"],"sources":["../../src/schema/prompt_template.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\n/**\n * Formats a document using a given prompt template.\n *\n * @async\n * @param {Document} document - The document to format.\n * @param {BasePromptTemplate} prompt - The prompt template to use for formatting.\n * @returns {Promise<string>} A Promise that resolves to the formatted document as a string.\n * @throws {Error} If the document is missing required metadata variables specified in the prompt template.\n */\nexport declare const formatDocument: (document: Document<Record<string, any>>, prompt: BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>) => Promise<string>;\n//# sourceMappingURL=prompt_template.d.ts.map"],"mappings":";;;;;;;;;AAWA;;;;;;AAAiM,cAA5KE,cAA4K,EAAA,CAAA,QAAA,EAAjJF,QAAiJ,CAAxIG,MAAwI,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA,MAAA,EAA1GF,kBAA0G,CAAA,GAAA,EAAzIG,8BAAAA,CAA+FC,wBAAAA,EAA0C,GAAA,CAAA,EAAA,GAAPC,OAAO,CAAA,MAAA,CAAA"}

package/dist/schema/query_constructor.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query_constructor.d.cts","names":["AttributeInfo"],"sources":["../../src/schema/query_constructor.d.ts"],"sourcesContent":["/**\n * A simple data structure that holds information about an attribute. It\n * is typically used to provide metadata about attributes in other classes\n * or data structures within the LangChain framework.\n */\nexport declare class AttributeInfo {\n    name: string;\n    type: string;\n    description: string;\n    constructor(name: string, type: string, description: string);\n}\n//# sourceMappingURL=query_constructor.d.ts.map"],"mappings":";;AAKA;;;;cAAqBA,aAAAA"}

package/dist/schema/query_constructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query_constructor.d.ts","names":["AttributeInfo"],"sources":["../../src/schema/query_constructor.d.ts"],"sourcesContent":["/**\n * A simple data structure that holds information about an attribute. It\n * is typically used to provide metadata about attributes in other classes\n * or data structures within the LangChain framework.\n */\nexport declare class AttributeInfo {\n    name: string;\n    type: string;\n    description: string;\n    constructor(name: string, type: string, description: string);\n}\n//# sourceMappingURL=query_constructor.d.ts.map"],"mappings":";;AAKA;;;;cAAqBA,aAAAA"}

package/dist/smith/config.d.cts

@@ -19,21 +19,12 @@ type EvaluatorInputFormatter = ({
   rawReferenceOutput,
   run
 }: {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   rawInput: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   rawPrediction: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   rawReferenceOutput?: any;
   run: Run;
 }) => EvaluatorInputs;
-type DynamicRunEvaluatorParams<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Input extends Record<string, any> = Record<string, unknown>,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Prediction extends Record<string, any> = Record<string, unknown>,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-Reference extends Record<string, any> = Record<string, unknown>> = {
+type DynamicRunEvaluatorParams<Input extends Record<string, any> = Record<string, unknown>, Prediction extends Record<string, any> = Record<string, unknown>, Reference extends Record<string, any> = Record<string, unknown>> = {
   input: Input;
   prediction?: Prediction;
   reference?: Reference;
@@ -191,7 +182,6 @@ type Criteria$1 = EvalConfig & {
    */
   llm?: BaseLanguageModel;
 };
-// for compatibility reasons
 type CriteriaEvalChainConfig = Criteria$1;
 declare function Criteria$1(criteria: Criteria | Record<string, string>, config?: Pick<Partial<LabeledCriteria>, "formatEvaluatorInputs" | "llm" | "feedbackKey">): EvalConfig;
 /**