@langchain/classic 1.0.0-alpha.1

package/dist/document_loaders/fs/multi_file.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","filePaths: string[]","loaders: LoadersMapping","unknown: UnknownHandling","UnknownHandling","documents: Document[]"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqCA,0DAAmB;CACtD,YACSC,WACAC,SACAC,UAA2BC,sDAAgB,MAClD;EACA,OAAO;EAJA;EACA;EACA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM;AAElB,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU,EACnC;OAAI,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,WAAW;EAChE;CAGN;;;;;;;;;;CAWD,MAAa,OAA4B;EACvC,MAAMC,YAAwB,CAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,kCAAmB,SAAS;GAClC,MAAM,WAAW,iCAAW,SAAS;AAErC,OAAI,SAAS,aAAa,EAAE;IAC1B,QAAQ,KAAK,CAAC,oBAAoB,EAAE,UAAU,CAAC;AAC/C;GACD;GAED,MAAM,gBAAgB,KAAK,+BAAgB,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;IACtC,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;GACzC,MACC,SAAQ,KAAK,SAAb;IACE,KAAKD,sDAAgB,OACnB;IACF,KAAKA,sDAAgB;KACnB,QAAQ,KAAK,CAAC,mBAAmB,EAAE,UAAU,CAAC;AAC9C;IACF,KAAKA,sDAAgB,MACnB,OAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,UAAU;IAClD,QACE,OAAM,IAAI,MAAM,CAAC,0BAA0B,EAAE,KAAK,SAAS;GAC9D;EAEJ;AAED,SAAO;CACR;AACF"}

package/dist/document_loaders/fs/multi_file.d.cts

@@ -0,0 +1,43 @@
+import { LoadersMapping, UnknownHandling } from "./directory.cjs";
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/document_loaders/fs/multi_file.d.ts
+
+/**
+ * A document loader that loads documents from multiple files. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ * @example
+ * ```typescript
+ *
+ * const multiFileLoader = new MultiFileLoader(
+ *   ["path/to/file1.pdf", "path/to/file2.txt"],
+ *   {
+ *     ".pdf": (path: string) => new PDFLoader(path),
+ *   },
+ * );
+ *
+ * const docs = await multiFileLoader.load();
+ * console.log({ docs });
+ *
+ * ```
+ */
+declare class MultiFileLoader extends BaseDocumentLoader {
+  filePaths: string[];
+  loaders: LoadersMapping;
+  unknown: UnknownHandling;
+  constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);
+  /**
+   * Loads the documents from the provided file paths. It checks if the file
+   * is a directory and ignores it. If a file is a file, it checks if there
+   * is a corresponding loader function for the file extension in the `loaders`
+   * mapping. If there is, it loads the documents. If there is no
+   * corresponding loader function and `unknown` is set to `Warn`, it logs a
+   * warning message. If `unknown` is set to `Error`, it throws an error.
+   * @returns A promise that resolves to an array of loaded documents.
+   */
+  load(): Promise<Document[]>;
+}
+//#endregion
+export { MultiFileLoader };
+//# sourceMappingURL=multi_file.d.cts.map

package/dist/document_loaders/fs/multi_file.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_file.d.cts","names":["Document","BaseDocumentLoader","LoadersMapping","UnknownHandling","MultiFileLoader","Promise"],"sources":["../../../src/document_loaders/fs/multi_file.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport declare class MultiFileLoader extends BaseDocumentLoader {\n    filePaths: string[];\n    loaders: LoadersMapping;\n    unknown: UnknownHandling;\n    constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);\n    /**\n     * Loads the documents from the provided file paths. It checks if the file\n     * is a directory and ignores it. If a file is a file, it checks if there\n     * is a corresponding loader function for the file extension in the `loaders`\n     * mapping. If there is, it loads the documents. If there is no\n     * corresponding loader function and `unknown` is set to `Warn`, it logs a\n     * warning message. If `unknown` is set to `Error`, it throws an error.\n     * @returns A promise that resolves to an array of loaded documents.\n     */\n    load(): Promise<Document[]>;\n}\n"],"mappings":";;;;;;;;AAqBA;;;;;;;;;AAA+D;;;;;;;cAA1CI,eAAAA,SAAwBH,kBAAAA;;WAEhCC;WACAC;4CACiCD,0BAA0BC;;;;;;;;;;UAU5DE,QAAQL"}

package/dist/document_loaders/fs/multi_file.d.ts

@@ -0,0 +1,43 @@
+import { LoadersMapping, UnknownHandling } from "./directory.js";
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/document_loaders/fs/multi_file.d.ts
+
+/**
+ * A document loader that loads documents from multiple files. It extends the
+ * `BaseDocumentLoader` class and implements the `load()` method.
+ * @example
+ * ```typescript
+ *
+ * const multiFileLoader = new MultiFileLoader(
+ *   ["path/to/file1.pdf", "path/to/file2.txt"],
+ *   {
+ *     ".pdf": (path: string) => new PDFLoader(path),
+ *   },
+ * );
+ *
+ * const docs = await multiFileLoader.load();
+ * console.log({ docs });
+ *
+ * ```
+ */
+declare class MultiFileLoader extends BaseDocumentLoader {
+  filePaths: string[];
+  loaders: LoadersMapping;
+  unknown: UnknownHandling;
+  constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);
+  /**
+   * Loads the documents from the provided file paths. It checks if the file
+   * is a directory and ignores it. If a file is a file, it checks if there
+   * is a corresponding loader function for the file extension in the `loaders`
+   * mapping. If there is, it loads the documents. If there is no
+   * corresponding loader function and `unknown` is set to `Warn`, it logs a
+   * warning message. If `unknown` is set to `Error`, it throws an error.
+   * @returns A promise that resolves to an array of loaded documents.
+   */
+  load(): Promise<Document[]>;
+}
+//#endregion
+export { MultiFileLoader };
+//# sourceMappingURL=multi_file.d.ts.map

package/dist/document_loaders/fs/multi_file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_file.d.ts","names":["Document","BaseDocumentLoader","LoadersMapping","UnknownHandling","MultiFileLoader","Promise"],"sources":["../../../src/document_loaders/fs/multi_file.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport declare class MultiFileLoader extends BaseDocumentLoader {\n    filePaths: string[];\n    loaders: LoadersMapping;\n    unknown: UnknownHandling;\n    constructor(filePaths: string[], loaders: LoadersMapping, unknown?: UnknownHandling);\n    /**\n     * Loads the documents from the provided file paths. It checks if the file\n     * is a directory and ignores it. If a file is a file, it checks if there\n     * is a corresponding loader function for the file extension in the `loaders`\n     * mapping. If there is, it loads the documents. If there is no\n     * corresponding loader function and `unknown` is set to `Warn`, it logs a\n     * warning message. If `unknown` is set to `Error`, it throws an error.\n     * @returns A promise that resolves to an array of loaded documents.\n     */\n    load(): Promise<Document[]>;\n}\n"],"mappings":";;;;;;;;AAqBA;;;;;;;;;AAA+D;;;;;;;cAA1CI,eAAAA,SAAwBH,kBAAAA;;WAEhCC;WACAC;4CACiCD,0BAA0BC;;;;;;;;;;UAU5DE,QAAQL"}

package/dist/document_loaders/fs/multi_file.js

@@ -0,0 +1,76 @@
+import { __export } from "../../_virtual/rolldown_runtime.js";
+import { UnknownHandling } from "./directory.js";
+import { extname, resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/document_loaders/fs/multi_file.ts
+var multi_file_exports = {};
+__export(multi_file_exports, { MultiFileLoader: () => MultiFileLoader });
+/**
+* A document loader that loads documents from multiple files. It extends the
+* `BaseDocumentLoader` class and implements the `load()` method.
+* @example
+* ```typescript
+*
+* const multiFileLoader = new MultiFileLoader(
+*   ["path/to/file1.pdf", "path/to/file2.txt"],
+*   {
+*     ".pdf": (path: string) => new PDFLoader(path),
+*   },
+* );
+*
+* const docs = await multiFileLoader.load();
+* console.log({ docs });
+*
+* ```
+*/
+var MultiFileLoader = class extends BaseDocumentLoader {
+	constructor(filePaths, loaders, unknown = UnknownHandling.Warn) {
+		super();
+		this.filePaths = filePaths;
+		this.loaders = loaders;
+		this.unknown = unknown;
+		if (Object.keys(loaders).length === 0) throw new Error("Must provide at least one loader");
+		for (const extension in loaders) if (Object.hasOwn(loaders, extension)) {
+			if (extension[0] !== ".") throw new Error(`Extension must start with a dot: ${extension}`);
+		}
+	}
+	/**
+	* Loads the documents from the provided file paths. It checks if the file
+	* is a directory and ignores it. If a file is a file, it checks if there
+	* is a corresponding loader function for the file extension in the `loaders`
+	* mapping. If there is, it loads the documents. If there is no
+	* corresponding loader function and `unknown` is set to `Warn`, it logs a
+	* warning message. If `unknown` is set to `Error`, it throws an error.
+	* @returns A promise that resolves to an array of loaded documents.
+	*/
+	async load() {
+		const documents = [];
+		for (const filePath of this.filePaths) {
+			const fullPath = resolve(filePath);
+			const fileStat = await stat(fullPath);
+			if (fileStat.isDirectory()) {
+				console.warn(`Ignoring directory: ${fullPath}`);
+				continue;
+			}
+			const loaderFactory = this.loaders[extname(fullPath)];
+			if (loaderFactory) {
+				const loader = loaderFactory(fullPath);
+				documents.push(...await loader.load());
+			} else switch (this.unknown) {
+				case UnknownHandling.Ignore: break;
+				case UnknownHandling.Warn:
+					console.warn(`Unknown file type: ${fullPath}`);
+					break;
+				case UnknownHandling.Error: throw new Error(`Unknown file type: ${fullPath}`);
+				default: throw new Error(`Unknown unknown handling: ${this.unknown}`);
+			}
+		}
+		return documents;
+	}
+};
+
+//#endregion
+export { MultiFileLoader, multi_file_exports };
+//# sourceMappingURL=multi_file.js.map

package/dist/document_loaders/fs/multi_file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi_file.js","names":["filePaths: string[]","loaders: LoadersMapping","unknown: UnknownHandling","documents: Document[]"],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"sourcesContent":["import { extname, resolve } from \"node:path\";\nimport { stat } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\nimport { type LoadersMapping, UnknownHandling } from \"./directory.js\";\n\n/**\n * A document loader that loads documents from multiple files. It extends the\n * `BaseDocumentLoader` class and implements the `load()` method.\n * @example\n * ```typescript\n *\n * const multiFileLoader = new MultiFileLoader(\n *   [\"path/to/file1.pdf\", \"path/to/file2.txt\"],\n *   {\n *     \".pdf\": (path: string) => new PDFLoader(path),\n *   },\n * );\n *\n * const docs = await multiFileLoader.load();\n * console.log({ docs });\n *\n * ```\n */\nexport class MultiFileLoader extends BaseDocumentLoader {\n  constructor(\n    public filePaths: string[],\n    public loaders: LoadersMapping,\n    public unknown: UnknownHandling = UnknownHandling.Warn\n  ) {\n    super();\n\n    if (Object.keys(loaders).length === 0) {\n      throw new Error(\"Must provide at least one loader\");\n    }\n    for (const extension in loaders) {\n      if (Object.hasOwn(loaders, extension)) {\n        if (extension[0] !== \".\") {\n          throw new Error(`Extension must start with a dot: ${extension}`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Loads the documents from the provided file paths. It checks if the file\n   * is a directory and ignores it. If a file is a file, it checks if there\n   * is a corresponding loader function for the file extension in the `loaders`\n   * mapping. If there is, it loads the documents. If there is no\n   * corresponding loader function and `unknown` is set to `Warn`, it logs a\n   * warning message. If `unknown` is set to `Error`, it throws an error.\n   * @returns A promise that resolves to an array of loaded documents.\n   */\n  public async load(): Promise<Document[]> {\n    const documents: Document[] = [];\n\n    for (const filePath of this.filePaths) {\n      const fullPath = resolve(filePath);\n      const fileStat = await stat(fullPath);\n\n      if (fileStat.isDirectory()) {\n        console.warn(`Ignoring directory: ${fullPath}`);\n        continue;\n      }\n\n      const loaderFactory = this.loaders[extname(fullPath)];\n      if (loaderFactory) {\n        const loader = loaderFactory(fullPath);\n        documents.push(...(await loader.load()));\n      } else {\n        switch (this.unknown) {\n          case UnknownHandling.Ignore:\n            break;\n          case UnknownHandling.Warn:\n            console.warn(`Unknown file type: ${fullPath}`);\n            break;\n          case UnknownHandling.Error:\n            throw new Error(`Unknown file type: ${fullPath}`);\n          default:\n            throw new Error(`Unknown unknown handling: ${this.unknown}`);\n        }\n      }\n    }\n\n    return documents;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqC,mBAAmB;CACtD,YACSA,WACAC,SACAC,UAA2B,gBAAgB,MAClD;EACA,OAAO;EAJA;EACA;EACA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM;AAElB,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU,EACnC;OAAI,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,WAAW;EAChE;CAGN;;;;;;;;;;CAWD,MAAa,OAA4B;EACvC,MAAMC,YAAwB,CAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,SAAS;GAClC,MAAM,WAAW,MAAM,KAAK,SAAS;AAErC,OAAI,SAAS,aAAa,EAAE;IAC1B,QAAQ,KAAK,CAAC,oBAAoB,EAAE,UAAU,CAAC;AAC/C;GACD;GAED,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;IACtC,UAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;GACzC,MACC,SAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,OACnB;IACF,KAAK,gBAAgB;KACnB,QAAQ,KAAK,CAAC,mBAAmB,EAAE,UAAU,CAAC;AAC9C;IACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,CAAC,mBAAmB,EAAE,UAAU;IAClD,QACE,OAAM,IAAI,MAAM,CAAC,0BAA0B,EAAE,KAAK,SAAS;GAC9D;EAEJ;AAED,SAAO;CACR;AACF"}

package/dist/document_loaders/fs/text.cjs

@@ -0,0 +1,101 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
+const __langchain_core_utils_env = require_rolldown_runtime.__toESM(require("@langchain/core/utils/env"));
+const __langchain_core_document_loaders_base = require_rolldown_runtime.__toESM(require("@langchain/core/document_loaders/base"));
+
+//#region src/document_loaders/fs/text.ts
+var text_exports = {};
+require_rolldown_runtime.__export(text_exports, { TextLoader: () => TextLoader });
+/**
+* A class that extends the `BaseDocumentLoader` class. It represents a
+* document loader that loads documents from a text file. The `load()`
+* method is implemented to read the text from the file or blob, parse it
+* using the `parse()` method, and create a `Document` instance for each
+* parsed page. The metadata includes the source of the text (file path or
+* blob) and, if there are multiple pages, the line number of each page.
+* @example
+* ```typescript
+* const loader = new TextLoader("src/document_loaders/example_data/example.txt");
+* const docs = await loader.load();
+* ```
+*/
+var TextLoader = class TextLoader extends __langchain_core_document_loaders_base.BaseDocumentLoader {
+	constructor(filePathOrBlob) {
+		super();
+		this.filePathOrBlob = filePathOrBlob;
+	}
+	/**
+	* A protected method that takes a `raw` string as a parameter and returns
+	* a promise that resolves to an array containing the raw text as a single
+	* element.
+	* @param raw The raw text to be parsed.
+	* @returns A promise that resolves to an array containing the raw text as a single element.
+	*/
+	async parse(raw) {
+		return [raw];
+	}
+	/**
+	* A method that loads the text file or blob and returns a promise that
+	* resolves to an array of `Document` instances. It reads the text from
+	* the file or blob using the `readFile` function from the
+	* `node:fs/promises` module or the `text()` method of the blob. It then
+	* parses the text using the `parse()` method and creates a `Document`
+	* instance for each parsed page. The metadata includes the source of the
+	* text (file path or blob) and, if there are multiple pages, the line
+	* number of each page.
+	* @returns A promise that resolves to an array of `Document` instances.
+	*/
+	async load() {
+		let text;
+		let metadata;
+		if (typeof this.filePathOrBlob === "string") {
+			const { readFile } = await TextLoader.imports();
+			text = await readFile(this.filePathOrBlob, "utf8");
+			metadata = { source: this.filePathOrBlob };
+		} else {
+			text = await this.filePathOrBlob.text();
+			metadata = {
+				source: "blob",
+				blobType: this.filePathOrBlob.type
+			};
+		}
+		const parsed = await this.parse(text);
+		parsed.forEach((pageContent, i) => {
+			if (typeof pageContent !== "string") throw new Error(`Expected string, at position ${i} got ${typeof pageContent}`);
+		});
+		return parsed.map((pageContent, i) => new __langchain_core_documents.Document({
+			pageContent,
+			metadata: parsed.length === 1 ? metadata : {
+				...metadata,
+				line: i + 1
+			}
+		}));
+	}
+	/**
+	* A static method that imports the `readFile` function from the
+	* `node:fs/promises` module. It is used to dynamically import the
+	* function when needed. If the import fails, it throws an error
+	* indicating that the `fs/promises` module is not available in the
+	* current environment.
+	* @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.
+	*/
+	static async imports() {
+		try {
+			const { readFile } = await import("node:fs/promises");
+			return { readFile };
+		} catch (e) {
+			console.error(e);
+			throw new Error(`Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${(0, __langchain_core_utils_env.getEnv)()}'. See https://<link to docs> for alternatives.`);
+		}
+	}
+};
+
+//#endregion
+exports.TextLoader = TextLoader;
+Object.defineProperty(exports, 'text_exports', {
+  enumerable: true,
+  get: function () {
+    return text_exports;
+  }
+});
+//# sourceMappingURL=text.cjs.map

package/dist/document_loaders/fs/text.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","filePathOrBlob: string | Blob","raw: string","text: string","metadata: Record<string, string>","Document"],"sources":["../../../src/document_loaders/fs/text.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmBA,0DAAmB;CACjD,YAAmBC,gBAA+B;EAChD,OAAO;EADU;CAElB;;;;;;;;CASD,MAAgB,MAAMC,KAAgC;AACpD,SAAO,CAAC,GAAI;CACb;;;;;;;;;;;;CAaD,MAAa,OAA4B;EACvC,IAAIC;EACJ,IAAIC;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,UAAU,GAAG,MAAM,WAAW,SAAS;GAC/C,OAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;GAClD,WAAW,EAAE,QAAQ,KAAK,eAAgB;EAC3C,OAAM;GACL,OAAO,MAAM,KAAK,eAAe,MAAM;GACvC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAM;EAClE;EACD,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;EACrC,OAAO,QAAQ,CAAC,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,OAAO,aAAa;EAGlE,EAAC;AACF,SAAO,OAAO,IACZ,CAAC,aAAa,MACZ,IAAIC,oCAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACX;EACR,GACJ;CACF;;;;;;;;;CAUD,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,UAAU,GAAG,MAAM,OAAO;AAClC,UAAO,EAAE,SAAU;EACpB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,qHAAqH,0CAAU,CAAC,+CAA+C,CAAC;EAEpL;CACF;AACF"}

package/dist/document_loaders/fs/text.d.cts

@@ -0,0 +1,57 @@
+import { Document } from "@langchain/core/documents";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+import { readFile } from "node:fs/promises";
+
+//#region src/document_loaders/fs/text.d.ts
+
+/**
+ * A class that extends the `BaseDocumentLoader` class. It represents a
+ * document loader that loads documents from a text file. The `load()`
+ * method is implemented to read the text from the file or blob, parse it
+ * using the `parse()` method, and create a `Document` instance for each
+ * parsed page. The metadata includes the source of the text (file path or
+ * blob) and, if there are multiple pages, the line number of each page.
+ * @example
+ * ```typescript
+ * const loader = new TextLoader("src/document_loaders/example_data/example.txt");
+ * const docs = await loader.load();
+ * ```
+ */
+declare class TextLoader extends BaseDocumentLoader {
+  filePathOrBlob: string | Blob;
+  constructor(filePathOrBlob: string | Blob);
+  /**
+   * A protected method that takes a `raw` string as a parameter and returns
+   * a promise that resolves to an array containing the raw text as a single
+   * element.
+   * @param raw The raw text to be parsed.
+   * @returns A promise that resolves to an array containing the raw text as a single element.
+   */
+  protected parse(raw: string): Promise<string[]>;
+  /**
+   * A method that loads the text file or blob and returns a promise that
+   * resolves to an array of `Document` instances. It reads the text from
+   * the file or blob using the `readFile` function from the
+   * `node:fs/promises` module or the `text()` method of the blob. It then
+   * parses the text using the `parse()` method and creates a `Document`
+   * instance for each parsed page. The metadata includes the source of the
+   * text (file path or blob) and, if there are multiple pages, the line
+   * number of each page.
+   * @returns A promise that resolves to an array of `Document` instances.
+   */
+  load(): Promise<Document[]>;
+  /**
+   * A static method that imports the `readFile` function from the
+   * `node:fs/promises` module. It is used to dynamically import the
+   * function when needed. If the import fails, it throws an error
+   * indicating that the `fs/promises` module is not available in the
+   * current environment.
+   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.
+   */
+  static imports(): Promise<{
+    readFile: typeof readFile;
+  }>;
+}
+//#endregion
+export { TextLoader };
+//# sourceMappingURL=text.d.cts.map

package/dist/document_loaders/fs/text.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.cts","names":["readFile","ReadFileT","Document","BaseDocumentLoader","TextLoader","Blob","Promise"],"sources":["../../../src/document_loaders/fs/text.d.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport declare class TextLoader extends BaseDocumentLoader {\n    filePathOrBlob: string | Blob;\n    constructor(filePathOrBlob: string | Blob);\n    /**\n     * A protected method that takes a `raw` string as a parameter and returns\n     * a promise that resolves to an array containing the raw text as a single\n     * element.\n     * @param raw The raw text to be parsed.\n     * @returns A promise that resolves to an array containing the raw text as a single element.\n     */\n    protected parse(raw: string): Promise<string[]>;\n    /**\n     * A method that loads the text file or blob and returns a promise that\n     * resolves to an array of `Document` instances. It reads the text from\n     * the file or blob using the `readFile` function from the\n     * `node:fs/promises` module or the `text()` method of the blob. It then\n     * parses the text using the `parse()` method and creates a `Document`\n     * instance for each parsed page. The metadata includes the source of the\n     * text (file path or blob) and, if there are multiple pages, the line\n     * number of each page.\n     * @returns A promise that resolves to an array of `Document` instances.\n     */\n    load(): Promise<Document[]>;\n    /**\n     * A static method that imports the `readFile` function from the\n     * `node:fs/promises` module. It is used to dynamically import the\n     * function when needed. If the import fails, it throws an error\n     * indicating that the `fs/promises` module is not available in the\n     * current environment.\n     * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n     */\n    static imports(): Promise<{\n        readFile: typeof ReadFileT;\n    }>;\n}\n"],"mappings":";;;;;;;;AAgBA;;;;;;;;;;AAA0D;cAArCI,UAAAA,SAAmBD,kBAAAA;2BACXE;uCACYA;;;;;;;;gCAQPC;;;;;;;;;;;;UAYtBA,QAAQJ;;;;;;;;;oBASEI;qBACGL"}

package/dist/document_loaders/fs/text.d.ts

@@ -0,0 +1,57 @@
+import { Document } from "@langchain/core/documents";
+import { readFile } from "node:fs/promises";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/document_loaders/fs/text.d.ts
+
+/**
+ * A class that extends the `BaseDocumentLoader` class. It represents a
+ * document loader that loads documents from a text file. The `load()`
+ * method is implemented to read the text from the file or blob, parse it
+ * using the `parse()` method, and create a `Document` instance for each
+ * parsed page. The metadata includes the source of the text (file path or
+ * blob) and, if there are multiple pages, the line number of each page.
+ * @example
+ * ```typescript
+ * const loader = new TextLoader("src/document_loaders/example_data/example.txt");
+ * const docs = await loader.load();
+ * ```
+ */
+declare class TextLoader extends BaseDocumentLoader {
+  filePathOrBlob: string | Blob;
+  constructor(filePathOrBlob: string | Blob);
+  /**
+   * A protected method that takes a `raw` string as a parameter and returns
+   * a promise that resolves to an array containing the raw text as a single
+   * element.
+   * @param raw The raw text to be parsed.
+   * @returns A promise that resolves to an array containing the raw text as a single element.
+   */
+  protected parse(raw: string): Promise<string[]>;
+  /**
+   * A method that loads the text file or blob and returns a promise that
+   * resolves to an array of `Document` instances. It reads the text from
+   * the file or blob using the `readFile` function from the
+   * `node:fs/promises` module or the `text()` method of the blob. It then
+   * parses the text using the `parse()` method and creates a `Document`
+   * instance for each parsed page. The metadata includes the source of the
+   * text (file path or blob) and, if there are multiple pages, the line
+   * number of each page.
+   * @returns A promise that resolves to an array of `Document` instances.
+   */
+  load(): Promise<Document[]>;
+  /**
+   * A static method that imports the `readFile` function from the
+   * `node:fs/promises` module. It is used to dynamically import the
+   * function when needed. If the import fails, it throws an error
+   * indicating that the `fs/promises` module is not available in the
+   * current environment.
+   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.
+   */
+  static imports(): Promise<{
+    readFile: typeof readFile;
+  }>;
+}
+//#endregion
+export { TextLoader };
+//# sourceMappingURL=text.d.ts.map

package/dist/document_loaders/fs/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","names":["readFile","ReadFileT","Document","BaseDocumentLoader","TextLoader","Blob","Promise"],"sources":["../../../src/document_loaders/fs/text.d.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport declare class TextLoader extends BaseDocumentLoader {\n    filePathOrBlob: string | Blob;\n    constructor(filePathOrBlob: string | Blob);\n    /**\n     * A protected method that takes a `raw` string as a parameter and returns\n     * a promise that resolves to an array containing the raw text as a single\n     * element.\n     * @param raw The raw text to be parsed.\n     * @returns A promise that resolves to an array containing the raw text as a single element.\n     */\n    protected parse(raw: string): Promise<string[]>;\n    /**\n     * A method that loads the text file or blob and returns a promise that\n     * resolves to an array of `Document` instances. It reads the text from\n     * the file or blob using the `readFile` function from the\n     * `node:fs/promises` module or the `text()` method of the blob. It then\n     * parses the text using the `parse()` method and creates a `Document`\n     * instance for each parsed page. The metadata includes the source of the\n     * text (file path or blob) and, if there are multiple pages, the line\n     * number of each page.\n     * @returns A promise that resolves to an array of `Document` instances.\n     */\n    load(): Promise<Document[]>;\n    /**\n     * A static method that imports the `readFile` function from the\n     * `node:fs/promises` module. It is used to dynamically import the\n     * function when needed. If the import fails, it throws an error\n     * indicating that the `fs/promises` module is not available in the\n     * current environment.\n     * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n     */\n    static imports(): Promise<{\n        readFile: typeof ReadFileT;\n    }>;\n}\n"],"mappings":";;;;;;;;AAgBA;;;;;;;;;;AAA0D;cAArCI,UAAAA,SAAmBD,kBAAAA;2BACXE;uCACYA;;;;;;;;gCAQPC;;;;;;;;;;;;UAYtBA,QAAQJ;;;;;;;;;oBASEI;qBACGL"}

package/dist/document_loaders/fs/text.js

@@ -0,0 +1,95 @@
+import { __export } from "../../_virtual/rolldown_runtime.js";
+import { Document } from "@langchain/core/documents";
+import { getEnv } from "@langchain/core/utils/env";
+import { BaseDocumentLoader } from "@langchain/core/document_loaders/base";
+
+//#region src/document_loaders/fs/text.ts
+var text_exports = {};
+__export(text_exports, { TextLoader: () => TextLoader });
+/**
+* A class that extends the `BaseDocumentLoader` class. It represents a
+* document loader that loads documents from a text file. The `load()`
+* method is implemented to read the text from the file or blob, parse it
+* using the `parse()` method, and create a `Document` instance for each
+* parsed page. The metadata includes the source of the text (file path or
+* blob) and, if there are multiple pages, the line number of each page.
+* @example
+* ```typescript
+* const loader = new TextLoader("src/document_loaders/example_data/example.txt");
+* const docs = await loader.load();
+* ```
+*/
+var TextLoader = class TextLoader extends BaseDocumentLoader {
+	constructor(filePathOrBlob) {
+		super();
+		this.filePathOrBlob = filePathOrBlob;
+	}
+	/**
+	* A protected method that takes a `raw` string as a parameter and returns
+	* a promise that resolves to an array containing the raw text as a single
+	* element.
+	* @param raw The raw text to be parsed.
+	* @returns A promise that resolves to an array containing the raw text as a single element.
+	*/
+	async parse(raw) {
+		return [raw];
+	}
+	/**
+	* A method that loads the text file or blob and returns a promise that
+	* resolves to an array of `Document` instances. It reads the text from
+	* the file or blob using the `readFile` function from the
+	* `node:fs/promises` module or the `text()` method of the blob. It then
+	* parses the text using the `parse()` method and creates a `Document`
+	* instance for each parsed page. The metadata includes the source of the
+	* text (file path or blob) and, if there are multiple pages, the line
+	* number of each page.
+	* @returns A promise that resolves to an array of `Document` instances.
+	*/
+	async load() {
+		let text;
+		let metadata;
+		if (typeof this.filePathOrBlob === "string") {
+			const { readFile } = await TextLoader.imports();
+			text = await readFile(this.filePathOrBlob, "utf8");
+			metadata = { source: this.filePathOrBlob };
+		} else {
+			text = await this.filePathOrBlob.text();
+			metadata = {
+				source: "blob",
+				blobType: this.filePathOrBlob.type
+			};
+		}
+		const parsed = await this.parse(text);
+		parsed.forEach((pageContent, i) => {
+			if (typeof pageContent !== "string") throw new Error(`Expected string, at position ${i} got ${typeof pageContent}`);
+		});
+		return parsed.map((pageContent, i) => new Document({
+			pageContent,
+			metadata: parsed.length === 1 ? metadata : {
+				...metadata,
+				line: i + 1
+			}
+		}));
+	}
+	/**
+	* A static method that imports the `readFile` function from the
+	* `node:fs/promises` module. It is used to dynamically import the
+	* function when needed. If the import fails, it throws an error
+	* indicating that the `fs/promises` module is not available in the
+	* current environment.
+	* @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.
+	*/
+	static async imports() {
+		try {
+			const { readFile } = await import("node:fs/promises");
+			return { readFile };
+		} catch (e) {
+			console.error(e);
+			throw new Error(`Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`);
+		}
+	}
+};
+
+//#endregion
+export { TextLoader, text_exports };
+//# sourceMappingURL=text.js.map

package/dist/document_loaders/fs/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":["filePathOrBlob: string | Blob","raw: string","text: string","metadata: Record<string, string>"],"sources":["../../../src/document_loaders/fs/text.ts"],"sourcesContent":["import type { readFile as ReadFileT } from \"node:fs/promises\";\nimport { Document } from \"@langchain/core/documents\";\nimport { getEnv } from \"@langchain/core/utils/env\";\nimport { BaseDocumentLoader } from \"@langchain/core/document_loaders/base\";\n\n/**\n * A class that extends the `BaseDocumentLoader` class. It represents a\n * document loader that loads documents from a text file. The `load()`\n * method is implemented to read the text from the file or blob, parse it\n * using the `parse()` method, and create a `Document` instance for each\n * parsed page. The metadata includes the source of the text (file path or\n * blob) and, if there are multiple pages, the line number of each page.\n * @example\n * ```typescript\n * const loader = new TextLoader(\"src/document_loaders/example_data/example.txt\");\n * const docs = await loader.load();\n * ```\n */\nexport class TextLoader extends BaseDocumentLoader {\n  constructor(public filePathOrBlob: string | Blob) {\n    super();\n  }\n\n  /**\n   * A protected method that takes a `raw` string as a parameter and returns\n   * a promise that resolves to an array containing the raw text as a single\n   * element.\n   * @param raw The raw text to be parsed.\n   * @returns A promise that resolves to an array containing the raw text as a single element.\n   */\n  protected async parse(raw: string): Promise<string[]> {\n    return [raw];\n  }\n\n  /**\n   * A method that loads the text file or blob and returns a promise that\n   * resolves to an array of `Document` instances. It reads the text from\n   * the file or blob using the `readFile` function from the\n   * `node:fs/promises` module or the `text()` method of the blob. It then\n   * parses the text using the `parse()` method and creates a `Document`\n   * instance for each parsed page. The metadata includes the source of the\n   * text (file path or blob) and, if there are multiple pages, the line\n   * number of each page.\n   * @returns A promise that resolves to an array of `Document` instances.\n   */\n  public async load(): Promise<Document[]> {\n    let text: string;\n    let metadata: Record<string, string>;\n    if (typeof this.filePathOrBlob === \"string\") {\n      const { readFile } = await TextLoader.imports();\n      text = await readFile(this.filePathOrBlob, \"utf8\");\n      metadata = { source: this.filePathOrBlob };\n    } else {\n      text = await this.filePathOrBlob.text();\n      metadata = { source: \"blob\", blobType: this.filePathOrBlob.type };\n    }\n    const parsed = await this.parse(text);\n    parsed.forEach((pageContent, i) => {\n      if (typeof pageContent !== \"string\") {\n        throw new Error(\n          `Expected string, at position ${i} got ${typeof pageContent}`\n        );\n      }\n    });\n    return parsed.map(\n      (pageContent, i) =>\n        new Document({\n          pageContent,\n          metadata:\n            parsed.length === 1\n              ? metadata\n              : {\n                  ...metadata,\n                  line: i + 1,\n                },\n        })\n    );\n  }\n\n  /**\n   * A static method that imports the `readFile` function from the\n   * `node:fs/promises` module. It is used to dynamically import the\n   * function when needed. If the import fails, it throws an error\n   * indicating that the `fs/promises` module is not available in the\n   * current environment.\n   * @returns A promise that resolves to an object containing the `readFile` function from the `node:fs/promises` module.\n   */\n  static async imports(): Promise<{\n    readFile: typeof ReadFileT;\n  }> {\n    try {\n      const { readFile } = await import(\"node:fs/promises\");\n      return { readFile };\n    } catch (e) {\n      console.error(e);\n      throw new Error(\n        `Failed to load fs/promises. TextLoader available only on environment 'node'. It appears you are running environment '${getEnv()}'. See https://<link to docs> for alternatives.`\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAkBA,IAAa,aAAb,MAAa,mBAAmB,mBAAmB;CACjD,YAAmBA,gBAA+B;EAChD,OAAO;EADU;CAElB;;;;;;;;CASD,MAAgB,MAAMC,KAAgC;AACpD,SAAO,CAAC,GAAI;CACb;;;;;;;;;;;;CAaD,MAAa,OAA4B;EACvC,IAAIC;EACJ,IAAIC;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,UAAU,GAAG,MAAM,WAAW,SAAS;GAC/C,OAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;GAClD,WAAW,EAAE,QAAQ,KAAK,eAAgB;EAC3C,OAAM;GACL,OAAO,MAAM,KAAK,eAAe,MAAM;GACvC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAM;EAClE;EACD,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;EACrC,OAAO,QAAQ,CAAC,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,OAAO,aAAa;EAGlE,EAAC;AACF,SAAO,OAAO,IACZ,CAAC,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACX;EACR,GACJ;CACF;;;;;;;;;CAUD,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,UAAU,GAAG,MAAM,OAAO;AAClC,UAAO,EAAE,SAAU;EACpB,SAAQ,GAAG;GACV,QAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,CAAC,qHAAqH,EAAE,QAAQ,CAAC,+CAA+C,CAAC;EAEpL;CACF;AACF"}

package/dist/document_transformers/openai_functions.cjs

@@ -0,0 +1,60 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_tagging = require('../chains/openai_functions/tagging.cjs');
+require('../chains/openai_functions/index.cjs');
+const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
+const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
+const __langchain_openai = require_rolldown_runtime.__toESM(require("@langchain/openai"));
+
+//#region src/document_transformers/openai_functions.ts
+var openai_functions_exports = {};
+require_rolldown_runtime.__export(openai_functions_exports, {
+	MetadataTagger: () => MetadataTagger,
+	createMetadataTagger: () => createMetadataTagger,
+	createMetadataTaggerFromZod: () => createMetadataTaggerFromZod
+});
+/**
+* A transformer that tags metadata to a document using a tagging chain.
+*/
+var MetadataTagger = class extends __langchain_core_documents.MappingDocumentTransformer {
+	static lc_name() {
+		return "MetadataTagger";
+	}
+	taggingChain;
+	constructor(fields) {
+		super();
+		this.taggingChain = fields.taggingChain;
+		if (this.taggingChain.inputKeys.length !== 1) throw new Error("Invalid input chain. The input chain must have exactly one input.");
+		if (this.taggingChain.outputKeys.length !== 1) throw new Error("Invalid input chain. The input chain must have exactly one output.");
+	}
+	async _transformDocument(document) {
+		const taggingChainResponse = await this.taggingChain.call({ [this.taggingChain.inputKeys[0]]: document.pageContent });
+		const extractedMetadata = taggingChainResponse[this.taggingChain.outputKeys[0]];
+		return new __langchain_core_documents.Document({
+			pageContent: document.pageContent,
+			metadata: {
+				...extractedMetadata,
+				...document.metadata
+			}
+		});
+	}
+};
+function createMetadataTagger(schema, options) {
+	const { llm = new __langchain_openai.ChatOpenAI({ model: "gpt-3.5-turbo-0613" }),...rest } = options;
+	const taggingChain = require_tagging.createTaggingChain(schema, llm, rest);
+	return new MetadataTagger({ taggingChain });
+}
+function createMetadataTaggerFromZod(schema, options) {
+	return createMetadataTagger((0, __langchain_core_utils_json_schema.toJsonSchema)(schema), options);
+}
+
+//#endregion
+exports.MetadataTagger = MetadataTagger;
+exports.createMetadataTagger = createMetadataTagger;
+exports.createMetadataTaggerFromZod = createMetadataTaggerFromZod;
+Object.defineProperty(exports, 'openai_functions_exports', {
+  enumerable: true,
+  get: function () {
+    return openai_functions_exports;
+  }
+});
+//# sourceMappingURL=openai_functions.cjs.map

package/dist/document_transformers/openai_functions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","fields: { taggingChain: BaseChain }","document: Document","Document","schema: JsonSchema7ObjectType","options: TaggingChainOptions & { llm?: ChatOpenAI }","ChatOpenAI","createTaggingChain","schema: InteropZodObject"],"sources":["../../src/document_transformers/openai_functions.ts"],"sourcesContent":["import {\n  Document,\n  MappingDocumentTransformer,\n} from \"@langchain/core/documents\";\nimport { ChatOpenAI } from \"@langchain/openai\";\nimport { InteropZodObject } from \"@langchain/core/utils/types\";\nimport {\n  type JsonSchema7ObjectType,\n  toJsonSchema,\n} from \"@langchain/core/utils/json_schema\";\nimport { BaseChain } from \"../chains/base.js\";\nimport {\n  TaggingChainOptions,\n  createTaggingChain,\n} from \"../chains/openai_functions/index.js\";\n\n/**\n * A transformer that tags metadata to a document using a tagging chain.\n */\nexport class MetadataTagger extends MappingDocumentTransformer {\n  static lc_name() {\n    return \"MetadataTagger\";\n  }\n\n  protected taggingChain: BaseChain;\n\n  constructor(fields: { taggingChain: BaseChain }) {\n    super();\n    this.taggingChain = fields.taggingChain;\n    if (this.taggingChain.inputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one input.\"\n      );\n    }\n    if (this.taggingChain.outputKeys.length !== 1) {\n      throw new Error(\n        \"Invalid input chain. The input chain must have exactly one output.\"\n      );\n    }\n  }\n\n  async _transformDocument(document: Document): Promise<Document> {\n    const taggingChainResponse = await this.taggingChain.call({\n      [this.taggingChain.inputKeys[0]]: document.pageContent,\n    });\n    const extractedMetadata =\n      taggingChainResponse[this.taggingChain.outputKeys[0]];\n    return new Document({\n      pageContent: document.pageContent,\n      metadata: { ...extractedMetadata, ...document.metadata },\n    });\n  }\n}\n\nexport function createMetadataTagger(\n  schema: JsonSchema7ObjectType,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  const { llm = new ChatOpenAI({ model: \"gpt-3.5-turbo-0613\" }), ...rest } =\n    options;\n  const taggingChain = createTaggingChain(schema, llm, rest);\n  return new MetadataTagger({ taggingChain });\n}\n\nexport function createMetadataTaggerFromZod(\n  schema: InteropZodObject,\n  options: TaggingChainOptions & { llm?: ChatOpenAI }\n) {\n  return createMetadataTagger(\n    toJsonSchema(schema) as JsonSchema7ObjectType,\n    options\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,IAAa,iBAAb,cAAoCA,sDAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;CACR;CAED,AAAU;CAEV,YAAYC,QAAqC;EAC/C,OAAO;EACP,KAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR;AAGJ,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR;CAGL;CAED,MAAM,mBAAmBC,UAAuC;EAC9D,MAAM,uBAAuB,MAAM,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC5C,EAAC;EACF,MAAM,oBACJ,qBAAqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAIC,oCAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAU;EACzD;CACF;AACF;AAED,SAAgB,qBACdC,QACAC,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,8BAAW,EAAE,OAAO,qBAAsB,GAAG,GAAG,MAAM,GACtE;CACF,MAAM,eAAeC,mCAAmB,QAAQ,KAAK,KAAK;AAC1D,QAAO,IAAI,eAAe,EAAE,aAAc;AAC3C;AAED,SAAgB,4BACdC,QACAH,SACA;AACA,QAAO,0EACQ,OAAO,EACpB,QACD;AACF"}