langchain 1.2.24 → 1.2.25

package/dist/load/index.d.ts

@@ -1,11 +1,19 @@
 import { OptionalImportMap } from "./import_type.js";
 
 //#region src/load/index.d.ts
-
 /**
  * Load a LangChain module from a serialized text representation.
  * NOTE: This functionality is currently in beta.
  * Loaded classes may change independently of semver.
+ *
+ * **WARNING — insecure deserialization risk.** This function instantiates
+ * classes and invokes constructors based on the contents of `text`. Never
+ * call this on untrusted or user-supplied input. Only deserialize data that
+ * originates from a trusted source you control.
+ *
+ * See `@langchain/core/load` {@link LoadOptions} for detailed security
+ * guidance on `secretsFromEnv`, `secretsMap`, and import maps.
+ *
  * @param text Serialized text representation of the module.
  * @param secretsMap
  * @param optionalImportsMap

package/dist/load/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["OptionalImportMap","load","T","Record","Promise"],"sources":["../../src/load/index.d.ts"],"sourcesContent":["import { OptionalImportMap } from \"./import_type.js\";\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @param additionalImportsMap\n * @param secretsFromEnv\n * @returns A loaded instance of a LangChain module.\n */\nexport declare function load<T>(text: string, secretsMap?: Record<string, any>, optionalImportsMap?: OptionalImportMap & Record<string, any>, additionalImportsMap?: Record<string, any>, secretsFromEnv?: boolean): Promise<T>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;AAYA;;;;;;;AAA4N;;iBAApMC,mCAAmCE,0CAA0CH,oBAAoBG,4CAA4CA,gDAAgDC,QAAQF"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;AAyBA;;;;;;;;;;;;;;;;;;iBAAsB,IAAA,GAAA,CACpB,IAAA,UAEA,UAAA,GAAY,MAAA,eAEZ,kBAAA,GAAoB,iBAAA,GAAoB,MAAA,eAExC,oBAAA,GAAsB,MAAA,eACtB,cAAA,aACC,OAAA,CAAQ,CAAA"}

package/dist/load/index.js

@@ -7,6 +7,15 @@ import { load as load$1 } from "@langchain/core/load";
 * Load a LangChain module from a serialized text representation.
 * NOTE: This functionality is currently in beta.
 * Loaded classes may change independently of semver.
+*
+* **WARNING — insecure deserialization risk.** This function instantiates
+* classes and invokes constructors based on the contents of `text`. Never
+* call this on untrusted or user-supplied input. Only deserialize data that
+* originates from a trusted source you control.
+*
+* See `@langchain/core/load` {@link LoadOptions} for detailed security
+* guidance on `secretsFromEnv`, `secretsMap`, and import maps.
+*
 * @param text Serialized text representation of the module.
 * @param secretsMap
 * @param optionalImportsMap

package/dist/load/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["text: string","secretsMap: Record<string, any>","optionalImportsMap: OptionalImportMap & Record<string, any>","additionalImportsMap: Record<string, any>","secretsFromEnv?: boolean","coreLoad","importMap"],"sources":["../../src/load/index.ts"],"sourcesContent":["import { load as coreLoad } from \"@langchain/core/load\";\nimport { optionalImportEntrypoints } from \"./import_constants.js\";\nimport * as importMap from \"./import_map.js\";\nimport { OptionalImportMap } from \"./import_type.js\";\n\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @param additionalImportsMap\n * @param secretsFromEnv\n * @returns A loaded instance of a LangChain module.\n */\nexport async function load<T>(\n  text: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  additionalImportsMap: Record<string, any> = {},\n  secretsFromEnv?: boolean\n): Promise<T> {\n  return coreLoad(text, {\n    secretsMap,\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap: { ...importMap, ...additionalImportsMap },\n    secretsFromEnv,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,eAAsB,KACpBA,MAEAC,aAAkC,CAAE,GAEpCC,qBAA8D,CAAE,GAEhEC,uBAA4C,CAAE,GAC9CC,gBACY;AACZ,QAAOC,OAAS,MAAM;EACpB;EACA;EACA;EACA,WAAW;GAAE,GAAGC;GAAW,GAAG;EAAsB;EACpD;CACD,EAAC;AACH"}
+{"version":3,"file":"index.js","names":["coreLoad","importMap"],"sources":["../../src/load/index.ts"],"sourcesContent":["import { load as coreLoad } from \"@langchain/core/load\";\nimport { optionalImportEntrypoints } from \"./import_constants.js\";\nimport * as importMap from \"./import_map.js\";\nimport { OptionalImportMap } from \"./import_type.js\";\n\n/**\n * Load a LangChain module from a serialized text representation.\n * NOTE: This functionality is currently in beta.\n * Loaded classes may change independently of semver.\n *\n * **WARNING — insecure deserialization risk.** This function instantiates\n * classes and invokes constructors based on the contents of `text`. Never\n * call this on untrusted or user-supplied input. Only deserialize data that\n * originates from a trusted source you control.\n *\n * See `@langchain/core/load` {@link LoadOptions} for detailed security\n * guidance on `secretsFromEnv`, `secretsMap`, and import maps.\n *\n * @param text Serialized text representation of the module.\n * @param secretsMap\n * @param optionalImportsMap\n * @param additionalImportsMap\n * @param secretsFromEnv\n * @returns A loaded instance of a LangChain module.\n */\nexport async function load<T>(\n  text: string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  additionalImportsMap: Record<string, any> = {},\n  secretsFromEnv?: boolean\n): Promise<T> {\n  return coreLoad(text, {\n    secretsMap,\n    optionalImportsMap,\n    optionalImportEntrypoints,\n    importMap: { ...importMap, ...additionalImportsMap },\n    secretsFromEnv,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,eAAsB,KACpB,MAEA,aAAkC,EAAE,EAEpC,qBAA8D,EAAE,EAEhE,uBAA4C,EAAE,EAC9C,gBACY;AACZ,QAAOA,OAAS,MAAM;EACpB;EACA;EACA;EACA,WAAW;GAAE,GAAGC;GAAW,GAAG;GAAsB;EACpD;EACD,CAAC"}

package/dist/load/serializable.cjs

@@ -1,8 +1,9 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 
 //#region src/load/serializable.ts
-var serializable_exports = {};
-require_rolldown_runtime.__reExport(serializable_exports, require("@langchain/core/load/serializable"));
+var serializable_exports = /* @__PURE__ */ require_runtime.__exportAll({});
+require_runtime.__reExport(serializable_exports, require("@langchain/core/load/serializable"));
 
 //#endregion
 Object.defineProperty(exports, 'serializable_exports', {
@@ -11,11 +12,11 @@ Object.defineProperty(exports, 'serializable_exports', {
     return serializable_exports;
   }
 });
-var __langchain_core_load_serializable = require("@langchain/core/load/serializable");
-Object.keys(__langchain_core_load_serializable).forEach(function (k) {
+var _langchain_core_load_serializable = require("@langchain/core/load/serializable");
+Object.keys(_langchain_core_load_serializable).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
-    get: function () { return __langchain_core_load_serializable[k]; }
+    get: function () { return _langchain_core_load_serializable[k]; }
   });
 });
 

package/dist/load/serializable.js

@@ -1,11 +1,11 @@
-import { __reExport } from "../_virtual/rolldown_runtime.js";
+import { __exportAll, __reExport } from "../_virtual/_rolldown/runtime.js";
 
 export * from "@langchain/core/load/serializable"
 
 //#region src/load/serializable.ts
-var serializable_exports = {};
-import * as import___langchain_core_load_serializable from "@langchain/core/load/serializable";
-__reExport(serializable_exports, import___langchain_core_load_serializable);
+var serializable_exports = /* @__PURE__ */ __exportAll({});
+import * as import__langchain_core_load_serializable from "@langchain/core/load/serializable";
+__reExport(serializable_exports, import__langchain_core_load_serializable);
 
 //#endregion
 export { serializable_exports };

package/dist/storage/encoder_backed.cjs

@@ -1,10 +1,10 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const __langchain_core_stores = require_rolldown_runtime.__toESM(require("@langchain/core/stores"));
-const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_stores = require("@langchain/core/stores");
+let _langchain_core_documents = require("@langchain/core/documents");
 
 //#region src/storage/encoder_backed.ts
-var encoder_backed_exports = {};
-require_rolldown_runtime.__export(encoder_backed_exports, {
+var encoder_backed_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	EncoderBackedStore: () => EncoderBackedStore,
 	createDocumentStoreFromByteStore: () => createDocumentStoreFromByteStore
 });
@@ -13,7 +13,7 @@ require_rolldown_runtime.__export(encoder_backed_exports, {
 * allowing for the encoding and decoding of keys and values. It extends
 * the BaseStore class.
 */
-var EncoderBackedStore = class extends __langchain_core_stores.BaseStore {
+var EncoderBackedStore = class extends _langchain_core_stores.BaseStore {
 	lc_namespace = ["langchain", "storage"];
 	store;
 	keyEncoder;
@@ -34,9 +34,8 @@ var EncoderBackedStore = class extends __langchain_core_stores.BaseStore {
 	*/
 	async mget(keys) {
 		const encodedKeys = keys.map(this.keyEncoder);
-		const values = await this.store.mget(encodedKeys);
-		return values.map((value) => {
-			if (value === void 0) return void 0;
+		return (await this.store.mget(encodedKeys)).map((value) => {
+			if (value === void 0) return;
 			return this.valueDeserializer(value);
 		});
 	}
@@ -78,7 +77,7 @@ function createDocumentStoreFromByteStore(store) {
 			pageContent: doc.pageContent,
 			metadata: doc.metadata
 		})),
-		valueDeserializer: (bytes) => new __langchain_core_documents.Document(JSON.parse(decoder.decode(bytes)))
+		valueDeserializer: (bytes) => new _langchain_core_documents.Document(JSON.parse(decoder.decode(bytes)))
 	});
 }
 

package/dist/storage/encoder_backed.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"encoder_backed.cjs","names":["BaseStore","fields: {\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n  }","keys: K[]","keyValuePairs: [K, V][]","encodedPairs: [string, SerializedType][]","prefix?: string | undefined","store: BaseStore<string, Uint8Array>","key: string","doc: Document","bytes: Uint8Array","Document"],"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,cAAoEA,kCAGlE;CACA,eAAe,CAAC,aAAa,SAAU;CAEvC;CAEA;CAEA;CAEA;CAEA,YAAYC,QAKT;EACD,MAAM,OAAO;EACb,KAAK,QAAQ,OAAO;EACpB,KAAK,aAAa,OAAO;EACzB,KAAK,kBAAkB,OAAO;EAC9B,KAAK,oBAAoB,OAAO;CACjC;;;;;;;CAQD,MAAM,KAAKC,MAAuC;EAChD,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;EAC7C,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK,YAAY;AACjD,SAAO,OAAO,IAAI,CAAC,UAAU;AAC3B,OAAI,UAAU,OACZ,QAAO;AAET,UAAO,KAAK,kBAAkB,MAAM;EACrC,EAAC;CACH;;;;;;;CAQD,MAAM,KAAKC,eAAwC;EACjD,MAAMC,eAA2C,cAAc,IAC7D,CAAC,CAAC,KAAK,MAAM,KAAK,CAAC,KAAK,WAAW,IAAI,EAAE,KAAK,gBAAgB,MAAM,AAAC,EACtE;AACD,SAAO,KAAK,MAAM,KAAK,aAAa;CACrC;;;;;;CAOD,MAAM,QAAQF,MAA0B;EACtC,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;AAC7C,SAAO,KAAK,MAAM,QAAQ,YAAY;CACvC;;;;;;CAOD,OAAO,UAAUG,QAAyD;EACxE,OAAO,KAAK,MAAM,UAAU,OAAO;CACpC;AACF;AAED,SAAgB,iCACdC,OACA;CACA,MAAM,UAAU,IAAI;CACpB,MAAM,UAAU,IAAI;AACpB,QAAO,IAAI,mBAAmB;EAC5B;EACA,YAAY,CAACC,QAAgB;EAC7B,iBAAiB,CAACC,QAChB,QAAQ,OACN,KAAK,UAAU;GAAE,aAAa,IAAI;GAAa,UAAU,IAAI;EAAU,EAAC,CACzE;EACH,mBAAmB,CAACC,UAClB,IAAIC,oCAAS,KAAK,MAAM,QAAQ,OAAO,MAAM,CAAC;CACjD;AACF"}
+{"version":3,"file":"encoder_backed.cjs","names":["BaseStore","Document"],"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,cAAoEA,iCAGlE;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,IAAIC,mCAAS,KAAK,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC;EAClD,CAAC"}

package/dist/storage/encoder_backed.d.cts

@@ -2,7 +2,6 @@ import { BaseStore } from "@langchain/core/stores";
 import { Document } from "@langchain/core/documents";
 
 //#region src/storage/encoder_backed.d.ts
-
 /**
  * Class that provides a layer of abstraction over the base storage,
  * allowing for the encoding and decoding of keys and values. It extends

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

@@ -1 +1 @@
-{"version":3,"file":"encoder_backed.d.cts","names":["Document","BaseStore","EncoderBackedStore","K","V","SerializedType","Promise","AsyncGenerator","createDocumentStoreFromByteStore","Uint8Array","Record","ArrayBufferLike"],"sources":["../../src/storage/encoder_backed.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\nexport declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {\n    lc_namespace: string[];\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n    constructor(fields: {\n        store: BaseStore<string, SerializedType>;\n        keyEncoder: (key: K) => string;\n        valueSerializer: (value: V) => SerializedType;\n        valueDeserializer: (value: SerializedType) => V;\n    });\n    /**\n     * Method to get multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keys Array of keys to get\n     * @returns Promise that resolves with an array of values or undefined for each key\n     */\n    mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Method to set multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keyValuePairs Array of key-value pairs to set\n     * @returns Promise that resolves when the operation is complete\n     */\n    mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Method to delete multiple keys at once. It works with the encoded keys.\n     * @param keys Array of keys to delete\n     * @returns Promise that resolves when the operation is complete\n     */\n    mdelete(keys: K[]): Promise<void>;\n    /**\n     * Method to yield keys. It works with the encoded keys.\n     * @param prefix Optional prefix to filter keys\n     * @returns AsyncGenerator that yields keys\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;\n}\nexport declare function createDocumentStoreFromByteStore(store: BaseStore<string, Uint8Array>): EncoderBackedStore<string, Document<Record<string, any>>, Uint8Array<ArrayBufferLike>>;\n//# sourceMappingURL=encoder_backed.d.ts.map"],"mappings":";;;;;;;AAOA;;;AAE6BK,cAFRH,kBAEQG,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,iBAAAA,GAAAA,CAAAA,SAF+CJ,SAE/CI,CAFyDF,CAEzDE,EAF4DD,CAE5DC,CAAAA,CAAAA;EAAlBJ,YAAAA,EAAAA,MAAAA,EAAAA;EACWE,KAAAA,EADXF,SACWE,CAAAA,MAAAA,EADOE,cACPF,CAAAA;EACOC,UAAAA,EAAAA,CAAAA,GAAAA,EADPD,CACOC,EAAAA,GAAAA,MAAAA;EAAMC,eAAAA,EAAAA,CAAAA,KAAAA,EAAND,CAAMC,EAAAA,GAAAA,cAAAA;EACJA,iBAAAA,EAAAA,CAAAA,KAAAA,EAAAA,cAAAA,EAAAA,GAAmBD,CAAnBC;EAAmBD,WAAAA,CAAAA,MAAAA,EAAAA;IAEjBC,KAAAA,EAAlBJ,SAAkBI,CAAAA,MAAAA,EAAAA,cAAAA,CAAAA;IAAlBJ,UAAAA,EAAAA,CAAAA,GAAAA,EACWE,CADXF,EAAAA,GAAAA,MAAAA;IACWE,eAAAA,EAAAA,CAAAA,KAAAA,EACOC,CADPD,EAAAA,GACaE,cADbF;IACOC,iBAAAA,EAAAA,CAAAA,KAAAA,EACEC,cADFD,EAAAA,GACqBA,CADrBA;EAAMC,CAAAA;EACJA;;;;;;EAePD,IAAAA,CAAAA,IAAAA,EAPbD,CAOaC,EAAAA,CAAAA,EAPPE,OAOOF,CAAAA,CAPEA,CAOFA,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAOE;;;;;;EAzBkD,IAAA,CAAA,aAAA,EAAA,CAyB5DH,CAzB4D,EAyBzDC,CAzByD,CAAA,EAAA,CAAA,EAyBlDE,OAzBkD,CAAA,IAAA,CAAA;EAuC7DE;;;;;EAA6IG,OAAAA,CAAAA,IAAAA,EARnJR,CAQmJQ,EAAAA,CAAAA,EAR7IL,OAQ6IK,CAAAA,IAAAA,CAAAA;EAAXF;;AAAxC;;;0CAFtEF,wBAAwBJ;;iBAE5CK,gCAAAA,QAAwCP,kBAAkBQ,cAAcP,2BAA2BF,SAASU,sBAAsBD,WAAWE"}
+{"version":3,"file":"encoder_backed.d.cts","names":[],"sources":["../../src/storage/encoder_backed.ts"],"mappings":";;;;;;AASA;;;cAAa,kBAAA,qCAAuD,SAAA,CAClE,CAAA,EACA,CAAA;EAEA,YAAA;EAEA,KAAA,EAAO,SAAA,SAAkB,cAAA;EAEzB,UAAA,GAAa,GAAA,EAAK,CAAA;EAElB,eAAA,GAAkB,KAAA,EAAO,CAAA,KAAM,cAAA;EAE/B,iBAAA,GAAoB,KAAA,EAAO,cAAA,KAAmB,CAAA;EAE9C,WAAA,CAAY,MAAA;IACV,KAAA,EAAO,SAAA,SAAkB,cAAA;IACzB,UAAA,GAAa,GAAA,EAAK,CAAA;IAClB,eAAA,GAAkB,KAAA,EAAO,CAAA,KAAM,cAAA;IAC/B,iBAAA,GAAoB,KAAA,EAAO,cAAA,KAAmB,CAAA;EAAA;EADrB;;;;;;EAgBrB,IAAA,CAAK,IAAA,EAAM,CAAA,KAAM,OAAA,EAAS,CAAA;EAiBL;;;;;;EAArB,IAAA,CAAK,aAAA,GAAgB,CAAA,EAAG,CAAA,MAAO,OAAA;EAlD6B;;;;;EA8D5D,OAAA,CAAQ,IAAA,EAAM,CAAA,KAAM,OAAA;EA9DwC;;;;;EAwE3D,SAAA,CAAU,MAAA,wBAA8B,cAAA,UAAwB,CAAA;AAAA;AAAA,iBAKzD,gCAAA,CACd,KAAA,EAAO,SAAA,SAAkB,UAAA,IAAW,kBAAA,SAAA,QAAA,CAAA,MAAA,gBAAA,UAAA,CAAA,eAAA"}

package/dist/storage/encoder_backed.d.ts

@@ -2,7 +2,6 @@ import { BaseStore } from "@langchain/core/stores";
 import { Document } from "@langchain/core/documents";
 
 //#region src/storage/encoder_backed.d.ts
-
 /**
  * Class that provides a layer of abstraction over the base storage,
  * allowing for the encoding and decoding of keys and values. It extends

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

@@ -1 +1 @@
-{"version":3,"file":"encoder_backed.d.ts","names":["Document","BaseStore","EncoderBackedStore","K","V","SerializedType","Promise","AsyncGenerator","createDocumentStoreFromByteStore","Uint8Array","Record","ArrayBufferLike"],"sources":["../../src/storage/encoder_backed.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\nexport declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {\n    lc_namespace: string[];\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n    constructor(fields: {\n        store: BaseStore<string, SerializedType>;\n        keyEncoder: (key: K) => string;\n        valueSerializer: (value: V) => SerializedType;\n        valueDeserializer: (value: SerializedType) => V;\n    });\n    /**\n     * Method to get multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keys Array of keys to get\n     * @returns Promise that resolves with an array of values or undefined for each key\n     */\n    mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Method to set multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keyValuePairs Array of key-value pairs to set\n     * @returns Promise that resolves when the operation is complete\n     */\n    mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Method to delete multiple keys at once. It works with the encoded keys.\n     * @param keys Array of keys to delete\n     * @returns Promise that resolves when the operation is complete\n     */\n    mdelete(keys: K[]): Promise<void>;\n    /**\n     * Method to yield keys. It works with the encoded keys.\n     * @param prefix Optional prefix to filter keys\n     * @returns AsyncGenerator that yields keys\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;\n}\nexport declare function createDocumentStoreFromByteStore(store: BaseStore<string, Uint8Array>): EncoderBackedStore<string, Document<Record<string, any>>, Uint8Array<ArrayBufferLike>>;\n//# sourceMappingURL=encoder_backed.d.ts.map"],"mappings":";;;;;;;AAOA;;;AAE6BK,cAFRH,kBAEQG,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,iBAAAA,GAAAA,CAAAA,SAF+CJ,SAE/CI,CAFyDF,CAEzDE,EAF4DD,CAE5DC,CAAAA,CAAAA;EAAlBJ,YAAAA,EAAAA,MAAAA,EAAAA;EACWE,KAAAA,EADXF,SACWE,CAAAA,MAAAA,EADOE,cACPF,CAAAA;EACOC,UAAAA,EAAAA,CAAAA,GAAAA,EADPD,CACOC,EAAAA,GAAAA,MAAAA;EAAMC,eAAAA,EAAAA,CAAAA,KAAAA,EAAND,CAAMC,EAAAA,GAAAA,cAAAA;EACJA,iBAAAA,EAAAA,CAAAA,KAAAA,EAAAA,cAAAA,EAAAA,GAAmBD,CAAnBC;EAAmBD,WAAAA,CAAAA,MAAAA,EAAAA;IAEjBC,KAAAA,EAAlBJ,SAAkBI,CAAAA,MAAAA,EAAAA,cAAAA,CAAAA;IAAlBJ,UAAAA,EAAAA,CAAAA,GAAAA,EACWE,CADXF,EAAAA,GAAAA,MAAAA;IACWE,eAAAA,EAAAA,CAAAA,KAAAA,EACOC,CADPD,EAAAA,GACaE,cADbF;IACOC,iBAAAA,EAAAA,CAAAA,KAAAA,EACEC,cADFD,EAAAA,GACqBA,CADrBA;EAAMC,CAAAA;EACJA;;;;;;EAePD,IAAAA,CAAAA,IAAAA,EAPbD,CAOaC,EAAAA,CAAAA,EAPPE,OAOOF,CAAAA,CAPEA,CAOFA,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAOE;;;;;;EAzBkD,IAAA,CAAA,aAAA,EAAA,CAyB5DH,CAzB4D,EAyBzDC,CAzByD,CAAA,EAAA,CAAA,EAyBlDE,OAzBkD,CAAA,IAAA,CAAA;EAuC7DE;;;;;EAA6IG,OAAAA,CAAAA,IAAAA,EARnJR,CAQmJQ,EAAAA,CAAAA,EAR7IL,OAQ6IK,CAAAA,IAAAA,CAAAA;EAAXF;;AAAxC;;;0CAFtEF,wBAAwBJ;;iBAE5CK,gCAAAA,QAAwCP,kBAAkBQ,cAAcP,2BAA2BF,SAASU,sBAAsBD,WAAWE"}
+{"version":3,"file":"encoder_backed.d.ts","names":[],"sources":["../../src/storage/encoder_backed.ts"],"mappings":";;;;;;AASA;;;cAAa,kBAAA,qCAAuD,SAAA,CAClE,CAAA,EACA,CAAA;EAEA,YAAA;EAEA,KAAA,EAAO,SAAA,SAAkB,cAAA;EAEzB,UAAA,GAAa,GAAA,EAAK,CAAA;EAElB,eAAA,GAAkB,KAAA,EAAO,CAAA,KAAM,cAAA;EAE/B,iBAAA,GAAoB,KAAA,EAAO,cAAA,KAAmB,CAAA;EAE9C,WAAA,CAAY,MAAA;IACV,KAAA,EAAO,SAAA,SAAkB,cAAA;IACzB,UAAA,GAAa,GAAA,EAAK,CAAA;IAClB,eAAA,GAAkB,KAAA,EAAO,CAAA,KAAM,cAAA;IAC/B,iBAAA,GAAoB,KAAA,EAAO,cAAA,KAAmB,CAAA;EAAA;EADrB;;;;;;EAgBrB,IAAA,CAAK,IAAA,EAAM,CAAA,KAAM,OAAA,EAAS,CAAA;EAiBL;;;;;;EAArB,IAAA,CAAK,aAAA,GAAgB,CAAA,EAAG,CAAA,MAAO,OAAA;EAlD6B;;;;;EA8D5D,OAAA,CAAQ,IAAA,EAAM,CAAA,KAAM,OAAA;EA9DwC;;;;;EAwE3D,SAAA,CAAU,MAAA,wBAA8B,cAAA,UAAwB,CAAA;AAAA;AAAA,iBAKzD,gCAAA,CACd,KAAA,EAAO,SAAA,SAAkB,UAAA,IAAW,kBAAA,SAAA,QAAA,CAAA,MAAA,gBAAA,UAAA,CAAA,eAAA"}

package/dist/storage/encoder_backed.js

@@ -1,10 +1,9 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { BaseStore } from "@langchain/core/stores";
 import { Document } from "@langchain/core/documents";
 
 //#region src/storage/encoder_backed.ts
-var encoder_backed_exports = {};
-__export(encoder_backed_exports, {
+var encoder_backed_exports = /* @__PURE__ */ __exportAll({
 	EncoderBackedStore: () => EncoderBackedStore,
 	createDocumentStoreFromByteStore: () => createDocumentStoreFromByteStore
 });
@@ -34,9 +33,8 @@ var EncoderBackedStore = class extends BaseStore {
 	*/
 	async mget(keys) {
 		const encodedKeys = keys.map(this.keyEncoder);
-		const values = await this.store.mget(encodedKeys);
-		return values.map((value) => {
-			if (value === void 0) return void 0;
+		return (await this.store.mget(encodedKeys)).map((value) => {
+			if (value === void 0) return;
 			return this.valueDeserializer(value);
 		});
 	}

package/dist/storage/encoder_backed.js.map

@@ -1 +1 @@
-{"version":3,"file":"encoder_backed.js","names":["fields: {\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n  }","keys: K[]","keyValuePairs: [K, V][]","encodedPairs: [string, SerializedType][]","prefix?: string | undefined","store: BaseStore<string, Uint8Array>","key: string","doc: Document","bytes: Uint8Array"],"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,SAAU;CAEvC;CAEA;CAEA;CAEA;CAEA,YAAYA,QAKT;EACD,MAAM,OAAO;EACb,KAAK,QAAQ,OAAO;EACpB,KAAK,aAAa,OAAO;EACzB,KAAK,kBAAkB,OAAO;EAC9B,KAAK,oBAAoB,OAAO;CACjC;;;;;;;CAQD,MAAM,KAAKC,MAAuC;EAChD,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;EAC7C,MAAM,SAAS,MAAM,KAAK,MAAM,KAAK,YAAY;AACjD,SAAO,OAAO,IAAI,CAAC,UAAU;AAC3B,OAAI,UAAU,OACZ,QAAO;AAET,UAAO,KAAK,kBAAkB,MAAM;EACrC,EAAC;CACH;;;;;;;CAQD,MAAM,KAAKC,eAAwC;EACjD,MAAMC,eAA2C,cAAc,IAC7D,CAAC,CAAC,KAAK,MAAM,KAAK,CAAC,KAAK,WAAW,IAAI,EAAE,KAAK,gBAAgB,MAAM,AAAC,EACtE;AACD,SAAO,KAAK,MAAM,KAAK,aAAa;CACrC;;;;;;CAOD,MAAM,QAAQF,MAA0B;EACtC,MAAM,cAAc,KAAK,IAAI,KAAK,WAAW;AAC7C,SAAO,KAAK,MAAM,QAAQ,YAAY;CACvC;;;;;;CAOD,OAAO,UAAUG,QAAyD;EACxE,OAAO,KAAK,MAAM,UAAU,OAAO;CACpC;AACF;AAED,SAAgB,iCACdC,OACA;CACA,MAAM,UAAU,IAAI;CACpB,MAAM,UAAU,IAAI;AACpB,QAAO,IAAI,mBAAmB;EAC5B;EACA,YAAY,CAACC,QAAgB;EAC7B,iBAAiB,CAACC,QAChB,QAAQ,OACN,KAAK,UAAU;GAAE,aAAa,IAAI;GAAa,UAAU,IAAI;EAAU,EAAC,CACzE;EACH,mBAAmB,CAACC,UAClB,IAAI,SAAS,KAAK,MAAM,QAAQ,OAAO,MAAM,CAAC;CACjD;AACF"}
+{"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"}

package/dist/storage/file_system.cjs

@@ -1,11 +1,13 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const __langchain_core_stores = require_rolldown_runtime.__toESM(require("@langchain/core/stores"));
-const node_fs_promises = require_rolldown_runtime.__toESM(require("node:fs/promises"));
-const node_path = require_rolldown_runtime.__toESM(require("node:path"));
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _langchain_core_stores = require("@langchain/core/stores");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
 
 //#region src/storage/file_system.ts
-var file_system_exports = {};
-require_rolldown_runtime.__export(file_system_exports, { LocalFileStore: () => LocalFileStore });
+var file_system_exports = /* @__PURE__ */ require_runtime.__exportAll({ LocalFileStore: () => LocalFileStore });
 /**
 * File system implementation of the BaseStore using a dictionary. Used for
 * storing key-value pairs in the file system.
@@ -36,7 +38,7 @@ require_rolldown_runtime.__export(file_system_exports, { LocalFileStore: () => L
 * Make sure that the path you specify when initializing the store is free
 * of other files.
 */
-var LocalFileStore = class extends __langchain_core_stores.BaseStore {
+var LocalFileStore = class extends _langchain_core_stores.BaseStore {
 	lc_namespace = ["langchain", "storage"];
 	rootPath;
 	constructor(fields) {
@@ -52,10 +54,10 @@ var LocalFileStore = class extends __langchain_core_stores.BaseStore {
 		if (!/^[a-zA-Z0-9_\-:.]+$/.test(key)) throw new Error("Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.");
 		try {
 			const fileContent = await node_fs_promises.readFile(this.getFullPath(key));
-			if (!fileContent) return void 0;
+			if (!fileContent) return;
 			return fileContent;
 		} catch (e) {
-			if ("code" in e && e.code === "ENOENT") return void 0;
+			if ("code" in e && e.code === "ENOENT") return;
 			throw new Error(`Error reading and parsing file at path: ${this.rootPath}.\nError: ${JSON.stringify(e)}`);
 		}
 	}
@@ -122,8 +124,7 @@ var LocalFileStore = class extends __langchain_core_stores.BaseStore {
 	* @returns AsyncGenerator that yields keys from the store.
 	*/
 	async *yieldKeys(prefix) {
-		const allFiles = await node_fs_promises.readdir(this.rootPath);
-		const allKeys = allFiles.map((file) => file.replace(".txt", ""));
+		const allKeys = (await node_fs_promises.readdir(this.rootPath)).map((file) => file.replace(".txt", ""));
 		for (const key of allKeys) if (prefix === void 0 || key.startsWith(prefix)) yield key;
 	}
 	/**

package/dist/storage/file_system.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.cjs","names":["BaseStore","fields: { rootPath: string }","key: string","fs","e: any","content: Uint8Array","path","keys: string[]","values: (Uint8Array | undefined)[]","keyValuePairs: [string, Uint8Array][]","prefix?: string","rootPath: string"],"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,kCAA8B;CAChE,eAAe,CAAC,aAAa,SAAU;CAEvC;CAEA,YAAYC,QAA8B;EACxC,MAAM,OAAO;EACb,KAAK,WAAW,OAAO;CACxB;;;;;;CAOD,MAAc,cAAcC,KAA8C;AAExE,MAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MACR;AAGJ,MAAI;GACF,MAAM,cAAc,MAAMC,iBAAG,SAAS,KAAK,YAAY,IAAI,CAAC;AAC5D,OAAI,CAAC,YACH,QAAO;AAET,UAAO;EAER,SAAQC,GAAQ;AAEf,OAAI,UAAU,KAAK,EAAE,SAAS,SAC5B,QAAO;AAET,SAAM,IAAI,MACR,CAAC,wCAAwC,EACvC,KAAK,SACN,UAAU,EAAE,KAAK,UAAU,EAAE,EAAE;EAEnC;CACF;;;;;CAMD,MAAc,eAAeC,SAAqBH,KAAa;AAC7D,MAAI;GACF,MAAMC,iBAAG,UAAU,KAAK,YAAY,IAAI,EAAE,QAAQ;EACnD,SAAQ,OAAO;AACd,SAAM,IAAI,MACR,CAAC,4BAA4B,EAAE,KAAK,YAClC,IACD,CAAC,UAAU,EAAE,KAAK,UAAU,MAAM,EAAE;EAExC;CACF;;;;;CAMD,AAAQ,YAAYD,KAAqB;AACvC,MAAI;GACF,MAAM,eAAe,GAAG,IAAI,IAAI,CAAC;AAGjC,OAAI,CAAC,sBAAsB,KAAK,IAAI,CAClC,OAAM,IAAI,MAAM,CAAC,2BAA2B,EAAE,KAAK;GAGrD,MAAM,WAAWI,UAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAaA,UAAK,QAAQ,KAAK,SAAS;AAE9C,OAAI,CAAC,SAAS,WAAW,WAAW,CAClC,OAAM,IAAI,MACR,CAAC,aAAa,EAAE,IAAI,sDAA2C,EAC/C,KAAK,SAAS,aAAa,EAAE,UAAU;AAI3D,UAAO;EACR,SAAQ,GAAG;AACV,SAAM,IAAI,MACR,CAAC,iCAAiC,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE;EAElE;CACF;;;;;;CAOD,MAAM,KAAKC,MAAgB;EACzB,MAAMC,SAAqC,CAAE;AAC7C,OAAK,MAAM,OAAO,MAAM;GACtB,MAAM,cAAc,MAAM,KAAK,cAAc,IAAI;GACjD,OAAO,KAAK,YAAY;EACzB;AACD,SAAO;CACR;;;;;;CAOD,MAAM,KAAKC,eAAsD;EAC/D,MAAM,QAAQ,IACZ,cAAc,IAAI,CAAC,CAAC,KAAK,MAAM,KAAK,KAAK,eAAe,OAAO,IAAI,CAAC,CACrE;CACF;;;;;;CAOD,MAAM,QAAQF,MAA+B;EAC3C,MAAM,QAAQ,IAAI,KAAK,IAAI,CAAC,QAAQJ,iBAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;CACvE;;;;;;;CAQD,OAAO,UAAUO,QAAyC;EACxD,MAAM,WAAW,MAAMP,iBAAG,QAAQ,KAAK,SAAS;EAChD,MAAM,UAAU,SAAS,IAAI,CAAC,SAAS,KAAK,QAAQ,QAAQ,GAAG,CAAC;AAChE,OAAK,MAAM,OAAO,QAChB,KAAI,WAAW,UAAa,IAAI,WAAW,OAAO,EAChD,MAAM;CAGX;;;;;;;CAQD,aAAa,SAASQ,UAA2C;AAC/D,MAAI;GAEF,MAAMR,iBAAG,OAAO,UAAUA,iBAAG,UAAU,OAAOA,iBAAG,UAAU,KAAK;EACjE,QAAO;AACN,OAAI;IAEF,MAAMA,iBAAG,MAAM,UAAU,EAAE,WAAW,KAAM,EAAC;GAC9C,SAAQ,OAAO;AACd,UAAM,IAAI,MACR,CAAC,yCAAyC,EAAE,SAAS,UAAU,EAAE,KAAK,UACpE,MACD,EAAE;GAEN;EACF;AAED,SAAO,IAAI,KAAK,EAAE,SAAU;CAC7B;AACF"}
+{"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"}

package/dist/storage/file_system.d.cts

@@ -1,7 +1,6 @@
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/storage/file_system.d.ts
-
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.

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

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

package/dist/storage/file_system.d.ts

@@ -1,7 +1,6 @@
 import { BaseStore } from "@langchain/core/stores";
 
 //#region src/storage/file_system.d.ts
-
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.

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

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

package/dist/storage/file_system.js

@@ -1,11 +1,10 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { BaseStore } from "@langchain/core/stores";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
 //#region src/storage/file_system.ts
-var file_system_exports = {};
-__export(file_system_exports, { LocalFileStore: () => LocalFileStore });
+var file_system_exports = /* @__PURE__ */ __exportAll({ LocalFileStore: () => LocalFileStore });
 /**
 * File system implementation of the BaseStore using a dictionary. Used for
 * storing key-value pairs in the file system.
@@ -52,10 +51,10 @@ var LocalFileStore = class extends BaseStore {
 		if (!/^[a-zA-Z0-9_\-:.]+$/.test(key)) throw new Error("Invalid key. Only alphanumeric characters, underscores, hyphens, colons, and periods are allowed.");
 		try {
 			const fileContent = await fs.readFile(this.getFullPath(key));
-			if (!fileContent) return void 0;
+			if (!fileContent) return;
 			return fileContent;
 		} catch (e) {
-			if ("code" in e && e.code === "ENOENT") return void 0;
+			if ("code" in e && e.code === "ENOENT") return;
 			throw new Error(`Error reading and parsing file at path: ${this.rootPath}.\nError: ${JSON.stringify(e)}`);
 		}
 	}
@@ -122,8 +121,7 @@ var LocalFileStore = class extends BaseStore {
 	* @returns AsyncGenerator that yields keys from the store.
 	*/
 	async *yieldKeys(prefix) {
-		const allFiles = await fs.readdir(this.rootPath);
-		const allKeys = allFiles.map((file) => file.replace(".txt", ""));
+		const allKeys = (await fs.readdir(this.rootPath)).map((file) => file.replace(".txt", ""));
 		for (const key of allKeys) if (prefix === void 0 || key.startsWith(prefix)) yield key;
 	}
 	/**

package/dist/storage/file_system.js.map

@@ -1 +1 @@
-{"version":3,"file":"file_system.js","names":["fields: { rootPath: string }","key: string","e: any","content: Uint8Array","keys: string[]","values: (Uint8Array | undefined)[]","keyValuePairs: [string, Uint8Array][]","prefix?: string","rootPath: string"],"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":"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"}
+{"version":3,"file":"file_system.js","names":[],"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,MAAM,GAAG,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,SAAM,GAAG,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,WAAW,KAAK,QAAQ,KAAK,UAAU,aAAa;GAC1D,MAAM,aAAa,KAAK,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,QAAQ,GAAG,OAAO,KAAK,YAAY,IAAI,CAAC,CAAC,CAAC;;;;;;;;CASxE,OAAO,UAAU,QAAyC;EAExD,MAAM,WADW,MAAM,GAAG,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,SAAM,GAAG,OAAO,UAAU,GAAG,UAAU,OAAO,GAAG,UAAU,KAAK;UAC1D;AACN,OAAI;AAEF,UAAM,GAAG,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,15 +1,15 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const __langchain_core_stores = require_rolldown_runtime.__toESM(require("@langchain/core/stores"));
+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 = {};
-require_rolldown_runtime.__export(in_memory_exports, { InMemoryStore: () => __langchain_core_stores.InMemoryStore });
+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;
+    return _langchain_core_stores.InMemoryStore;
   }
 });
 Object.defineProperty(exports, 'in_memory_exports', {

package/dist/storage/in_memory.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "1.2.24",
+  "version": "1.2.25",
   "description": "Typescript bindings for langchain",
   "author": "LangChain",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "@types/uuid": "^9",
     "@types/ws": "^8",
     "@vitest/coverage-v8": "^3.2.4",
-    "cheerio": "1.0.0-rc.12",
+    "cheerio": "1.2.0",
     "dotenv": "^16.0.3",
     "dpdm": "^3.14.0",
     "eslint": "^9.34.0",
@@ -52,15 +52,15 @@
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
     "yaml": "^2.8.1",
-    "@langchain/anthropic": "1.3.17",
-    "@langchain/core": "^1.1.24",
+    "@langchain/anthropic": "1.3.18",
     "@langchain/cohere": "1.0.2",
+    "@langchain/core": "^1.1.26",
+    "@langchain/openai": "1.2.8",
     "@langchain/eslint": "0.1.1",
-    "@langchain/openai": "1.2.7",
     "@langchain/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "@langchain/core": "^1.1.24"
+    "@langchain/core": "^1.1.26"
   },
   "dependencies": {
     "@langchain/langgraph": "^1.1.2",