@langchain/classic 1.0.40 → 1.0.41

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","UnknownHandling"],"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,sCAAAA,mBAAmB;CACtD,YACE,WACA,SACA,UAAkCC,sCAAAA,gBAAgB,MAClD;AACA,SAAO;AAJA,OAAA,YAAA;AACA,OAAA,UAAA;AACA,OAAA,UAAA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU;OAC/B,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;CAexE,MAAa,OAA4B;EACvC,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,YAAA,GAAA,UAAA,SAAmB,SAAS;AAGlC,QAAI,OAAA,GAAA,iBAAA,MAFwB,SAAS,EAExB,aAAa,EAAE;AAC1B,YAAQ,KAAK,uBAAuB,WAAW;AAC/C;;GAGF,MAAM,gBAAgB,KAAK,SAAA,GAAA,UAAA,SAAgB,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;AACtC,cAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;SAExC,SAAQ,KAAK,SAAb;IACE,KAAKA,sCAAAA,gBAAgB,OACnB;IACF,KAAKA,sCAAAA,gBAAgB;AACnB,aAAQ,KAAK,sBAAsB,WAAW;AAC9C;IACF,KAAKA,sCAAAA,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,WAAW;IACnD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;AAKpE,SAAO"}
+{"version":3,"file":"multi_file.cjs","names":["BaseDocumentLoader","UnknownHandling"],"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,sCAAAA,mBAAmB;CAE7C;CACA;CACA;CAHT,YACE,WACA,SACA,UAAkCC,sCAAAA,gBAAgB,MAClD;EACA,MAAM;EAJC,KAAA,YAAA;EACA,KAAA,UAAA;EACA,KAAA,UAAA;EAIP,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,MAAM,IAAI,MAAM,kCAAkC;EAEpD,KAAK,MAAM,aAAa,SACtB,IAAI,OAAO,OAAO,SAAS,SAAS,GAC9B;OAAA,UAAU,OAAO,KACnB,MAAM,IAAI,MAAM,oCAAoC,WAAW;EAAA;CAIvE;;;;;;;;;;CAWA,MAAa,OAA4B;EACvC,MAAM,YAAwB,CAAC;EAE/B,KAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,YAAA,GAAA,UAAA,QAAA,CAAmB,QAAQ;GAGjC,KAAI,OAAA,GAAA,iBAAA,KAAA,CAFwB,QAAQ,EAAA,CAEvB,YAAY,GAAG;IAC1B,QAAQ,KAAK,uBAAuB,UAAU;IAC9C;GACF;GAEA,MAAM,gBAAgB,KAAK,SAAA,GAAA,UAAA,QAAA,CAAgB,QAAQ;GACnD,IAAI,eAAe;IACjB,MAAM,SAAS,cAAc,QAAQ;IACrC,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;GACzC,OACE,QAAQ,KAAK,SAAb;IACE,KAAKA,sCAAAA,gBAAgB,QACnB;IACF,KAAKA,sCAAAA,gBAAgB;KACnB,QAAQ,KAAK,sBAAsB,UAAU;KAC7C;IACF,KAAKA,sCAAAA,gBAAgB,OACnB,MAAM,IAAI,MAAM,sBAAsB,UAAU;IAClD,SACE,MAAM,IAAI,MAAM,6BAA6B,KAAK,SAAS;GAC/D;EAEJ;EAEA,OAAO;CACT;AACF"}

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

@@ -1,7 +1,6 @@
 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

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.d.cts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,SAAA;EACA,OAAA,EAAS,cAAA;EACT,OAAA,EAAS,eAAA;EAHlB,WAAA,CACS,SAAA,YACA,OAAA,EAAS,cAAA,EACT,OAAA,GAAS,eAAA;EADT;;;;;;;;;EA0BI,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;AAAA"}
+{"version":3,"file":"multi_file.d.cts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAwBa,wBAAwB;EAE1B;EACA,SAAS;EACT,SAAS;EAHlB,YACS,qBACA,SAAS,gBACT,UAAS;;;;;;;;;;EAyBL,QAAQ,QAAQ"}

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

@@ -1,7 +1,6 @@
 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

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.d.ts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;;;;;;;;;cAAa,eAAA,SAAwB,kBAAA;EAE1B,SAAA;EACA,OAAA,EAAS,cAAA;EACT,OAAA,EAAS,eAAA;EAHlB,WAAA,CACS,SAAA,YACA,OAAA,EAAS,cAAA,EACT,OAAA,GAAS,eAAA;EADT;;;;;;;;;EA0BI,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;AAAA"}
+{"version":3,"file":"multi_file.d.ts","names":[],"sources":["../../../src/document_loaders/fs/multi_file.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cAwBa,wBAAwB;EAE1B;EACA,SAAS;EACT,SAAS;EAHlB,YACS,qBACA,SAAS,gBACT,UAAS;;;;;;;;;;EAyBL,QAAQ,QAAQ"}

package/dist/document_loaders/fs/multi_file.js

@@ -24,6 +24,9 @@ var multi_file_exports = /* @__PURE__ */ __exportAll({ MultiFileLoader: () => Mu
 * ```
 */
 var MultiFileLoader = class extends BaseDocumentLoader {
+	filePaths;
+	loaders;
+	unknown;
 	constructor(filePaths, loaders, unknown = UnknownHandling.Warn) {
 		super();
 		this.filePaths = filePaths;

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

@@ -1 +1 @@
-{"version":3,"file":"multi_file.js","names":[],"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,YACE,WACA,SACA,UAAkC,gBAAgB,MAClD;AACA,SAAO;AAJA,OAAA,YAAA;AACA,OAAA,UAAA;AACA,OAAA,UAAA;AAIP,MAAI,OAAO,KAAK,QAAQ,CAAC,WAAW,EAClC,OAAM,IAAI,MAAM,mCAAmC;AAErD,OAAK,MAAM,aAAa,QACtB,KAAI,OAAO,OAAO,SAAS,UAAU;OAC/B,UAAU,OAAO,IACnB,OAAM,IAAI,MAAM,oCAAoC,YAAY;;;;;;;;;;;;CAexE,MAAa,OAA4B;EACvC,MAAM,YAAwB,EAAE;AAEhC,OAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,SAAS;AAGlC,QAAI,MAFmB,KAAK,SAAS,EAExB,aAAa,EAAE;AAC1B,YAAQ,KAAK,uBAAuB,WAAW;AAC/C;;GAGF,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,SAAS;AACpD,OAAI,eAAe;IACjB,MAAM,SAAS,cAAc,SAAS;AACtC,cAAU,KAAK,GAAI,MAAM,OAAO,MAAM,CAAE;SAExC,SAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,OACnB;IACF,KAAK,gBAAgB;AACnB,aAAQ,KAAK,sBAAsB,WAAW;AAC9C;IACF,KAAK,gBAAgB,MACnB,OAAM,IAAI,MAAM,sBAAsB,WAAW;IACnD,QACE,OAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU;;;AAKpE,SAAO"}
+{"version":3,"file":"multi_file.js","names":[],"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;CAE7C;CACA;CACA;CAHT,YACE,WACA,SACA,UAAkC,gBAAgB,MAClD;EACA,MAAM;EAJC,KAAA,YAAA;EACA,KAAA,UAAA;EACA,KAAA,UAAA;EAIP,IAAI,OAAO,KAAK,OAAO,CAAC,CAAC,WAAW,GAClC,MAAM,IAAI,MAAM,kCAAkC;EAEpD,KAAK,MAAM,aAAa,SACtB,IAAI,OAAO,OAAO,SAAS,SAAS,GAC9B;OAAA,UAAU,OAAO,KACnB,MAAM,IAAI,MAAM,oCAAoC,WAAW;EAAA;CAIvE;;;;;;;;;;CAWA,MAAa,OAA4B;EACvC,MAAM,YAAwB,CAAC;EAE/B,KAAK,MAAM,YAAY,KAAK,WAAW;GACrC,MAAM,WAAW,QAAQ,QAAQ;GAGjC,KAAI,MAFmB,KAAK,QAAQ,EAAA,CAEvB,YAAY,GAAG;IAC1B,QAAQ,KAAK,uBAAuB,UAAU;IAC9C;GACF;GAEA,MAAM,gBAAgB,KAAK,QAAQ,QAAQ,QAAQ;GACnD,IAAI,eAAe;IACjB,MAAM,SAAS,cAAc,QAAQ;IACrC,UAAU,KAAK,GAAI,MAAM,OAAO,KAAK,CAAE;GACzC,OACE,QAAQ,KAAK,SAAb;IACE,KAAK,gBAAgB,QACnB;IACF,KAAK,gBAAgB;KACnB,QAAQ,KAAK,sBAAsB,UAAU;KAC7C;IACF,KAAK,gBAAgB,OACnB,MAAM,IAAI,MAAM,sBAAsB,UAAU;IAClD,SACE,MAAM,IAAI,MAAM,6BAA6B,KAAK,SAAS;GAC/D;EAEJ;EAEA,OAAO;CACT;AACF"}

package/dist/document_loaders/fs/text.cjs

@@ -19,6 +19,7 @@ var text_exports = /* @__PURE__ */ require_runtime.__exportAll({ TextLoader: ()
 * ```
 */
 var TextLoader = class TextLoader extends _langchain_core_document_loaders_base.BaseDocumentLoader {
+	filePathOrBlob;
 	constructor(filePathOrBlob) {
 		super();
 		this.filePathOrBlob = filePathOrBlob;

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

@@ -1 +1 @@
-{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","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,sCAAAA,mBAAmB;CACjD,YAAY,gBAAsC;AAChD,SAAO;AADU,OAAA,iBAAA;;;;;;;;;CAWnB,MAAgB,MAAM,KAAgC;AACpD,SAAO,CAAC,IAAI;;;;;;;;;;;;;CAcd,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,SAAS;AAC/C,UAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;AAClD,cAAW,EAAE,QAAQ,KAAK,gBAAgB;SACrC;AACL,UAAO,MAAM,KAAK,eAAe,MAAM;AACvC,cAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;IAAM;;EAEnE,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;AACrC,SAAO,SAAS,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,cACjD;IAEH;AACF,SAAO,OAAO,KACX,aAAa,MACZ,IAAIC,0BAAAA,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;IACX;GACR,CAAC,CACL;;;;;;;;;;CAWH,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,UAAO,EAAE,UAAU;WACZ,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,yHAAA,GAAA,0BAAA,SAAgI,CAAC,iDAClI"}
+{"version":3,"file":"text.cjs","names":["BaseDocumentLoader","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,sCAAAA,mBAAmB;CAC9B;CAAnB,YAAY,gBAAsC;EAChD,MAAM;EADW,KAAA,iBAAA;CAEnB;;;;;;;;CASA,MAAgB,MAAM,KAAgC;EACpD,OAAO,CAAC,GAAG;CACb;;;;;;;;;;;;CAaA,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;EACJ,IAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,QAAQ;GAC9C,OAAO,MAAM,SAAS,KAAK,gBAAgB,MAAM;GACjD,WAAW,EAAE,QAAQ,KAAK,eAAe;EAC3C,OAAO;GACL,OAAO,MAAM,KAAK,eAAe,KAAK;GACtC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAK;EAClE;EACA,MAAM,SAAS,MAAM,KAAK,MAAM,IAAI;EACpC,OAAO,SAAS,aAAa,MAAM;GACjC,IAAI,OAAO,gBAAgB,UACzB,MAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,aAClD;EAEJ,CAAC;EACD,OAAO,OAAO,KACX,aAAa,MACZ,IAAIC,0BAAAA,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACZ;EACR,CAAC,CACL;CACF;;;;;;;;;CAUA,aAAa,UAEV;EACD,IAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;GAClC,OAAO,EAAE,SAAS;EACpB,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;GACf,MAAM,IAAI,MACR,yHAAA,GAAA,0BAAA,OAAA,CAA+H,EAAE,gDACnI;EACF;CACF;AACF"}

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

@@ -1,7 +1,6 @@
 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

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

@@ -1 +1 @@
-{"version":3,"file":"text.d.cts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;cAAa,UAAA,SAAmB,kBAAA;EACX,cAAA,WAAyB,IAAA;EAA5C,WAAA,CAAmB,cAAA,WAAyB,IAAA;EAAzB;;;;;;;EAAA,UAWH,KAAA,CAAM,GAAA,WAAc,OAAA;EAevB;;;;;;;;;;;EAAA,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;;;;;SA0ChB,OAAA,CAAA,GAAW,OAAA;IACtB,QAAA,SAAiB,QAAA;EAAA;AAAA"}
+{"version":3,"file":"text.d.cts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa,mBAAmB;EACX,yBAAyB;EAA5C,YAAmB,yBAAyB;;;;;;;;YAW5B,MAAM,cAAc;;;;;;;;;;;;EAevB,QAAQ,QAAQ;;;;;;;;;SA0ChB,WAAW;IACtB,iBAAiB"}

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

@@ -1,7 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { Document } from "@langchain/core/documents";
 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

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

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;cAAa,UAAA,SAAmB,kBAAA;EACX,cAAA,WAAyB,IAAA;EAA5C,WAAA,CAAmB,cAAA,WAAyB,IAAA;EAAzB;;;;;;;EAAA,UAWH,KAAA,CAAM,GAAA,WAAc,OAAA;EAevB;;;;;;;;;;;EAAA,IAAA,CAAA,GAAQ,OAAA,CAAQ,QAAA;;;;;;;;;SA0ChB,OAAA,CAAA,GAAW,OAAA;IACtB,QAAA,SAAiB,QAAA;EAAA;AAAA"}
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../../src/document_loaders/fs/text.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkBa,mBAAmB;EACX,yBAAyB;EAA5C,YAAmB,yBAAyB;;;;;;;;YAW5B,MAAM,cAAc;;;;;;;;;;;;EAevB,QAAQ,QAAQ;;;;;;;;;SA0ChB,WAAW;IACtB,iBAAiB"}

package/dist/document_loaders/fs/text.js

@@ -18,6 +18,7 @@ var text_exports = /* @__PURE__ */ __exportAll({ TextLoader: () => TextLoader })
 * ```
 */
 var TextLoader = class TextLoader extends BaseDocumentLoader {
+	filePathOrBlob;
 	constructor(filePathOrBlob) {
 		super();
 		this.filePathOrBlob = filePathOrBlob;

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

@@ -1 +1 @@
-{"version":3,"file":"text.js","names":[],"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,YAAY,gBAAsC;AAChD,SAAO;AADU,OAAA,iBAAA;;;;;;;;;CAWnB,MAAgB,MAAM,KAAgC;AACpD,SAAO,CAAC,IAAI;;;;;;;;;;;;;CAcd,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;AACJ,MAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,SAAS;AAC/C,UAAO,MAAM,SAAS,KAAK,gBAAgB,OAAO;AAClD,cAAW,EAAE,QAAQ,KAAK,gBAAgB;SACrC;AACL,UAAO,MAAM,KAAK,eAAe,MAAM;AACvC,cAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;IAAM;;EAEnE,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK;AACrC,SAAO,SAAS,aAAa,MAAM;AACjC,OAAI,OAAO,gBAAgB,SACzB,OAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,cACjD;IAEH;AACF,SAAO,OAAO,KACX,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;IACX;GACR,CAAC,CACL;;;;;;;;;;CAWH,aAAa,UAEV;AACD,MAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;AAClC,UAAO,EAAE,UAAU;WACZ,GAAG;AACV,WAAQ,MAAM,EAAE;AAChB,SAAM,IAAI,MACR,wHAAwH,QAAQ,CAAC,iDAClI"}
+{"version":3,"file":"text.js","names":[],"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;CAC9B;CAAnB,YAAY,gBAAsC;EAChD,MAAM;EADW,KAAA,iBAAA;CAEnB;;;;;;;;CASA,MAAgB,MAAM,KAAgC;EACpD,OAAO,CAAC,GAAG;CACb;;;;;;;;;;;;CAaA,MAAa,OAA4B;EACvC,IAAI;EACJ,IAAI;EACJ,IAAI,OAAO,KAAK,mBAAmB,UAAU;GAC3C,MAAM,EAAE,aAAa,MAAM,WAAW,QAAQ;GAC9C,OAAO,MAAM,SAAS,KAAK,gBAAgB,MAAM;GACjD,WAAW,EAAE,QAAQ,KAAK,eAAe;EAC3C,OAAO;GACL,OAAO,MAAM,KAAK,eAAe,KAAK;GACtC,WAAW;IAAE,QAAQ;IAAQ,UAAU,KAAK,eAAe;GAAK;EAClE;EACA,MAAM,SAAS,MAAM,KAAK,MAAM,IAAI;EACpC,OAAO,SAAS,aAAa,MAAM;GACjC,IAAI,OAAO,gBAAgB,UACzB,MAAM,IAAI,MACR,gCAAgC,EAAE,OAAO,OAAO,aAClD;EAEJ,CAAC;EACD,OAAO,OAAO,KACX,aAAa,MACZ,IAAI,SAAS;GACX;GACA,UACE,OAAO,WAAW,IACd,WACA;IACE,GAAG;IACH,MAAM,IAAI;GACZ;EACR,CAAC,CACL;CACF;;;;;;;;;CAUA,aAAa,UAEV;EACD,IAAI;GACF,MAAM,EAAE,aAAa,MAAM,OAAO;GAClC,OAAO,EAAE,SAAS;EACpB,SAAS,GAAG;GACV,QAAQ,MAAM,CAAC;GACf,MAAM,IAAI,MACR,wHAAwH,OAAO,EAAE,gDACnI;EACF;CACF;AACF"}

package/dist/document_transformers/openai_functions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","Document","ChatOpenAI","createTaggingChain"],"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,0BAAAA,2BAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT;CAEA,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR,oEACD;AAEH,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR,qEACD;;CAIL,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,aAC5C,CAAC,EAEqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAIC,0BAAAA,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;IAAU;GACzD,CAAC;;;AAIN,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,kBAAAA,WAAW,EAAE,OAAO,sBAAsB,CAAC,EAAE,GAAG,SAChE;AAEF,QAAO,IAAI,eAAe,EAAE,cADPC,gBAAAA,mBAAmB,QAAQ,KAAK,KACb,EAAE,CAAC;;AAG7C,SAAgB,4BACd,QACA,SACA;AACA,QAAO,sBAAA,GAAA,kCAAA,cACQ,OAAO,EACpB,QACD"}
+{"version":3,"file":"openai_functions.cjs","names":["MappingDocumentTransformer","Document","ChatOpenAI","createTaggingChain"],"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,0BAAAA,2BAA2B;CAC7D,OAAO,UAAU;EACf,OAAO;CACT;CAEA;CAEA,YAAY,QAAqC;EAC/C,MAAM;EACN,KAAK,eAAe,OAAO;EAC3B,IAAI,KAAK,aAAa,UAAU,WAAW,GACzC,MAAM,IAAI,MACR,mEACF;EAEF,IAAI,KAAK,aAAa,WAAW,WAAW,GAC1C,MAAM,IAAI,MACR,oEACF;CAEJ;CAEA,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC7C,CAAC,EAAA,CAEsB,KAAK,aAAa,WAAW;EACpD,OAAO,IAAIC,0BAAAA,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAS;EACzD,CAAC;CACH;AACF;AAEA,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAIC,kBAAAA,WAAW,EAAE,OAAO,qBAAqB,CAAC,GAAG,GAAG,SAChE;CAEF,OAAO,IAAI,eAAe,EAAE,cADPC,gBAAAA,mBAAmB,QAAQ,KAAK,IACzB,EAAa,CAAC;AAC5C;AAEA,SAAgB,4BACd,QACA,SACA;CACA,OAAO,sBAAA,GAAA,kCAAA,aAAA,CACQ,MAAM,GACnB,OACF;AACF"}

package/dist/document_transformers/openai_functions.d.cts

@@ -1,10 +1,10 @@
 import { BaseChain } from "../chains/base.cjs";
 import { TaggingChainOptions } from "../chains/openai_functions/tagging.cjs";
+import "../chains/openai_functions/index.cjs";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { ChatOpenAI } from "@langchain/openai";
 import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
 import { JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
-
 //#region src/document_transformers/openai_functions.d.ts
 /**
  * A transformer that tags metadata to a document using a tagging chain.

package/dist/document_transformers/openai_functions.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.cts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,cAAA,SAAuB,0BAAA;EAAA,OAC3B,OAAA,CAAA;EAAA,UAIG,YAAA,EAAc,SAAA;EAExB,WAAA,CAAY,MAAA;IAAU,YAAA,EAAc,SAAA;EAAA;EAe9B,kBAAA,CAAmB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,iBAaxC,oBAAA,CACd,MAAA,EAAQ,qBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA;AAAA,iBAQrC,2BAAA,CACd,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA"}
+{"version":3,"file":"openai_functions.d.cts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,uBAAuB;SAC3B;YAIG,cAAc;EAExB,YAAY;IAAU,cAAc;;EAe9B,mBAAmB,UAAU,WAAW,QAAQ;;iBAaxC,qBACd,QAAQ,uBACR,SAAS;EAAwB,MAAM;IAAY;iBAQrC,4BACd,QAAQ,kBACR,SAAS;EAAwB,MAAM;IAAY"}

package/dist/document_transformers/openai_functions.d.ts

@@ -1,10 +1,10 @@
 import { BaseChain } from "../chains/base.js";
 import { TaggingChainOptions } from "../chains/openai_functions/tagging.js";
+import "../chains/openai_functions/index.js";
 import { InteropZodObject } from "@langchain/core/utils/types";
 import { JsonSchema7ObjectType } from "@langchain/core/utils/json_schema";
 import { ChatOpenAI } from "@langchain/openai";
 import { Document, MappingDocumentTransformer } from "@langchain/core/documents";
-
 //#region src/document_transformers/openai_functions.d.ts
 /**
  * A transformer that tags metadata to a document using a tagging chain.

package/dist/document_transformers/openai_functions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.d.ts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,cAAA,SAAuB,0BAAA;EAAA,OAC3B,OAAA,CAAA;EAAA,UAIG,YAAA,EAAc,SAAA;EAExB,WAAA,CAAY,MAAA;IAAU,YAAA,EAAc,SAAA;EAAA;EAe9B,kBAAA,CAAmB,QAAA,EAAU,QAAA,GAAW,OAAA,CAAQ,QAAA;AAAA;AAAA,iBAaxC,oBAAA,CACd,MAAA,EAAQ,qBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA;AAAA,iBAQrC,2BAAA,CACd,MAAA,EAAQ,gBAAA,EACR,OAAA,EAAS,mBAAA;EAAwB,GAAA,GAAM,UAAA;AAAA,IAAY,cAAA"}
+{"version":3,"file":"openai_functions.d.ts","names":[],"sources":["../../src/document_transformers/openai_functions.ts"],"mappings":";;;;;;;;;;;cAmBa,uBAAuB;SAC3B;YAIG,cAAc;EAExB,YAAY;IAAU,cAAc;;EAe9B,mBAAmB,UAAU,WAAW,QAAQ;;iBAaxC,qBACd,QAAQ,uBACR,SAAS;EAAwB,MAAM;IAAY;iBAQrC,4BACd,QAAQ,kBACR,SAAS;EAAwB,MAAM;IAAY"}

package/dist/document_transformers/openai_functions.js.map

@@ -1 +1 @@
-{"version":3,"file":"openai_functions.js","names":[],"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,cAAoC,2BAA2B;CAC7D,OAAO,UAAU;AACf,SAAO;;CAGT;CAEA,YAAY,QAAqC;AAC/C,SAAO;AACP,OAAK,eAAe,OAAO;AAC3B,MAAI,KAAK,aAAa,UAAU,WAAW,EACzC,OAAM,IAAI,MACR,oEACD;AAEH,MAAI,KAAK,aAAa,WAAW,WAAW,EAC1C,OAAM,IAAI,MACR,qEACD;;CAIL,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,aAC5C,CAAC,EAEqB,KAAK,aAAa,WAAW;AACpD,SAAO,IAAI,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;IAAU;GACzD,CAAC;;;AAIN,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,sBAAsB,CAAC,EAAE,GAAG,SAChE;AAEF,QAAO,IAAI,eAAe,EAAE,cADP,mBAAmB,QAAQ,KAAK,KACb,EAAE,CAAC;;AAG7C,SAAgB,4BACd,QACA,SACA;AACA,QAAO,qBACL,aAAa,OAAO,EACpB,QACD"}
+{"version":3,"file":"openai_functions.js","names":[],"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,cAAoC,2BAA2B;CAC7D,OAAO,UAAU;EACf,OAAO;CACT;CAEA;CAEA,YAAY,QAAqC;EAC/C,MAAM;EACN,KAAK,eAAe,OAAO;EAC3B,IAAI,KAAK,aAAa,UAAU,WAAW,GACzC,MAAM,IAAI,MACR,mEACF;EAEF,IAAI,KAAK,aAAa,WAAW,WAAW,GAC1C,MAAM,IAAI,MACR,oEACF;CAEJ;CAEA,MAAM,mBAAmB,UAAuC;EAI9D,MAAM,qBACJ,MAJiC,KAAK,aAAa,KAAK,GACvD,KAAK,aAAa,UAAU,KAAK,SAAS,YAC7C,CAAC,EAAA,CAEsB,KAAK,aAAa,WAAW;EACpD,OAAO,IAAI,SAAS;GAClB,aAAa,SAAS;GACtB,UAAU;IAAE,GAAG;IAAmB,GAAG,SAAS;GAAS;EACzD,CAAC;CACH;AACF;AAEA,SAAgB,qBACd,QACA,SACA;CACA,MAAM,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,qBAAqB,CAAC,GAAG,GAAG,SAChE;CAEF,OAAO,IAAI,eAAe,EAAE,cADP,mBAAmB,QAAQ,KAAK,IACzB,EAAa,CAAC;AAC5C;AAEA,SAAgB,4BACd,QACA,SACA;CACA,OAAO,qBACL,aAAa,MAAM,GACnB,OACF;AACF"}

package/dist/embeddings/cache_backed.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.cjs","names":["Embeddings","EncoderBackedStore"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors =\n        await this.underlyingEmbeddings.embedDocuments(missingDocuments);\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2CA,2BAAAA,WAAW;CACpD;CAEA;CAEA,YAAY,QAAqC;AAC/C,QAAM,OAAO;AACb,OAAK,uBAAuB,OAAO;AACnC,OAAK,yBAAyB,OAAO;;;;;;;;;;;;;;;;;CAkBvC,MAAM,WAAW,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;;;;;;;;;;;;CAavD,MAAM,eAAe,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,EAAE;EAC1B,MAAM,mBAAmB,EAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,KAAA,GAAW;AAC5B,mBAAgB,KAAK,EAAE;AACvB,oBAAiB,KAAK,UAAU,GAAG;;AAGvC,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBACJ,MAAM,KAAK,qBAAqB,eAAe,iBAAiB;GAClE,MAAM,gBAAsC,iBAAiB,KAC1D,UAAU,MAAM,CAAC,UAAU,eAAe,GAAG,CAC/C;AACD,SAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,EAC/C,SAAQ,gBAAgB,MAAM,eAAe;;AAGjD,SAAO;;;;;;;;;;CAWT,OAAO,eACL,sBACA,wBACA,SAGA;EACA,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,qBAAqB,IAAIC,+BAAAA,mBAI7B;GACA,OAAO;GACP,aAAa,SAAS,SAAS,aAAa,OAAA,GAAA,2BAAA,QAAa,IAAI;GAC7D,kBAAkB,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,oBAAoB,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;GAC9C,CAAC;AACF,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;GACzB,CAAC"}
+{"version":3,"file":"cache_backed.cjs","names":["Embeddings","EncoderBackedStore"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors =\n        await this.underlyingEmbeddings.embedDocuments(missingDocuments);\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2CA,2BAAAA,WAAW;CACpD;CAEA;CAEA,YAAY,QAAqC;EAC/C,MAAM,MAAM;EACZ,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACvC;;;;;;;;;;;;;;;;CAiBA,MAAM,WAAW,UAAqC;EACpD,OAAO,KAAK,qBAAqB,WAAW,QAAQ;CACtD;;;;;;;;;;;CAYA,MAAM,eAAe,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,SAAS;EAChE,MAAM,kBAAkB,CAAC;EACzB,MAAM,mBAAmB,CAAC;EAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,GACvC,IAAI,QAAQ,OAAO,KAAA,GAAW;GAC5B,gBAAgB,KAAK,CAAC;GACtB,iBAAiB,KAAK,UAAU,EAAE;EACpC;EAEF,IAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBACJ,MAAM,KAAK,qBAAqB,eAAe,gBAAgB;GACjE,MAAM,gBAAsC,iBAAiB,KAC1D,UAAU,MAAM,CAAC,UAAU,eAAe,EAAE,CAC/C;GACA,MAAM,KAAK,uBAAuB,KAAK,aAAa;GACpD,KAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEjD;EACA,OAAO;CACT;;;;;;;;;CAUA,OAAO,eACL,sBACA,wBACA,SAGA;EACA,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,qBAAqB,IAAIC,+BAAAA,mBAI7B;GACA,OAAO;GACP,aAAa,SAAS,SAAS,aAAa,OAAA,GAAA,2BAAA,OAAA,CAAa,GAAG;GAC5D,kBAAkB,UAAU,QAAQ,OAAO,KAAK,UAAU,KAAK,CAAC;GAChE,oBAAoB,oBAClB,KAAK,MAAM,QAAQ,OAAO,eAAe,CAAC;EAC9C,CAAC;EACD,OAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EAC1B,CAAC;CACH;AACF"}

package/dist/embeddings/cache_backed.d.cts

@@ -1,7 +1,6 @@
 import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
 import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
 import { BaseStore } from "@langchain/core/stores";
-
 //#region src/embeddings/cache_backed.d.ts
 /**
  * Interface for the fields required to initialize an instance of the

package/dist/embeddings/cache_backed.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.d.cts","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"mappings":";;;;;;;AAcA;;UAAiB,2BAAA,SAAoC,iBAAA;EACnD,oBAAA,EAAsB,mBAAA;EACtB,sBAAA,EAAwB,SAAA;AAAA;;;;;;;;;;AAkD1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,qBAAA,SAA8B,UAAA;EAAA,UAC/B,oBAAA,EAAsB,mBAAA;EAAA,UAEtB,sBAAA,EAAwB,SAAA;EAElC,WAAA,CAAY,MAAA,EAAQ,2BAAA;;;;;;;;;;;;;;;;EAqBd,UAAA,CAAW,QAAA,WAAmB,OAAA;;;;;;;;;;;EAc9B,cAAA,CAAe,SAAA,aAAsB,OAAA;;;;;;;;;SAgCpC,cAAA,CACL,oBAAA,EAAsB,mBAAA,EACtB,sBAAA,EAAwB,SAAA,SAAkB,UAAA,GAC1C,OAAA;IACE,SAAA;EAAA,IACD,qBAAA;AAAA"}
+{"version":3,"file":"cache_backed.d.cts","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"mappings":";;;;;;;;UAciB,oCAAoC;EACnD,sBAAsB;EACtB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDb,8BAA8B;YAC/B,sBAAsB;YAEtB,wBAAwB;EAElC,YAAY,QAAQ;;;;;;;;;;;;;;;;EAqBd,WAAW,mBAAmB;;;;;;;;;;;EAc9B,eAAe,sBAAsB;;;;;;;;;SAgCpC,eACL,sBAAsB,qBACtB,wBAAwB,kBAAkB,aAC1C;IACE;MACD"}

package/dist/embeddings/cache_backed.d.ts

@@ -1,7 +1,6 @@
 import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
 import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
 import { BaseStore } from "@langchain/core/stores";
-
 //#region src/embeddings/cache_backed.d.ts
 /**
  * Interface for the fields required to initialize an instance of the

package/dist/embeddings/cache_backed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.d.ts","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"mappings":";;;;;;;AAcA;;UAAiB,2BAAA,SAAoC,iBAAA;EACnD,oBAAA,EAAsB,mBAAA;EACtB,sBAAA,EAAwB,SAAA;AAAA;;;;;;;;;;AAkD1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,qBAAA,SAA8B,UAAA;EAAA,UAC/B,oBAAA,EAAsB,mBAAA;EAAA,UAEtB,sBAAA,EAAwB,SAAA;EAElC,WAAA,CAAY,MAAA,EAAQ,2BAAA;;;;;;;;;;;;;;;;EAqBd,UAAA,CAAW,QAAA,WAAmB,OAAA;;;;;;;;;;;EAc9B,cAAA,CAAe,SAAA,aAAsB,OAAA;;;;;;;;;SAgCpC,cAAA,CACL,oBAAA,EAAsB,mBAAA,EACtB,sBAAA,EAAwB,SAAA,SAAkB,UAAA,GAC1C,OAAA;IACE,SAAA;EAAA,IACD,qBAAA;AAAA"}
+{"version":3,"file":"cache_backed.d.ts","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"mappings":";;;;;;;;UAciB,oCAAoC;EACnD,sBAAsB;EACtB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDb,8BAA8B;YAC/B,sBAAsB;YAEtB,wBAAwB;EAElC,YAAY,QAAQ;;;;;;;;;;;;;;;;EAqBd,WAAW,mBAAmB;;;;;;;;;;;EAc9B,eAAe,sBAAsB;;;;;;;;;SAgCpC,eACL,sBAAsB,qBACtB,wBAAwB,kBAAkB,aAC1C;IACE;MACD"}

package/dist/embeddings/cache_backed.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache_backed.js","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors =\n        await this.underlyingEmbeddings.embedDocuments(missingDocuments);\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2C,WAAW;CACpD;CAEA;CAEA,YAAY,QAAqC;AAC/C,QAAM,OAAO;AACb,OAAK,uBAAuB,OAAO;AACnC,OAAK,yBAAyB,OAAO;;;;;;;;;;;;;;;;;CAkBvC,MAAM,WAAW,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;;;;;;;;;;;;CAavD,MAAM,eAAe,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,EAAE;EAC1B,MAAM,mBAAmB,EAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,KAAA,GAAW;AAC5B,mBAAgB,KAAK,EAAE;AACvB,oBAAiB,KAAK,UAAU,GAAG;;AAGvC,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBACJ,MAAM,KAAK,qBAAqB,eAAe,iBAAiB;GAClE,MAAM,gBAAsC,iBAAiB,KAC1D,UAAU,MAAM,CAAC,UAAU,eAAe,GAAG,CAC/C;AACD,SAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,EAC/C,SAAQ,gBAAgB,MAAM,eAAe;;AAGjD,SAAO;;;;;;;;;;CAWT,OAAO,eACL,sBACA,wBACA,SAGA;EACA,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,UAAU,IAAI,aAAa;EACjC,MAAM,qBAAqB,IAAI,mBAI7B;GACA,OAAO;GACP,aAAa,SAAS,SAAS,aAAa,MAAM,OAAO,IAAI;GAC7D,kBAAkB,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,oBAAoB,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;GAC9C,CAAC;AACF,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;GACzB,CAAC"}
+{"version":3,"file":"cache_backed.js","names":[],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors =\n        await this.underlyingEmbeddings.embedDocuments(missingDocuments);\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2C,WAAW;CACpD;CAEA;CAEA,YAAY,QAAqC;EAC/C,MAAM,MAAM;EACZ,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACvC;;;;;;;;;;;;;;;;CAiBA,MAAM,WAAW,UAAqC;EACpD,OAAO,KAAK,qBAAqB,WAAW,QAAQ;CACtD;;;;;;;;;;;CAYA,MAAM,eAAe,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,SAAS;EAChE,MAAM,kBAAkB,CAAC;EACzB,MAAM,mBAAmB,CAAC;EAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,GACvC,IAAI,QAAQ,OAAO,KAAA,GAAW;GAC5B,gBAAgB,KAAK,CAAC;GACtB,iBAAiB,KAAK,UAAU,EAAE;EACpC;EAEF,IAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBACJ,MAAM,KAAK,qBAAqB,eAAe,gBAAgB;GACjE,MAAM,gBAAsC,iBAAiB,KAC1D,UAAU,MAAM,CAAC,UAAU,eAAe,EAAE,CAC/C;GACA,MAAM,KAAK,uBAAuB,KAAK,aAAa;GACpD,KAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEjD;EACA,OAAO;CACT;;;;;;;;;CAUA,OAAO,eACL,sBACA,wBACA,SAGA;EACA,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,UAAU,IAAI,YAAY;EAChC,MAAM,qBAAqB,IAAI,mBAI7B;GACA,OAAO;GACP,aAAa,SAAS,SAAS,aAAa,MAAM,OAAO,GAAG;GAC5D,kBAAkB,UAAU,QAAQ,OAAO,KAAK,UAAU,KAAK,CAAC;GAChE,oBAAoB,oBAClB,KAAK,MAAM,QAAQ,OAAO,eAAe,CAAC;EAC9C,CAAC;EACD,OAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EAC1B,CAAC;CACH;AACF"}

package/dist/evaluation/agents/index.cjs

@@ -1 +1,3 @@
-require("./trajectory.cjs");
+const require_trajectory = require("./trajectory.cjs");
+exports.TrajectoryEvalChain = require_trajectory.TrajectoryEvalChain;
+exports.TrajectoryOutputParser = require_trajectory.TrajectoryOutputParser;

package/dist/evaluation/agents/index.d.cts

@@ -1 +1,2 @@
-import { TrajectoryEvalChain, TrajectoryOutputParser } from "./trajectory.cjs";
+import { TrajectoryEvalChain, TrajectoryOutputParser } from "./trajectory.cjs";
+export { TrajectoryEvalChain, TrajectoryOutputParser };

package/dist/evaluation/agents/index.d.ts

@@ -1 +1,2 @@
-import { TrajectoryEvalChain, TrajectoryOutputParser } from "./trajectory.js";
+import { TrajectoryEvalChain, TrajectoryOutputParser } from "./trajectory.js";
+export { TrajectoryEvalChain, TrajectoryOutputParser };

package/dist/evaluation/agents/index.js

@@ -1,2 +1,2 @@
-import "./trajectory.js";
-export {};
+import { TrajectoryEvalChain, TrajectoryOutputParser } from "./trajectory.js";
+export { TrajectoryEvalChain, TrajectoryOutputParser };

package/dist/evaluation/agents/prompt.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_prompts = require("@langchain/core/prompts");
 //#region src/evaluation/agents/prompt.ts
 /**
@@ -89,17 +88,17 @@ The model did not use the appropriate tools to answer the question.\
 Judgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.
 
 Score: 2`;
-const EVAL_CHAT_PROMPT = /* @__PURE__ */ _langchain_core_prompts.ChatPromptTemplate.fromMessages([
-	/* @__PURE__ */ _langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
-	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
-	/* @__PURE__ */ _langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
-	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE)
+const EVAL_CHAT_PROMPT = /* #__PURE__ */ _langchain_core_prompts.ChatPromptTemplate.fromMessages([
+	/* #__PURE__ */ _langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+	/* #__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+	/* #__PURE__ */ _langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+	/* #__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE)
 ]);
-const TOOL_FREE_EVAL_CHAT_PROMPT = /* @__PURE__ */ _langchain_core_prompts.ChatPromptTemplate.fromMessages([
-	/* @__PURE__ */ _langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
-	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
-	/* @__PURE__ */ _langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
-	/* @__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(`An AI language model has been given access to a set of tools to help answer a user's question.
+const TOOL_FREE_EVAL_CHAT_PROMPT = /* #__PURE__ */ _langchain_core_prompts.ChatPromptTemplate.fromMessages([
+	/* #__PURE__ */ _langchain_core_prompts.SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+	/* #__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+	/* #__PURE__ */ _langchain_core_prompts.AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+	/* #__PURE__ */ _langchain_core_prompts.HumanMessagePromptTemplate.fromTemplate(`An AI language model has been given access to a set of tools to help answer a user's question.
 
 The question the human asked the AI model was:
 [QUESTION]

package/dist/evaluation/agents/prompt.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;;;AAWA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CtB,MAAM,iBAAiB;;;;;;;;;;AAWvB,MAAa,mBAAmC,wCAAA,mBAAmB,aACjE;CACkB,wCAAA,4BAA4B,aAC1C,8DACD;CACe,wCAAA,2BAA2B,aAAa,cAAc;CACtD,wCAAA,wBAAwB,aAAa,eAAe;CACpD,wCAAA,2BAA2B,aAAa,cAAc;CACvE,CACF;AA6BD,MAAa,6BACK,wCAAA,mBAAmB,aAAa;CAC9B,wCAAA,4BAA4B,aAC1C,8DACD;CACe,wCAAA,2BAA2B,aAAa,cAAc;CACtD,wCAAA,wBAAwB,aAAa,eAAe;CACpD,wCAAA,2BAA2B,aACzC;;;;;;;;;;;;;;;;;;;;;;;;;+DACD;CACF,CAAC"}
+{"version":3,"file":"prompt.cjs","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;;AAWA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CtB,MAAM,iBAAiB;;;;;;;;;;AAWvB,MAAa,mBAAmC,wCAAA,mBAAmB,aACjE;CACkB,wCAAA,4BAA4B,aAC1C,6DACF;CACgB,wCAAA,2BAA2B,aAAa,aAAa;CACrD,wCAAA,wBAAwB,aAAa,cAAc;CACnD,wCAAA,2BAA2B,aAAa,aAAa;AACvE,CACF;AA6BA,MAAa,6BACK,wCAAA,mBAAmB,aAAa;CAC9B,wCAAA,4BAA4B,aAC1C,6DACF;CACgB,wCAAA,2BAA2B,aAAa,aAAa;CACrD,wCAAA,wBAAwB,aAAa,cAAc;CACnD,wCAAA,2BAA2B,aACzC;;;;;;;;;;;;;;;;;;;;;;;;;8DACF;AACF,CAAC"}

package/dist/evaluation/agents/prompt.js

@@ -88,17 +88,17 @@ The model did not use the appropriate tools to answer the question.\
 Judgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.
 
 Score: 2`;
-const EVAL_CHAT_PROMPT = /* @__PURE__ */ ChatPromptTemplate.fromMessages([
-	/* @__PURE__ */ SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
-	/* @__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
-	/* @__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
-	/* @__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE)
+const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages([
+	/* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+	/* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+	/* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+	/* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE)
 ]);
-const TOOL_FREE_EVAL_CHAT_PROMPT = /* @__PURE__ */ ChatPromptTemplate.fromMessages([
-	/* @__PURE__ */ SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
-	/* @__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
-	/* @__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
-	/* @__PURE__ */ HumanMessagePromptTemplate.fromTemplate(`An AI language model has been given access to a set of tools to help answer a user's question.
+const TOOL_FREE_EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages([
+	/* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate("You are a helpful assistant that evaluates language models."),
+	/* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),
+	/* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),
+	/* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(`An AI language model has been given access to a set of tools to help answer a user's question.
 
 The question the human asked the AI model was:
 [QUESTION]

package/dist/evaluation/agents/prompt.js.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;;AAWA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CtB,MAAM,iBAAiB;;;;;;;;;;AAWvB,MAAa,mBAAmC,mCAAmB,aACjE;CACkB,4CAA4B,aAC1C,8DACD;CACe,2CAA2B,aAAa,cAAc;CACtD,wCAAwB,aAAa,eAAe;CACpD,2CAA2B,aAAa,cAAc;CACvE,CACF;AA6BD,MAAa,6BACK,mCAAmB,aAAa;CAC9B,4CAA4B,aAC1C,8DACD;CACe,2CAA2B,aAAa,cAAc;CACtD,wCAAwB,aAAa,eAAe;CACpD,2CAA2B,aACzC;;;;;;;;;;;;;;;;;;;;;;;;;+DACD;CACF,CAAC"}
+{"version":3,"file":"prompt.js","names":[],"sources":["../../../src/evaluation/agents/prompt.ts"],"sourcesContent":["/**\n * Prompt for trajectory evaluation chain.\n */\n\nimport {\n  AIMessagePromptTemplate,\n  ChatPromptTemplate,\n  HumanMessagePromptTemplate,\n  SystemMessagePromptTemplate,\n} from \"@langchain/core/prompts\";\n\nconst EVAL_TEMPLATE = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\n{toolDescriptions}\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_INPUT = `An AI language model has been given access to the following set of tools to help answer a user's question.\n\nThe tools given to the AI model are:\n[TOOL_DESCRIPTIONS]\nTool 1:\nName: Search\nDescription: useful for when you need to ask with search\n\nTool 2:\nName: Lookup\nDescription: useful for when you need to ask with lookup\n\nTool 3:\nName: Calculator\nDescription: useful for doing calculations\n\nTool 4:\nName: Search the Web (SerpAPI)\nDescription: useful for when you need to answer questions about current events\n[END_TOOL_DESCRIPTIONS]\n\nThe question the human asked the AI model was: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\n\n    The AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\nStep 1:\nTool used: Search the Web (SerpAPI)\nTool input: If laid the Statue of Liberty end to end, how many times would it stretch across the United States?\nTool output: The Statue of Liberty was given to the United States by France, as a symbol of the two countries' friendship. It was erected atop an American-designed ...\n[END_AGENT_TRAJECTORY]\n\n[RESPONSE]\nThe AI language model's final answer to the question was: There are different ways to measure the length of the United States, but if we use the distance between the Statue of Liberty and the westernmost point of the contiguous United States (Cape Alava, Washington), which is approximately 2,857 miles (4,596 km), and assume that the Statue of Liberty is 305 feet (93 meters) tall, then the statue would stretch across the United States approximately 17.5 times if laid end to end.\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\nii. Does the AI language use a logical sequence of tools to answer the question?\niii. Does the AI language model use the tools in a helpful way?\niv. Does the AI language model use too many steps to answer the question?\nv. Are the appropriate tools used to answer the question?`;\n\nconst EXAMPLE_OUTPUT = `First, let's evaluate the final answer. The final uses good reasoning but is wrong. 2,857 divided by 305 is not 17.5.\\\nThe model should have used the calculator to figure this out. Second does the model use a logical sequence of tools to answer the question?\\\nThe way model uses the search is not helpful. The model should have used the search tool to figure the width of the US or the height of the statue.\\\nThe model didn't use the calculator tool and gave an incorrect answer. The search API should be used for current events or specific questions.\\\nThe tools were not used in a helpful way. The model did not use too many steps to answer the question.\\\nThe model did not use the appropriate tools to answer the question.\\\n\nJudgment: Given the good reasoning in the final answer but otherwise poor performance, we give the model a score of 2.\n\nScore: 2`;\n\nexport const EVAL_CHAT_PROMPT = /* #__PURE__ */ ChatPromptTemplate.fromMessages(\n  [\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EVAL_TEMPLATE),\n  ]\n);\n\nconst TOOL_FREE_EVAL_TEMPLATE = `An AI language model has been given access to a set of tools to help answer a user's question.\n\nThe question the human asked the AI model was:\n[QUESTION]\n{question}\n[END_QUESTION]{reference}\n\nThe AI language model decided to use the following set of tools to answer the question:\n[AGENT_TRAJECTORY]\n{agentTrajectory}\n[END_AGENT_TRAJECTORY]\n\nThe AI language model's final answer to the question was:\n[RESPONSE]\n{answer}\n[END_RESPONSE]\n\nLet's do a detailed evaluation of the AI language model's answer step by step.\n\nWe consider the following criteria before giving a score from 1 to 5:\n\ni. Is the final answer helpful?\n    ii. Does the AI language use a logical sequence of tools to answer the question?\n    iii. Does the AI language model use the tools in a helpful way?\n    iv. Does the AI language model use too many steps to answer the question?\n    v. Are the appropriate tools used to answer the question?`;\n\nexport const TOOL_FREE_EVAL_CHAT_PROMPT =\n  /* #__PURE__ */ ChatPromptTemplate.fromMessages([\n    /* #__PURE__ */ SystemMessagePromptTemplate.fromTemplate(\n      \"You are a helpful assistant that evaluates language models.\"\n    ),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(EXAMPLE_INPUT),\n    /* #__PURE__ */ AIMessagePromptTemplate.fromTemplate(EXAMPLE_OUTPUT),\n    /* #__PURE__ */ HumanMessagePromptTemplate.fromTemplate(\n      TOOL_FREE_EVAL_TEMPLATE\n    ),\n  ]);\n"],"mappings":";;;;;AAWA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCtB,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CtB,MAAM,iBAAiB;;;;;;;;;;AAWvB,MAAa,mBAAmC,mCAAmB,aACjE;CACkB,4CAA4B,aAC1C,6DACF;CACgB,2CAA2B,aAAa,aAAa;CACrD,wCAAwB,aAAa,cAAc;CACnD,2CAA2B,aAAa,aAAa;AACvE,CACF;AA6BA,MAAa,6BACK,mCAAmB,aAAa;CAC9B,4CAA4B,aAC1C,6DACF;CACgB,2CAA2B,aAAa,aAAa;CACrD,wCAAwB,aAAa,cAAc;CACnD,2CAA2B,aACzC;;;;;;;;;;;;;;;;;;;;;;;;;8DACF;AACF,CAAC"}

package/dist/evaluation/agents/trajectory.cjs

@@ -1,4 +1,3 @@
-require("../../_virtual/_rolldown/runtime.cjs");
 const require_base = require("../base.cjs");
 const require_prompt = require("./prompt.cjs");
 let _langchain_core_outputs = require("@langchain/core/outputs");