langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/retrievers/time_weighted.d.ts

@@ -1,142 +0,0 @@
-import { DocumentInterface } from "@langchain/core/documents";
-import { CallbackManagerForRetrieverRun } from "@langchain/core/callbacks/manager";
-import { VectorStoreInterface } from "@langchain/core/vectorstores";
-import { BaseRetriever, BaseRetrieverInput } from "@langchain/core/retrievers";
-
-//#region src/retrievers/time_weighted.d.ts
-
-/**
- * Interface for the fields required to initialize a
- * TimeWeightedVectorStoreRetriever instance.
- */
-interface TimeWeightedVectorStoreRetrieverFields extends BaseRetrieverInput {
-  vectorStore: VectorStoreInterface;
-  searchKwargs?: number;
-  memoryStream?: DocumentInterface[];
-  decayRate?: number;
-  k?: number;
-  otherScoreKeys?: string[];
-  defaultSalience?: number;
-}
-declare const LAST_ACCESSED_AT_KEY = "last_accessed_at";
-declare const BUFFER_IDX = "buffer_idx";
-/**
- * TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.
- * ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py
- * @example
- * ```typescript
- * const retriever = new TimeWeightedVectorStoreRetriever({
- *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),
- *   memoryStream: [],
- *   searchKwargs: 2,
- * });
- * await retriever.addDocuments([
- *   { pageContent: "My name is John.", metadata: {} },
- *   { pageContent: "My favourite food is pizza.", metadata: {} },
- *
- * ]);
- * const results = await retriever.getRelevantDocuments(
- *   "What is my favourite food?",
- * );
- * ```
- */
-declare class TimeWeightedVectorStoreRetriever extends BaseRetriever {
-  static lc_name(): string;
-  get lc_namespace(): string[];
-  /**
-   * The vectorstore to store documents and determine salience.
-   */
-  private vectorStore;
-  /**
-   * The number of top K most relevant documents to consider when searching.
-   */
-  private searchKwargs;
-  /**
-   * The memory_stream of documents to search through.
-   */
-  private memoryStream;
-  /**
-   * The exponential decay factor used as (1.0-decay_rate)**(hrs_passed).
-   */
-  private decayRate;
-  /**
-   * The maximum number of documents to retrieve in a given call.
-   */
-  private k;
-  /**
-   * Other keys in the metadata to factor into the score, e.g. 'importance'.
-   */
-  private otherScoreKeys;
-  /**
-   * The salience to assign memories not retrieved from the vector store.
-   */
-  private defaultSalience;
-  /**
-   * Constructor to initialize the required fields
-   * @param fields - The fields required for initializing the TimeWeightedVectorStoreRetriever
-   */
-  constructor(fields: TimeWeightedVectorStoreRetrieverFields);
-  /**
-   * Get the memory stream of documents.
-   * @returns The memory stream of documents.
-   */
-  getMemoryStream(): DocumentInterface[];
-  /**
-   * Set the memory stream of documents.
-   * @param memoryStream The new memory stream of documents.
-   */
-  setMemoryStream(memoryStream: DocumentInterface[]): void;
-  /**
-   * Get relevant documents based on time-weighted relevance
-   * @param query - The query to search for
-   * @returns The relevant documents
-   */
-  _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<DocumentInterface[]>;
-  /**
-   * NOTE: When adding documents to a vector store, use addDocuments
-   * via retriever instead of directly to the vector store.
-   * This is because it is necessary to process the document
-   * in prepareDocuments.
-   *
-   * @param docs - The documents to add to vector store in the retriever
-   */
-  addDocuments(docs: DocumentInterface[]): Promise<void>;
-  /**
-   * Get memory documents and their scores
-   * @returns An object containing memory documents and their scores
-   */
-  private getMemoryDocsAndScores;
-  private getSalientDocuments;
-  /**
-   * Compute the final result set of documents based on the combined scores
-   * @param docsAndScores - An object containing documents and their scores
-   * @param now - The current timestamp
-   * @returns The final set of documents
-   */
-  private computeResults;
-  /**
-   * Prepare documents with necessary metadata before saving
-   * @param docs - The documents to prepare
-   * @param now - The current timestamp
-   * @returns The prepared documents
-   */
-  private prepareDocuments;
-  /**
-   * Calculate the combined score based on vector relevance and other factors
-   * @param doc - The document to calculate the score for
-   * @param vectorRelevance - The relevance score from the vector store
-   * @param nowMsec - The current timestamp in milliseconds
-   * @returns The combined score for the document
-   */
-  private getCombinedScore;
-  /**
-   * Calculate the hours passed between two time points
-   * @param time - The current time in seconds
-   * @param refTime - The reference time in seconds
-   * @returns The number of hours passed between the two time points
-   */
-  private getHoursPassed;
-}
-//#endregion
-export { BUFFER_IDX, LAST_ACCESSED_AT_KEY, TimeWeightedVectorStoreRetriever, TimeWeightedVectorStoreRetrieverFields };
-//# sourceMappingURL=time_weighted.d.ts.map

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.getRelevantDocuments(\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.js

@@ -1,228 +0,0 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
-import { BaseRetriever } from "@langchain/core/retrievers";
-
-//#region src/retrievers/time_weighted.ts
-var time_weighted_exports = {};
-__export(time_weighted_exports, {
-	BUFFER_IDX: () => BUFFER_IDX,
-	LAST_ACCESSED_AT_KEY: () => LAST_ACCESSED_AT_KEY,
-	TimeWeightedVectorStoreRetriever: () => TimeWeightedVectorStoreRetriever
-});
-const LAST_ACCESSED_AT_KEY = "last_accessed_at";
-const BUFFER_IDX = "buffer_idx";
-/**
-* TimeWeightedVectorStoreRetriever retrieves documents based on their time-weighted relevance.
-* ref: https://github.com/langchain-ai/langchain/blob/master/libs/langchain/langchain/retrievers/time_weighted_retriever.py
-* @example
-* ```typescript
-* const retriever = new TimeWeightedVectorStoreRetriever({
-*   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),
-*   memoryStream: [],
-*   searchKwargs: 2,
-* });
-* await retriever.addDocuments([
-*   { pageContent: "My name is John.", metadata: {} },
-*   { pageContent: "My favourite food is pizza.", metadata: {} },
-*
-* ]);
-* const results = await retriever.getRelevantDocuments(
-*   "What is my favourite food?",
-* );
-* ```
-*/
-var TimeWeightedVectorStoreRetriever = class extends BaseRetriever {
-	static lc_name() {
-		return "TimeWeightedVectorStoreRetriever";
-	}
-	get lc_namespace() {
-		return [
-			"langchain",
-			"retrievers",
-			"time_weighted"
-		];
-	}
-	/**
-	* The vectorstore to store documents and determine salience.
-	*/
-	vectorStore;
-	/**
-	* The number of top K most relevant documents to consider when searching.
-	*/
-	searchKwargs;
-	/**
-	* The memory_stream of documents to search through.
-	*/
-	memoryStream;
-	/**
-	* The exponential decay factor used as (1.0-decay_rate)**(hrs_passed).
-	*/
-	decayRate;
-	/**
-	* The maximum number of documents to retrieve in a given call.
-	*/
-	k;
-	/**
-	* Other keys in the metadata to factor into the score, e.g. 'importance'.
-	*/
-	otherScoreKeys;
-	/**
-	* The salience to assign memories not retrieved from the vector store.
-	*/
-	defaultSalience;
-	/**
-	* Constructor to initialize the required fields
-	* @param fields - The fields required for initializing the TimeWeightedVectorStoreRetriever
-	*/
-	constructor(fields) {
-		super(fields);
-		this.vectorStore = fields.vectorStore;
-		this.searchKwargs = fields.searchKwargs ?? 100;
-		this.memoryStream = fields.memoryStream ?? [];
-		this.decayRate = fields.decayRate ?? .01;
-		this.k = fields.k ?? 4;
-		this.otherScoreKeys = fields.otherScoreKeys ?? [];
-		this.defaultSalience = fields.defaultSalience ?? null;
-	}
-	/**
-	* Get the memory stream of documents.
-	* @returns The memory stream of documents.
-	*/
-	getMemoryStream() {
-		return this.memoryStream;
-	}
-	/**
-	* Set the memory stream of documents.
-	* @param memoryStream The new memory stream of documents.
-	*/
-	setMemoryStream(memoryStream) {
-		this.memoryStream = memoryStream;
-	}
-	/**
-	* Get relevant documents based on time-weighted relevance
-	* @param query - The query to search for
-	* @returns The relevant documents
-	*/
-	async _getRelevantDocuments(query, runManager) {
-		const now = Math.floor(Date.now() / 1e3);
-		const memoryDocsAndScores = this.getMemoryDocsAndScores();
-		const salientDocsAndScores = await this.getSalientDocuments(query, runManager);
-		const docsAndScores = {
-			...memoryDocsAndScores,
-			...salientDocsAndScores
-		};
-		return this.computeResults(docsAndScores, now);
-	}
-	/**
-	* NOTE: When adding documents to a vector store, use addDocuments
-	* via retriever instead of directly to the vector store.
-	* This is because it is necessary to process the document
-	* in prepareDocuments.
-	*
-	* @param docs - The documents to add to vector store in the retriever
-	*/
-	async addDocuments(docs) {
-		const now = Math.floor(Date.now() / 1e3);
-		const savedDocs = this.prepareDocuments(docs, now);
-		this.memoryStream.push(...savedDocs);
-		await this.vectorStore.addDocuments(savedDocs);
-	}
-	/**
-	* Get memory documents and their scores
-	* @returns An object containing memory documents and their scores
-	*/
-	getMemoryDocsAndScores() {
-		const memoryDocsAndScores = {};
-		for (const doc of this.memoryStream.slice(-this.k)) {
-			const bufferIdx = doc.metadata[BUFFER_IDX];
-			if (bufferIdx === void 0) throw new Error(`Found a document in the vector store that is missing required metadata. This retriever only supports vector stores with documents that have been added through the "addDocuments" method on a TimeWeightedVectorStoreRetriever, not directly added or loaded into the backing vector store.`);
-			memoryDocsAndScores[bufferIdx] = {
-				doc,
-				score: this.defaultSalience ?? 0
-			};
-		}
-		return memoryDocsAndScores;
-	}
-	/**
-	* Get salient documents and their scores based on the query
-	* @param query - The query to search for
-	* @returns An object containing salient documents and their scores
-	*/
-	async getSalientDocuments(query, runManager) {
-		const docAndScores = await this.vectorStore.similaritySearchWithScore(query, this.searchKwargs, void 0, runManager?.getChild());
-		const results = {};
-		for (const [fetchedDoc, score] of docAndScores) {
-			const bufferIdx = fetchedDoc.metadata[BUFFER_IDX];
-			if (bufferIdx === void 0) throw new Error(`Found a document in the vector store that is missing required metadata. This retriever only supports vector stores with documents that have been added through the "addDocuments" method on a TimeWeightedVectorStoreRetriever, not directly added or loaded into the backing vector store.`);
-			const doc = this.memoryStream[bufferIdx];
-			results[bufferIdx] = {
-				doc,
-				score
-			};
-		}
-		return results;
-	}
-	/**
-	* Compute the final result set of documents based on the combined scores
-	* @param docsAndScores - An object containing documents and their scores
-	* @param now - The current timestamp
-	* @returns The final set of documents
-	*/
-	computeResults(docsAndScores, now) {
-		const recordedDocs = Object.values(docsAndScores).map(({ doc, score }) => ({
-			doc,
-			score: this.getCombinedScore(doc, score, now)
-		})).sort((a, b) => b.score - a.score);
-		const results = [];
-		for (const { doc } of recordedDocs) {
-			const bufferedDoc = this.memoryStream[doc.metadata[BUFFER_IDX]];
-			bufferedDoc.metadata[LAST_ACCESSED_AT_KEY] = now;
-			results.push(bufferedDoc);
-			if (results.length > this.k) break;
-		}
-		return results;
-	}
-	/**
-	* Prepare documents with necessary metadata before saving
-	* @param docs - The documents to prepare
-	* @param now - The current timestamp
-	* @returns The prepared documents
-	*/
-	prepareDocuments(docs, now) {
-		return docs.map((doc, i) => ({
-			...doc,
-			metadata: {
-				...doc.metadata,
-				[LAST_ACCESSED_AT_KEY]: doc.metadata[LAST_ACCESSED_AT_KEY] ?? now,
-				created_at: doc.metadata.created_at ?? now,
-				[BUFFER_IDX]: this.memoryStream.length + i
-			}
-		}));
-	}
-	/**
-	* Calculate the combined score based on vector relevance and other factors
-	* @param doc - The document to calculate the score for
-	* @param vectorRelevance - The relevance score from the vector store
-	* @param nowMsec - The current timestamp in milliseconds
-	* @returns The combined score for the document
-	*/
-	getCombinedScore(doc, vectorRelevance, nowMsec) {
-		const hoursPassed = this.getHoursPassed(nowMsec, doc.metadata[LAST_ACCESSED_AT_KEY]);
-		let score = (1 - this.decayRate) ** hoursPassed;
-		for (const key of this.otherScoreKeys) score += doc.metadata[key];
-		if (vectorRelevance !== null) score += vectorRelevance;
-		return score;
-	}
-	/**
-	* Calculate the hours passed between two time points
-	* @param time - The current time in seconds
-	* @param refTime - The reference time in seconds
-	* @returns The number of hours passed between the two time points
-	*/
-	getHoursPassed(time, refTime) {
-		return (time - refTime) / 3600;
-	}
-};
-
-//#endregion
-export { BUFFER_IDX, LAST_ACCESSED_AT_KEY, TimeWeightedVectorStoreRetriever, time_weighted_exports };
-//# sourceMappingURL=time_weighted.js.map

package/dist/retrievers/time_weighted.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"time_weighted.js","names":["fields: TimeWeightedVectorStoreRetrieverFields","memoryStream: DocumentInterface[]","query: string","runManager?: CallbackManagerForRetrieverRun","docs: DocumentInterface[]","memoryDocsAndScores: Record<\n      number,\n      { doc: DocumentInterface; score: number }\n    >","docAndScores: [DocumentInterface, number][]","results: Record<number, { doc: DocumentInterface; score: number }>","docsAndScores: Record<number, { doc: DocumentInterface; score: number }>","now: number","results: DocumentInterface[]","doc: DocumentInterface","vectorRelevance: number | null","nowMsec: number","time: number","refTime: number"],"sources":["../../src/retrievers/time_weighted.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/**\n * Interface for the fields required to initialize a\n * TimeWeightedVectorStoreRetriever instance.\n */\nexport interface TimeWeightedVectorStoreRetrieverFields\n  extends BaseRetrieverInput {\n  vectorStore: VectorStoreInterface;\n  searchKwargs?: number;\n  memoryStream?: DocumentInterface[];\n  decayRate?: number;\n  k?: number;\n  otherScoreKeys?: string[];\n  defaultSalience?: number;\n}\n\nexport const LAST_ACCESSED_AT_KEY = \"last_accessed_at\";\nexport const BUFFER_IDX = \"buffer_idx\";\n\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.getRelevantDocuments(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport class TimeWeightedVectorStoreRetriever extends BaseRetriever {\n  static lc_name() {\n    return \"TimeWeightedVectorStoreRetriever\";\n  }\n\n  get lc_namespace() {\n    return [\"langchain\", \"retrievers\", \"time_weighted\"];\n  }\n\n  /**\n   * The vectorstore to store documents and determine salience.\n   */\n  private vectorStore: VectorStoreInterface;\n\n  /**\n   * The number of top K most relevant documents to consider when searching.\n   */\n  private searchKwargs: number;\n\n  /**\n   * The memory_stream of documents to search through.\n   */\n  private memoryStream: DocumentInterface[];\n\n  /**\n   * The exponential decay factor used as (1.0-decay_rate)**(hrs_passed).\n   */\n  private decayRate: number;\n\n  /**\n   * The maximum number of documents to retrieve in a given call.\n   */\n  private k: number;\n\n  /**\n   * Other keys in the metadata to factor into the score, e.g. 'importance'.\n   */\n  private otherScoreKeys: string[];\n\n  /**\n   * The salience to assign memories not retrieved from the vector store.\n   */\n  private defaultSalience: number | null;\n\n  /**\n   * Constructor to initialize the required fields\n   * @param fields - The fields required for initializing the TimeWeightedVectorStoreRetriever\n   */\n  constructor(fields: TimeWeightedVectorStoreRetrieverFields) {\n    super(fields);\n    this.vectorStore = fields.vectorStore;\n    this.searchKwargs = fields.searchKwargs ?? 100;\n    this.memoryStream = fields.memoryStream ?? [];\n    this.decayRate = fields.decayRate ?? 0.01;\n    this.k = fields.k ?? 4;\n    this.otherScoreKeys = fields.otherScoreKeys ?? [];\n    this.defaultSalience = fields.defaultSalience ?? null;\n  }\n\n  /**\n   * Get the memory stream of documents.\n   * @returns The memory stream of documents.\n   */\n  getMemoryStream(): DocumentInterface[] {\n    return this.memoryStream;\n  }\n\n  /**\n   * Set the memory stream of documents.\n   * @param memoryStream The new memory stream of documents.\n   */\n  setMemoryStream(memoryStream: DocumentInterface[]) {\n    this.memoryStream = memoryStream;\n  }\n\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  async _getRelevantDocuments(\n    query: string,\n    runManager?: CallbackManagerForRetrieverRun\n  ): Promise<DocumentInterface[]> {\n    const now = Math.floor(Date.now() / 1000);\n    const memoryDocsAndScores = this.getMemoryDocsAndScores();\n\n    const salientDocsAndScores = await this.getSalientDocuments(\n      query,\n      runManager\n    );\n    const docsAndScores = { ...memoryDocsAndScores, ...salientDocsAndScores };\n\n    return this.computeResults(docsAndScores, now);\n  }\n\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  async addDocuments(docs: DocumentInterface[]): Promise<void> {\n    const now = Math.floor(Date.now() / 1000);\n    const savedDocs = this.prepareDocuments(docs, now);\n\n    this.memoryStream.push(...savedDocs);\n    await this.vectorStore.addDocuments(savedDocs);\n  }\n\n  /**\n   * Get memory documents and their scores\n   * @returns An object containing memory documents and their scores\n   */\n  private getMemoryDocsAndScores(): Record<\n    number,\n    { doc: DocumentInterface; score: number }\n  > {\n    const memoryDocsAndScores: Record<\n      number,\n      { doc: DocumentInterface; score: number }\n    > = {};\n    for (const doc of this.memoryStream.slice(-this.k)) {\n      const bufferIdx = doc.metadata[BUFFER_IDX];\n      if (bufferIdx === undefined) {\n        throw new Error(\n          `Found a document in the vector store that is missing required metadata. This retriever only supports vector stores with documents that have been added through the \"addDocuments\" method on a TimeWeightedVectorStoreRetriever, not directly added or loaded into the backing vector store.`\n        );\n      }\n      memoryDocsAndScores[bufferIdx] = {\n        doc,\n        score: this.defaultSalience ?? 0,\n      };\n    }\n    return memoryDocsAndScores;\n  }\n\n  /**\n   * Get salient documents and their scores based on the query\n   * @param query - The query to search for\n   * @returns An object containing salient documents and their scores\n   */\n  private async getSalientDocuments(\n    query: string,\n    runManager?: CallbackManagerForRetrieverRun\n  ): Promise<Record<number, { doc: DocumentInterface; score: number }>> {\n    const docAndScores: [DocumentInterface, number][] =\n      await this.vectorStore.similaritySearchWithScore(\n        query,\n        this.searchKwargs,\n        undefined,\n        runManager?.getChild()\n      );\n    const results: Record<number, { doc: DocumentInterface; score: number }> =\n      {};\n    for (const [fetchedDoc, score] of docAndScores) {\n      const bufferIdx = fetchedDoc.metadata[BUFFER_IDX];\n      if (bufferIdx === undefined) {\n        throw new Error(\n          `Found a document in the vector store that is missing required metadata. This retriever only supports vector stores with documents that have been added through the \"addDocuments\" method on a TimeWeightedVectorStoreRetriever, not directly added or loaded into the backing vector store.`\n        );\n      }\n      const doc = this.memoryStream[bufferIdx];\n      results[bufferIdx] = { doc, score };\n    }\n    return results;\n  }\n\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    docsAndScores: Record<number, { doc: DocumentInterface; score: number }>,\n    now: number\n  ): DocumentInterface[] {\n    const recordedDocs = Object.values(docsAndScores)\n      .map(({ doc, score }) => ({\n        doc,\n        score: this.getCombinedScore(doc, score, now),\n      }))\n      .sort((a, b) => b.score - a.score);\n\n    const results: DocumentInterface[] = [];\n    for (const { doc } of recordedDocs) {\n      const bufferedDoc = this.memoryStream[doc.metadata[BUFFER_IDX]];\n      bufferedDoc.metadata[LAST_ACCESSED_AT_KEY] = now;\n      results.push(bufferedDoc);\n      if (results.length > this.k) {\n        break;\n      }\n    }\n    return results;\n  }\n\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    docs: DocumentInterface[],\n    now: number\n  ): DocumentInterface[] {\n    return docs.map((doc, i) => ({\n      ...doc,\n      metadata: {\n        ...doc.metadata,\n        [LAST_ACCESSED_AT_KEY]: doc.metadata[LAST_ACCESSED_AT_KEY] ?? now,\n        created_at: doc.metadata.created_at ?? now,\n        [BUFFER_IDX]: this.memoryStream.length + i,\n      },\n    }));\n  }\n\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    doc: DocumentInterface,\n    vectorRelevance: number | null,\n    nowMsec: number\n  ): number {\n    const hoursPassed = this.getHoursPassed(\n      nowMsec,\n      doc.metadata[LAST_ACCESSED_AT_KEY]\n    );\n    let score = (1.0 - this.decayRate) ** hoursPassed;\n    for (const key of this.otherScoreKeys) {\n      score += doc.metadata[key];\n    }\n    if (vectorRelevance !== null) {\n      score += vectorRelevance;\n    }\n    return score;\n  }\n\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(time: number, refTime: number): number {\n    return (time - refTime) / 3600;\n  }\n}\n"],"mappings":"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"}

package/dist/sql_db.cjs

@@ -1,119 +0,0 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_sql_utils = require('./util/sql_utils.cjs');
-const __langchain_core_load_serializable = require_rolldown_runtime.__toESM(require("@langchain/core/load/serializable"));
-
-//#region src/sql_db.ts
-var sql_db_exports = {};
-require_rolldown_runtime.__export(sql_db_exports, { SqlDatabase: () => SqlDatabase });
-/**
-* Class that represents a SQL database in the LangChain framework.
-*
-* @security **Security Notice**
-* This class generates SQL queries for the given database.
-* The SQLDatabase class provides a getTableInfo method that can be used
-* to get column information as well as sample data from the table.
-* To mitigate risk of leaking sensitive data, limit permissions
-* to read and scope to the tables that are needed.
-* Optionally, use the includesTables or ignoreTables class parameters
-* to limit which tables can/cannot be accessed.
-*
-* @link See https://js.langchain.com/docs/security for more information.
-*/
-var SqlDatabase = class SqlDatabase extends __langchain_core_load_serializable.Serializable {
-	lc_namespace = ["langchain", "sql_db"];
-	toJSON() {
-		return this.toJSONNotImplemented();
-	}
-	appDataSourceOptions;
-	appDataSource;
-	allTables = [];
-	includesTables = [];
-	ignoreTables = [];
-	sampleRowsInTableInfo = 3;
-	customDescription;
-	constructor(fields) {
-		super(...arguments);
-		this.appDataSource = fields.appDataSource;
-		this.appDataSourceOptions = fields.appDataSource.options;
-		if (fields?.includesTables && fields?.ignoreTables) throw new Error("Cannot specify both includeTables and ignoreTables");
-		this.includesTables = fields?.includesTables ?? [];
-		this.ignoreTables = fields?.ignoreTables ?? [];
-		this.sampleRowsInTableInfo = fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;
-	}
-	static async fromDataSourceParams(fields) {
-		const sqlDatabase = new SqlDatabase(fields);
-		if (!sqlDatabase.appDataSource.isInitialized) await sqlDatabase.appDataSource.initialize();
-		sqlDatabase.allTables = await require_sql_utils.getTableAndColumnsName(sqlDatabase.appDataSource);
-		sqlDatabase.customDescription = Object.fromEntries(Object.entries(fields?.customDescription ?? {}).filter(([key, _]) => sqlDatabase.allTables.map((table) => table.tableName).includes(key)));
-		require_sql_utils.verifyIncludeTablesExistInDatabase(sqlDatabase.allTables, sqlDatabase.includesTables);
-		require_sql_utils.verifyIgnoreTablesExistInDatabase(sqlDatabase.allTables, sqlDatabase.ignoreTables);
-		return sqlDatabase;
-	}
-	static async fromOptionsParams(fields) {
-		const { DataSource } = await import("typeorm");
-		const dataSource = new DataSource(fields.appDataSourceOptions);
-		return SqlDatabase.fromDataSourceParams({
-			...fields,
-			appDataSource: dataSource
-		});
-	}
-	/**
-	* Get information about specified tables.
-	*
-	* Follows best practices as specified in: Rajkumar et al, 2022
-	* (https://arxiv.org/abs/2204.00498)
-	*
-	* If `sample_rows_in_table_info`, the specified number of sample rows will be
-	* appended to each table description. This can increase performance as
-	* demonstrated in the paper.
-	*/
-	async getTableInfo(targetTables) {
-		let selectedTables = this.includesTables.length > 0 ? this.allTables.filter((currentTable) => this.includesTables.includes(currentTable.tableName)) : this.allTables;
-		if (this.ignoreTables.length > 0) selectedTables = selectedTables.filter((currentTable) => !this.ignoreTables.includes(currentTable.tableName));
-		if (targetTables && targetTables.length > 0) {
-			require_sql_utils.verifyListTablesExistInDatabase(this.allTables, targetTables, "Wrong target table name:");
-			selectedTables = this.allTables.filter((currentTable) => targetTables.includes(currentTable.tableName));
-		}
-		return require_sql_utils.generateTableInfoFromTables(selectedTables, this.appDataSource, this.sampleRowsInTableInfo, this.customDescription);
-	}
-	/**
-	* Execute a SQL command and return a string representing the results.
-	* If the statement returns rows, a string of the results is returned.
-	* If the statement returns no rows, an empty string is returned.
-	*/
-	async run(command, fetch = "all") {
-		const res = await this.appDataSource.query(command);
-		if (fetch === "all") return JSON.stringify(res);
-		if (res?.length > 0) return JSON.stringify(res[0]);
-		return "";
-	}
-	serialize() {
-		return {
-			_type: "sql_database",
-			appDataSourceOptions: this.appDataSourceOptions,
-			includesTables: this.includesTables,
-			ignoreTables: this.ignoreTables,
-			sampleRowsInTableInfo: this.sampleRowsInTableInfo
-		};
-	}
-	/** @ignore */
-	static async imports() {
-		try {
-			const { DataSource } = await import("typeorm");
-			return { DataSource };
-		} catch (e) {
-			console.error(e);
-			throw new Error("Failed to load typeorm. Please install it with eg. `pnpm install typeorm`.");
-		}
-	}
-};
-
-//#endregion
-exports.SqlDatabase = SqlDatabase;
-Object.defineProperty(exports, 'sql_db_exports', {
-  enumerable: true,
-  get: function () {
-    return sql_db_exports;
-  }
-});
-//# sourceMappingURL=sql_db.cjs.map

package/dist/sql_db.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"sql_db.cjs","names":["Serializable","fields: SqlDatabaseDataSourceParams","getTableAndColumnsName","table: SqlTable","verifyIncludeTablesExistInDatabase","verifyIgnoreTablesExistInDatabase","fields: SqlDatabaseOptionsParams","targetTables?: Array<string>","verifyListTablesExistInDatabase","generateTableInfoFromTables","command: string","fetch: \"all\" | \"one\""],"sources":["../src/sql_db.ts"],"sourcesContent":["import type { DataSource as DataSourceT, DataSourceOptions } from \"typeorm\";\nimport { Serializable } from \"@langchain/core/load/serializable\";\nimport {\n  generateTableInfoFromTables,\n  getTableAndColumnsName,\n  SerializedSqlDatabase,\n  SqlDatabaseDataSourceParams,\n  SqlDatabaseOptionsParams,\n  SqlTable,\n  verifyIgnoreTablesExistInDatabase,\n  verifyIncludeTablesExistInDatabase,\n  verifyListTablesExistInDatabase,\n} from \"./util/sql_utils.js\";\n\nexport type { SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams };\n\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 class SqlDatabase\n  extends Serializable\n  implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams\n{\n  lc_namespace = [\"langchain\", \"sql_db\"];\n\n  toJSON() {\n    return this.toJSONNotImplemented();\n  }\n\n  appDataSourceOptions: DataSourceOptions;\n\n  appDataSource: DataSourceT;\n\n  allTables: Array<SqlTable> = [];\n\n  includesTables: Array<string> = [];\n\n  ignoreTables: Array<string> = [];\n\n  sampleRowsInTableInfo = 3;\n\n  customDescription?: Record<string, string>;\n\n  protected constructor(fields: SqlDatabaseDataSourceParams) {\n    super(...arguments);\n    this.appDataSource = fields.appDataSource;\n    this.appDataSourceOptions = fields.appDataSource.options;\n    if (fields?.includesTables && fields?.ignoreTables) {\n      throw new Error(\"Cannot specify both includeTables and ignoreTables\");\n    }\n    this.includesTables = fields?.includesTables ?? [];\n    this.ignoreTables = fields?.ignoreTables ?? [];\n    this.sampleRowsInTableInfo =\n      fields?.sampleRowsInTableInfo ?? this.sampleRowsInTableInfo;\n  }\n\n  static async fromDataSourceParams(\n    fields: SqlDatabaseDataSourceParams\n  ): Promise<SqlDatabase> {\n    const sqlDatabase = new SqlDatabase(fields);\n    if (!sqlDatabase.appDataSource.isInitialized) {\n      await sqlDatabase.appDataSource.initialize();\n    }\n    sqlDatabase.allTables = await getTableAndColumnsName(\n      sqlDatabase.appDataSource\n    );\n    sqlDatabase.customDescription = Object.fromEntries(\n      Object.entries(fields?.customDescription ?? {}).filter(([key, _]) =>\n        sqlDatabase.allTables\n          .map((table: SqlTable) => table.tableName)\n          .includes(key)\n      )\n    );\n    verifyIncludeTablesExistInDatabase(\n      sqlDatabase.allTables,\n      sqlDatabase.includesTables\n    );\n    verifyIgnoreTablesExistInDatabase(\n      sqlDatabase.allTables,\n      sqlDatabase.ignoreTables\n    );\n    return sqlDatabase;\n  }\n\n  static async fromOptionsParams(\n    fields: SqlDatabaseOptionsParams\n  ): Promise<SqlDatabase> {\n    const { DataSource } = await import(\"typeorm\");\n    const dataSource = new DataSource(fields.appDataSourceOptions);\n    return SqlDatabase.fromDataSourceParams({\n      ...fields,\n      appDataSource: dataSource,\n    });\n  }\n\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  async getTableInfo(targetTables?: Array<string>): Promise<string> {\n    let selectedTables =\n      this.includesTables.length > 0\n        ? this.allTables.filter((currentTable) =>\n            this.includesTables.includes(currentTable.tableName)\n          )\n        : this.allTables;\n\n    if (this.ignoreTables.length > 0) {\n      selectedTables = selectedTables.filter(\n        (currentTable) => !this.ignoreTables.includes(currentTable.tableName)\n      );\n    }\n\n    if (targetTables && targetTables.length > 0) {\n      verifyListTablesExistInDatabase(\n        this.allTables,\n        targetTables,\n        \"Wrong target table name:\"\n      );\n      selectedTables = this.allTables.filter((currentTable) =>\n        targetTables.includes(currentTable.tableName)\n      );\n    }\n\n    return generateTableInfoFromTables(\n      selectedTables,\n      this.appDataSource,\n      this.sampleRowsInTableInfo,\n      this.customDescription\n    );\n  }\n\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  async run(command: string, fetch: \"all\" | \"one\" = \"all\"): Promise<string> {\n    // TODO: Potential security issue here\n    const res = await this.appDataSource.query(command);\n\n    if (fetch === \"all\") {\n      return JSON.stringify(res);\n    }\n\n    if (res?.length > 0) {\n      return JSON.stringify(res[0]);\n    }\n\n    return \"\";\n  }\n\n  serialize(): SerializedSqlDatabase {\n    return {\n      _type: \"sql_database\",\n      appDataSourceOptions: this.appDataSourceOptions,\n      includesTables: this.includesTables,\n      ignoreTables: this.ignoreTables,\n      sampleRowsInTableInfo: this.sampleRowsInTableInfo,\n    };\n  }\n\n  /** @ignore */\n  static async imports() {\n    try {\n      const { DataSource } = await import(\"typeorm\");\n      return { DataSource };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        \"Failed to load typeorm. Please install it with eg. `pnpm install typeorm`.\"\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,cAAb,MAAa,oBACHA,gDAEV;CACE,eAAe,CAAC,aAAa,QAAS;CAEtC,SAAS;AACP,SAAO,KAAK,sBAAsB;CACnC;CAED;CAEA;CAEA,YAA6B,CAAE;CAE/B,iBAAgC,CAAE;CAElC,eAA8B,CAAE;CAEhC,wBAAwB;CAExB;CAEA,AAAU,YAAYC,QAAqC;EACzD,MAAM,GAAG,UAAU;EACnB,KAAK,gBAAgB,OAAO;EAC5B,KAAK,uBAAuB,OAAO,cAAc;AACjD,MAAI,QAAQ,kBAAkB,QAAQ,aACpC,OAAM,IAAI,MAAM;EAElB,KAAK,iBAAiB,QAAQ,kBAAkB,CAAE;EAClD,KAAK,eAAe,QAAQ,gBAAgB,CAAE;EAC9C,KAAK,wBACH,QAAQ,yBAAyB,KAAK;CACzC;CAED,aAAa,qBACXA,QACsB;EACtB,MAAM,cAAc,IAAI,YAAY;AACpC,MAAI,CAAC,YAAY,cAAc,eAC7B,MAAM,YAAY,cAAc,YAAY;EAE9C,YAAY,YAAY,MAAMC,yCAC5B,YAAY,cACb;EACD,YAAY,oBAAoB,OAAO,YACrC,OAAO,QAAQ,QAAQ,qBAAqB,CAAE,EAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAC9D,YAAY,UACT,IAAI,CAACC,UAAoB,MAAM,UAAU,CACzC,SAAS,IAAI,CACjB,CACF;EACDC,qDACE,YAAY,WACZ,YAAY,eACb;EACDC,oDACE,YAAY,WACZ,YAAY,aACb;AACD,SAAO;CACR;CAED,aAAa,kBACXC,QACsB;EACtB,MAAM,EAAE,YAAY,GAAG,MAAM,OAAO;EACpC,MAAM,aAAa,IAAI,WAAW,OAAO;AACzC,SAAO,YAAY,qBAAqB;GACtC,GAAG;GACH,eAAe;EAChB,EAAC;CACH;;;;;;;;;;;CAYD,MAAM,aAAaC,cAA+C;EAChE,IAAI,iBACF,KAAK,eAAe,SAAS,IACzB,KAAK,UAAU,OAAO,CAAC,iBACrB,KAAK,eAAe,SAAS,aAAa,UAAU,CACrD,GACD,KAAK;AAEX,MAAI,KAAK,aAAa,SAAS,GAC7B,iBAAiB,eAAe,OAC9B,CAAC,iBAAiB,CAAC,KAAK,aAAa,SAAS,aAAa,UAAU,CACtE;AAGH,MAAI,gBAAgB,aAAa,SAAS,GAAG;GAC3CC,kDACE,KAAK,WACL,cACA,2BACD;GACD,iBAAiB,KAAK,UAAU,OAAO,CAAC,iBACtC,aAAa,SAAS,aAAa,UAAU,CAC9C;EACF;AAED,SAAOC,8CACL,gBACA,KAAK,eACL,KAAK,uBACL,KAAK,kBACN;CACF;;;;;;CAOD,MAAM,IAAIC,SAAiBC,QAAuB,OAAwB;EAExE,MAAM,MAAM,MAAM,KAAK,cAAc,MAAM,QAAQ;AAEnD,MAAI,UAAU,MACZ,QAAO,KAAK,UAAU,IAAI;AAG5B,MAAI,KAAK,SAAS,EAChB,QAAO,KAAK,UAAU,IAAI,GAAG;AAG/B,SAAO;CACR;CAED,YAAmC;AACjC,SAAO;GACL,OAAO;GACP,sBAAsB,KAAK;GAC3B,gBAAgB,KAAK;GACrB,cAAc,KAAK;GACnB,uBAAuB,KAAK;EAC7B;CACF;;CAGD,aAAa,UAAU;AACrB,MAAI;GACF,MAAM,EAAE,YAAY,GAAG,MAAM,OAAO;AACpC,UAAO,EAAE,WAAY;EACtB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR;EAEH;CACF;AACF"}

package/dist/sql_db.d.cts

@@ -1,60 +0,0 @@
-import { SerializedSqlDatabase, SqlDatabaseDataSourceParams, SqlDatabaseOptionsParams, SqlTable } from "./util/sql_utils.cjs";
-import * as _langchain_core_load_serializable0 from "@langchain/core/load/serializable";
-import { Serializable } from "@langchain/core/load/serializable";
-import { DataSource, DataSourceOptions } from "typeorm";
-
-//#region src/sql_db.d.ts
-
-/**
- * Class that represents a SQL database in the LangChain framework.
- *
- * @security **Security Notice**
- * This class generates SQL queries for the given database.
- * The SQLDatabase class provides a getTableInfo method that can be used
- * to get column information as well as sample data from the table.
- * To mitigate risk of leaking sensitive data, limit permissions
- * to read and scope to the tables that are needed.
- * Optionally, use the includesTables or ignoreTables class parameters
- * to limit which tables can/cannot be accessed.
- *
- * @link See https://js.langchain.com/docs/security for more information.
- */
-declare class SqlDatabase extends Serializable implements SqlDatabaseOptionsParams, SqlDatabaseDataSourceParams {
-  lc_namespace: string[];
-  toJSON(): _langchain_core_load_serializable0.SerializedNotImplemented;
-  appDataSourceOptions: DataSourceOptions;
-  appDataSource: DataSource;
-  allTables: Array<SqlTable>;
-  includesTables: Array<string>;
-  ignoreTables: Array<string>;
-  sampleRowsInTableInfo: number;
-  customDescription?: Record<string, string>;
-  protected constructor(fields: SqlDatabaseDataSourceParams);
-  static fromDataSourceParams(fields: SqlDatabaseDataSourceParams): Promise<SqlDatabase>;
-  static fromOptionsParams(fields: SqlDatabaseOptionsParams): Promise<SqlDatabase>;
-  /**
-   * Get information about specified tables.
-   *
-   * Follows best practices as specified in: Rajkumar et al, 2022
-   * (https://arxiv.org/abs/2204.00498)
-   *
-   * If `sample_rows_in_table_info`, the specified number of sample rows will be
-   * appended to each table description. This can increase performance as
-   * demonstrated in the paper.
-   */
-  getTableInfo(targetTables?: Array<string>): Promise<string>;
-  /**
-   * Execute a SQL command and return a string representing the results.
-   * If the statement returns rows, a string of the results is returned.
-   * If the statement returns no rows, an empty string is returned.
-   */
-  run(command: string, fetch?: "all" | "one"): Promise<string>;
-  serialize(): SerializedSqlDatabase;
-  /** @ignore */
-  static imports(): Promise<{
-    DataSource: typeof DataSource;
-  }>;
-}
-//#endregion
-export { SqlDatabase, type SqlDatabaseDataSourceParams, type SqlDatabaseOptionsParams };
-//# sourceMappingURL=sql_db.d.cts.map

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"}