@langchain/classic 1.0.4 → 1.0.5

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAA4B,kBAAA,EAAA,MAAA;CAAA;AAAyDC,cAK5EE,uBAL4EF,CAAAA,UAK1CJ,WAL0CI,CAAAA,SAKrBH,oBALqBG,CAKAA,CALAA,CAAAA,CAAAA;EAAC,kBAA3BF,EAAAA,MAAAA;EAAyB,UAA9BG,EAAAA,MAAAA;EAAI,IAAA,EAAA,MAAA;EAKjDC,WAAAA,CAAAA,KAAAA,EAIEH,4BAJqB,CAIQC,CAJR,CAAA;EAAA,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAKjBG,OALiB,CAKTR,QALS,EAAA,CAAA;EAAA,OAAWC,eAAAA,CAAAA,UAMlBA,WANkBA,CAAAA,CAAAA,WAAAA,EAMQI,CANRJ,EAAAA,OAAAA,EAMoBK,IANpBL,CAMyBG,4BANzBH,CAMsDI,CANtDJ,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAM2EM,uBAN3EN,CAMmGI,CANnGJ,CAAAA"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;AAaA;;;;AAE8CY,UAF7BD,sBAE6BC,CAAAA,UAFIR,WAEJQ,CAAAA,SAFyBV,kBAEzBU,CAAAA;EAAC,WAAhBP,EADdO,CACcP;EAAc,yBAGtCC,EAHwBD,gBAGxBC,CAHuCM,CAGvCN,CAAAA;EAAe,gBAFAN,EAAAA,iBAAAA,CAAAA;IAOLY,KAAAA,EAAAA,MAAAA;EAAC,CAAA,EALXN,eALgEJ,CAAAA;EAAkB,OAAA,CAAA,EAAA,OAAA;EAiCpEW,gBAAAA,CAAAA,EAAAA,OAAkB;EAAA,YAAA,CAAA,EAAA;IAAWT,CAAAA,CAAAA,EAAAA,MAAAA;IAAqEQ,MAAAA,CAAAA,EAvBtGA,CAuBsGA,CAAAA,YAAAA,CAAAA;IAGtGA,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAGVN,kBAAAA,CAAAA,EAAAA,OAAAA;EAAe,CAAA;;;;;;;;;;;;;;;;;;;AANgG;cAAjGO,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;;AAaA;;;;AAE8CY,UAF7BD,sBAE6BC,CAAAA,UAFIR,WAEJQ,CAAAA,SAFyBV,kBAEzBU,CAAAA;EAAC,WAAhBP,EADdO,CACcP;EAAc,yBAGtCC,EAHwBD,gBAGxBC,CAHuCM,CAGvCN,CAAAA;EAAe,gBAFAN,EAAAA,iBAAAA,CAAAA;IAOLY,KAAAA,EAAAA,MAAAA;EAAC,CAAA,EALXN,eALgEJ,CAAAA;EAAkB,OAAA,CAAA,EAAA,OAAA;EAiCpEW,gBAAAA,CAAAA,EAAAA,OAAkB;EAAA,YAAA,CAAA,EAAA;IAAWT,CAAAA,CAAAA,EAAAA,MAAAA;IAAqEQ,MAAAA,CAAAA,EAvBtGA,CAuBsGA,CAAAA,YAAAA,CAAAA;IAGtGA,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAGVN,kBAAAA,CAAAA,EAAAA,OAAAA;EAAe,CAAA;;;;;;;;;;;;;;;;;;;AANgG;cAAjGO,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;AAQA;;AACiBE,UADAG,sCAAAA,SAA+CJ,kBAC/CC,CAAAA;EAAoB,WAElBC,EAFFD,oBAEEC;EAAiB,YAH4BF,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,CAAA,EAG/DE,iBAH+D,EAAA;EAS7DG,SAAAA,CAAAA,EAAAA,MAAAA;EACAC,CAAAA,CAAAA,EAAAA,MAAAA;EAqBAC,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgC,eAAA,CAAA,EAAA,MAAA;;AAwC9BL,cA9DFG,oBAAAA,GA8DEH,kBAAAA;AAKWA,cAlEbI,UAAAA,GAkEaJ,YAAAA;;;;;;;AA7CyC;;;;;;;;;;;;;;cAAtDK,gCAAAA,SAAyCR,aAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmCtCK;;;;;qBAKDF;;;;;gCAKWA;;;;;;oDAMoBC,iCAAiCK,QAAQN;;;;;;;;;qBASxEA,sBAAsBM"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;;AAQA;;AACiBE,UADAG,sCAAAA,SAA+CJ,kBAC/CC,CAAAA;EAAoB,WAElBC,EAFFD,oBAEEC;EAAiB,YAH4BF,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,CAAA,EAG/DE,iBAH+D,EAAA;EAS7DG,SAAAA,CAAAA,EAAAA,MAAAA;EACAC,CAAAA,CAAAA,EAAAA,MAAAA;EAqBAC,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAgC,eAAA,CAAA,EAAA,MAAA;;AAwC9BL,cA9DFG,oBAAAA,GA8DEH,kBAAAA;AAKWA,cAlEbI,UAAAA,GAkEaJ,YAAAA;;;;;;;AA7CyC;;;;;;;;;;;;;;cAAtDK,gCAAAA,SAAyCR,aAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmCtCK;;;;;qBAKDF;;;;;gCAKWA;;;;;;oDAMoBC,iCAAiCK,QAAQN;;;;;;;;;qBASxEA,sBAAsBM"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompt_template.d.cts","names":["Document","BasePromptTemplate","formatDocument","Record","_________langchain_core_dist_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/dist/prompt_values\").BasePromptValueInterface, any>) => Promise<string>;\n"],"mappings":";;;;;;;;;AAWA;;;;;;AAAuMM,cAAlLJ,cAAkLI,EAAAA,CAAAA,QAAAA,EAAvJN,QAAuJM,CAA9IH,MAA8IG,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAhHL,kBAAgHK,CAAAA,GAAAA,EAA/I,wBAAA,EAA+IA,GAAAA,CAAAA,EAAAA,GAAAA,OAAAA,CAAAA,MAAAA,CAAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompt_template.d.ts","names":["Document","BasePromptTemplate","formatDocument","Record","_________langchain_core_dist_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/dist/prompt_values\").BasePromptValueInterface, any>) => Promise<string>;\n"],"mappings":";;;;;;;;;AAWA;;;;;;AAAuMM,cAAlLJ,cAAkLI,EAAAA,CAAAA,QAAAA,EAAvJN,QAAuJM,CAA9IH,MAA8IG,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAhHL,kBAAgHK,CAAAA,GAAAA,EAA/I,wBAAA,EAA+IA,GAAAA,CAAAA,EAAAA,GAAAA,OAAAA,CAAAA,MAAAA,CAAAA"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;AAKA;;;;cAAqBA,aAAAA"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;AAKA;;;;cAAqBA,aAAAA"}

package/dist/smith/config.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.cts","names":["BaseLanguageModel","RunnableConfig","Example","Run","EvaluationResult","RunEvaluator","Criteria","CriteriaType","EmbeddingDistanceEvalChainInput","LoadEvaluatorOptions","EvaluatorType","EvaluatorInputs","EvaluatorInputFormatter","rawInput","rawPrediction","rawReferenceOutput","run","DynamicRunEvaluatorParams","Record","Input","Prediction","Reference","RunEvaluatorLike","Promise","isOffTheShelfEvaluator","T","EvalConfig","U","isCustomEvaluator","RunEvalType","RunEvalConfig","CriteriaEvalChainConfig","LabeledCriteria","Partial","Pick","EmbeddingDistance"],"sources":["../../src/smith/config.d.ts"],"sourcesContent":["import { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { Example, Run } from \"langsmith\";\nimport { EvaluationResult, RunEvaluator } from \"langsmith/evaluation\";\nimport { Criteria as CriteriaType, type EmbeddingDistanceEvalChainInput } from \"../evaluation/index.js\";\nimport { LoadEvaluatorOptions } from \"../evaluation/loader.js\";\nimport { EvaluatorType } from \"../evaluation/types.js\";\nexport type EvaluatorInputs = {\n    input?: string | unknown;\n    prediction: string | unknown;\n    reference?: string | unknown;\n};\nexport type EvaluatorInputFormatter = ({ rawInput, rawPrediction, rawReferenceOutput, run }: {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    rawInput: any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    rawPrediction: any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    rawReferenceOutput?: any;\n    run: Run;\n}) => EvaluatorInputs;\nexport type DynamicRunEvaluatorParams<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nInput extends Record<string, any> = Record<string, unknown>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nPrediction extends Record<string, any> = Record<string, unknown>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nReference extends Record<string, any> = Record<string, unknown>> = {\n    input: Input;\n    prediction?: Prediction;\n    reference?: Reference;\n    run: Run;\n    example?: Example;\n};\n/**\n * Type of a function that can be coerced into a RunEvaluator function.\n * While we have the class-based RunEvaluator, it's often more convenient to directly\n * pass a function to the runner. This type allows us to do that.\n */\nexport type RunEvaluatorLike = ((props: DynamicRunEvaluatorParams, options: RunnableConfig) => Promise<EvaluationResult>) | ((props: DynamicRunEvaluatorParams, options: RunnableConfig) => EvaluationResult);\nexport declare function isOffTheShelfEvaluator<T extends keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike>(evaluator: T | EvalConfig | U): evaluator is T | EvalConfig;\nexport declare function isCustomEvaluator<T extends keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike>(evaluator: T | EvalConfig | U): evaluator is U;\nexport type RunEvalType<T extends keyof EvaluatorType = \"criteria\" | \"labeled_criteria\" | \"embedding_distance\", U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = T | EvalConfig | U;\n/**\n * Configuration class for running evaluations on datasets.\n *\n * @remarks\n * RunEvalConfig in LangSmith is a configuration class for running evaluations on datasets. Its primary purpose is to define the parameters and evaluators that will be applied during the evaluation of a dataset. This configuration can include various evaluators, custom evaluators, and different keys for inputs, predictions, and references.\n *\n * @typeparam T - The type of evaluators.\n * @typeparam U - The type of custom evaluators.\n */\nexport type RunEvalConfig<T extends keyof EvaluatorType = \"criteria\" | \"labeled_criteria\" | \"embedding_distance\", U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = {\n    /**\n     * Evaluators to apply to a dataset run.\n     * You can optionally specify these by name, or by\n     * configuring them with an EvalConfig object.\n     */\n    evaluators?: RunEvalType<T, U>[];\n    /**\n     * Convert the evaluation data into formats that can be used by the evaluator.\n     * This should most commonly be a string.\n     * Parameters are the raw input from the run, the raw output, raw reference output, and the raw run.\n     * @example\n     * ```ts\n     * // Chain input: { input: \"some string\" }\n     * // Chain output: { output: \"some output\" }\n     * // Reference example output format: { output: \"some reference output\" }\n     * const formatEvaluatorInputs = ({\n     *   rawInput,\n     *   rawPrediction,\n     *   rawReferenceOutput,\n     * }) => {\n     *   return {\n     *     input: rawInput.input,\n     *     prediction: rawPrediction.output,\n     *     reference: rawReferenceOutput.output,\n     *   };\n     * };\n     * ```\n     * @returns The prepared data.\n     */\n    formatEvaluatorInputs?: EvaluatorInputFormatter;\n    /**\n     * Custom evaluators to apply to a dataset run.\n     * Each evaluator is provided with a run trace containing the model\n     * outputs, as well as an \"example\" object representing a record\n     * in the dataset.\n     *\n     * @deprecated Use `evaluators` instead.\n     */\n    customEvaluators?: U[];\n};\nexport interface EvalConfig extends LoadEvaluatorOptions {\n    /**\n     * The name of the evaluator to use.\n     * Example: labeled_criteria, criteria, etc.\n     */\n    evaluatorType: keyof EvaluatorType;\n    /**\n     * The feedback (or metric) name to use for the logged\n     * evaluation results. If none provided, we default to\n     * the evaluationName.\n     */\n    feedbackKey?: string;\n    /**\n     * Convert the evaluation data into formats that can be used by the evaluator.\n     * This should most commonly be a string.\n     * Parameters are the raw input from the run, the raw output, raw reference output, and the raw run.\n     * @example\n     * ```ts\n     * // Chain input: { input: \"some string\" }\n     * // Chain output: { output: \"some output\" }\n     * // Reference example output format: { output: \"some reference output\" }\n     * const formatEvaluatorInputs = ({\n     *   rawInput,\n     *   rawPrediction,\n     *   rawReferenceOutput,\n     * }) => {\n     *   return {\n     *     input: rawInput.input,\n     *     prediction: rawPrediction.output,\n     *     reference: rawReferenceOutput.output,\n     *   };\n     * };\n     * ```\n     * @returns The prepared data.\n     */\n    formatEvaluatorInputs: EvaluatorInputFormatter;\n}\n/**\n * Configuration to load a \"CriteriaEvalChain\" evaluator,\n * which prompts an LLM to determine whether the model's\n * prediction complies with the provided criteria.\n * @param criteria - The criteria to use for the evaluator.\n * @param llm - The language model to use for the evaluator.\n * @returns The configuration for the evaluator.\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [Criteria(\"helpfulness\")],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [\n *     Criteria({\n *       \"isCompliant\": \"Does the submission comply with the requirements of XYZ\"\n *     })\n *   ],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"criteria\",\n *     criteria: \"helpfulness\"\n *     formatEvaluatorInputs: ...\n *   }]\n * };\n * ```\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"criteria\",\n *     criteria: { \"isCompliant\": \"Does the submission comply with the requirements of XYZ\" },\n *     formatEvaluatorInputs: ...\n *   }]\n * };\n */\nexport type Criteria = EvalConfig & {\n    evaluatorType: \"criteria\";\n    /**\n     * The \"criteria\" to insert into the prompt template\n     * used for evaluation. See the prompt at\n     * https://smith.langchain.com/hub/langchain-ai/criteria-evaluator\n     * for more information.\n     */\n    criteria?: CriteriaType | Record<string, string>;\n    /**\n     * The language model to use as the evaluator, defaults to GPT-4\n     */\n    llm?: BaseLanguageModel;\n};\n// for compatibility reasons\nexport type CriteriaEvalChainConfig = Criteria;\nexport declare function Criteria(criteria: CriteriaType | Record<string, string>, config?: Pick<Partial<LabeledCriteria>, \"formatEvaluatorInputs\" | \"llm\" | \"feedbackKey\">): EvalConfig;\n/**\n * Configuration to load a \"LabeledCriteriaEvalChain\" evaluator,\n * which prompts an LLM to determine whether the model's\n * prediction complies with the provided criteria and also\n * provides a \"ground truth\" label for the evaluator to incorporate\n * in its evaluation.\n * @param criteria - The criteria to use for the evaluator.\n * @param llm - The language model to use for the evaluator.\n * @returns The configuration for the evaluator.\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [LabeledCriteria(\"correctness\")],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [\n *     LabeledCriteria({\n *       \"mentionsAllFacts\": \"Does the include all facts provided in the reference?\"\n *     })\n *   ],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"labeled_criteria\",\n *     criteria: \"correctness\",\n *     formatEvaluatorInputs: ...\n *   }],\n * };\n * ```\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"labeled_criteria\",\n *     criteria: { \"mentionsAllFacts\": \"Does the include all facts provided in the reference?\" },\n *     formatEvaluatorInputs: ...\n *   }],\n * };\n */\nexport type LabeledCriteria = EvalConfig & {\n    evaluatorType: \"labeled_criteria\";\n    /**\n     * The \"criteria\" to insert into the prompt template\n     * used for evaluation. See the prompt at\n     * https://smith.langchain.com/hub/langchain-ai/labeled-criteria\n     * for more information.\n     */\n    criteria?: CriteriaType | Record<string, string>;\n    /**\n     * The language model to use as the evaluator, defaults to GPT-4\n     */\n    llm?: BaseLanguageModel;\n};\nexport declare function LabeledCriteria(criteria: CriteriaType | Record<string, string>, config?: Pick<Partial<LabeledCriteria>, \"formatEvaluatorInputs\" | \"llm\" | \"feedbackKey\">): LabeledCriteria;\n/**\n * Configuration to load a \"EmbeddingDistanceEvalChain\" evaluator,\n * which embeds distances to score semantic difference between\n * a prediction and reference.\n */\nexport type EmbeddingDistance = EvalConfig & EmbeddingDistanceEvalChainInput & {\n    evaluatorType: \"embedding_distance\";\n};\nexport declare function EmbeddingDistance(distanceMetric: EmbeddingDistanceEvalChainInput[\"distanceMetric\"], config?: Pick<Partial<LabeledCriteria>, \"formatEvaluatorInputs\" | \"embedding\" | \"feedbackKey\">): EmbeddingDistance;\n"],"mappings":"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"}

package/dist/smith/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","names":["BaseLanguageModel","RunnableConfig","Example","Run","EvaluationResult","RunEvaluator","Criteria","CriteriaType","EmbeddingDistanceEvalChainInput","LoadEvaluatorOptions","EvaluatorType","EvaluatorInputs","EvaluatorInputFormatter","rawInput","rawPrediction","rawReferenceOutput","run","DynamicRunEvaluatorParams","Record","Input","Prediction","Reference","RunEvaluatorLike","Promise","isOffTheShelfEvaluator","T","EvalConfig","U","isCustomEvaluator","RunEvalType","RunEvalConfig","CriteriaEvalChainConfig","LabeledCriteria","Partial","Pick","EmbeddingDistance"],"sources":["../../src/smith/config.d.ts"],"sourcesContent":["import { BaseLanguageModel } from \"@langchain/core/language_models/base\";\nimport { RunnableConfig } from \"@langchain/core/runnables\";\nimport { Example, Run } from \"langsmith\";\nimport { EvaluationResult, RunEvaluator } from \"langsmith/evaluation\";\nimport { Criteria as CriteriaType, type EmbeddingDistanceEvalChainInput } from \"../evaluation/index.js\";\nimport { LoadEvaluatorOptions } from \"../evaluation/loader.js\";\nimport { EvaluatorType } from \"../evaluation/types.js\";\nexport type EvaluatorInputs = {\n    input?: string | unknown;\n    prediction: string | unknown;\n    reference?: string | unknown;\n};\nexport type EvaluatorInputFormatter = ({ rawInput, rawPrediction, rawReferenceOutput, run }: {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    rawInput: any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    rawPrediction: any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    rawReferenceOutput?: any;\n    run: Run;\n}) => EvaluatorInputs;\nexport type DynamicRunEvaluatorParams<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nInput extends Record<string, any> = Record<string, unknown>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nPrediction extends Record<string, any> = Record<string, unknown>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nReference extends Record<string, any> = Record<string, unknown>> = {\n    input: Input;\n    prediction?: Prediction;\n    reference?: Reference;\n    run: Run;\n    example?: Example;\n};\n/**\n * Type of a function that can be coerced into a RunEvaluator function.\n * While we have the class-based RunEvaluator, it's often more convenient to directly\n * pass a function to the runner. This type allows us to do that.\n */\nexport type RunEvaluatorLike = ((props: DynamicRunEvaluatorParams, options: RunnableConfig) => Promise<EvaluationResult>) | ((props: DynamicRunEvaluatorParams, options: RunnableConfig) => EvaluationResult);\nexport declare function isOffTheShelfEvaluator<T extends keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike>(evaluator: T | EvalConfig | U): evaluator is T | EvalConfig;\nexport declare function isCustomEvaluator<T extends keyof EvaluatorType, U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike>(evaluator: T | EvalConfig | U): evaluator is U;\nexport type RunEvalType<T extends keyof EvaluatorType = \"criteria\" | \"labeled_criteria\" | \"embedding_distance\", U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = T | EvalConfig | U;\n/**\n * Configuration class for running evaluations on datasets.\n *\n * @remarks\n * RunEvalConfig in LangSmith is a configuration class for running evaluations on datasets. Its primary purpose is to define the parameters and evaluators that will be applied during the evaluation of a dataset. This configuration can include various evaluators, custom evaluators, and different keys for inputs, predictions, and references.\n *\n * @typeparam T - The type of evaluators.\n * @typeparam U - The type of custom evaluators.\n */\nexport type RunEvalConfig<T extends keyof EvaluatorType = \"criteria\" | \"labeled_criteria\" | \"embedding_distance\", U extends RunEvaluator | RunEvaluatorLike = RunEvaluator | RunEvaluatorLike> = {\n    /**\n     * Evaluators to apply to a dataset run.\n     * You can optionally specify these by name, or by\n     * configuring them with an EvalConfig object.\n     */\n    evaluators?: RunEvalType<T, U>[];\n    /**\n     * Convert the evaluation data into formats that can be used by the evaluator.\n     * This should most commonly be a string.\n     * Parameters are the raw input from the run, the raw output, raw reference output, and the raw run.\n     * @example\n     * ```ts\n     * // Chain input: { input: \"some string\" }\n     * // Chain output: { output: \"some output\" }\n     * // Reference example output format: { output: \"some reference output\" }\n     * const formatEvaluatorInputs = ({\n     *   rawInput,\n     *   rawPrediction,\n     *   rawReferenceOutput,\n     * }) => {\n     *   return {\n     *     input: rawInput.input,\n     *     prediction: rawPrediction.output,\n     *     reference: rawReferenceOutput.output,\n     *   };\n     * };\n     * ```\n     * @returns The prepared data.\n     */\n    formatEvaluatorInputs?: EvaluatorInputFormatter;\n    /**\n     * Custom evaluators to apply to a dataset run.\n     * Each evaluator is provided with a run trace containing the model\n     * outputs, as well as an \"example\" object representing a record\n     * in the dataset.\n     *\n     * @deprecated Use `evaluators` instead.\n     */\n    customEvaluators?: U[];\n};\nexport interface EvalConfig extends LoadEvaluatorOptions {\n    /**\n     * The name of the evaluator to use.\n     * Example: labeled_criteria, criteria, etc.\n     */\n    evaluatorType: keyof EvaluatorType;\n    /**\n     * The feedback (or metric) name to use for the logged\n     * evaluation results. If none provided, we default to\n     * the evaluationName.\n     */\n    feedbackKey?: string;\n    /**\n     * Convert the evaluation data into formats that can be used by the evaluator.\n     * This should most commonly be a string.\n     * Parameters are the raw input from the run, the raw output, raw reference output, and the raw run.\n     * @example\n     * ```ts\n     * // Chain input: { input: \"some string\" }\n     * // Chain output: { output: \"some output\" }\n     * // Reference example output format: { output: \"some reference output\" }\n     * const formatEvaluatorInputs = ({\n     *   rawInput,\n     *   rawPrediction,\n     *   rawReferenceOutput,\n     * }) => {\n     *   return {\n     *     input: rawInput.input,\n     *     prediction: rawPrediction.output,\n     *     reference: rawReferenceOutput.output,\n     *   };\n     * };\n     * ```\n     * @returns The prepared data.\n     */\n    formatEvaluatorInputs: EvaluatorInputFormatter;\n}\n/**\n * Configuration to load a \"CriteriaEvalChain\" evaluator,\n * which prompts an LLM to determine whether the model's\n * prediction complies with the provided criteria.\n * @param criteria - The criteria to use for the evaluator.\n * @param llm - The language model to use for the evaluator.\n * @returns The configuration for the evaluator.\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [Criteria(\"helpfulness\")],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [\n *     Criteria({\n *       \"isCompliant\": \"Does the submission comply with the requirements of XYZ\"\n *     })\n *   ],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"criteria\",\n *     criteria: \"helpfulness\"\n *     formatEvaluatorInputs: ...\n *   }]\n * };\n * ```\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"criteria\",\n *     criteria: { \"isCompliant\": \"Does the submission comply with the requirements of XYZ\" },\n *     formatEvaluatorInputs: ...\n *   }]\n * };\n */\nexport type Criteria = EvalConfig & {\n    evaluatorType: \"criteria\";\n    /**\n     * The \"criteria\" to insert into the prompt template\n     * used for evaluation. See the prompt at\n     * https://smith.langchain.com/hub/langchain-ai/criteria-evaluator\n     * for more information.\n     */\n    criteria?: CriteriaType | Record<string, string>;\n    /**\n     * The language model to use as the evaluator, defaults to GPT-4\n     */\n    llm?: BaseLanguageModel;\n};\n// for compatibility reasons\nexport type CriteriaEvalChainConfig = Criteria;\nexport declare function Criteria(criteria: CriteriaType | Record<string, string>, config?: Pick<Partial<LabeledCriteria>, \"formatEvaluatorInputs\" | \"llm\" | \"feedbackKey\">): EvalConfig;\n/**\n * Configuration to load a \"LabeledCriteriaEvalChain\" evaluator,\n * which prompts an LLM to determine whether the model's\n * prediction complies with the provided criteria and also\n * provides a \"ground truth\" label for the evaluator to incorporate\n * in its evaluation.\n * @param criteria - The criteria to use for the evaluator.\n * @param llm - The language model to use for the evaluator.\n * @returns The configuration for the evaluator.\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [LabeledCriteria(\"correctness\")],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [\n *     LabeledCriteria({\n *       \"mentionsAllFacts\": \"Does the include all facts provided in the reference?\"\n *     })\n *   ],\n * };\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"labeled_criteria\",\n *     criteria: \"correctness\",\n *     formatEvaluatorInputs: ...\n *   }],\n * };\n * ```\n * @example\n * ```ts\n * const evalConfig = {\n *   evaluators: [{\n *     evaluatorType: \"labeled_criteria\",\n *     criteria: { \"mentionsAllFacts\": \"Does the include all facts provided in the reference?\" },\n *     formatEvaluatorInputs: ...\n *   }],\n * };\n */\nexport type LabeledCriteria = EvalConfig & {\n    evaluatorType: \"labeled_criteria\";\n    /**\n     * The \"criteria\" to insert into the prompt template\n     * used for evaluation. See the prompt at\n     * https://smith.langchain.com/hub/langchain-ai/labeled-criteria\n     * for more information.\n     */\n    criteria?: CriteriaType | Record<string, string>;\n    /**\n     * The language model to use as the evaluator, defaults to GPT-4\n     */\n    llm?: BaseLanguageModel;\n};\nexport declare function LabeledCriteria(criteria: CriteriaType | Record<string, string>, config?: Pick<Partial<LabeledCriteria>, \"formatEvaluatorInputs\" | \"llm\" | \"feedbackKey\">): LabeledCriteria;\n/**\n * Configuration to load a \"EmbeddingDistanceEvalChain\" evaluator,\n * which embeds distances to score semantic difference between\n * a prediction and reference.\n */\nexport type EmbeddingDistance = EvalConfig & EmbeddingDistanceEvalChainInput & {\n    evaluatorType: \"embedding_distance\";\n};\nexport declare function EmbeddingDistance(distanceMetric: EmbeddingDistanceEvalChainInput[\"distanceMetric\"], config?: Pick<Partial<LabeledCriteria>, \"formatEvaluatorInputs\" | \"embedding\" | \"feedbackKey\">): EmbeddingDistance;\n"],"mappings":"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"}

package/dist/smith/runner_utils.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner_utils.d.cts","names":["Runnable","Client","Feedback","TraceableFunction","RunEvalConfig","ChainOrFactory","AnyTraceableFunction","Promise","RunOnDatasetParams","Record","Omit","EvalResults","runOnDataset"],"sources":["../../src/smith/runner_utils.d.ts"],"sourcesContent":["import { Runnable } from \"@langchain/core/runnables\";\nimport { Client, Feedback } from \"langsmith\";\nimport type { TraceableFunction } from \"langsmith/singletons/traceable\";\nimport { type RunEvalConfig } from \"./config.js\";\nexport type ChainOrFactory = Runnable | (() => Runnable) | AnyTraceableFunction\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | ((obj: any) => any)\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | ((obj: any) => Promise<any>) | (() => (obj: unknown) => unknown) | (() => (obj: unknown) => Promise<unknown>);\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AnyTraceableFunction = TraceableFunction<(...any: any[]) => any>;\nexport interface RunOnDatasetParams extends Omit<RunEvalConfig, \"customEvaluators\"> {\n    /**\n     * Name of the project for logging and tracking.\n     */\n    projectName?: string;\n    /**\n     * Additional metadata for the project.\n     */\n    projectMetadata?: Record<string, unknown>;\n    /**\n     * Client instance for LangSmith service interaction.\n     */\n    client?: Client;\n    /**\n     * Maximum concurrency level for dataset processing.\n     */\n    maxConcurrency?: number;\n    /**\n     * @deprecated Pass keys directly to the RunOnDatasetParams instead\n     */\n    evaluationConfig?: RunEvalConfig;\n}\nexport type EvalResults = {\n    projectName: string;\n    results: {\n        [key: string]: {\n            execution_time?: number;\n            run_id: string;\n            feedback: Feedback[];\n        };\n    };\n};\n/**\n * Evaluates a given model or chain against a specified LangSmith dataset.\n *\n * This function fetches example records from the specified dataset,\n * runs the model or chain against each example, and returns the evaluation\n * results.\n *\n * @param chainOrFactory - A model or factory/constructor function to be evaluated. It can be a\n * Runnable instance, a factory function that returns a Runnable, or a user-defined\n * function or factory.\n *\n * @param datasetName - The name of the dataset against which the evaluation will be\n * performed. This dataset should already be defined and contain the relevant data\n * for evaluation.\n *\n * @param options - (Optional) Additional parameters for the evaluation process:\n *   - `evaluators` (RunEvalType[]): Evaluators to apply to a dataset run.\n *   - `formatEvaluatorInputs` (EvaluatorInputFormatter): Convert the evaluation data into formats that can be used by the evaluator.\n *   - `projectName` (string): Name of the project for logging and tracking.\n *   - `projectMetadata` (Record<string, unknown>): Additional metadata for the project.\n *   - `client` (Client): Client instance for LangSmith service interaction.\n *   - `maxConcurrency` (number): Maximum concurrency level for dataset processing.\n *\n * @returns A promise that resolves to an `EvalResults` object. This object includes\n * detailed results of the evaluation, such as execution time, run IDs, and feedback\n * for each entry in the dataset.\n *\n * @example\n * ```typescript\n * // Example usage for evaluating a model on a dataset\n * async function evaluateModel() {\n *   const chain = /* ...create your model or chain...*\\//\n *   const datasetName = 'example-dataset';\n *   const client = new Client(/* ...config... *\\//);\n *\n *   const results = await runOnDataset(chain, datasetName, {\n *     evaluators: [/* ...evaluators... *\\//],\n *     client,\n *   });\n *\n *   console.log('Evaluation Results:', results);\n * }\n *\n * evaluateModel();\n * ```\n * In this example, `runOnDataset` is used to evaluate a language model (or a chain of models) against\n * a dataset named 'example-dataset'. The evaluation process is configured using `RunOnDatasetParams[\"evaluators\"]`, which can\n * include both standard and custom evaluators. The `Client` instance is used to interact with LangChain services.\n * The function returns the evaluation results, which can be logged or further processed as needed.\n */\nexport declare function runOnDataset(chainOrFactory: ChainOrFactory, datasetName: string, options?: RunOnDatasetParams): Promise<EvalResults>;\nexport {};\n"],"mappings":";;;;;;KAIYK,cAAAA,GAAiBL,kBAAkBA,YAAYM;;EAA3D,CAAYD,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAc;;EAAA,CAAA,CAAA,GAAGL,EAAAA,GAAAA,EAAAA,GAIXO,OAJWP,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,GAAAA,GAAAA,CAAAA,GAAAA,EAAAA,OAAAA,EAAAA,GAAAA,OAAAA,CAAAA,GAAAA,CAAAA,GAAAA,GAAAA,CAAAA,GAAAA,EAAAA,OAAAA,EAAAA,GAIkEO,OAJlEP,CAAAA,OAAAA,CAAAA,CAAAA;;KAMxBM,oBAAAA,GAAuBH,iBAN+BG,CAAAA,CAAAA,GAAAA,GAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,CAAAA;AAIzCC,UAGDC,kBAAAA,SAA2BE,IAH1BH,CAG+BH,aAH/BG,EAAAA,kBAAAA,CAAAA,CAAAA;EAAO;AAA6E;AAAW;EAGhGC,WAAAA,CAAAA,EAAAA,MAAAA;EAAkB;;;EAQP,eAIfP,CAAAA,EAJSQ,MAITR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAM;;AAZ6B;EAsBpCU,MAAAA,CAAAA,EAVCV,MAUU;EA4DCW;;;EAA2C,cAAiCJ,CAAAA,EAAAA,MAAAA;EAAkB;;AAAU;qBA9DzGJ;;KAEXO,WAAAA;;;;;;gBAMUT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDEU,YAAAA,iBAA6BP,+CAA+CG,qBAAqBD,QAAQI"}

package/dist/smith/runner_utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runner_utils.d.ts","names":["Runnable","Client","Feedback","TraceableFunction","RunEvalConfig","ChainOrFactory","AnyTraceableFunction","Promise","RunOnDatasetParams","Record","Omit","EvalResults","runOnDataset"],"sources":["../../src/smith/runner_utils.d.ts"],"sourcesContent":["import { Runnable } from \"@langchain/core/runnables\";\nimport { Client, Feedback } from \"langsmith\";\nimport type { TraceableFunction } from \"langsmith/singletons/traceable\";\nimport { type RunEvalConfig } from \"./config.js\";\nexport type ChainOrFactory = Runnable | (() => Runnable) | AnyTraceableFunction\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | ((obj: any) => any)\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n | ((obj: any) => Promise<any>) | (() => (obj: unknown) => unknown) | (() => (obj: unknown) => Promise<unknown>);\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AnyTraceableFunction = TraceableFunction<(...any: any[]) => any>;\nexport interface RunOnDatasetParams extends Omit<RunEvalConfig, \"customEvaluators\"> {\n    /**\n     * Name of the project for logging and tracking.\n     */\n    projectName?: string;\n    /**\n     * Additional metadata for the project.\n     */\n    projectMetadata?: Record<string, unknown>;\n    /**\n     * Client instance for LangSmith service interaction.\n     */\n    client?: Client;\n    /**\n     * Maximum concurrency level for dataset processing.\n     */\n    maxConcurrency?: number;\n    /**\n     * @deprecated Pass keys directly to the RunOnDatasetParams instead\n     */\n    evaluationConfig?: RunEvalConfig;\n}\nexport type EvalResults = {\n    projectName: string;\n    results: {\n        [key: string]: {\n            execution_time?: number;\n            run_id: string;\n            feedback: Feedback[];\n        };\n    };\n};\n/**\n * Evaluates a given model or chain against a specified LangSmith dataset.\n *\n * This function fetches example records from the specified dataset,\n * runs the model or chain against each example, and returns the evaluation\n * results.\n *\n * @param chainOrFactory - A model or factory/constructor function to be evaluated. It can be a\n * Runnable instance, a factory function that returns a Runnable, or a user-defined\n * function or factory.\n *\n * @param datasetName - The name of the dataset against which the evaluation will be\n * performed. This dataset should already be defined and contain the relevant data\n * for evaluation.\n *\n * @param options - (Optional) Additional parameters for the evaluation process:\n *   - `evaluators` (RunEvalType[]): Evaluators to apply to a dataset run.\n *   - `formatEvaluatorInputs` (EvaluatorInputFormatter): Convert the evaluation data into formats that can be used by the evaluator.\n *   - `projectName` (string): Name of the project for logging and tracking.\n *   - `projectMetadata` (Record<string, unknown>): Additional metadata for the project.\n *   - `client` (Client): Client instance for LangSmith service interaction.\n *   - `maxConcurrency` (number): Maximum concurrency level for dataset processing.\n *\n * @returns A promise that resolves to an `EvalResults` object. This object includes\n * detailed results of the evaluation, such as execution time, run IDs, and feedback\n * for each entry in the dataset.\n *\n * @example\n * ```typescript\n * // Example usage for evaluating a model on a dataset\n * async function evaluateModel() {\n *   const chain = /* ...create your model or chain...*\\//\n *   const datasetName = 'example-dataset';\n *   const client = new Client(/* ...config... *\\//);\n *\n *   const results = await runOnDataset(chain, datasetName, {\n *     evaluators: [/* ...evaluators... *\\//],\n *     client,\n *   });\n *\n *   console.log('Evaluation Results:', results);\n * }\n *\n * evaluateModel();\n * ```\n * In this example, `runOnDataset` is used to evaluate a language model (or a chain of models) against\n * a dataset named 'example-dataset'. The evaluation process is configured using `RunOnDatasetParams[\"evaluators\"]`, which can\n * include both standard and custom evaluators. The `Client` instance is used to interact with LangChain services.\n * The function returns the evaluation results, which can be logged or further processed as needed.\n */\nexport declare function runOnDataset(chainOrFactory: ChainOrFactory, datasetName: string, options?: RunOnDatasetParams): Promise<EvalResults>;\nexport {};\n"],"mappings":";;;;;;KAIYK,cAAAA,GAAiBL,kBAAkBA,YAAYM;;EAA3D,CAAYD,CAAAA,GAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAc;;EAAA,CAAA,CAAA,GAAGL,EAAAA,GAAAA,EAAAA,GAIXO,OAJWP,CAAAA,GAAAA,CAAAA,CAAAA,GAAAA,CAAAA,GAAAA,GAAAA,CAAAA,GAAAA,EAAAA,OAAAA,EAAAA,GAAAA,OAAAA,CAAAA,GAAAA,CAAAA,GAAAA,GAAAA,CAAAA,GAAAA,EAAAA,OAAAA,EAAAA,GAIkEO,OAJlEP,CAAAA,OAAAA,CAAAA,CAAAA;;KAMxBM,oBAAAA,GAAuBH,iBAN+BG,CAAAA,CAAAA,GAAAA,GAAAA,EAAAA,GAAAA,EAAAA,EAAAA,GAAAA,GAAAA,CAAAA;AAIzCC,UAGDC,kBAAAA,SAA2BE,IAH1BH,CAG+BH,aAH/BG,EAAAA,kBAAAA,CAAAA,CAAAA;EAAO;AAA6E;AAAW;EAGhGC,WAAAA,CAAAA,EAAAA,MAAAA;EAAkB;;;EAQP,eAIfP,CAAAA,EAJSQ,MAITR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;EAAM;;AAZ6B;EAsBpCU,MAAAA,CAAAA,EAVCV,MAUU;EA4DCW;;;EAA2C,cAAiCJ,CAAAA,EAAAA,MAAAA;EAAkB;;AAAU;qBA9DzGJ;;KAEXO,WAAAA;;;;;;gBAMUT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDEU,YAAAA,iBAA6BP,+CAA+CG,qBAAqBD,QAAQI"}

package/dist/sql_db.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql_db.d.cts","names":["DataSource","DataSourceT","DataSourceOptions","Serializable","SerializedSqlDatabase","SqlDatabaseDataSourceParams","SqlDatabaseOptionsParams","SqlTable","SqlDatabase","_langchain_core_load_serializable0","SerializedNotImplemented","Array","Record","Promise"],"sources":["../src/sql_db.d.ts"],"sourcesContent":["import type { DataSource as DataSourceT, DataSourceOptions } from \"typeorm\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from \"./util/sql_utils.js\";\nexport type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };\n/**\n * Class that represents a SQL database in the LangChain framework.\n *\n * @security **Security Notice**\n * This class generates SQL queries for the given database.\n * The SQLDatabase class provides a getTableInfo method that can be used\n * to get column information as well as sample data from the table.\n * To mitigate risk of leaking sensitive data, limit permissions\n * to read and scope to the tables that are needed.\n * Optionally, use the includesTables or ignoreTables class parameters\n * to limit which tables can/cannot be accessed.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {\n    lc_namespace: string[];\n    toJSON(): import(\"@langchain/core/load/serializable\").SerializedNotImplemented;\n    appDataSourceOptions: DataSourceOptions;\n    appDataSource: DataSourceT;\n    allTables: Array<SqlTable>;\n    includesTables: Array<string>;\n    ignoreTables: Array<string>;\n    sampleRowsInTableInfo: number;\n    customDescription?: Record<string, string>;\n    protected constructor(fields: SqlDatabaseDataSourceParams);\n    static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;\n    static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;\n    /**\n     * Get information about specified tables.\n     *\n     * Follows best practices as specified in: Rajkumar et al, 2022\n     * (https://arxiv.org/abs/2204.00498)\n     *\n     * If `sample_rows_in_table_info`, the specified number of sample rows will be\n     * appended to each table description. This can increase performance as\n     * demonstrated in the paper.\n     */\n    getTableInfo(targetTables?: Array<string>): Promise<string>;\n    /**\n     * Execute a SQL command and return a string representing the results.\n     * If the statement returns rows, a string of the results is returned.\n     * If the statement returns no rows, an empty string is returned.\n     */\n    run(command: string, fetch?: \"all\" | \"one\"): Promise<string>;\n    serialize(): SerializedSqlDatabase;\n    /** @ignore */\n    static imports(): Promise<{\n        DataSource: typeof DataSourceT;\n    }>;\n}\n"],"mappings":";;;;;;;;;AAkBA;;;;;;;;;;;;AAW8EQ,cAXzDA,WAAAA,SAAoBL,YAAAA,YAAwBG,wBAWaE,EAXaH,2BAWbG,CAAAA;EAAW,YAAnBK,EAAAA,MAAAA,EAAAA;EAAO,MACxCP,CAAAA,CAAAA,EAZLG,kCAAAA,CAE0BC,wBAUrBJ;EAAwB,oBAAWE,EAT9CN,iBAS8CM;EAAW,aAAnBK,EAR7CZ,UAQ6CY;EAAO,SAWvCF,EAlBjBA,KAkBiBA,CAlBXJ,QAkBWI,CAAAA;EAAK,cAAWE,EAjB5BF,KAiB4BE,CAAAA,MAAAA,CAAAA;EAAO,YAMNA,EAtB/BF,KAsB+BE,CAAAA,MAAAA,CAAAA;EAAO,qBACvCT,EAAAA,MAAAA;EAAqB,iBAGXH,CAAAA,EAxBHW,MAwBGX,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAW,UADhBY,WAAAA,CAAAA,MAAAA,EAtBYR,2BAsBZQ;EAAO,OAhCYV,oBAAAA,CAAAA,MAAAA,EAWDE,2BAXCF,CAAAA,EAW6BU,OAX7BV,CAWqCK,WAXrCL,CAAAA;EAAY,OAAYG,iBAAAA,CAAAA,MAAAA,EAY5BA,wBAZ4BA,CAAAA,EAYDO,OAZCP,CAYOE,WAZPF,CAAAA;EAAwB;AAA6B;;;;;;;;;8BAuBtFK,gBAAgBE;;;;;;+CAMCA;eAChCT;;oBAEKS;uBACKZ"}

package/dist/sql_db.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql_db.d.ts","names":["DataSource","DataSourceT","DataSourceOptions","Serializable","SerializedSqlDatabase","SqlDatabaseDataSourceParams","SqlDatabaseOptionsParams","SqlTable","SqlDatabase","_langchain_core_load_serializable0","SerializedNotImplemented","Array","Record","Promise"],"sources":["../src/sql_db.d.ts"],"sourcesContent":["import type { DataSource as DataSourceT, DataSourceOptions } from \"typeorm\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from \"./util/sql_utils.js\";\nexport type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };\n/**\n * Class that represents a SQL database in the LangChain framework.\n *\n * @security **Security Notice**\n * This class generates SQL queries for the given database.\n * The SQLDatabase class provides a getTableInfo method that can be used\n * to get column information as well as sample data from the table.\n * To mitigate risk of leaking sensitive data, limit permissions\n * to read and scope to the tables that are needed.\n * Optionally, use the includesTables or ignoreTables class parameters\n * to limit which tables can/cannot be accessed.\n *\n * @link See https://js.langchain.com/docs/security for more information.\n */\nexport declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {\n    lc_namespace: string[];\n    toJSON(): import(\"@langchain/core/load/serializable\").SerializedNotImplemented;\n    appDataSourceOptions: DataSourceOptions;\n    appDataSource: DataSourceT;\n    allTables: Array<SqlTable>;\n    includesTables: Array<string>;\n    ignoreTables: Array<string>;\n    sampleRowsInTableInfo: number;\n    customDescription?: Record<string, string>;\n    protected constructor(fields: SqlDatabaseDataSourceParams);\n    static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;\n    static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;\n    /**\n     * Get information about specified tables.\n     *\n     * Follows best practices as specified in: Rajkumar et al, 2022\n     * (https://arxiv.org/abs/2204.00498)\n     *\n     * If `sample_rows_in_table_info`, the specified number of sample rows will be\n     * appended to each table description. This can increase performance as\n     * demonstrated in the paper.\n     */\n    getTableInfo(targetTables?: Array<string>): Promise<string>;\n    /**\n     * Execute a SQL command and return a string representing the results.\n     * If the statement returns rows, a string of the results is returned.\n     * If the statement returns no rows, an empty string is returned.\n     */\n    run(command: string, fetch?: \"all\" | \"one\"): Promise<string>;\n    serialize(): SerializedSqlDatabase;\n    /** @ignore */\n    static imports(): Promise<{\n        DataSource: typeof DataSourceT;\n    }>;\n}\n"],"mappings":";;;;;;;;;AAkBA;;;;;;;;;;;;AAW8EQ,cAXzDA,WAAAA,SAAoBL,YAAAA,YAAwBG,wBAWaE,EAXaH,2BAWbG,CAAAA;EAAW,YAAnBK,EAAAA,MAAAA,EAAAA;EAAO,MACxCP,CAAAA,CAAAA,EAZLG,kCAAAA,CAE0BC,wBAUrBJ;EAAwB,oBAAWE,EAT9CN,iBAS8CM;EAAW,aAAnBK,EAR7CZ,UAQ6CY;EAAO,SAWvCF,EAlBjBA,KAkBiBA,CAlBXJ,QAkBWI,CAAAA;EAAK,cAAWE,EAjB5BF,KAiB4BE,CAAAA,MAAAA,CAAAA;EAAO,YAMNA,EAtB/BF,KAsB+BE,CAAAA,MAAAA,CAAAA;EAAO,qBACvCT,EAAAA,MAAAA;EAAqB,iBAGXH,CAAAA,EAxBHW,MAwBGX,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAW,UADhBY,WAAAA,CAAAA,MAAAA,EAtBYR,2BAsBZQ;EAAO,OAhCYV,oBAAAA,CAAAA,MAAAA,EAWDE,2BAXCF,CAAAA,EAW6BU,OAX7BV,CAWqCK,WAXrCL,CAAAA;EAAY,OAAYG,iBAAAA,CAAAA,MAAAA,EAY5BA,wBAZ4BA,CAAAA,EAYDO,OAZCP,CAYOE,WAZPF,CAAAA;EAAwB;AAA6B;;;;;;;;;8BAuBtFK,gBAAgBE;;;;;;+CAMCA;eAChCT;;oBAEKS;uBACKZ"}

package/dist/storage/encoder_backed.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoder_backed.d.cts","names":["Document","BaseStore","EncoderBackedStore","K","V","SerializedType","Promise","AsyncGenerator","createDocumentStoreFromByteStore","Uint8Array","Record","ArrayBufferLike"],"sources":["../../src/storage/encoder_backed.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {\n    lc_namespace: string[];\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n    constructor(fields: {\n        store: BaseStore<string, SerializedType>;\n        keyEncoder: (key: K) => string;\n        valueSerializer: (value: V) => SerializedType;\n        valueDeserializer: (value: SerializedType) => V;\n    });\n    /**\n     * Method to get multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keys Array of keys to get\n     * @returns Promise that resolves with an array of values or undefined for each key\n     */\n    mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Method to set multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keyValuePairs Array of key-value pairs to set\n     * @returns Promise that resolves when the operation is complete\n     */\n    mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Method to delete multiple keys at once. It works with the encoded keys.\n     * @param keys Array of keys to delete\n     * @returns Promise that resolves when the operation is complete\n     */\n    mdelete(keys: K[]): Promise<void>;\n    /**\n     * Method to yield keys. It works with the encoded keys.\n     * @param prefix Optional prefix to filter keys\n     * @returns AsyncGenerator that yields keys\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;\n}\nexport declare function createDocumentStoreFromByteStore(store: BaseStore<string, Uint8Array>): EncoderBackedStore<string, Document<Record<string, any>>, Uint8Array<ArrayBufferLike>>;\n"],"mappings":";;;;;;;AAQA;;;;AAE6BK,cAFRH,kBAEQG,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,iBAAAA,GAAAA,CAAAA,SAF+CJ,SAE/CI,CAFyDF,CAEzDE,EAF4DD,CAE5DC,CAAAA,CAAAA;EAAc,YAAhCJ,EAAAA,MAAAA,EAAAA;EAAS,KACEE,EADXF,SACWE,CAAAA,MAAAA,EADOE,cACPF,CAAAA;EAAC,UACMC,EAAAA,CAAAA,GAAAA,EADPD,CACOC,EAAAA,GAAAA,MAAAA;EAAC,eAAKC,EAAAA,CAAAA,KAAAA,EAAND,CAAMC,EAAAA,GAAAA,cAAAA;EAAc,iBAClBA,EAAAA,CAAAA,KAAAA,EAAAA,cAAAA,EAAAA,GAAmBD,CAAnBC;EAAc,WAAKD,CAAAA,MAAAA,EAAAA;IAEjBC,KAAAA,EAAlBJ,SAAkBI,CAAAA,MAAAA,EAAAA,cAAAA,CAAAA;IAAlBJ,UAAAA,EAAAA,CAAAA,GAAAA,EACWE,CADXF,EAAAA,GAAAA,MAAAA;IACWE,eAAAA,EAAAA,CAAAA,KAAAA,EACOC,CADPD,EAAAA,GACaE,cADbF;IACOC,iBAAAA,EAAAA,CAAAA,KAAAA,EACEC,cADFD,EAAAA,GACqBA,CADrBA;EAAC,CAAA;EAAmB;;;;;;EAgB3B,IAAEA,CAAAA,IAAAA,EAPbD,CAOaC,EAAAA,CAAAA,EAPPE,OAOOF,CAAAA,CAPEA,CAOFA,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAC;;;;;;EAzBwD,IAAA,CAAA,aAAA,EAAA,CAyB5DD,CAzB4D,EAyBzDC,CAzByD,CAAA,EAAA,CAAA,EAyBlDE,OAzBkD,CAAA,IAAA,CAAA;EAuC7DE;;;;;EAAkH,OAAfR,CAAAA,IAAAA,EARzGG,CAQyGH,EAAAA,CAAAA,EARnGM,OAQmGN,CAAAA,IAAAA,CAAAA;EAAQ;;;AAAjB;;0CAFtEO,wBAAwBJ;;iBAE5CK,gCAAAA,QAAwCP,kBAAkBQ,cAAcP,2BAA2BF,SAASU,sBAAsBD,WAAWE"}

package/dist/storage/encoder_backed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encoder_backed.d.ts","names":["Document","BaseStore","EncoderBackedStore","K","V","SerializedType","Promise","AsyncGenerator","createDocumentStoreFromByteStore","Uint8Array","Record","ArrayBufferLike"],"sources":["../../src/storage/encoder_backed.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {\n    lc_namespace: string[];\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n    constructor(fields: {\n        store: BaseStore<string, SerializedType>;\n        keyEncoder: (key: K) => string;\n        valueSerializer: (value: V) => SerializedType;\n        valueDeserializer: (value: SerializedType) => V;\n    });\n    /**\n     * Method to get multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keys Array of keys to get\n     * @returns Promise that resolves with an array of values or undefined for each key\n     */\n    mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Method to set multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keyValuePairs Array of key-value pairs to set\n     * @returns Promise that resolves when the operation is complete\n     */\n    mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Method to delete multiple keys at once. It works with the encoded keys.\n     * @param keys Array of keys to delete\n     * @returns Promise that resolves when the operation is complete\n     */\n    mdelete(keys: K[]): Promise<void>;\n    /**\n     * Method to yield keys. It works with the encoded keys.\n     * @param prefix Optional prefix to filter keys\n     * @returns AsyncGenerator that yields keys\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;\n}\nexport declare function createDocumentStoreFromByteStore(store: BaseStore<string, Uint8Array>): EncoderBackedStore<string, Document<Record<string, any>>, Uint8Array<ArrayBufferLike>>;\n"],"mappings":";;;;;;;AAQA;;;;AAE6BK,cAFRH,kBAEQG,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,iBAAAA,GAAAA,CAAAA,SAF+CJ,SAE/CI,CAFyDF,CAEzDE,EAF4DD,CAE5DC,CAAAA,CAAAA;EAAc,YAAhCJ,EAAAA,MAAAA,EAAAA;EAAS,KACEE,EADXF,SACWE,CAAAA,MAAAA,EADOE,cACPF,CAAAA;EAAC,UACMC,EAAAA,CAAAA,GAAAA,EADPD,CACOC,EAAAA,GAAAA,MAAAA;EAAC,eAAKC,EAAAA,CAAAA,KAAAA,EAAND,CAAMC,EAAAA,GAAAA,cAAAA;EAAc,iBAClBA,EAAAA,CAAAA,KAAAA,EAAAA,cAAAA,EAAAA,GAAmBD,CAAnBC;EAAc,WAAKD,CAAAA,MAAAA,EAAAA;IAEjBC,KAAAA,EAAlBJ,SAAkBI,CAAAA,MAAAA,EAAAA,cAAAA,CAAAA;IAAlBJ,UAAAA,EAAAA,CAAAA,GAAAA,EACWE,CADXF,EAAAA,GAAAA,MAAAA;IACWE,eAAAA,EAAAA,CAAAA,KAAAA,EACOC,CADPD,EAAAA,GACaE,cADbF;IACOC,iBAAAA,EAAAA,CAAAA,KAAAA,EACEC,cADFD,EAAAA,GACqBA,CADrBA;EAAC,CAAA;EAAmB;;;;;;EAgB3B,IAAEA,CAAAA,IAAAA,EAPbD,CAOaC,EAAAA,CAAAA,EAPPE,OAOOF,CAAAA,CAPEA,CAOFA,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAC;;;;;;EAzBwD,IAAA,CAAA,aAAA,EAAA,CAyB5DD,CAzB4D,EAyBzDC,CAzByD,CAAA,EAAA,CAAA,EAyBlDE,OAzBkD,CAAA,IAAA,CAAA;EAuC7DE;;;;;EAAkH,OAAfR,CAAAA,IAAAA,EARzGG,CAQyGH,EAAAA,CAAAA,EARnGM,OAQmGN,CAAAA,IAAAA,CAAAA;EAAQ;;;AAAjB;;0CAFtEO,wBAAwBJ;;iBAE5CK,gCAAAA,QAAwCP,kBAAkBQ,cAAcP,2BAA2BF,SAASU,sBAAsBD,WAAWE"}

package/dist/storage/file_system.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file_system.d.cts","names":["BaseStore","LocalFileStore","Uint8Array","ArrayBufferLike","Promise","AsyncGenerator"],"sources":["../../src/storage/file_system.d.ts"],"sourcesContent":["import { BaseStore } from \"@langchain/core/stores\";\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport declare class LocalFileStore extends BaseStore<string, Uint8Array> {\n    lc_namespace: string[];\n    rootPath: string;\n    constructor(fields: {\n        rootPath: string;\n    });\n    private getParsedFile;\n    private setFileContent;\n    /**\n     * Returns the full path of the file where the value of the given key is stored.\n     * @param key the key to get the full path for\n     */\n    private getFullPath;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<(Uint8Array<ArrayBufferLike> | undefined)[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, Uint8Array][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string): AsyncGenerator<string>;\n    /**\n     * Static method for initializing the class.\n     * Preforms a check to see if the directory exists, and if not, creates it.\n     * @param path Path to the directory.\n     * @returns Promise that resolves to an instance of the class.\n     */\n    static fromPath(rootPath: string): Promise<LocalFileStore>;\n}\n"],"mappings":";;;;;;AA+BA;;;;;;;;;;;;;AAAqD;;;;;;;;;;;;;;;cAAhCC,cAAAA,SAAuBD,kBAAkBE;;;;;;;;;;;;;;;;;;wBAkBpCE,SAASF,WAAWC;;;;;;+BAMbD,gBAAgBE;;;;;;2BAMpBA;;;;;;;8BAOGC;;;;;;;qCAOOD,QAAQH"}

package/dist/storage/file_system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file_system.d.ts","names":["BaseStore","LocalFileStore","Uint8Array","ArrayBufferLike","Promise","AsyncGenerator"],"sources":["../../src/storage/file_system.d.ts"],"sourcesContent":["import { BaseStore } from \"@langchain/core/stores\";\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport declare class LocalFileStore extends BaseStore<string, Uint8Array> {\n    lc_namespace: string[];\n    rootPath: string;\n    constructor(fields: {\n        rootPath: string;\n    });\n    private getParsedFile;\n    private setFileContent;\n    /**\n     * Returns the full path of the file where the value of the given key is stored.\n     * @param key the key to get the full path for\n     */\n    private getFullPath;\n    /**\n     * Retrieves the values associated with the given keys from the store.\n     * @param keys Keys to retrieve values for.\n     * @returns Array of values associated with the given keys.\n     */\n    mget(keys: string[]): Promise<(Uint8Array<ArrayBufferLike> | undefined)[]>;\n    /**\n     * Sets the values for the given keys in the store.\n     * @param keyValuePairs Array of key-value pairs to set in the store.\n     * @returns Promise that resolves when all key-value pairs have been set.\n     */\n    mset(keyValuePairs: [string, Uint8Array][]): Promise<void>;\n    /**\n     * Deletes the given keys and their associated values from the store.\n     * @param keys Keys to delete from the store.\n     * @returns Promise that resolves when all keys have been deleted.\n     */\n    mdelete(keys: string[]): Promise<void>;\n    /**\n     * Asynchronous generator that yields keys from the store. If a prefix is\n     * provided, it only yields keys that start with the prefix.\n     * @param prefix Optional prefix to filter keys.\n     * @returns AsyncGenerator that yields keys from the store.\n     */\n    yieldKeys(prefix?: string): AsyncGenerator<string>;\n    /**\n     * Static method for initializing the class.\n     * Preforms a check to see if the directory exists, and if not, creates it.\n     * @param path Path to the directory.\n     * @returns Promise that resolves to an instance of the class.\n     */\n    static fromPath(rootPath: string): Promise<LocalFileStore>;\n}\n"],"mappings":";;;;;;AA+BA;;;;;;;;;;;;;AAAqD;;;;;;;;;;;;;;;cAAhCC,cAAAA,SAAuBD,kBAAkBE;;;;;;;;;;;;;;;;;;wBAkBpCE,SAASF,WAAWC;;;;;;+BAMbD,gBAAgBE;;;;;;2BAMpBA;;;;;;;8BAOGC;;;;;;;qCAOOD,QAAQH"}

package/dist/stores/doc/base.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["Document","Docstore","Promise","Record"],"sources":["../../../src/stores/doc/base.d.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport declare abstract class Docstore {\n    abstract search(search: string): Promise<Document>;\n    abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;AAKA;;AAC6CA,uBADfC,QAAAA,CACeD;EAAQ,SAAhBE,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA,CAAQF,QAARE,CAAAA;EAAO,SACLF,GAAAA,CAAAA,KAAAA,EAAfG,MAAeH,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA,EAAYE,OAAZF,CAAAA,IAAAA,CAAAA"}

package/dist/stores/doc/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["Document","Docstore","Promise","Record"],"sources":["../../../src/stores/doc/base.d.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport declare abstract class Docstore {\n    abstract search(search: string): Promise<Document>;\n    abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;AAKA;;AAC6CA,uBADfC,QAAAA,CACeD;EAAQ,SAAhBE,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EAAAA,OAAAA,CAAQF,QAARE,CAAAA;EAAO,SACLF,GAAAA,CAAAA,KAAAA,EAAfG,MAAeH,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA,EAAYE,OAAZF,CAAAA,IAAAA,CAAAA"}

package/dist/stores/doc/in_memory.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"in_memory.d.cts","names":["Document","BaseStoreInterface","Docstore","InMemoryDocstore","Map","Promise","Record","AsyncGenerator","SynchronousInMemoryDocstore"],"sources":["../../../src/stores/doc/in_memory.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<string, Document> {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Promise<Document>;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): Promise<void>;\n    mget(keys: string[]): Promise<Document[]>;\n    mset(keyValuePairs: [string, Document][]): Promise<void>;\n    mdelete(_keys: string[]): Promise<void>;\n    // eslint-disable-next-line require-yield\n    yieldKeys(_prefix?: string): AsyncGenerator<string>;\n}\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport declare class SynchronousInMemoryDocstore {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Document;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): void;\n}\n"],"mappings":";;;;;;;;AAOA;;AAA6FA,cAAxEG,gBAAAA,SAAyBD,QAAAA,YAAoBD,kBAA2BD,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA;EAAQ,KAC9EA,EAAZI,GAAYJ,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA;EAAQ,WAApBI,CAAAA,IAAAA,CAAAA,EACYA,GADZA,CAAAA,MAAAA,EACwBJ,QADxBI,CAAAA;EAAG;;;;;EAawB,MAAvBE,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANaD,OAMbC,CANqBN,QAMrBM,CAAAA;EAAM;;;;;EAEiC,GACxBD,CAAAA,KAAAA,EAHfC,MAGeD,CAAAA,MAAAA,EAHAL,QAGAK,CAAAA,CAAAA,EAHYA,OAGZA,CAAAA,IAAAA,CAAAA;EAAO,IAEJE,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAJPF,OAIOE,CAJCP,QAIDO,EAAAA,CAAAA;EAAc,IAnBDL,CAAAA,aAAAA,EAAAA,CAAAA,MAAAA,EAgBbF,QAhBaE,CAAAA,EAAAA,CAAAA,EAgBCG,OAhBDH,CAAAA,IAAAA,CAAAA;EAAQ,OAAYD,CAAAA,KAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAiBpCI,OAjBoCJ,CAAAA,IAAAA,CAAAA;EAAkB;EAwB/DO,SAAAA,CAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EALYD,cAKe,CAAA,MAAA,CAAA;;;;;AAEzBH,cAFFI,2BAAAA,CAEEJ;EAAG,KAMEJ,EAPjBI,GAOiBJ,CAAAA,MAAAA,EAPLA,QAOKA,CAAAA;EAAQ,WAMNA,CAAAA,IAAAA,CAAAA,EAZPI,GAYOJ,CAAAA,MAAAA,EAZKA,QAYLA,CAAAA;EAAQ;AAAjB;;;;0BANOA;;;;;;aAMbM,eAAeN"}

package/dist/stores/doc/in_memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"in_memory.d.ts","names":["Document","BaseStoreInterface","Docstore","InMemoryDocstore","Map","Promise","Record","AsyncGenerator","SynchronousInMemoryDocstore"],"sources":["../../../src/stores/doc/in_memory.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<string, Document> {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Promise<Document>;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): Promise<void>;\n    mget(keys: string[]): Promise<Document[]>;\n    mset(keyValuePairs: [string, Document][]): Promise<void>;\n    mdelete(_keys: string[]): Promise<void>;\n    // eslint-disable-next-line require-yield\n    yieldKeys(_prefix?: string): AsyncGenerator<string>;\n}\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport declare class SynchronousInMemoryDocstore {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Document;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): void;\n}\n"],"mappings":";;;;;;;;AAOA;;AAA6FA,cAAxEG,gBAAAA,SAAyBD,QAAAA,YAAoBD,kBAA2BD,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA,CAAAA;EAAQ,KAC9EA,EAAZI,GAAYJ,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA;EAAQ,WAApBI,CAAAA,IAAAA,CAAAA,EACYA,GADZA,CAAAA,MAAAA,EACwBJ,QADxBI,CAAAA;EAAG;;;;;EAawB,MAAvBE,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANaD,OAMbC,CANqBN,QAMrBM,CAAAA;EAAM;;;;;EAEiC,GACxBD,CAAAA,KAAAA,EAHfC,MAGeD,CAAAA,MAAAA,EAHAL,QAGAK,CAAAA,CAAAA,EAHYA,OAGZA,CAAAA,IAAAA,CAAAA;EAAO,IAEJE,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAJPF,OAIOE,CAJCP,QAIDO,EAAAA,CAAAA;EAAc,IAnBDL,CAAAA,aAAAA,EAAAA,CAAAA,MAAAA,EAgBbF,QAhBaE,CAAAA,EAAAA,CAAAA,EAgBCG,OAhBDH,CAAAA,IAAAA,CAAAA;EAAQ,OAAYD,CAAAA,KAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAiBpCI,OAjBoCJ,CAAAA,IAAAA,CAAAA;EAAkB;EAwB/DO,SAAAA,CAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EALYD,cAKe,CAAA,MAAA,CAAA;;;;;AAEzBH,cAFFI,2BAAAA,CAEEJ;EAAG,KAMEJ,EAPjBI,GAOiBJ,CAAAA,MAAAA,EAPLA,QAOKA,CAAAA;EAAQ,WAMNA,CAAAA,IAAAA,CAAAA,EAZPI,GAYOJ,CAAAA,MAAAA,EAZKA,QAYLA,CAAAA;EAAQ;AAAjB;;;;0BANOA;;;;;;aAMbM,eAAeN"}

package/dist/stores/file/base.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["Serializable","BaseFileStore","Promise"],"sources":["../../../src/stores/file/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport declare abstract class BaseFileStore extends Serializable {\n    abstract readFile(path: string): Promise<string>;\n    abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAKA;;AACqCE,uBADPD,aAAAA,SAAsBD,YAAAA,CACfE;EAAO,SACYA,QAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EADnBA,OACmBA,CAAAA,MAAAA,CAAAA;EAAO,SAFXF,SAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,CAAAA,EAEIE,OAFJF,CAAAA,IAAAA,CAAAA;AAAY"}

package/dist/stores/file/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","names":["Serializable","BaseFileStore","Promise"],"sources":["../../../src/stores/file/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport declare abstract class BaseFileStore extends Serializable {\n    abstract readFile(path: string): Promise<string>;\n    abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAKA;;AACqCE,uBADPD,aAAAA,SAAsBD,YAAAA,CACfE;EAAO,SACYA,QAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EADnBA,OACmBA,CAAAA,MAAAA,CAAAA;EAAO,SAFXF,SAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,QAAAA,EAAAA,MAAAA,CAAAA,EAEIE,OAFJF,CAAAA,IAAAA,CAAAA;AAAY"}

package/dist/stores/file/in_memory.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"in_memory.d.cts","names":["BaseFileStore","InMemoryFileStore","Promise"],"sources":["../../../src/stores/file/in_memory.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport declare class InMemoryFileStore extends BaseFileStore {\n    lc_namespace: string[];\n    private files;\n    /**\n     * Retrieves the contents of a file given its path. If the file does not\n     * exist, it throws an error.\n     * @param path The path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes contents to a file at a given path. If the file already exists,\n     * it overwrites the existing contents.\n     * @param path The path of the file to write.\n     * @param contents The contents to write to the file.\n     * @returns Void\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAQA;;;;;AAA4D,cAAvCC,iBAAAA,SAA0BD,aAAAA,CAAa;;;;;;;;;0BAShCE;;;;;;;;6CAQmBA"}

package/dist/stores/file/in_memory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"in_memory.d.ts","names":["BaseFileStore","InMemoryFileStore","Promise"],"sources":["../../../src/stores/file/in_memory.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport declare class InMemoryFileStore extends BaseFileStore {\n    lc_namespace: string[];\n    private files;\n    /**\n     * Retrieves the contents of a file given its path. If the file does not\n     * exist, it throws an error.\n     * @param path The path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes contents to a file at a given path. If the file already exists,\n     * it overwrites the existing contents.\n     * @param path The path of the file to write.\n     * @param contents The contents to write to the file.\n     * @returns Void\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAQA;;;;;AAA4D,cAAvCC,iBAAAA,SAA0BD,aAAAA,CAAa;;;;;;;;;0BAShCE;;;;;;;;6CAQmBA"}

package/dist/stores/file/node.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.cts","names":["BaseFileStore","NodeFileStore","Promise"],"sources":["../../../src/stores/file/node.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport declare class NodeFileStore extends BaseFileStore {\n    basePath: string;\n    lc_namespace: string[];\n    constructor(basePath?: string);\n    /**\n     * Reads the contents of a file at the given path.\n     * @param path Path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes the given contents to a file at the specified path.\n     * @param path Path of the file to write to.\n     * @param contents Contents to write to the file.\n     * @returns Promise that resolves when the file has been written.\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAKA;;AAS4BE,cATPD,aAAAA,SAAsBD,aAAAA,CASfE;EAAO,QAOYA,EAAAA,MAAAA;EAAO,YAhBXF,EAAAA,MAAAA,EAAAA;EAAa,WAAA,CAAA,QAAA,CAAA,EAAA,MAAA;;;;;;0BAS5BE;;;;;;;6CAOmBA"}

package/dist/stores/file/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","names":["BaseFileStore","NodeFileStore","Promise"],"sources":["../../../src/stores/file/node.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport declare class NodeFileStore extends BaseFileStore {\n    basePath: string;\n    lc_namespace: string[];\n    constructor(basePath?: string);\n    /**\n     * Reads the contents of a file at the given path.\n     * @param path Path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes the given contents to a file at the specified path.\n     * @param path Path of the file to write to.\n     * @param contents Contents to write to the file.\n     * @returns Promise that resolves when the file has been written.\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAKA;;AAS4BE,cATPD,aAAAA,SAAsBD,aAAAA,CASfE;EAAO,QAOYA,EAAAA,MAAAA;EAAO,YAhBXF,EAAAA,MAAAA,EAAAA;EAAa,WAAA,CAAA,QAAA,CAAA,EAAA,MAAA;;;;;;0BAS5BE;;;;;;;6CAOmBA"}

package/dist/text_splitter.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text_splitter.d.cts","names":[],"sources":["../src/text_splitter.d.ts"],"sourcesContent":["export * from \"@langchain/textsplitters\";\n"],"mappings":""}

package/dist/text_splitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text_splitter.d.ts","names":[],"sources":["../src/text_splitter.d.ts"],"sourcesContent":["export * from \"@langchain/textsplitters\";\n"],"mappings":""}

package/dist/tools/chain.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain.d.cts","names":["DynamicTool","DynamicToolInput","BaseChain","ChainToolInput","Omit","ChainTool","chain"],"sources":["../../src/tools/chain.d.ts"],"sourcesContent":["import { DynamicTool, DynamicToolInput } from \"@langchain/core/tools\";\nimport { BaseChain } from \"../chains/base.js\";\n/**\n * Interface for the input parameters of the ChainTool constructor.\n * Extends the DynamicToolInput interface, replacing the 'func' property\n * with a 'chain' property.\n */\nexport interface ChainToolInput extends Omit<DynamicToolInput, \"func\"> {\n    chain: BaseChain;\n}\n/**\n * Class that extends DynamicTool for creating tools that can run chains.\n * Takes an instance of a class that extends BaseChain as a parameter in\n * its constructor and uses it to run the chain when its 'func' method is\n * called.\n */\nexport declare class ChainTool extends DynamicTool {\n    static lc_name(): string;\n    chain: BaseChain;\n    constructor({ chain, ...rest }: ChainToolInput);\n}\n"],"mappings":";;;;;;;AAOA;;;AACWE,UADMC,cAAAA,SAAuBC,IAC7BF,CADkCD,gBAClCC,EAAAA,MAAAA,CAAAA,CAAAA;EAAS,KADoBE,EAC7BF,SAD6BE;AAAI;AAS5C;;;;;;AAAkD,cAA7BC,SAAAA,SAAkBL,WAAAA,CAAW;;SAEvCE;;;;KACyBC"}

package/dist/tools/chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain.d.ts","names":["DynamicTool","DynamicToolInput","BaseChain","ChainToolInput","Omit","ChainTool","chain"],"sources":["../../src/tools/chain.d.ts"],"sourcesContent":["import { DynamicTool, DynamicToolInput } from \"@langchain/core/tools\";\nimport { BaseChain } from \"../chains/base.js\";\n/**\n * Interface for the input parameters of the ChainTool constructor.\n * Extends the DynamicToolInput interface, replacing the 'func' property\n * with a 'chain' property.\n */\nexport interface ChainToolInput extends Omit<DynamicToolInput, \"func\"> {\n    chain: BaseChain;\n}\n/**\n * Class that extends DynamicTool for creating tools that can run chains.\n * Takes an instance of a class that extends BaseChain as a parameter in\n * its constructor and uses it to run the chain when its 'func' method is\n * called.\n */\nexport declare class ChainTool extends DynamicTool {\n    static lc_name(): string;\n    chain: BaseChain;\n    constructor({ chain, ...rest }: ChainToolInput);\n}\n"],"mappings":";;;;;;;AAOA;;;AACWE,UADMC,cAAAA,SAAuBC,IAC7BF,CADkCD,gBAClCC,EAAAA,MAAAA,CAAAA,CAAAA;EAAS,KADoBE,EAC7BF,SAD6BE;AAAI;AAS5C;;;;;;AAAkD,cAA7BC,SAAAA,SAAkBL,WAAAA,CAAW;;SAEvCE;;;;KACyBC"}

package/dist/tools/fs.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fs.d.cts","names":["z","StructuredTool","ToolParams","InferInteropZodOutput","BaseFileStore","ReadFileParams","readSchema","ZodString","ZodTypeAny","ZodObject","ReadToolSchema","ReadFileTool","store","file_path","Promise","WriteFileParams","writeSchema","WriteToolSchema","WriteFileTool","text"],"sources":["../../src/tools/fs.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { StructuredTool, ToolParams } from \"@langchain/core/tools\";\nimport { InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport { BaseFileStore } from \"../stores/file/base.js\";\n/**\n * Interface for parameters required by the ReadFileTool class.\n */\ninterface ReadFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const readSchema: z.ZodObject<{\n    file_path: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n}, {\n    file_path: string;\n}>;\ntype ReadToolSchema = typeof readSchema;\n/**\n * Class for reading files from the disk. Extends the StructuredTool\n * class.\n */\nexport declare class ReadFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n    }, {\n        file_path: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store }: ReadFileParams);\n    _call({ file_path }: InferInteropZodOutput<ReadToolSchema>): Promise<string>;\n}\n/**\n * Interface for parameters required by the WriteFileTool class.\n */\ninterface WriteFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const writeSchema: z.ZodObject<{\n    file_path: z.ZodString;\n    text: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n    text: string;\n}, {\n    file_path: string;\n    text: string;\n}>;\ntype WriteToolSchema = typeof writeSchema;\n/**\n * Class for writing data to files on the disk. Extends the StructuredTool\n * class.\n */\nexport declare class WriteFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n        text: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n        text: string;\n    }, {\n        file_path: string;\n        text: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store, ...rest }: WriteFileParams);\n    _call({ file_path, text }: InferInteropZodOutput<WriteToolSchema>): Promise<string>;\n}\nexport {};\n"],"mappings":";;;;;;;;;AAGuD;UAI7CK,cAAAA,SAAuBH,UAAT,CAAA;EAAA,KACbE,EAAAA,aAAAA;;AADgC,cAG7BE,UAH6B,EAGjBN,CAAAA,CAAES,SAHe,CAAA;EAG7BH,SAAAA,EACCN,CAAAA,CAAEO,SAKf;CAAA,EAAA,OAAA,EAJUP,CAAAA,CAAEQ,UAIZ,EAAA;EAAA,SALeD,EAAAA,MAAAA;CAAS,EAAA;EACF,SAFIE,EAAAA,MAAAA;AAAS,CAAA,CAAA;AAAA,KAOhCC,cAAAA,GAAc,OAAUJ,UAAAA;AAK7B;;;;AAEYN,cAFSW,YAAAA,SAAqBV,cAAAA,CAE5BQ;EAAS,OASZL,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAa,MACNQ,EAVNZ,CAAAA,CAAES,SAUIG,CAAAA;IAASP,SAAAA,EATRL,CAAAA,CAAEO,SASMF;EAAc,CAAA,EAC7BQ,OAAAA,EATIb,CAAAA,CAAEQ,UASNK,EAAAA;IAAmCH,SAAAA,EAAAA,MAAAA;EAAc,CAAA,EAApCP;IAAwCW,SAAAA,EAAAA,MAAAA;EAAO,CAAA,CAAA;EAbhB,IAAA,EAAA,MAAA;EAkB9CC,WAAAA,EAAAA,MAAe;EAAA,KAAA,EAPdX,aAOc;EAAA,WACdA,CAAAA;IAAAA;EAAAA,CAAAA,EAPgBC,cAOhBD;EAAa,KADUF,CAAAA;IAAAA;EAAAA,CAAAA,EALTC,qBAKSD,CALaQ,cAKbR,CAAAA,CAAAA,EAL+BY,OAK/BZ,CAAAA,MAAAA,CAAAA;AAAU;AAAA;;;UAAlCa,eAAAA,SAAwBb,UAKtBK,CAAAA;EAAS,KACPC,EALHJ,aAKGI;;AAHwB,cAAxBQ,WAAwB,EAAXhB,CAAAA,CAAES,SAAS,CAAA;EAUjCQ,SAAAA,EATUjB,CAAAA,CAAEO,SASG;EAKCW,IAAAA,EAbXlB,CAAAA,CAAEO,SAasB;CAAA,EAAA,OAAA,EAZtBP,CAAAA,CAAEQ,UAYoB,EAAA;EAAA,SAGbD,EAAAA,MAAAA;EAAS,IAChBP,EAAEO,MAAAA;CAAS,EAAA;EACG,SAHdE,EAAAA,MAAAA;EAAS,IAYZL,EAAAA,MAAAA;CAAa,CAAA;KAnBnBa,eAAAA,GAoB+BF,OApBNC,WAoBMD;;;;;AACoCD,cAhBnDI,aAAAA,SAAsBjB,cAAAA,CAgB6Ba;EAAO,OAhBpCb,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,MAAA,EAE7CD,CAAAA,CAAES,SAF2C,CAAA;eAGtCT,CAAAA,CAAEO;UACPP,CAAAA,CAAEO;cACAP,CAAAA,CAAEQ;;;;;;;;;SASPJ;;;;KACyBW;;;;KACLZ,sBAAsBc,mBAAmBH"}

package/dist/tools/fs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fs.d.ts","names":["z","StructuredTool","ToolParams","InferInteropZodOutput","BaseFileStore","ReadFileParams","readSchema","ZodString","ZodTypeAny","ZodObject","ReadToolSchema","ReadFileTool","store","file_path","Promise","WriteFileParams","writeSchema","WriteToolSchema","WriteFileTool","text"],"sources":["../../src/tools/fs.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { StructuredTool, ToolParams } from \"@langchain/core/tools\";\nimport { InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport { BaseFileStore } from \"../stores/file/base.js\";\n/**\n * Interface for parameters required by the ReadFileTool class.\n */\ninterface ReadFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const readSchema: z.ZodObject<{\n    file_path: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n}, {\n    file_path: string;\n}>;\ntype ReadToolSchema = typeof readSchema;\n/**\n * Class for reading files from the disk. Extends the StructuredTool\n * class.\n */\nexport declare class ReadFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n    }, {\n        file_path: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store }: ReadFileParams);\n    _call({ file_path }: InferInteropZodOutput<ReadToolSchema>): Promise<string>;\n}\n/**\n * Interface for parameters required by the WriteFileTool class.\n */\ninterface WriteFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const writeSchema: z.ZodObject<{\n    file_path: z.ZodString;\n    text: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n    text: string;\n}, {\n    file_path: string;\n    text: string;\n}>;\ntype WriteToolSchema = typeof writeSchema;\n/**\n * Class for writing data to files on the disk. Extends the StructuredTool\n * class.\n */\nexport declare class WriteFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n        text: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n        text: string;\n    }, {\n        file_path: string;\n        text: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store, ...rest }: WriteFileParams);\n    _call({ file_path, text }: InferInteropZodOutput<WriteToolSchema>): Promise<string>;\n}\nexport {};\n"],"mappings":";;;;;;;;;AAGuD;UAI7CK,cAAAA,SAAuBH,UAAT,CAAA;EAAA,KACbE,EAAAA,aAAAA;;AADgC,cAG7BE,UAH6B,EAGjBN,CAAAA,CAAES,SAHe,CAAA;EAG7BH,SAAAA,EACCN,CAAAA,CAAEO,SAKf;CAAA,EAAA,OAAA,EAJUP,CAAAA,CAAEQ,UAIZ,EAAA;EAAA,SALeD,EAAAA,MAAAA;CAAS,EAAA;EACF,SAFIE,EAAAA,MAAAA;AAAS,CAAA,CAAA;AAAA,KAOhCC,cAAAA,GAAc,OAAUJ,UAAAA;AAK7B;;;;AAEYN,cAFSW,YAAAA,SAAqBV,cAAAA,CAE5BQ;EAAS,OASZL,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAa,MACNQ,EAVNZ,CAAAA,CAAES,SAUIG,CAAAA;IAASP,SAAAA,EATRL,CAAAA,CAAEO,SASMF;EAAc,CAAA,EAC7BQ,OAAAA,EATIb,CAAAA,CAAEQ,UASNK,EAAAA;IAAmCH,SAAAA,EAAAA,MAAAA;EAAc,CAAA,EAApCP;IAAwCW,SAAAA,EAAAA,MAAAA;EAAO,CAAA,CAAA;EAbhB,IAAA,EAAA,MAAA;EAkB9CC,WAAAA,EAAAA,MAAe;EAAA,KAAA,EAPdX,aAOc;EAAA,WACdA,CAAAA;IAAAA;EAAAA,CAAAA,EAPgBC,cAOhBD;EAAa,KADUF,CAAAA;IAAAA;EAAAA,CAAAA,EALTC,qBAKSD,CALaQ,cAKbR,CAAAA,CAAAA,EAL+BY,OAK/BZ,CAAAA,MAAAA,CAAAA;AAAU;AAAA;;;UAAlCa,eAAAA,SAAwBb,UAKtBK,CAAAA;EAAS,KACPC,EALHJ,aAKGI;;AAHwB,cAAxBQ,WAAwB,EAAXhB,CAAAA,CAAES,SAAS,CAAA;EAUjCQ,SAAAA,EATUjB,CAAAA,CAAEO,SASG;EAKCW,IAAAA,EAbXlB,CAAAA,CAAEO,SAasB;CAAA,EAAA,OAAA,EAZtBP,CAAAA,CAAEQ,UAYoB,EAAA;EAAA,SAGbD,EAAAA,MAAAA;EAAS,IAChBP,EAAEO,MAAAA;CAAS,EAAA;EACG,SAHdE,EAAAA,MAAAA;EAAS,IAYZL,EAAAA,MAAAA;CAAa,CAAA;KAnBnBa,eAAAA,GAoB+BF,OApBNC,WAoBMD;;;;;AACoCD,cAhBnDI,aAAAA,SAAsBjB,cAAAA,CAgB6Ba;EAAO,OAhBpCb,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,MAAA,EAE7CD,CAAAA,CAAES,SAF2C,CAAA;eAGtCT,CAAAA,CAAEO;UACPP,CAAAA,CAAEO;cACAP,CAAAA,CAAEQ;;;;;;;;;SASPJ;;;;KACyBW;;;;KACLZ,sBAAsBc,mBAAmBH"}

package/dist/tools/json.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.cts","names":["Serializable","Tool","ToolParams","Json","JsonObject","JsonSpec","JsonToolFields","JsonListKeysTool","Promise","JsonGetValueTool"],"sources":["../../src/tools/json.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nexport type Json = string | number | boolean | null | {\n    [key: string]: Json;\n} | Json[];\nexport type JsonObject = {\n    [key: string]: Json;\n};\n/**\n * Represents a JSON object in the LangChain framework. Provides methods\n * to get keys and values from the JSON object.\n */\nexport declare class JsonSpec extends Serializable {\n    lc_namespace: string[];\n    obj: JsonObject;\n    maxValueLength: number;\n    constructor(obj: JsonObject, max_value_length?: number);\n    /**\n     * Retrieves all keys at a given path in the JSON object.\n     * @param input The path to the keys in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns A string containing all keys at the given path, separated by commas.\n     */\n    getKeys(input: string): string;\n    /**\n     * Retrieves the value at a given path in the JSON object.\n     * @param input The path to the value in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns The value at the given path in the JSON object, as a string. If the value is a large dictionary or exceeds the maximum length, a message is returned instead.\n     */\n    getValue(input: string): string;\n}\nexport interface JsonToolFields extends ToolParams {\n    jsonSpec: JsonSpec;\n}\n/**\n * A tool in the LangChain framework that lists all keys at a given path\n * in a JSON object.\n */\nexport declare class JsonListKeysTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    jsonSpec: JsonSpec;\n    constructor(jsonSpec: JsonSpec);\n    constructor(fields: JsonToolFields);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool in the LangChain framework that retrieves the value at a given\n * path in a JSON object.\n */\nexport declare class JsonGetValueTool extends Tool {\n    jsonSpec: JsonSpec;\n    static lc_name(): string;\n    name: string;\n    constructor(jsonSpec: JsonSpec);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n"],"mappings":";;;;KAEYG,IAAAA;iBACOA;AADnB,CAAA,GAEIA,IAFQA,EAAAA;AAAI,KAGJC,UAAAA,GAHI;EAAA,CAAA,GACGD,EAAAA,MAAAA,CAAAA,EAGAA,IAHAA;CAAI;AACf;AACR;AAOA;;AAESC,cAFYC,QAAAA,SAAiBL,YAAAA,CAE7BI;EAAU,YAEEA,EAAAA,MAAAA,EAAAA;EAAU,GAJOJ,EAE7BI,UAF6BJ;EAAY,cAAA,EAAA,MAAA;EAkBjCM,WAAAA,CAAAA,GAAAA,EAdIF,UAcU,EAAA,gBAAA,CAAA,EAAA,MAAA;EAAA;;;AAAmB;AAOlD;EAAqC,OAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAAA;;;;;EAAa,QAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAclD;AAAqC,UArBpBE,cAAAA,SAAuBJ,UAqBH,CAAA;EAAA,QACvBG,EArBAA,QAqBAA;;;;AADoC;;cAd7BE,gBAAAA,SAAyBN,IAAAA;;;YAGhCI;wBACYA;sBACFC;;wBAEEE;;;;;;;cAOLC,gBAAAA,SAAyBR,IAAAA;YAChCI;;;wBAGYA;;wBAEAG"}

package/dist/tools/json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","names":["Serializable","Tool","ToolParams","Json","JsonObject","JsonSpec","JsonToolFields","JsonListKeysTool","Promise","JsonGetValueTool"],"sources":["../../src/tools/json.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nexport type Json = string | number | boolean | null | {\n    [key: string]: Json;\n} | Json[];\nexport type JsonObject = {\n    [key: string]: Json;\n};\n/**\n * Represents a JSON object in the LangChain framework. Provides methods\n * to get keys and values from the JSON object.\n */\nexport declare class JsonSpec extends Serializable {\n    lc_namespace: string[];\n    obj: JsonObject;\n    maxValueLength: number;\n    constructor(obj: JsonObject, max_value_length?: number);\n    /**\n     * Retrieves all keys at a given path in the JSON object.\n     * @param input The path to the keys in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns A string containing all keys at the given path, separated by commas.\n     */\n    getKeys(input: string): string;\n    /**\n     * Retrieves the value at a given path in the JSON object.\n     * @param input The path to the value in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns The value at the given path in the JSON object, as a string. If the value is a large dictionary or exceeds the maximum length, a message is returned instead.\n     */\n    getValue(input: string): string;\n}\nexport interface JsonToolFields extends ToolParams {\n    jsonSpec: JsonSpec;\n}\n/**\n * A tool in the LangChain framework that lists all keys at a given path\n * in a JSON object.\n */\nexport declare class JsonListKeysTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    jsonSpec: JsonSpec;\n    constructor(jsonSpec: JsonSpec);\n    constructor(fields: JsonToolFields);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool in the LangChain framework that retrieves the value at a given\n * path in a JSON object.\n */\nexport declare class JsonGetValueTool extends Tool {\n    jsonSpec: JsonSpec;\n    static lc_name(): string;\n    name: string;\n    constructor(jsonSpec: JsonSpec);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n"],"mappings":";;;;KAEYG,IAAAA;iBACOA;AADnB,CAAA,GAEIA,IAFQA,EAAAA;AAAI,KAGJC,UAAAA,GAHI;EAAA,CAAA,GACGD,EAAAA,MAAAA,CAAAA,EAGAA,IAHAA;CAAI;AACf;AACR;AAOA;;AAESC,cAFYC,QAAAA,SAAiBL,YAAAA,CAE7BI;EAAU,YAEEA,EAAAA,MAAAA,EAAAA;EAAU,GAJOJ,EAE7BI,UAF6BJ;EAAY,cAAA,EAAA,MAAA;EAkBjCM,WAAAA,CAAAA,GAAAA,EAdIF,UAcU,EAAA,gBAAA,CAAA,EAAA,MAAA;EAAA;;;AAAmB;AAOlD;EAAqC,OAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAAA;;;;;EAAa,QAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAAA,MAAA;AAclD;AAAqC,UArBpBE,cAAAA,SAAuBJ,UAqBH,CAAA;EAAA,QACvBG,EArBAA,QAqBAA;;;;AADoC;;cAd7BE,gBAAAA,SAAyBN,IAAAA;;;YAGhCI;wBACYA;sBACFC;;wBAEEE;;;;;;;cAOLC,gBAAAA,SAAyBR,IAAAA;YAChCI;;;wBAGYA;;wBAEAG"}

package/dist/tools/render.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render.d.cts","names":["StructuredToolInterface","ToolDefinition","renderTextDescription","renderTextDescriptionAndArgs"],"sources":["../../src/tools/render.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\n/**\n * Render the tool name and description in plain text.\n *\n * Output will be in the format of:\n * ```\n * search: This tool is used for search\n * calculator: This tool is used for math\n * ```\n * @param tools\n * @returns a string of all tools and their descriptions\n */\nexport declare function renderTextDescription(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n/**\n * Render the tool name, description, and args in plain text.\n * Output will be in the format of:'\n * ```\n * search: This tool is used for search, args: {\"query\": {\"type\": \"string\"}}\n * calculator: This tool is used for math,\n * args: {\"expression\": {\"type\": \"string\"}}\n * ```\n * @param tools\n * @returns a string of all tools, their descriptions and a stringified version of their schemas\n */\nexport declare function renderTextDescriptionAndArgs(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n"],"mappings":";;;;;;;AAaA;;;;AAA+F;AAY/F;;;;AAAsG,iBAZ9EE,qBAAAA,CAY8E,KAAA,EAZjDF,uBAYiD,EAAA,GAZrBC,cAYqB,EAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;iBAA9EE,4BAAAA,QAAoCH,4BAA4BC"}

package/dist/tools/render.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render.d.ts","names":["StructuredToolInterface","ToolDefinition","renderTextDescription","renderTextDescriptionAndArgs"],"sources":["../../src/tools/render.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\n/**\n * Render the tool name and description in plain text.\n *\n * Output will be in the format of:\n * ```\n * search: This tool is used for search\n * calculator: This tool is used for math\n * ```\n * @param tools\n * @returns a string of all tools and their descriptions\n */\nexport declare function renderTextDescription(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n/**\n * Render the tool name, description, and args in plain text.\n * Output will be in the format of:'\n * ```\n * search: This tool is used for search, args: {\"query\": {\"type\": \"string\"}}\n * calculator: This tool is used for math,\n * args: {\"expression\": {\"type\": \"string\"}}\n * ```\n * @param tools\n * @returns a string of all tools, their descriptions and a stringified version of their schemas\n */\nexport declare function renderTextDescriptionAndArgs(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n"],"mappings":";;;;;;;AAaA;;;;AAA+F;AAY/F;;;;AAAsG,iBAZ9EE,qBAAAA,CAY8E,KAAA,EAZjDF,uBAYiD,EAAA,GAZrBC,cAYqB,EAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;iBAA9EE,4BAAAA,QAAoCH,4BAA4BC"}

package/dist/tools/requests.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requests.d.cts","names":["Tool","Headers","RequestTool","RequestsGetTool","maxOutputLength","Promise","RequestsPostTool"],"sources":["../../src/tools/requests.d.ts"],"sourcesContent":["import { Tool } from \"@langchain/core/tools\";\nexport interface Headers {\n    [key: string]: string;\n}\n/**\n * Interface for HTTP request tools. Contains properties for headers and\n * maximum output length.\n */\nexport interface RequestTool {\n    headers: Headers;\n    maxOutputLength: number;\n}\n/**\n * Class for making GET requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a URL string, and the\n * output will be the text response of the GET request.\n */\nexport declare class RequestsGetTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * Class for making POST requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a JSON string with two\n * keys: 'url' and 'data'. The output will be the text response of the\n * POST request.\n */\nexport declare class RequestsPostTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n"],"mappings":";;;UACiBC,OAAAA;;AAAjB;AAOA;AASA;;;AAK0BA,UAdTC,WAAAA,CAcSD;EAAO,OAAIG,EAbxBH,OAawBG;EAAe,eAI1BC,EAAAA,MAAAA;;;AAT8C;AAkBxE;;;AAK0BJ,cAvBLE,eAAAA,SAAwBH,IAAAA,YAAgBE,WAuBnCD,CAAAA;EAAO,OAAIG,EAtBxBH,OAsBwBG;EAAe,OAI1BC,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,IATaL,EAAAA,MAAAA;EAAI,eAAYE,EAAAA,MAAAA;EAAW,WAAA,CAAA,OAAA,CAAA,EAb/CD,OAa+C,EAAA;IAAA;IAAA,EAAA;;;;wBAT/CI;;;;;;;;;cASLC,gBAAAA,SAAyBN,IAAAA,YAAgBE;WACjDD;;;;wBAIaA;;;;;;wBAIAI"}

package/dist/tools/requests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"requests.d.ts","names":["Tool","Headers","RequestTool","RequestsGetTool","maxOutputLength","Promise","RequestsPostTool"],"sources":["../../src/tools/requests.d.ts"],"sourcesContent":["import { Tool } from \"@langchain/core/tools\";\nexport interface Headers {\n    [key: string]: string;\n}\n/**\n * Interface for HTTP request tools. Contains properties for headers and\n * maximum output length.\n */\nexport interface RequestTool {\n    headers: Headers;\n    maxOutputLength: number;\n}\n/**\n * Class for making GET requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a URL string, and the\n * output will be the text response of the GET request.\n */\nexport declare class RequestsGetTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * Class for making POST requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a JSON string with two\n * keys: 'url' and 'data'. The output will be the text response of the\n * POST request.\n */\nexport declare class RequestsPostTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n"],"mappings":";;;UACiBC,OAAAA;;AAAjB;AAOA;AASA;;;AAK0BA,UAdTC,WAAAA,CAcSD;EAAO,OAAIG,EAbxBH,OAawBG;EAAe,eAI1BC,EAAAA,MAAAA;;;AAT8C;AAkBxE;;;AAK0BJ,cAvBLE,eAAAA,SAAwBH,IAAAA,YAAgBE,WAuBnCD,CAAAA;EAAO,OAAIG,EAtBxBH,OAsBwBG;EAAe,OAI1BC,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,IATaL,EAAAA,MAAAA;EAAI,eAAYE,EAAAA,MAAAA;EAAW,WAAA,CAAA,OAAA,CAAA,EAb/CD,OAa+C,EAAA;IAAA;IAAA,EAAA;;;;wBAT/CI;;;;;;;;;cASLC,gBAAAA,SAAyBN,IAAAA,YAAgBE;WACjDD;;;;wBAIaA;;;;;;wBAIAI"}

package/dist/tools/retriever.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retriever.d.cts","names":["BaseRetrieverInterface","z","DynamicStructuredTool","DynamicStructuredToolInput","createRetrieverTool","Omit","ZodString","ZodTypeAny","ZodObject"],"sources":["../../src/tools/retriever.d.ts"],"sourcesContent":["import type { BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { z } from \"zod/v3\";\nimport { DynamicStructuredTool, type DynamicStructuredToolInput } from \"@langchain/core/tools\";\nexport declare function createRetrieverTool(retriever: BaseRetrieverInterface, input: Omit<DynamicStructuredToolInput, \"func\" | \"schema\">): DynamicStructuredTool<z.ZodObject<{\n    query: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    query: string;\n}, {\n    query: string;\n}>, {\n    query: string;\n}, {\n    query: string;\n}, string>;\n"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAA,KAAA,EAAA,MAAA;CAAA,EAAA;EAAkC,KAAcD,EAAAA,MAAAA;CAA0B,CAAA,EAAA;EAA3B,KAC7EG,EAAAA,MAAAA;CAAS,EAAA;EACE,KAF4IE,EAAAA,MAAAA;CAAS,EAAA,MAAjCN,CAAAA"}

package/dist/tools/retriever.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retriever.d.ts","names":["BaseRetrieverInterface","z","DynamicStructuredTool","DynamicStructuredToolInput","createRetrieverTool","Omit","ZodString","ZodTypeAny","ZodObject"],"sources":["../../src/tools/retriever.d.ts"],"sourcesContent":["import type { BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { z } from \"zod/v3\";\nimport { DynamicStructuredTool, type DynamicStructuredToolInput } from \"@langchain/core/tools\";\nexport declare function createRetrieverTool(retriever: BaseRetrieverInterface, input: Omit<DynamicStructuredToolInput, \"func\" | \"schema\">): DynamicStructuredTool<z.ZodObject<{\n    query: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    query: string;\n}, {\n    query: string;\n}>, {\n    query: string;\n}, {\n    query: string;\n}, string>;\n"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAA,KAAA,EAAA,MAAA;CAAA,EAAA;EAAkC,KAAcD,EAAAA,MAAAA;CAA0B,CAAA,EAAA;EAA3B,KAC7EG,EAAAA,MAAAA;CAAS,EAAA;EACE,KAF4IE,EAAAA,MAAAA;CAAS,EAAA,MAAjCN,CAAAA"}

package/dist/tools/sql.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql.d.cts","names":["BaseLanguageModelInterface","Tool","LLMChain","SqlDatabase","SqlTool","QuerySqlTool","Promise","InfoSqlTool","ListTablesSqlTool","QueryCheckerToolArgs","QueryCheckerTool"],"sources":["../../src/tools/sql.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { SqlDatabase } from \"../sql_db.js\";\n/**\n * Interface for SQL tools. It has a `db` property which is a SQL\n * database.\n */\ninterface SqlTool {\n    db: SqlDatabase;\n}\n/**\n * A tool for executing SQL queries. It takes a SQL database as a\n * parameter and assigns it to the `db` property. The `_call` method is\n * used to run the SQL query and return the result. If the query is\n * incorrect, an error message is returned.\n */\nexport declare class QuerySqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for retrieving information about SQL tables. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to retrieve the schema and sample rows for the\n * specified tables. If the tables do not exist, an error message is\n * returned.\n */\nexport declare class InfoSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for listing all tables in a SQL database. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to return a comma-separated list of all tables\n * in the database.\n */\nexport declare class ListTablesSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    _call(_: string): Promise<string>;\n    description: string;\n}\n/**\n * Arguments for the QueryCheckerTool class.\n */\ntype QueryCheckerToolArgs = {\n    llmChain?: LLMChain;\n    llm: BaseLanguageModelInterface;\n    _chainType?: never;\n};\n/**\n * A tool for checking SQL queries for common mistakes. It takes a\n * LLMChain or QueryCheckerToolArgs as a parameter. The `_call` method is\n * used to check the input query for common mistakes and returns a\n * prediction.\n */\nexport declare class QueryCheckerTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    template: string;\n    llmChain: LLMChain;\n    constructor(llmChainOrOptions?: LLMChain | QueryCheckerToolArgs);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\nexport {};\n"],"mappings":";;;;;;;;;AAGgD;AAchD;UATUI,OAAAA,CASuB;EAAA,EAAA,EARzBD,WAWAA;;;;;AAHyD;AAgBjE;;AAGQA,cAnBaE,YAAAA,SAAqBJ,IAAAA,YAAgBG,OAmBlDD,CAAAA;EAAW,OACCA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,IAELG,EAAAA,MAAAA;EAAO,EAAA,EAnBzBH,WAaiCF;EAAI,WAAYG,CAAAA,EAAAA,EAZrCD,WAYqCC;EAAO;EAe3CI,KAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAiB,EAzBZF,OAyBY,CAAA,MAAA,CAAA;EAAA,WAAA,EAAA,MAAA;;;;;;AAAgC;AAOrE;;AAKcJ,cA3BMK,WAAAA,SAAoBN,IAAAA,YAAgBG,OA2B1CF,CAAAA;EAAQ,OACdF,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0B,IAAA,EAAA,MAAA;EASdU,EAAAA,EAlCbP,WAkCaO;EAAgB,WAAA,CAAA,EAAA,EAjCjBP,WAiCiB;EAAA;EAIf,KACcD,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EApCVI,OAoCUJ,CAAAA,MAAAA,CAAAA;EAAQ,WAAGO,EAAAA,MAAAA;;;AALG;;;;;cAtB7BD,iBAAAA,SAA0BP,IAAAA,YAAgBG;;;MAGvDD;kBACYA;oBACEG;;;;;;KAMjBG,oBAAAA;aACUP;OACNF;;;;;;;;;cASYU,gBAAAA,SAAyBT,IAAAA;;;;YAIhCC;kCACsBA,WAAWO;;wBAErBH"}

package/dist/tools/sql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql.d.ts","names":["BaseLanguageModelInterface","Tool","LLMChain","SqlDatabase","SqlTool","QuerySqlTool","Promise","InfoSqlTool","ListTablesSqlTool","QueryCheckerToolArgs","QueryCheckerTool"],"sources":["../../src/tools/sql.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { SqlDatabase } from \"../sql_db.js\";\n/**\n * Interface for SQL tools. It has a `db` property which is a SQL\n * database.\n */\ninterface SqlTool {\n    db: SqlDatabase;\n}\n/**\n * A tool for executing SQL queries. It takes a SQL database as a\n * parameter and assigns it to the `db` property. The `_call` method is\n * used to run the SQL query and return the result. If the query is\n * incorrect, an error message is returned.\n */\nexport declare class QuerySqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for retrieving information about SQL tables. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to retrieve the schema and sample rows for the\n * specified tables. If the tables do not exist, an error message is\n * returned.\n */\nexport declare class InfoSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for listing all tables in a SQL database. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to return a comma-separated list of all tables\n * in the database.\n */\nexport declare class ListTablesSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    _call(_: string): Promise<string>;\n    description: string;\n}\n/**\n * Arguments for the QueryCheckerTool class.\n */\ntype QueryCheckerToolArgs = {\n    llmChain?: LLMChain;\n    llm: BaseLanguageModelInterface;\n    _chainType?: never;\n};\n/**\n * A tool for checking SQL queries for common mistakes. It takes a\n * LLMChain or QueryCheckerToolArgs as a parameter. The `_call` method is\n * used to check the input query for common mistakes and returns a\n * prediction.\n */\nexport declare class QueryCheckerTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    template: string;\n    llmChain: LLMChain;\n    constructor(llmChainOrOptions?: LLMChain | QueryCheckerToolArgs);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\nexport {};\n"],"mappings":";;;;;;;;;AAGgD;AAchD;UATUI,OAAAA,CASuB;EAAA,EAAA,EARzBD,WAWAA;;;;;AAHyD;AAgBjE;;AAGQA,cAnBaE,YAAAA,SAAqBJ,IAAAA,YAAgBG,OAmBlDD,CAAAA;EAAW,OACCA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,IAELG,EAAAA,MAAAA;EAAO,EAAA,EAnBzBH,WAaiCF;EAAI,WAAYG,CAAAA,EAAAA,EAZrCD,WAYqCC;EAAO;EAe3CI,KAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAiB,EAzBZF,OAyBY,CAAA,MAAA,CAAA;EAAA,WAAA,EAAA,MAAA;;;;;;AAAgC;AAOrE;;AAKcJ,cA3BMK,WAAAA,SAAoBN,IAAAA,YAAgBG,OA2B1CF,CAAAA;EAAQ,OACdF,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0B,IAAA,EAAA,MAAA;EASdU,EAAAA,EAlCbP,WAkCaO;EAAgB,WAAA,CAAA,EAAA,EAjCjBP,WAiCiB;EAAA;EAIf,KACcD,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EApCVI,OAoCUJ,CAAAA,MAAAA,CAAAA;EAAQ,WAAGO,EAAAA,MAAAA;;;AALG;;;;;cAtB7BD,iBAAAA,SAA0BP,IAAAA,YAAgBG;;;MAGvDD;kBACYA;oBACEG;;;;;;KAMjBG,oBAAAA;aACUP;OACNF;;;;;;;;;cASYU,gBAAAA,SAAyBT,IAAAA;;;;YAIhCC;kCACsBA,WAAWO;;wBAErBH"}

package/dist/tools/vectorstore.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vectorstore.d.cts","names":["BaseLanguageModelInterface","VectorStoreInterface","Tool","VectorDBQAChain","VectorStoreTool","VectorStoreQATool","Promise"],"sources":["../../src/tools/vectorstore.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { VectorDBQAChain } from \"../chains/vector_db_qa.js\";\n/**\n * Interface for tools that interact with a Vector Store.\n */\ninterface VectorStoreTool {\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n}\n/**\n * A tool for the VectorDBQA chain to interact with a Vector Store. It is\n * used to answer questions about a specific topic. The input to this tool\n * should be a fully formed question.\n */\nexport declare class VectorStoreQATool extends Tool implements VectorStoreTool {\n    static lc_name(): string;\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n    name: string;\n    description: string;\n    chain: VectorDBQAChain;\n    constructor(name: string, description: string, fields: VectorStoreTool);\n    /**\n     * Returns a string that describes what the tool does.\n     * @param name The name of the tool.\n     * @param description A description of what the tool does.\n     * @returns A string that describes what the tool does.\n     */\n    static getDescription(name: string, description: string): string;\n    /** @ignore */\n    _call(input: string): Promise<string>;\n}\nexport {};\n"],"mappings":";;;;;;;;;AAG4D;UAIlDI,eAAAA,CAAe;EAAA,WACRH,EAAAA,oBAAAA;EAAoB,GAC5BD,EAAAA,0BAAAA;AAA0B;AAOnC;;;;;AAO2DI,cAPtCC,iBAAAA,SAA0BH,IAAAA,YAAgBE,eAOJA,CAAAA;EAAe,OAShDE,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,WAhBcJ,EAE9BD,oBAF8BC;EAAI,GAAYE,EAGtDJ,0BAHsDI;EAAe,IAAA,EAAA,MAAA;;SAMnED;yDACgDC;;;;;;;;;wBASjCE"}

package/dist/tools/vectorstore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vectorstore.d.ts","names":["BaseLanguageModelInterface","VectorStoreInterface","Tool","VectorDBQAChain","VectorStoreTool","VectorStoreQATool","Promise"],"sources":["../../src/tools/vectorstore.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { VectorDBQAChain } from \"../chains/vector_db_qa.js\";\n/**\n * Interface for tools that interact with a Vector Store.\n */\ninterface VectorStoreTool {\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n}\n/**\n * A tool for the VectorDBQA chain to interact with a Vector Store. It is\n * used to answer questions about a specific topic. The input to this tool\n * should be a fully formed question.\n */\nexport declare class VectorStoreQATool extends Tool implements VectorStoreTool {\n    static lc_name(): string;\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n    name: string;\n    description: string;\n    chain: VectorDBQAChain;\n    constructor(name: string, description: string, fields: VectorStoreTool);\n    /**\n     * Returns a string that describes what the tool does.\n     * @param name The name of the tool.\n     * @param description A description of what the tool does.\n     * @returns A string that describes what the tool does.\n     */\n    static getDescription(name: string, description: string): string;\n    /** @ignore */\n    _call(input: string): Promise<string>;\n}\nexport {};\n"],"mappings":";;;;;;;;;AAG4D;UAIlDI,eAAAA,CAAe;EAAA,WACRH,EAAAA,oBAAAA;EAAoB,GAC5BD,EAAAA,0BAAAA;AAA0B;AAOnC;;;;;AAO2DI,cAPtCC,iBAAAA,SAA0BH,IAAAA,YAAgBE,eAOJA,CAAAA;EAAe,OAShDE,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAO,WAhBcJ,EAE9BD,oBAF8BC;EAAI,GAAYE,EAGtDJ,0BAHsDI;EAAe,IAAA,EAAA,MAAA;;SAMnED;yDACgDC;;;;;;;;;wBASjCE"}

package/dist/tools/webbrowser.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webbrowser.d.cts","names":["BaseLanguageModelInterface","EmbeddingsInterface","CallbackManager","CallbackManagerForToolRun","Tool","ToolParams","TextSplitter","parseInputs","getText","Headers","Record","RequestConfig","RequestInit","Omit","WebBrowserArgs","WebBrowser","model","headers","embeddings","requestConfig","textSplitter","Promise"],"sources":["../../src/tools/webbrowser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { CallbackManager, CallbackManagerForToolRun } from \"@langchain/core/callbacks/manager\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nimport { TextSplitter } from \"@langchain/textsplitters\";\nexport declare const parseInputs: (inputs: string) => [string, string];\nexport declare const getText: (html: string, baseUrl: string, summary: boolean) => string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Headers = Record<string, any>;\n/**\n * Configuration options for fetch requests, similar to axios config but for fetch\n */\nexport interface RequestConfig extends Omit<RequestInit, \"headers\"> {\n    withCredentials?: boolean;\n}\n/**\n * Defines the arguments that can be passed to the WebBrowser constructor.\n * It extends the ToolParams interface and includes properties for a\n * language model, embeddings, HTTP headers, an Axios configuration, a\n * callback manager, and a text splitter.\n */\nexport interface WebBrowserArgs extends ToolParams {\n    model: BaseLanguageModelInterface;\n    embeddings: EmbeddingsInterface;\n    headers?: Headers;\n    requestConfig?: RequestConfig;\n    /** @deprecated */\n    callbackManager?: CallbackManager;\n    textSplitter?: TextSplitter;\n}\n/**\n * A class designed to interact with web pages, either to extract\n * information from them or to summarize their content. It uses the native\n * fetch API to send HTTP requests and the cheerio library to parse the\n * returned HTML.\n * @example\n * ```typescript\n * const browser = new WebBrowser({\n *   model: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   embeddings: new OpenAIEmbeddings({}),\n * });\n * const result = await browser.invoke(\"https:exampleurl.com\");\n * ```\n */\nexport declare class WebBrowser extends Tool {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    private model;\n    private embeddings;\n    private headers;\n    private requestConfig;\n    private textSplitter;\n    constructor({ model, headers, embeddings, requestConfig, textSplitter }: WebBrowserArgs);\n    /** @ignore */\n    _call(inputs: string, runManager?: CallbackManagerForToolRun): Promise<string>;\n    name: string;\n    description: string;\n}\nexport {};\n"],"mappings":";;;;;;;cAKqBO;cACAC;AADrB;AACA,KAEKC,OAAAA,GAAUC,MAF0E,CAAA,MAAA,EAAA,GAAA,CAAA;AAAC;AAM1F;;AAA4CE,UAA3BD,aAAAA,SAAsBE,IAAKD,CAAAA,WAAAA,EAAAA,SAAAA,CAAAA,CAAAA;EAAW,eAAhBC,CAAAA,EAAAA,OAAAA;AAAI;AAS3C;;;;;;AAMsBX,UANLY,cAAAA,SAAuBT,UAMlBH,CAAAA;EAAe,KAClBI,EANRN,0BAMQM;EAAY,UAPSD,EAExBJ,mBAFwBI;EAAU,OAAA,CAAA,EAGpCI,OAHoC;EAuB7BM,aAAU,CAAA,EAnBXJ,aAmBW;EAAA;EAAA,eAQbK,CAAAA,EAzBId,eAyBJc;EAAK,YAAEC,CAAAA,EAxBNX,YAwBMW;;;;;;;;AARmB;;;;;;;;cAAvBF,UAAAA,SAAmBX,IAAAA;;;;;;;;;;;;;;KAQqCU;;qCAEtCX,4BAA4BkB"}

package/dist/tools/webbrowser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webbrowser.d.ts","names":["BaseLanguageModelInterface","EmbeddingsInterface","CallbackManager","CallbackManagerForToolRun","Tool","ToolParams","TextSplitter","parseInputs","getText","Headers","Record","RequestConfig","RequestInit","Omit","WebBrowserArgs","WebBrowser","model","headers","embeddings","requestConfig","textSplitter","Promise"],"sources":["../../src/tools/webbrowser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { CallbackManager, CallbackManagerForToolRun } from \"@langchain/core/callbacks/manager\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nimport { TextSplitter } from \"@langchain/textsplitters\";\nexport declare const parseInputs: (inputs: string) => [string, string];\nexport declare const getText: (html: string, baseUrl: string, summary: boolean) => string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Headers = Record<string, any>;\n/**\n * Configuration options for fetch requests, similar to axios config but for fetch\n */\nexport interface RequestConfig extends Omit<RequestInit, \"headers\"> {\n    withCredentials?: boolean;\n}\n/**\n * Defines the arguments that can be passed to the WebBrowser constructor.\n * It extends the ToolParams interface and includes properties for a\n * language model, embeddings, HTTP headers, an Axios configuration, a\n * callback manager, and a text splitter.\n */\nexport interface WebBrowserArgs extends ToolParams {\n    model: BaseLanguageModelInterface;\n    embeddings: EmbeddingsInterface;\n    headers?: Headers;\n    requestConfig?: RequestConfig;\n    /** @deprecated */\n    callbackManager?: CallbackManager;\n    textSplitter?: TextSplitter;\n}\n/**\n * A class designed to interact with web pages, either to extract\n * information from them or to summarize their content. It uses the native\n * fetch API to send HTTP requests and the cheerio library to parse the\n * returned HTML.\n * @example\n * ```typescript\n * const browser = new WebBrowser({\n *   model: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   embeddings: new OpenAIEmbeddings({}),\n * });\n * const result = await browser.invoke(\"https:exampleurl.com\");\n * ```\n */\nexport declare class WebBrowser extends Tool {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    private model;\n    private embeddings;\n    private headers;\n    private requestConfig;\n    private textSplitter;\n    constructor({ model, headers, embeddings, requestConfig, textSplitter }: WebBrowserArgs);\n    /** @ignore */\n    _call(inputs: string, runManager?: CallbackManagerForToolRun): Promise<string>;\n    name: string;\n    description: string;\n}\nexport {};\n"],"mappings":";;;;;;;cAKqBO;cACAC;AADrB;AACA,KAEKC,OAAAA,GAAUC,MAF0E,CAAA,MAAA,EAAA,GAAA,CAAA;AAAC;AAM1F;;AAA4CE,UAA3BD,aAAAA,SAAsBE,IAAKD,CAAAA,WAAAA,EAAAA,SAAAA,CAAAA,CAAAA;EAAW,eAAhBC,CAAAA,EAAAA,OAAAA;AAAI;AAS3C;;;;;;AAMsBX,UANLY,cAAAA,SAAuBT,UAMlBH,CAAAA;EAAe,KAClBI,EANRN,0BAMQM;EAAY,UAPSD,EAExBJ,mBAFwBI;EAAU,OAAA,CAAA,EAGpCI,OAHoC;EAuB7BM,aAAU,CAAA,EAnBXJ,aAmBW;EAAA;EAAA,eAQbK,CAAAA,EAzBId,eAyBJc;EAAK,YAAEC,CAAAA,EAxBNX,YAwBMW;;;;;;;;AARmB;;;;;;;;cAAvBF,UAAAA,SAAmBX,IAAAA;;;;;;;;;;;;;;KAQqCU;;qCAEtCX,4BAA4BkB"}

package/dist/types/expression-parser.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expression-parser.d.cts","names":["ParseOptions","ParseFunction","Options","StartRule","Start","Program","Identifier","IdentifierName","Literal","NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","DecimalLiteral","PrimaryExpression","ArrayExpression","ObjectExpression","Expression","ElementList","PropertyNameAndValueList","PropertyAssignment","PropertyName","MemberExpression","CallExpression","Arguments","ExpressionStatement","ExpressionNode"],"sources":["../../src/types/expression-parser.d.ts"],"sourcesContent":["export interface ParseOptions {\n    filename?: string;\n    startRule?: \"Start\";\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    tracer?: any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n}\nexport type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {\n    startRule: infer StartRule;\n} ? StartRule extends \"Start\" ? Start : Start : Start;\n// These types were autogenerated by ts-pegjs\nexport type Start = Program;\nexport type Identifier = IdentifierName;\nexport type IdentifierName = {\n    type: \"Identifier\";\n    name: string;\n};\nexport type Literal = NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral;\nexport type NullLiteral = {\n    type: \"NullLiteral\";\n    value: null;\n};\nexport type BooleanLiteral = {\n    type: \"BooleanLiteral\";\n    value: true;\n} | {\n    type: \"BooleanLiteral\";\n    value: false;\n};\nexport type NumericLiteral = DecimalLiteral;\nexport type DecimalLiteral = {\n    type: \"NumericLiteral\";\n    value: number;\n};\nexport type StringLiteral = {\n    type: \"StringLiteral\";\n    value: string;\n};\nexport type PrimaryExpression = Identifier | Literal | ArrayExpression | ObjectExpression | Expression;\nexport type ArrayExpression = {\n    type: \"ArrayExpression\";\n    elements: ElementList;\n};\nexport type ElementList = PrimaryExpression[];\nexport type ObjectExpression = {\n    type: \"ObjectExpression\";\n    properties: [];\n} | {\n    type: \"ObjectExpression\";\n    properties: PropertyNameAndValueList;\n};\nexport type PropertyNameAndValueList = PrimaryExpression[];\nexport type PropertyAssignment = {\n    type: \"PropertyAssignment\";\n    key: PropertyName;\n    value: Expression;\n    kind: \"init\";\n};\nexport type PropertyName = IdentifierName | StringLiteral | NumericLiteral;\nexport type MemberExpression = {\n    type: \"MemberExpression\";\n    property: StringLiteral;\n    computed: true;\n    object: MemberExpression | Identifier | StringLiteral;\n} | {\n    type: \"MemberExpression\";\n    property: Identifier;\n    computed: false;\n    object: MemberExpression | Identifier | StringLiteral;\n};\nexport type CallExpression = {\n    type: \"CallExpression\";\n    arguments: Arguments;\n    callee: MemberExpression | Identifier;\n};\nexport type Arguments = PrimaryExpression[];\nexport type Expression = CallExpression | MemberExpression;\nexport type ExpressionStatement = {\n    type: \"ExpressionStatement\";\n    expression: Expression;\n};\nexport type Program = {\n    type: \"Program\";\n    body: ExpressionStatement;\n};\nexport type ExpressionNode = Program | ExpressionStatement | ArrayExpression | BooleanLiteral | CallExpression | Identifier | MemberExpression | NumericLiteral | ObjectExpression | PropertyAssignment | NullLiteral | StringLiteral;\n"],"mappings":"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"}

package/dist/types/expression-parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expression-parser.d.ts","names":["ParseOptions","ParseFunction","Options","StartRule","Start","Program","Identifier","IdentifierName","Literal","NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","DecimalLiteral","PrimaryExpression","ArrayExpression","ObjectExpression","Expression","ElementList","PropertyNameAndValueList","PropertyAssignment","PropertyName","MemberExpression","CallExpression","Arguments","ExpressionStatement","ExpressionNode"],"sources":["../../src/types/expression-parser.d.ts"],"sourcesContent":["export interface ParseOptions {\n    filename?: string;\n    startRule?: \"Start\";\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    tracer?: any;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n}\nexport type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {\n    startRule: infer StartRule;\n} ? StartRule extends \"Start\" ? Start : Start : Start;\n// These types were autogenerated by ts-pegjs\nexport type Start = Program;\nexport type Identifier = IdentifierName;\nexport type IdentifierName = {\n    type: \"Identifier\";\n    name: string;\n};\nexport type Literal = NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral;\nexport type NullLiteral = {\n    type: \"NullLiteral\";\n    value: null;\n};\nexport type BooleanLiteral = {\n    type: \"BooleanLiteral\";\n    value: true;\n} | {\n    type: \"BooleanLiteral\";\n    value: false;\n};\nexport type NumericLiteral = DecimalLiteral;\nexport type DecimalLiteral = {\n    type: \"NumericLiteral\";\n    value: number;\n};\nexport type StringLiteral = {\n    type: \"StringLiteral\";\n    value: string;\n};\nexport type PrimaryExpression = Identifier | Literal | ArrayExpression | ObjectExpression | Expression;\nexport type ArrayExpression = {\n    type: \"ArrayExpression\";\n    elements: ElementList;\n};\nexport type ElementList = PrimaryExpression[];\nexport type ObjectExpression = {\n    type: \"ObjectExpression\";\n    properties: [];\n} | {\n    type: \"ObjectExpression\";\n    properties: PropertyNameAndValueList;\n};\nexport type PropertyNameAndValueList = PrimaryExpression[];\nexport type PropertyAssignment = {\n    type: \"PropertyAssignment\";\n    key: PropertyName;\n    value: Expression;\n    kind: \"init\";\n};\nexport type PropertyName = IdentifierName | StringLiteral | NumericLiteral;\nexport type MemberExpression = {\n    type: \"MemberExpression\";\n    property: StringLiteral;\n    computed: true;\n    object: MemberExpression | Identifier | StringLiteral;\n} | {\n    type: \"MemberExpression\";\n    property: Identifier;\n    computed: false;\n    object: MemberExpression | Identifier | StringLiteral;\n};\nexport type CallExpression = {\n    type: \"CallExpression\";\n    arguments: Arguments;\n    callee: MemberExpression | Identifier;\n};\nexport type Arguments = PrimaryExpression[];\nexport type Expression = CallExpression | MemberExpression;\nexport type ExpressionStatement = {\n    type: \"ExpressionStatement\";\n    expression: Expression;\n};\nexport type Program = {\n    type: \"Program\";\n    body: ExpressionStatement;\n};\nexport type ExpressionNode = Program | ExpressionStatement | ArrayExpression | BooleanLiteral | CallExpression | Identifier | MemberExpression | NumericLiteral | ObjectExpression | PropertyAssignment | NullLiteral | StringLiteral;\n"],"mappings":"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"}

package/dist/types/type-utils.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-utils.d.cts","names":["Optional","T","K","Omit","Pick","Partial"],"sources":["../../src/types/type-utils.d.ts"],"sourcesContent":["// Utility for marking only some keys of an interface as optional\n// Compare to Partial<T> which marks all keys as optional\nexport type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n"],"mappings":";;AAEA;AAAoB,KAARA,QAAQ,CAAA,CAAA,EAAA,UAAA,MAAoBC,CAApB,CAAA,GAAyBE,IAAzB,CAA8BF,CAA9B,EAAiCC,CAAjC,CAAA,GAAsCG,OAAtC,CAA8CD,IAA9C,CAAmDH,CAAnD,EAAsDC,CAAtD,CAAA,CAAA"}

package/dist/types/type-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-utils.d.ts","names":["Optional","T","K","Omit","Pick","Partial"],"sources":["../../src/types/type-utils.d.ts"],"sourcesContent":["// Utility for marking only some keys of an interface as optional\n// Compare to Partial<T> which marks all keys as optional\nexport type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n"],"mappings":";;AAEA;AAAoB,KAARA,QAAQ,CAAA,CAAA,EAAA,UAAA,MAAoBC,CAApB,CAAA,GAAyBE,IAAzB,CAA8BF,CAA9B,EAAiCC,CAAjC,CAAA,GAAsCG,OAAtC,CAA8CD,IAA9C,CAAmDH,CAAnD,EAAsDC,CAAtD,CAAA,CAAA"}