@langchain/classic 1.0.23 → 1.0.24-dev-1773698445534

package/dist/storage/encoder_backed.js.map

@@ -1 +1 @@
-{"version":3,"file":"encoder_backed.js","names":[],"sources":["../../src/storage/encoder_backed.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<\n  K,\n  V\n> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  store: BaseStore<string, SerializedType>;\n\n  keyEncoder: (key: K) => string;\n\n  valueSerializer: (value: V) => SerializedType;\n\n  valueDeserializer: (value: SerializedType) => V;\n\n  constructor(fields: {\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n  }) {\n    super(fields);\n    this.store = fields.store;\n    this.keyEncoder = fields.keyEncoder;\n    this.valueSerializer = fields.valueSerializer;\n    this.valueDeserializer = fields.valueDeserializer;\n  }\n\n  /**\n   * Method to get multiple keys at once. It works with the encoded keys and\n   * serialized values.\n   * @param keys Array of keys to get\n   * @returns Promise that resolves with an array of values or undefined for each key\n   */\n  async mget(keys: K[]): Promise<(V | undefined)[]> {\n    const encodedKeys = keys.map(this.keyEncoder);\n    const values = await this.store.mget(encodedKeys);\n    return values.map((value) => {\n      if (value === undefined) {\n        return undefined;\n      }\n      return this.valueDeserializer(value);\n    });\n  }\n\n  /**\n   * Method to set multiple keys at once. It works with the encoded keys and\n   * serialized values.\n   * @param keyValuePairs Array of key-value pairs to set\n   * @returns Promise that resolves when the operation is complete\n   */\n  async mset(keyValuePairs: [K, V][]): Promise<void> {\n    const encodedPairs: [string, SerializedType][] = keyValuePairs.map(\n      ([key, value]) => [this.keyEncoder(key), this.valueSerializer(value)]\n    );\n    return this.store.mset(encodedPairs);\n  }\n\n  /**\n   * Method to delete multiple keys at once. It works with the encoded keys.\n   * @param keys Array of keys to delete\n   * @returns Promise that resolves when the operation is complete\n   */\n  async mdelete(keys: K[]): Promise<void> {\n    const encodedKeys = keys.map(this.keyEncoder);\n    return this.store.mdelete(encodedKeys);\n  }\n\n  /**\n   * Method to yield keys. It works with the encoded keys.\n   * @param prefix Optional prefix to filter keys\n   * @returns AsyncGenerator that yields keys\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K> {\n    yield* this.store.yieldKeys(prefix);\n  }\n}\n\nexport function createDocumentStoreFromByteStore(\n  store: BaseStore<string, Uint8Array>\n) {\n  const encoder = new TextEncoder();\n  const decoder = new TextDecoder();\n  return new EncoderBackedStore({\n    store,\n    keyEncoder: (key: string) => key,\n    valueSerializer: (doc: Document) =>\n      encoder.encode(\n        JSON.stringify({ pageContent: doc.pageContent, metadata: doc.metadata })\n      ),\n    valueDeserializer: (bytes: Uint8Array) =>\n      new Document(JSON.parse(decoder.decode(bytes))),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;AASA,IAAa,qBAAb,cAAoE,UAGlE;CACA,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA;CAEA;CAEA;CAEA,YAAY,QAKT;AACD,QAAM,OAAO;AACb,OAAK,QAAQ,OAAO;AACpB,OAAK,aAAa,OAAO;AACzB,OAAK,kBAAkB,OAAO;AAC9B,OAAK,oBAAoB,OAAO;;;;;;;;CASlC,MAAM,KAAK,MAAuC;EAChD,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;AAE7C,UADe,MAAM,KAAK,MAAM,KAAK,YAAY,EACnC,KAAK,UAAU;AAC3B,OAAI,UAAU,OACZ;AAEF,UAAO,KAAK,kBAAkB,MAAM;IACpC;;;;;;;;CASJ,MAAM,KAAK,eAAwC;EACjD,MAAM,eAA2C,cAAc,KAC5D,CAAC,KAAK,WAAW,CAAC,KAAK,WAAW,IAAI,EAAE,KAAK,gBAAgB,MAAM,CAAC,CACtE;AACD,SAAO,KAAK,MAAM,KAAK,aAAa;;;;;;;CAQtC,MAAM,QAAQ,MAA0B;EACtC,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;AAC7C,SAAO,KAAK,MAAM,QAAQ,YAAY;;;;;;;CAQxC,OAAO,UAAU,QAAyD;AACxE,SAAO,KAAK,MAAM,UAAU,OAAO;;;AAIvC,SAAgB,iCACd,OACA;CACA,MAAM,UAAU,IAAI,aAAa;CACjC,MAAM,UAAU,IAAI,aAAa;AACjC,QAAO,IAAI,mBAAmB;EAC5B;EACA,aAAa,QAAgB;EAC7B,kBAAkB,QAChB,QAAQ,OACN,KAAK,UAAU;GAAE,aAAa,IAAI;GAAa,UAAU,IAAI;GAAU,CAAC,CACzE;EACH,oBAAoB,UAClB,IAAI,SAAS,KAAK,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC;EAClD,CAAC"}
+{"version":3,"file":"encoder_backed.js","names":[],"sources":["../../src/storage/encoder_backed.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<\n  K,\n  V\n> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  store: BaseStore<string, SerializedType>;\n\n  keyEncoder: (key: K) => string;\n\n  valueSerializer: (value: V) => SerializedType;\n\n  valueDeserializer: (value: SerializedType) => V;\n\n  constructor(fields: {\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n  }) {\n    super(fields);\n    this.store = fields.store;\n    this.keyEncoder = fields.keyEncoder;\n    this.valueSerializer = fields.valueSerializer;\n    this.valueDeserializer = fields.valueDeserializer;\n  }\n\n  /**\n   * Method to get multiple keys at once. It works with the encoded keys and\n   * serialized values.\n   * @param keys Array of keys to get\n   * @returns Promise that resolves with an array of values or undefined for each key\n   */\n  async mget(keys: K[]): Promise<(V | undefined)[]> {\n    const encodedKeys = keys.map(this.keyEncoder);\n    const values = await this.store.mget(encodedKeys);\n    return values.map((value) => {\n      if (value === undefined) {\n        return undefined;\n      }\n      return this.valueDeserializer(value);\n    });\n  }\n\n  /**\n   * Method to set multiple keys at once. It works with the encoded keys and\n   * serialized values.\n   * @param keyValuePairs Array of key-value pairs to set\n   * @returns Promise that resolves when the operation is complete\n   */\n  async mset(keyValuePairs: [K, V][]): Promise<void> {\n    const encodedPairs: [string, SerializedType][] = keyValuePairs.map(\n      ([key, value]) => [this.keyEncoder(key), this.valueSerializer(value)]\n    );\n    return this.store.mset(encodedPairs);\n  }\n\n  /**\n   * Method to delete multiple keys at once. It works with the encoded keys.\n   * @param keys Array of keys to delete\n   * @returns Promise that resolves when the operation is complete\n   */\n  async mdelete(keys: K[]): Promise<void> {\n    const encodedKeys = keys.map(this.keyEncoder);\n    return this.store.mdelete(encodedKeys);\n  }\n\n  /**\n   * Method to yield keys. It works with the encoded keys.\n   * @param prefix Optional prefix to filter keys\n   * @returns AsyncGenerator that yields keys\n   */\n  async *yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K> {\n    yield* this.store.yieldKeys(prefix);\n  }\n}\n\nexport function createDocumentStoreFromByteStore(\n  store: BaseStore<string, Uint8Array>\n) {\n  const encoder = new TextEncoder();\n  const decoder = new TextDecoder();\n  return new EncoderBackedStore({\n    store,\n    keyEncoder: (key: string) => key,\n    valueSerializer: (doc: Document) =>\n      encoder.encode(\n        JSON.stringify({ pageContent: doc.pageContent, metadata: doc.metadata })\n      ),\n    valueDeserializer: (bytes: Uint8Array) =>\n      new Document(JSON.parse(decoder.decode(bytes))),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;AASA,IAAa,qBAAb,cAAoE,UAGlE;CACA,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA;CAEA;CAEA;CAEA,YAAY,QAKT;AACD,QAAM,OAAO;AACb,OAAK,QAAQ,OAAO;AACpB,OAAK,aAAa,OAAO;AACzB,OAAK,kBAAkB,OAAO;AAC9B,OAAK,oBAAoB,OAAO;;;;;;;;CASlC,MAAM,KAAK,MAAuC;EAChD,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;AAE7C,UADe,MAAM,KAAK,MAAM,KAAK,YAAY,EACnC,KAAK,UAAU;AAC3B,OAAI,UAAU,KAAA,EACZ;AAEF,UAAO,KAAK,kBAAkB,MAAM;IACpC;;;;;;;;CASJ,MAAM,KAAK,eAAwC;EACjD,MAAM,eAA2C,cAAc,KAC5D,CAAC,KAAK,WAAW,CAAC,KAAK,WAAW,IAAI,EAAE,KAAK,gBAAgB,MAAM,CAAC,CACtE;AACD,SAAO,KAAK,MAAM,KAAK,aAAa;;;;;;;CAQtC,MAAM,QAAQ,MAA0B;EACtC,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;AAC7C,SAAO,KAAK,MAAM,QAAQ,YAAY;;;;;;;CAQxC,OAAO,UAAU,QAAyD;AACxE,SAAO,KAAK,MAAM,UAAU,OAAO;;;AAIvC,SAAgB,iCACd,OACA;CACA,MAAM,UAAU,IAAI,aAAa;CACjC,MAAM,UAAU,IAAI,aAAa;AACjC,QAAO,IAAI,mBAAmB;EAC5B;EACA,aAAa,QAAgB;EAC7B,kBAAkB,QAChB,QAAQ,OACN,KAAK,UAAU;GAAE,aAAa,IAAI;GAAa,UAAU,IAAI;GAAU,CAAC,CACzE;EACH,oBAAoB,UAClB,IAAI,SAAS,KAAK,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC;EAClD,CAAC"}

package/dist/storage/file_system.cjs

@@ -1,11 +1,10 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 let node_path = require("node:path");
 node_path = require_runtime.__toESM(node_path);
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_runtime.__toESM(node_fs_promises);
 let _langchain_core_stores = require("@langchain/core/stores");
-
 //#region src/storage/file_system.ts
 var file_system_exports = /* @__PURE__ */ require_runtime.__exportAll({ LocalFileStore: () => LocalFileStore });
 /**
@@ -146,13 +145,13 @@ var LocalFileStore = class extends _langchain_core_stores.BaseStore {
 		return new this({ rootPath });
 	}
 };
-
 //#endregion
 exports.LocalFileStore = LocalFileStore;
-Object.defineProperty(exports, 'file_system_exports', {
-  enumerable: true,
-  get: function () {
-    return file_system_exports;
-  }
+Object.defineProperty(exports, "file_system_exports", {
+	enumerable: true,
+	get: function() {
+		return file_system_exports;
+	}
 });
+
 //# sourceMappingURL=file_system.cjs.map

package/dist/storage/file_system.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.cjs","names":["BaseStore","fs","path"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoCA,iCAA8B;CAChE,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;CAQzB,MAAc,cAAc,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR,oGACD;AAEH,MAAI;GACF,MAAM,cAAc,MAAMC,iBAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH;AAEF,UAAO;WAEA,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B;AAEF,SAAM,IAAI,MACR,2CACE,KAAK,SACN,YAAY,KAAK,UAAU,EAAE,GAC/B;;;;;;;CAQL,MAAc,eAAe,SAAqB,KAAa;AAC7D,MAAI;AACF,SAAMA,iBAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;WAC3C,OAAO;AACd,SAAM,IAAI,MACR,+BAA+B,KAAK,YAClC,IACD,CAAC,YAAY,KAAK,UAAU,MAAM,GACpC;;;;;;;CAQL,AAAQ,YAAY,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI;AAG5B,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,8BAA8B,MAAM;GAGtD,MAAM,WAAWC,UAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,UAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,gBAAgB,IAAI,wDACJ,KAAK,SAAS,eAAe,WAC9C;AAGH,UAAO;WACA,GAAG;AACV,SAAM,IAAI,MACR,oCAAoC,IAAI,YAAY,OAAO,EAAE,GAC9D;;;;;;;;CASL,MAAM,KAAK,MAAgB;EACzB,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;AACjD,UAAO,KAAK,YAAY;;AAE1B,SAAO;;;;;;;CAQT,MAAM,KAAK,eAAsD;AAC/D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;;;;;;;CAQH,MAAM,QAAQ,MAA+B;AAC3C,QAAM,QAAQ,IAAI,KAAK,KAAK,QAAQD,iBAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAMA,iBAAG,QAAQ,KAAK,SAAS,EACvB,KAAK,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,CAChD,OAAM;;;;;;;;CAWZ,aAAa,SAAS,UAA2C;AAC/D,MAAI;AAEF,SAAMA,iBAAG,OAAO,UAAUA,iBAAG,UAAU,OAAOA,iBAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAMA,iBAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;YACtC,OAAO;AACd,UAAM,IAAI,MACR,4CAA4C,SAAS,YAAY,KAAK,UACpE,MACD,GACF;;;AAIL,SAAO,IAAI,KAAK,EAAE,UAAU,CAAC"}
+{"version":3,"file":"file_system.cjs","names":["BaseStore","fs","path"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoCA,uBAAAA,UAA8B;CAChE,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;CAQzB,MAAc,cAAc,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR,oGACD;AAEH,MAAI;GACF,MAAM,cAAc,MAAMC,iBAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH;AAEF,UAAO;WAEA,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B;AAEF,SAAM,IAAI,MACR,2CACE,KAAK,SACN,YAAY,KAAK,UAAU,EAAE,GAC/B;;;;;;;CAQL,MAAc,eAAe,SAAqB,KAAa;AAC7D,MAAI;AACF,SAAMA,iBAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;WAC3C,OAAO;AACd,SAAM,IAAI,MACR,+BAA+B,KAAK,YAClC,IACD,CAAC,YAAY,KAAK,UAAU,MAAM,GACpC;;;;;;;CAQL,YAAoB,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI;AAG5B,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,8BAA8B,MAAM;GAGtD,MAAM,WAAWC,UAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,UAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,gBAAgB,IAAI,wDACJ,KAAK,SAAS,eAAe,WAC9C;AAGH,UAAO;WACA,GAAG;AACV,SAAM,IAAI,MACR,oCAAoC,IAAI,YAAY,OAAO,EAAE,GAC9D;;;;;;;;CASL,MAAM,KAAK,MAAgB;EACzB,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;AACjD,UAAO,KAAK,YAAY;;AAE1B,SAAO;;;;;;;CAQT,MAAM,KAAK,eAAsD;AAC/D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;;;;;;;CAQH,MAAM,QAAQ,MAA+B;AAC3C,QAAM,QAAQ,IAAI,KAAK,KAAK,QAAQD,iBAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAMA,iBAAG,QAAQ,KAAK,SAAS,EACvB,KAAK,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,KAAA,KAAa,IAAI,WAAW,OAAO,CAChD,OAAM;;;;;;;;CAWZ,aAAa,SAAS,UAA2C;AAC/D,MAAI;AAEF,SAAMA,iBAAG,OAAO,UAAUA,iBAAG,UAAU,OAAOA,iBAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAMA,iBAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;YACtC,OAAO;AACd,UAAM,IAAI,MACR,4CAA4C,SAAS,YAAY,KAAK,UACpE,MACD,GACF;;;AAIL,SAAO,IAAI,KAAK,EAAE,UAAU,CAAC"}

package/dist/storage/file_system.js

@@ -2,7 +2,6 @@ import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import * as path$1 from "node:path";
 import * as fs$1 from "node:fs/promises";
 import { BaseStore } from "@langchain/core/stores";
-
 //#region src/storage/file_system.ts
 var file_system_exports = /* @__PURE__ */ __exportAll({ LocalFileStore: () => LocalFileStore });
 /**
@@ -143,7 +142,7 @@ var LocalFileStore = class extends BaseStore {
 		return new this({ rootPath });
 	}
 };
-
 //#endregion
 export { LocalFileStore, file_system_exports };
+
 //# sourceMappingURL=file_system.js.map

package/dist/storage/file_system.js.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.js","names":["fs","path"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoC,UAA8B;CAChE,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;CAQzB,MAAc,cAAc,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR,oGACD;AAEH,MAAI;GACF,MAAM,cAAc,MAAMA,KAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH;AAEF,UAAO;WAEA,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B;AAEF,SAAM,IAAI,MACR,2CACE,KAAK,SACN,YAAY,KAAK,UAAU,EAAE,GAC/B;;;;;;;CAQL,MAAc,eAAe,SAAqB,KAAa;AAC7D,MAAI;AACF,SAAMA,KAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;WAC3C,OAAO;AACd,SAAM,IAAI,MACR,+BAA+B,KAAK,YAClC,IACD,CAAC,YAAY,KAAK,UAAU,MAAM,GACpC;;;;;;;CAQL,AAAQ,YAAY,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI;AAG5B,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,8BAA8B,MAAM;GAGtD,MAAM,WAAWC,OAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,OAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,gBAAgB,IAAI,wDACJ,KAAK,SAAS,eAAe,WAC9C;AAGH,UAAO;WACA,GAAG;AACV,SAAM,IAAI,MACR,oCAAoC,IAAI,YAAY,OAAO,EAAE,GAC9D;;;;;;;;CASL,MAAM,KAAK,MAAgB;EACzB,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;AACjD,UAAO,KAAK,YAAY;;AAE1B,SAAO;;;;;;;CAQT,MAAM,KAAK,eAAsD;AAC/D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;;;;;;;CAQH,MAAM,QAAQ,MAA+B;AAC3C,QAAM,QAAQ,IAAI,KAAK,KAAK,QAAQD,KAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAMA,KAAG,QAAQ,KAAK,SAAS,EACvB,KAAK,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,CAChD,OAAM;;;;;;;;CAWZ,aAAa,SAAS,UAA2C;AAC/D,MAAI;AAEF,SAAMA,KAAG,OAAO,UAAUA,KAAG,UAAU,OAAOA,KAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAMA,KAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;YACtC,OAAO;AACd,UAAM,IAAI,MACR,4CAA4C,SAAS,YAAY,KAAK,UACpE,MACD,GACF;;;AAIL,SAAO,IAAI,KAAK,EAAE,UAAU,CAAC"}
+{"version":3,"file":"file_system.js","names":["fs","path"],"sources":["../../src/storage/file_system.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\n/**\n * File system implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in the file system.\n * @example\n * ```typescript\n * const store = await LocalFileStore.fromPath(\"./messages\");\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     new TextEncoder().encode(\n *       JSON.stringify(\n *         index % 2 === 0\n *           ? new AIMessage(\"ai stuff...\")\n *           : new HumanMessage(\"human stuff...\"),\n *       ),\n *     ),\n *   ]),\n * );\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));\n * for await (const key of store.yieldKeys(\"message:id:\")) {\n *   await store.mdelete([key]);\n * }\n * ```\n *\n * @security **Security Notice** This file store\n * can alter any text file in the provided directory and any subfolders.\n * Make sure that the path you specify when initializing the store is free\n * of other files.\n */\nexport class LocalFileStore extends BaseStore<string, Uint8Array> {\n  lc_namespace = [\"langchain\", \"storage\"];\n\n  rootPath: string;\n\n  constructor(fields: { rootPath: string }) {\n    super(fields);\n    this.rootPath = fields.rootPath;\n  }\n\n  /**\n   * Read and parse the file at the given path.\n   * @param key The key to read the file for.\n   * @returns Promise that resolves to the parsed file content.\n   */\n  private async getParsedFile(key: string): Promise<Uint8Array | undefined> {\n    // Validate the key to prevent path traversal\n    if (!/^[a-zA-Z0-9_\\-:.]+$/.test(key)) {\n      throw new Error(\n        \"Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.\"\n      );\n    }\n    try {\n      const fileContent = await fs.readFile(this.getFullPath(key));\n      if (!fileContent) {\n        return undefined;\n      }\n      return fileContent;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (e: any) {\n      // File does not exist yet.\n      if (\"code\" in e && e.code === \"ENOENT\") {\n        return undefined;\n      }\n      throw new Error(\n        `Error reading and parsing file at path: ${\n          this.rootPath\n        }.\\nError: ${JSON.stringify(e)}`\n      );\n    }\n  }\n\n  /**\n   * Writes the given key-value pairs to the file at the given path.\n   * @param fileContent An object with the key-value pairs to be written to the file.\n   */\n  private async setFileContent(content: Uint8Array, key: string) {\n    try {\n      await fs.writeFile(this.getFullPath(key), content);\n    } catch (error) {\n      throw new Error(\n        `Error writing file at path: ${this.getFullPath(\n          key\n        )}.\\nError: ${JSON.stringify(error)}`\n      );\n    }\n  }\n\n  /**\n   * Returns the full path of the file where the value of the given key is stored.\n   * @param key the key to get the full path for\n   */\n  private getFullPath(key: string): string {\n    try {\n      const keyAsTxtFile = `${key}.txt`;\n\n      // Validate the key to prevent path traversal\n      if (!/^[a-zA-Z0-9_.\\-/]+$/.test(key)) {\n        throw new Error(`Invalid characters in key: ${key}`);\n      }\n\n      const fullPath = path.resolve(this.rootPath, keyAsTxtFile);\n      const commonPath = path.resolve(this.rootPath);\n\n      if (!fullPath.startsWith(commonPath)) {\n        throw new Error(\n          `Invalid key: ${key}. Key should be relative to the root path. ` +\n            `Root path: ${this.rootPath}, Full path: ${fullPath}`\n        );\n      }\n\n      return fullPath;\n    } catch (e) {\n      throw new Error(\n        `Error getting full path for key: ${key}.\\nError: ${String(e)}`\n      );\n    }\n  }\n\n  /**\n   * Retrieves the values associated with the given keys from the store.\n   * @param keys Keys to retrieve values for.\n   * @returns Array of values associated with the given keys.\n   */\n  async mget(keys: string[]) {\n    const values: (Uint8Array | undefined)[] = [];\n    for (const key of keys) {\n      const fileContent = await this.getParsedFile(key);\n      values.push(fileContent);\n    }\n    return values;\n  }\n\n  /**\n   * Sets the values for the given keys in the store.\n   * @param keyValuePairs Array of key-value pairs to set in the store.\n   * @returns Promise that resolves when all key-value pairs have been set.\n   */\n  async mset(keyValuePairs: [string, Uint8Array][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.setFileContent(value, key))\n    );\n  }\n\n  /**\n   * Deletes the given keys and their associated values from the store.\n   * @param keys Keys to delete from the store.\n   * @returns Promise that resolves when all keys have been deleted.\n   */\n  async mdelete(keys: string[]): Promise<void> {\n    await Promise.all(keys.map((key) => fs.unlink(this.getFullPath(key))));\n  }\n\n  /**\n   * Asynchronous generator that yields keys from the store. If a prefix is\n   * provided, it only yields keys that start with the prefix.\n   * @param prefix Optional prefix to filter keys.\n   * @returns AsyncGenerator that yields keys from the store.\n   */\n  async *yieldKeys(prefix?: string): AsyncGenerator<string> {\n    const allFiles = await fs.readdir(this.rootPath);\n    const allKeys = allFiles.map((file) => file.replace(\".txt\", \"\"));\n    for (const key of allKeys) {\n      if (prefix === undefined || key.startsWith(prefix)) {\n        yield key;\n      }\n    }\n  }\n\n  /**\n   * Static method for initializing the class.\n   * Preforms a check to see if the directory exists, and if not, creates it.\n   * @param path Path to the directory.\n   * @returns Promise that resolves to an instance of the class.\n   */\n  static async fromPath(rootPath: string): Promise<LocalFileStore> {\n    try {\n      // Verifies the directory exists at the provided path, and that it is readable and writable.\n      await fs.access(rootPath, fs.constants.R_OK | fs.constants.W_OK);\n    } catch {\n      try {\n        // Directory does not exist, create it.\n        await fs.mkdir(rootPath, { recursive: true });\n      } catch (error) {\n        throw new Error(\n          `An error occurred creating directory at: ${rootPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\n      }\n    }\n\n    return new this({ rootPath });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,iBAAb,cAAoC,UAA8B;CAChE,eAAe,CAAC,aAAa,UAAU;CAEvC;CAEA,YAAY,QAA8B;AACxC,QAAM,OAAO;AACb,OAAK,WAAW,OAAO;;;;;;;CAQzB,MAAc,cAAc,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR,oGACD;AAEH,MAAI;GACF,MAAM,cAAc,MAAMA,KAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH;AAEF,UAAO;WAEA,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B;AAEF,SAAM,IAAI,MACR,2CACE,KAAK,SACN,YAAY,KAAK,UAAU,EAAE,GAC/B;;;;;;;CAQL,MAAc,eAAe,SAAqB,KAAa;AAC7D,MAAI;AACF,SAAMA,KAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;WAC3C,OAAO;AACd,SAAM,IAAI,MACR,+BAA+B,KAAK,YAClC,IACD,CAAC,YAAY,KAAK,UAAU,MAAM,GACpC;;;;;;;CAQL,YAAoB,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI;AAG5B,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,8BAA8B,MAAM;GAGtD,MAAM,WAAWC,OAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,OAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,gBAAgB,IAAI,wDACJ,KAAK,SAAS,eAAe,WAC9C;AAGH,UAAO;WACA,GAAG;AACV,SAAM,IAAI,MACR,oCAAoC,IAAI,YAAY,OAAO,EAAE,GAC9D;;;;;;;;CASL,MAAM,KAAK,MAAgB;EACzB,MAAM,SAAqC,EAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;AACjD,UAAO,KAAK,YAAY;;AAE1B,SAAO;;;;;;;CAQT,MAAM,KAAK,eAAsD;AAC/D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;;;;;;;CAQH,MAAM,QAAQ,MAA+B;AAC3C,QAAM,QAAQ,IAAI,KAAK,KAAK,QAAQD,KAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAMA,KAAG,QAAQ,KAAK,SAAS,EACvB,KAAK,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,KAAA,KAAa,IAAI,WAAW,OAAO,CAChD,OAAM;;;;;;;;CAWZ,aAAa,SAAS,UAA2C;AAC/D,MAAI;AAEF,SAAMA,KAAG,OAAO,UAAUA,KAAG,UAAU,OAAOA,KAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAMA,KAAG,MAAM,UAAU,EAAE,WAAW,MAAM,CAAC;YACtC,OAAO;AACd,UAAM,IAAI,MACR,4CAA4C,SAAS,YAAY,KAAK,UACpE,MACD,GACF;;;AAIL,SAAO,IAAI,KAAK,EAAE,UAAU,CAAC"}

package/dist/storage/in_memory.cjs

@@ -1,21 +1,20 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_stores = require("@langchain/core/stores");
-
 //#region src/storage/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({ InMemoryStore: () => _langchain_core_stores.InMemoryStore });
-
 //#endregion
-Object.defineProperty(exports, 'InMemoryStore', {
-  enumerable: true,
-  get: function () {
-    return _langchain_core_stores.InMemoryStore;
-  }
+Object.defineProperty(exports, "InMemoryStore", {
+	enumerable: true,
+	get: function() {
+		return _langchain_core_stores.InMemoryStore;
+	}
 });
-Object.defineProperty(exports, 'in_memory_exports', {
-  enumerable: true,
-  get: function () {
-    return in_memory_exports;
-  }
+Object.defineProperty(exports, "in_memory_exports", {
+	enumerable: true,
+	get: function() {
+		return in_memory_exports;
+	}
 });
+
 //# sourceMappingURL=in_memory.cjs.map

package/dist/storage/in_memory.js

@@ -1,9 +1,8 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { InMemoryStore } from "@langchain/core/stores";
-
 //#region src/storage/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ __exportAll({ InMemoryStore: () => InMemoryStore });
-
 //#endregion
 export { InMemoryStore, in_memory_exports };
+
 //# sourceMappingURL=in_memory.js.map

package/dist/stores/doc/base.cjs

@@ -1,20 +1,18 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/stores/doc/base.ts
-var base_exports = /* @__PURE__ */ require_runtime.__exportAll({ Docstore: () => Docstore });
+var base_exports = /* @__PURE__ */ require("../../_virtual/_rolldown/runtime.cjs").__exportAll({ Docstore: () => Docstore });
 /**
 * Abstract class for a document store. All document stores should extend
 * this class.
 */
 var Docstore = class {};
-
 //#endregion
 exports.Docstore = Docstore;
-Object.defineProperty(exports, 'base_exports', {
-  enumerable: true,
-  get: function () {
-    return base_exports;
-  }
+Object.defineProperty(exports, "base_exports", {
+	enumerable: true,
+	get: function() {
+		return base_exports;
+	}
 });
+
 //# sourceMappingURL=base.cjs.map

package/dist/stores/doc/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;;;AAMA,IAAsB,WAAtB,MAA+B"}
+{"version":3,"file":"base.cjs","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,WAAtB,MAA+B"}

package/dist/stores/doc/base.js

@@ -1,5 +1,4 @@
 import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
-
 //#region src/stores/doc/base.ts
 var base_exports = /* @__PURE__ */ __exportAll({ Docstore: () => Docstore });
 /**
@@ -7,7 +6,7 @@ var base_exports = /* @__PURE__ */ __exportAll({ Docstore: () => Docstore });
 * this class.
 */
 var Docstore = class {};
-
 //#endregion
 export { Docstore, base_exports };
+
 //# sourceMappingURL=base.js.map

package/dist/stores/doc/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;;AAMA,IAAsB,WAAtB,MAA+B"}
+{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/doc/base.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport abstract class Docstore {\n  abstract search(search: string): Promise<Document>;\n\n  abstract add(texts: Record<string, Document>): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,WAAtB,MAA+B"}

package/dist/stores/doc/in_memory.cjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-const require_stores_doc_base = require('./base.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_stores_doc_base = require("./base.cjs");
 //#region src/stores/doc/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	InMemoryDocstore: () => InMemoryDocstore,
@@ -81,14 +80,14 @@ var SynchronousInMemoryDocstore = class {
 		for (const [key, value] of Object.entries(texts)) this._docs.set(key, value);
 	}
 };
-
 //#endregion
 exports.InMemoryDocstore = InMemoryDocstore;
 exports.SynchronousInMemoryDocstore = SynchronousInMemoryDocstore;
-Object.defineProperty(exports, 'in_memory_exports', {
-  enumerable: true,
-  get: function () {
-    return in_memory_exports;
-  }
+Object.defineProperty(exports, "in_memory_exports", {
+	enumerable: true,
+	get: function() {
+		return in_memory_exports;
+	}
 });
+
 //# sourceMappingURL=in_memory.cjs.map

package/dist/stores/doc/in_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.cjs","names":["Docstore"],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAQA,IAAa,mBAAb,cACUA,iCAEV;CACE;CAEA,YAAY,MAA8B;AACxC,SAAO;AACP,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,MAAM,OAAO,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,MAAM,IAAI,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM;;CAI9B,MAAM,KAAK,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,eAAoD;AAC7D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAChE;;CAGH,MAAM,QAAQ,OAAgC;AAC5C,QAAM,IAAI,MAAM,mBAAmB;;CAIrC,OAAO,UAAU,SAA0C;AACzD,QAAM,IAAI,MAAM,kBAAkB;;;;;;AAOtC,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAY,MAA8B;AACxC,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,OAAO,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,IAAI,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM"}
+{"version":3,"file":"in_memory.cjs","names":["Docstore"],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAQA,IAAa,mBAAb,cACUA,wBAAAA,SAEV;CACE;CAEA,YAAY,MAA8B;AACxC,SAAO;AACP,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,MAAM,OAAO,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,MAAM,IAAI,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM;;CAI9B,MAAM,KAAK,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,eAAoD;AAC7D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAChE;;CAGH,MAAM,QAAQ,OAAgC;AAC5C,QAAM,IAAI,MAAM,mBAAmB;;CAIrC,OAAO,UAAU,SAA0C;AACzD,QAAM,IAAI,MAAM,kBAAkB;;;;;;AAOtC,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAY,MAA8B;AACxC,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,OAAO,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,IAAI,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM"}

package/dist/stores/doc/in_memory.js

@@ -1,6 +1,5 @@
 import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { Docstore } from "./base.js";
-
 //#region src/stores/doc/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ __exportAll({
 	InMemoryDocstore: () => InMemoryDocstore,
@@ -80,7 +79,7 @@ var SynchronousInMemoryDocstore = class {
 		for (const [key, value] of Object.entries(texts)) this._docs.set(key, value);
 	}
 };
-
 //#endregion
 export { InMemoryDocstore, SynchronousInMemoryDocstore, in_memory_exports };
+
 //# sourceMappingURL=in_memory.js.map

package/dist/stores/doc/in_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.js","names":[],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAQA,IAAa,mBAAb,cACU,SAEV;CACE;CAEA,YAAY,MAA8B;AACxC,SAAO;AACP,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,MAAM,OAAO,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,MAAM,IAAI,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM;;CAI9B,MAAM,KAAK,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,eAAoD;AAC7D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAChE;;CAGH,MAAM,QAAQ,OAAgC;AAC5C,QAAM,IAAI,MAAM,mBAAmB;;CAIrC,OAAO,UAAU,SAA0C;AACzD,QAAM,IAAI,MAAM,kBAAkB;;;;;;AAOtC,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAY,MAA8B;AACxC,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,OAAO,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,IAAI,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM"}
+{"version":3,"file":"in_memory.js","names":[],"sources":["../../../src/stores/doc/in_memory.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport class InMemoryDocstore\n  extends Docstore\n  implements BaseStoreInterface<string, Document>\n{\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    super();\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  async search(search: string): Promise<Document> {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  async add(texts: Record<string, Document>): Promise<void> {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n\n  async mget(keys: string[]): Promise<Document[]> {\n    return Promise.all(keys.map((key) => this.search(key)));\n  }\n\n  async mset(keyValuePairs: [string, Document][]): Promise<void> {\n    await Promise.all(\n      keyValuePairs.map(([key, value]) => this.add({ [key]: value }))\n    );\n  }\n\n  async mdelete(_keys: string[]): Promise<void> {\n    throw new Error(\"Not implemented.\");\n  }\n\n  // eslint-disable-next-line require-yield\n  async *yieldKeys(_prefix?: string): AsyncGenerator<string> {\n    throw new Error(\"Not implemented\");\n  }\n}\n\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport class SynchronousInMemoryDocstore {\n  _docs: Map<string, Document>;\n\n  constructor(docs?: Map<string, Document>) {\n    this._docs = docs ?? new Map();\n  }\n\n  /**\n   * Searches for a document in the store based on its ID.\n   * @param search The ID of the document to search for.\n   * @returns The document with the given ID.\n   */\n  search(search: string): Document {\n    const result = this._docs.get(search);\n    if (!result) {\n      throw new Error(`ID ${search} not found.`);\n    } else {\n      return result;\n    }\n  }\n\n  /**\n   * Adds new documents to the store.\n   * @param texts An object where the keys are document IDs and the values are the documents themselves.\n   * @returns Void\n   */\n  add(texts: Record<string, Document>): void {\n    const keys = [...this._docs.keys()];\n    const overlapping = Object.keys(texts).filter((x) => keys.includes(x));\n\n    if (overlapping.length > 0) {\n      throw new Error(`Tried to add ids that already exist: ${overlapping}`);\n    }\n\n    for (const [key, value] of Object.entries(texts)) {\n      this._docs.set(key, value);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAQA,IAAa,mBAAb,cACU,SAEV;CACE;CAEA,YAAY,MAA8B;AACxC,SAAO;AACP,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,MAAM,OAAO,QAAmC;EAC9C,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,MAAM,IAAI,OAAgD;EACxD,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM;;CAI9B,MAAM,KAAK,MAAqC;AAC9C,SAAO,QAAQ,IAAI,KAAK,KAAK,QAAQ,KAAK,OAAO,IAAI,CAAC,CAAC;;CAGzD,MAAM,KAAK,eAAoD;AAC7D,QAAM,QAAQ,IACZ,cAAc,KAAK,CAAC,KAAK,WAAW,KAAK,IAAI,GAAG,MAAM,OAAO,CAAC,CAAC,CAChE;;CAGH,MAAM,QAAQ,OAAgC;AAC5C,QAAM,IAAI,MAAM,mBAAmB;;CAIrC,OAAO,UAAU,SAA0C;AACzD,QAAM,IAAI,MAAM,kBAAkB;;;;;;AAOtC,IAAa,8BAAb,MAAyC;CACvC;CAEA,YAAY,MAA8B;AACxC,OAAK,QAAQ,wBAAQ,IAAI,KAAK;;;;;;;CAQhC,OAAO,QAA0B;EAC/B,MAAM,SAAS,KAAK,MAAM,IAAI,OAAO;AACrC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,MAAM,OAAO,aAAa;MAE1C,QAAO;;;;;;;CASX,IAAI,OAAuC;EACzC,MAAM,OAAO,CAAC,GAAG,KAAK,MAAM,MAAM,CAAC;EACnC,MAAM,cAAc,OAAO,KAAK,MAAM,CAAC,QAAQ,MAAM,KAAK,SAAS,EAAE,CAAC;AAEtE,MAAI,YAAY,SAAS,EACvB,OAAM,IAAI,MAAM,wCAAwC,cAAc;AAGxE,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,MAAK,MAAM,IAAI,KAAK,MAAM"}

package/dist/stores/file/base.cjs

@@ -1,13 +1,12 @@
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+require("../../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_load_serializable = require("@langchain/core/load/serializable");
-
 //#region src/stores/file/base.ts
 /**
 * Base class for all file stores. All file stores should extend this
 * class.
 */
 var BaseFileStore = class extends _langchain_core_load_serializable.Serializable {};
-
 //#endregion
 exports.BaseFileStore = BaseFileStore;
+
 //# sourceMappingURL=base.cjs.map

package/dist/stores/file/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["Serializable"],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;;AAMA,IAAsB,gBAAtB,cAA4CA,+CAAa"}
+{"version":3,"file":"base.cjs","names":["Serializable"],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,gBAAtB,cAA4CA,kCAAAA,aAAa"}

package/dist/stores/file/base.js

@@ -1,12 +1,11 @@
 import { Serializable } from "@langchain/core/load/serializable";
-
 //#region src/stores/file/base.ts
 /**
 * Base class for all file stores. All file stores should extend this
 * class.
 */
 var BaseFileStore = class extends Serializable {};
-
 //#endregion
 export { BaseFileStore };
+
 //# sourceMappingURL=base.js.map

package/dist/stores/file/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA,IAAsB,gBAAtB,cAA4C,aAAa"}
+{"version":3,"file":"base.js","names":[],"sources":["../../../src/stores/file/base.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport abstract class BaseFileStore extends Serializable {\n  abstract readFile(path: string): Promise<string>;\n\n  abstract writeFile(path: string, contents: string): Promise<void>;\n}\n"],"mappings":";;;;;;AAMA,IAAsB,gBAAtB,cAA4C,aAAa"}

package/dist/stores/file/in_memory.cjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-const require_base = require('./base.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_base = require("./base.cjs");
 //#region src/stores/file/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({ InMemoryFileStore: () => InMemoryFileStore });
 /**
@@ -41,13 +40,13 @@ var InMemoryFileStore = class extends require_base.BaseFileStore {
 		this.files.set(path, contents);
 	}
 };
-
 //#endregion
 exports.InMemoryFileStore = InMemoryFileStore;
-Object.defineProperty(exports, 'in_memory_exports', {
-  enumerable: true,
-  get: function () {
-    return in_memory_exports;
-  }
+Object.defineProperty(exports, "in_memory_exports", {
+	enumerable: true,
+	get: function() {
+		return in_memory_exports;
+	}
 });
+
 //# sourceMappingURL=in_memory.cjs.map

package/dist/stores/file/in_memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.cjs","names":["BaseFileStore"],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuCA,2BAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAY;CAE3D,AAAQ,wBAA6B,IAAI,KAAK;;;;;;;CAQ9C,MAAM,SAAS,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,mBAAmB,OAAO;AAE5C,SAAO;;;;;;;;;CAUT,MAAM,UAAU,MAAc,UAAiC;AAC7D,OAAK,MAAM,IAAI,MAAM,SAAS"}
+{"version":3,"file":"in_memory.cjs","names":["BaseFileStore"],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuCA,aAAAA,cAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAY;CAE3D,wBAAqC,IAAI,KAAK;;;;;;;CAQ9C,MAAM,SAAS,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,mBAAmB,OAAO;AAE5C,SAAO;;;;;;;;;CAUT,MAAM,UAAU,MAAc,UAAiC;AAC7D,OAAK,MAAM,IAAI,MAAM,SAAS"}

package/dist/stores/file/in_memory.js

@@ -1,6 +1,5 @@
 import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { BaseFileStore } from "./base.js";
-
 //#region src/stores/file/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ __exportAll({ InMemoryFileStore: () => InMemoryFileStore });
 /**
@@ -40,7 +39,7 @@ var InMemoryFileStore = class extends BaseFileStore {
 		this.files.set(path, contents);
 	}
 };
-
 //#endregion
 export { InMemoryFileStore, in_memory_exports };
+
 //# sourceMappingURL=in_memory.js.map

package/dist/stores/file/in_memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"in_memory.js","names":[],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,IAAa,oBAAb,cAAuC,cAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAY;CAE3D,AAAQ,wBAA6B,IAAI,KAAK;;;;;;;CAQ9C,MAAM,SAAS,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,mBAAmB,OAAO;AAE5C,SAAO;;;;;;;;;CAUT,MAAM,UAAU,MAAc,UAAiC;AAC7D,OAAK,MAAM,IAAI,MAAM,SAAS"}
+{"version":3,"file":"in_memory.js","names":[],"sources":["../../../src/stores/file/in_memory.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport class InMemoryFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"in_memory\"];\n\n  private files: Map<string, string> = new Map();\n\n  /**\n   * Retrieves the contents of a file given its path. If the file does not\n   * exist, it throws an error.\n   * @param path The path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    const contents = this.files.get(path);\n    if (contents === undefined) {\n      throw new Error(`File not found: ${path}`);\n    }\n    return contents;\n  }\n\n  /**\n   * Writes contents to a file at a given path. If the file already exists,\n   * it overwrites the existing contents.\n   * @param path The path of the file to write.\n   * @param contents The contents to write to the file.\n   * @returns Void\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    this.files.set(path, contents);\n  }\n}\n"],"mappings":";;;;;;;;;;;AASA,IAAa,oBAAb,cAAuC,cAAc;CACnD,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAY;CAE3D,wBAAqC,IAAI,KAAK;;;;;;;CAQ9C,MAAM,SAAS,MAA+B;EAC5C,MAAM,WAAW,KAAK,MAAM,IAAI,KAAK;AACrC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,mBAAmB,OAAO;AAE5C,SAAO;;;;;;;;;CAUT,MAAM,UAAU,MAAc,UAAiC;AAC7D,OAAK,MAAM,IAAI,MAAM,SAAS"}

package/dist/stores/file/node.cjs

@@ -1,11 +1,10 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-const require_base = require('./base.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_base = require("./base.cjs");
 let node_path = require("node:path");
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = require_runtime.__toESM(node_fs_promises);
 let node_fs = require("node:fs");
-
 //#region src/stores/file/node.ts
 var node_exports = /* @__PURE__ */ require_runtime.__exportAll({ NodeFileStore: () => NodeFileStore });
 /**
@@ -41,13 +40,13 @@ var NodeFileStore = class extends require_base.BaseFileStore {
 		await node_fs_promises.writeFile((0, node_path.join)(this.basePath, path), contents, "utf8");
 	}
 };
-
 //#endregion
 exports.NodeFileStore = NodeFileStore;
-Object.defineProperty(exports, 'node_exports', {
-  enumerable: true,
-  get: function () {
-    return node_exports;
-  }
+Object.defineProperty(exports, "node_exports", {
+	enumerable: true,
+	get: function() {
+		return node_exports;
+	}
 });
+
 //# sourceMappingURL=node.cjs.map

package/dist/stores/file/node.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.cjs","names":["BaseFileStore","fs"],"sources":["../../../src/stores/file/node.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport { mkdtempSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { BaseFileStore } from \"./base.js\";\n\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport class NodeFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"node\"];\n\n  constructor(public basePath: string = mkdtempSync(\"langchain-\")) {\n    super();\n  }\n\n  /**\n   * Reads the contents of a file at the given path.\n   * @param path Path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    return await fs.readFile(join(this.basePath, path), \"utf8\");\n  }\n\n  /**\n   * Writes the given contents to a file at the specified path.\n   * @param path Path of the file to write to.\n   * @param contents Contents to write to the file.\n   * @returns Promise that resolves when the file has been written.\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    await fs.writeFile(join(this.basePath, path), contents, \"utf8\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAUA,IAAa,gBAAb,cAAmCA,2BAAc;CAC/C,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAO;CAEtD,YAAY,AAAO,oCAA+B,aAAa,EAAE;AAC/D,SAAO;EADU;;;;;;;CASnB,MAAM,SAAS,MAA+B;AAC5C,SAAO,MAAMC,iBAAG,6BAAc,KAAK,UAAU,KAAK,EAAE,OAAO;;;;;;;;CAS7D,MAAM,UAAU,MAAc,UAAiC;AAC7D,QAAMA,iBAAG,8BAAe,KAAK,UAAU,KAAK,EAAE,UAAU,OAAO"}
+{"version":3,"file":"node.cjs","names":["BaseFileStore","fs"],"sources":["../../../src/stores/file/node.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport { mkdtempSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { BaseFileStore } from \"./base.js\";\n\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport class NodeFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"node\"];\n\n  constructor(public basePath: string = mkdtempSync(\"langchain-\")) {\n    super();\n  }\n\n  /**\n   * Reads the contents of a file at the given path.\n   * @param path Path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    return await fs.readFile(join(this.basePath, path), \"utf8\");\n  }\n\n  /**\n   * Writes the given contents to a file at the specified path.\n   * @param path Path of the file to write to.\n   * @param contents Contents to write to the file.\n   * @returns Promise that resolves when the file has been written.\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    await fs.writeFile(join(this.basePath, path), contents, \"utf8\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAUA,IAAa,gBAAb,cAAmCA,aAAAA,cAAc;CAC/C,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAO;CAEtD,YAAY,YAAO,GAAA,QAAA,aAA+B,aAAa,EAAE;AAC/D,SAAO;AADU,OAAA,WAAA;;;;;;;CASnB,MAAM,SAAS,MAA+B;AAC5C,SAAO,MAAMC,iBAAG,UAAA,GAAA,UAAA,MAAc,KAAK,UAAU,KAAK,EAAE,OAAO;;;;;;;;CAS7D,MAAM,UAAU,MAAc,UAAiC;AAC7D,QAAMA,iBAAG,WAAA,GAAA,UAAA,MAAe,KAAK,UAAU,KAAK,EAAE,UAAU,OAAO"}

package/dist/stores/file/node.js

@@ -3,7 +3,6 @@ import { BaseFileStore } from "./base.js";
 import { join } from "node:path";
 import * as fs$1 from "node:fs/promises";
 import { mkdtempSync } from "node:fs";
-
 //#region src/stores/file/node.ts
 var node_exports = /* @__PURE__ */ __exportAll({ NodeFileStore: () => NodeFileStore });
 /**
@@ -39,7 +38,7 @@ var NodeFileStore = class extends BaseFileStore {
 		await fs$1.writeFile(join(this.basePath, path), contents, "utf8");
 	}
 };
-
 //#endregion
 export { NodeFileStore, node_exports };
+
 //# sourceMappingURL=node.js.map

package/dist/stores/file/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","names":["fs"],"sources":["../../../src/stores/file/node.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport { mkdtempSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { BaseFileStore } from \"./base.js\";\n\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport class NodeFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"node\"];\n\n  constructor(public basePath: string = mkdtempSync(\"langchain-\")) {\n    super();\n  }\n\n  /**\n   * Reads the contents of a file at the given path.\n   * @param path Path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    return await fs.readFile(join(this.basePath, path), \"utf8\");\n  }\n\n  /**\n   * Writes the given contents to a file at the specified path.\n   * @param path Path of the file to write to.\n   * @param contents Contents to write to the file.\n   * @returns Promise that resolves when the file has been written.\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    await fs.writeFile(join(this.basePath, path), contents, \"utf8\");\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAUA,IAAa,gBAAb,cAAmC,cAAc;CAC/C,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAO;CAEtD,YAAY,AAAO,WAAmB,YAAY,aAAa,EAAE;AAC/D,SAAO;EADU;;;;;;;CASnB,MAAM,SAAS,MAA+B;AAC5C,SAAO,MAAMA,KAAG,SAAS,KAAK,KAAK,UAAU,KAAK,EAAE,OAAO;;;;;;;;CAS7D,MAAM,UAAU,MAAc,UAAiC;AAC7D,QAAMA,KAAG,UAAU,KAAK,KAAK,UAAU,KAAK,EAAE,UAAU,OAAO"}
+{"version":3,"file":"node.js","names":["fs"],"sources":["../../../src/stores/file/node.ts"],"sourcesContent":["import * as fs from \"node:fs/promises\";\nimport { mkdtempSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { BaseFileStore } from \"./base.js\";\n\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport class NodeFileStore extends BaseFileStore {\n  lc_namespace = [\"langchain\", \"stores\", \"file\", \"node\"];\n\n  constructor(public basePath: string = mkdtempSync(\"langchain-\")) {\n    super();\n  }\n\n  /**\n   * Reads the contents of a file at the given path.\n   * @param path Path of the file to read.\n   * @returns The contents of the file as a string.\n   */\n  async readFile(path: string): Promise<string> {\n    return await fs.readFile(join(this.basePath, path), \"utf8\");\n  }\n\n  /**\n   * Writes the given contents to a file at the specified path.\n   * @param path Path of the file to write to.\n   * @param contents Contents to write to the file.\n   * @returns Promise that resolves when the file has been written.\n   */\n  async writeFile(path: string, contents: string): Promise<void> {\n    await fs.writeFile(join(this.basePath, path), contents, \"utf8\");\n  }\n}\n"],"mappings":";;;;;;;;;;;AAUA,IAAa,gBAAb,cAAmC,cAAc;CAC/C,eAAe;EAAC;EAAa;EAAU;EAAQ;EAAO;CAEtD,YAAY,WAA0B,YAAY,aAAa,EAAE;AAC/D,SAAO;AADU,OAAA,WAAA;;;;;;;CASnB,MAAM,SAAS,MAA+B;AAC5C,SAAO,MAAMA,KAAG,SAAS,KAAK,KAAK,UAAU,KAAK,EAAE,OAAO;;;;;;;;CAS7D,MAAM,UAAU,MAAc,UAAiC;AAC7D,QAAMA,KAAG,UAAU,KAAK,KAAK,UAAU,KAAK,EAAE,UAAU,OAAO"}

package/dist/stores/message/in_memory.cjs

@@ -1,21 +1,20 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_chat_history = require("@langchain/core/chat_history");
-
 //#region src/stores/message/in_memory.ts
 var in_memory_exports = /* @__PURE__ */ require_runtime.__exportAll({ ChatMessageHistory: () => _langchain_core_chat_history.InMemoryChatMessageHistory });
-
 //#endregion
-Object.defineProperty(exports, 'ChatMessageHistory', {
-  enumerable: true,
-  get: function () {
-    return _langchain_core_chat_history.InMemoryChatMessageHistory;
-  }
+Object.defineProperty(exports, "ChatMessageHistory", {
+	enumerable: true,
+	get: function() {
+		return _langchain_core_chat_history.InMemoryChatMessageHistory;
+	}
 });
-Object.defineProperty(exports, 'in_memory_exports', {
-  enumerable: true,
-  get: function () {
-    return in_memory_exports;
-  }
+Object.defineProperty(exports, "in_memory_exports", {
+	enumerable: true,
+	get: function() {
+		return in_memory_exports;
+	}
 });
+
 //# sourceMappingURL=in_memory.cjs.map