langchain 1.5.4 → 1.5.6

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAyBsB,KAAK,GACzB,cAEA,aAAY,qBAEZ,qBAAoB,oBAAoB,qBAExC,uBAAsB,qBACtB,2BACC,QAAQ"}

package/dist/load/index.d.ts

@@ -1,5 +1,4 @@
 import { OptionalImportMap } from "./import_type.js";
-
 //#region src/load/index.d.ts
 /**
  * Load a LangChain module from a serialized text representation.

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/load/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBAyBsB,KAAK,GACzB,cAEA,aAAY,qBAEZ,qBAAoB,oBAAoB,qBAExC,uBAAsB,qBACtB,2BACC,QAAQ"}

package/dist/load/index.js.map

@@ -1 +1 @@
-{"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  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // oxlint-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"}
+{"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  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  secretsMap: Record<string, any> = {},\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  optionalImportsMap: OptionalImportMap & Record<string, any> = {},\n  // oxlint-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,CAAC,GAEnC,qBAA8D,CAAC,GAE/D,uBAA4C,CAAC,GAC7C,gBACY;CACZ,OAAOA,OAAS,MAAM;EACpB;EACA;EACA;EACA,WAAW;GAAE,GAAGC;GAAW,GAAG;EAAqB;EACnD;CACF,CAAC;AACH"}

package/dist/storage/encoder_backed.cjs.map

@@ -1 +1 @@
-{"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// oxlint-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,uBAAAA,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,UAAO,MADc,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,IAAIC,0BAAAA,SAAS,KAAK,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC;EAClD,CAAC"}
+{"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// oxlint-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,uBAAAA,UAGlE;CACA,eAAe,CAAC,aAAa,SAAS;CAEtC;CAEA;CAEA;CAEA;CAEA,YAAY,QAKT;EACD,MAAM,MAAM;EACZ,KAAK,QAAQ,OAAO;EACpB,KAAK,aAAa,OAAO;EACzB,KAAK,kBAAkB,OAAO;EAC9B,KAAK,oBAAoB,OAAO;CAClC;;;;;;;CAQA,MAAM,KAAK,MAAuC;EAChD,MAAM,cAAc,KAAK,IAAI,KAAK,UAAU;EAE5C,QAAO,MADc,KAAK,MAAM,KAAK,WAAW,EAAA,CAClC,KAAK,UAAU;GAC3B,IAAI,UAAU,KAAA,GACZ;GAEF,OAAO,KAAK,kBAAkB,KAAK;EACrC,CAAC;CACH;;;;;;;CAQA,MAAM,KAAK,eAAwC;EACjD,MAAM,eAA2C,cAAc,KAC5D,CAAC,KAAK,WAAW,CAAC,KAAK,WAAW,GAAG,GAAG,KAAK,gBAAgB,KAAK,CAAC,CACtE;EACA,OAAO,KAAK,MAAM,KAAK,YAAY;CACrC;;;;;;CAOA,MAAM,QAAQ,MAA0B;EACtC,MAAM,cAAc,KAAK,IAAI,KAAK,UAAU;EAC5C,OAAO,KAAK,MAAM,QAAQ,WAAW;CACvC;;;;;;CAOA,OAAO,UAAU,QAAyD;EACxE,OAAO,KAAK,MAAM,UAAU,MAAM;CACpC;AACF;AAEA,SAAgB,iCACd,OACA;CACA,MAAM,UAAU,IAAI,YAAY;CAChC,MAAM,UAAU,IAAI,YAAY;CAChC,OAAO,IAAI,mBAAmB;EAC5B;EACA,aAAa,QAAgB;EAC7B,kBAAkB,QAChB,QAAQ,OACN,KAAK,UAAU;GAAE,aAAa,IAAI;GAAa,UAAU,IAAI;EAAS,CAAC,CACzE;EACF,oBAAoB,UAClB,IAAIC,0BAAAA,SAAS,KAAK,MAAM,QAAQ,OAAO,KAAK,CAAC,CAAC;CAClD,CAAC;AACH"}

package/dist/storage/encoder_backed.d.cts

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"encoder_backed.d.cts","names":[],"sources":["../../src/storage/encoder_backed.ts"],"mappings":";;;;;;;;cASa,mBAAmB,GAAG,GAAG,8BAA8B,UAClE,GACA;EAEA;EAEA,OAAO,kBAAkB;EAEzB,aAAa,KAAK;EAElB,kBAAkB,OAAO,MAAM;EAE/B,oBAAoB,OAAO,mBAAmB;EAE9C,YAAY;IACV,OAAO,kBAAkB;IACzB,aAAa,KAAK;IAClB,kBAAkB,OAAO,MAAM;IAC/B,oBAAoB,OAAO,mBAAmB;;;;;;;;EAe1C,KAAK,MAAM,MAAM,SAAS;;;;;;;EAiB1B,KAAK,gBAAgB,GAAG,OAAO;;;;;;EAY/B,QAAQ,MAAM,MAAM;;;;;;EAUnB,UAAU,8BAA8B,wBAAwB;;iBAKzD,iCACd,OAAO,kBAAkB,cAAW,2BAAA,SAAA,sBAAA,WAAA"}

package/dist/storage/encoder_backed.d.ts

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"encoder_backed.d.ts","names":[],"sources":["../../src/storage/encoder_backed.ts"],"mappings":";;;;;;;;cASa,mBAAmB,GAAG,GAAG,8BAA8B,UAClE,GACA;EAEA;EAEA,OAAO,kBAAkB;EAEzB,aAAa,KAAK;EAElB,kBAAkB,OAAO,MAAM;EAE/B,oBAAoB,OAAO,mBAAmB;EAE9C,YAAY;IACV,OAAO,kBAAkB;IACzB,aAAa,KAAK;IAClB,kBAAkB,OAAO,MAAM;IAC/B,oBAAoB,OAAO,mBAAmB;;;;;;;;EAe1C,KAAK,MAAM,MAAM,SAAS;;;;;;;EAiB1B,KAAK,gBAAgB,GAAG,OAAO;;;;;;EAY/B,QAAQ,MAAM,MAAM;;;;;;EAUnB,UAAU,8BAA8B,wBAAwB;;iBAKzD,iCACd,OAAO,kBAAkB,cAAW,2BAAA,SAAA,sBAAA,WAAA"}

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// oxlint-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,UAAO,MADc,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"}
+{"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// oxlint-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,SAAS;CAEtC;CAEA;CAEA;CAEA;CAEA,YAAY,QAKT;EACD,MAAM,MAAM;EACZ,KAAK,QAAQ,OAAO;EACpB,KAAK,aAAa,OAAO;EACzB,KAAK,kBAAkB,OAAO;EAC9B,KAAK,oBAAoB,OAAO;CAClC;;;;;;;CAQA,MAAM,KAAK,MAAuC;EAChD,MAAM,cAAc,KAAK,IAAI,KAAK,UAAU;EAE5C,QAAO,MADc,KAAK,MAAM,KAAK,WAAW,EAAA,CAClC,KAAK,UAAU;GAC3B,IAAI,UAAU,KAAA,GACZ;GAEF,OAAO,KAAK,kBAAkB,KAAK;EACrC,CAAC;CACH;;;;;;;CAQA,MAAM,KAAK,eAAwC;EACjD,MAAM,eAA2C,cAAc,KAC5D,CAAC,KAAK,WAAW,CAAC,KAAK,WAAW,GAAG,GAAG,KAAK,gBAAgB,KAAK,CAAC,CACtE;EACA,OAAO,KAAK,MAAM,KAAK,YAAY;CACrC;;;;;;CAOA,MAAM,QAAQ,MAA0B;EACtC,MAAM,cAAc,KAAK,IAAI,KAAK,UAAU;EAC5C,OAAO,KAAK,MAAM,QAAQ,WAAW;CACvC;;;;;;CAOA,OAAO,UAAU,QAAyD;EACxE,OAAO,KAAK,MAAM,UAAU,MAAM;CACpC;AACF;AAEA,SAAgB,iCACd,OACA;CACA,MAAM,UAAU,IAAI,YAAY;CAChC,MAAM,UAAU,IAAI,YAAY;CAChC,OAAO,IAAI,mBAAmB;EAC5B;EACA,aAAa,QAAgB;EAC7B,kBAAkB,QAChB,QAAQ,OACN,KAAK,UAAU;GAAE,aAAa,IAAI;GAAa,UAAU,IAAI;EAAS,CAAC,CACzE;EACF,oBAAoB,UAClB,IAAI,SAAS,KAAK,MAAM,QAAQ,OAAO,KAAK,CAAC,CAAC;CAClD,CAAC;AACH"}

package/dist/storage/file_system.cjs

@@ -83,9 +83,10 @@ var LocalFileStore = class extends _langchain_core_stores.BaseStore {
 		try {
 			const keyAsTxtFile = `${key}.txt`;
 			if (!/^[a-zA-Z0-9_.\-/]+$/.test(key)) throw new Error(`Invalid characters in key: ${key}`);
-			const fullPath = node_path.resolve(this.rootPath, keyAsTxtFile);
-			const commonPath = node_path.resolve(this.rootPath);
-			if (!fullPath.startsWith(commonPath)) throw new Error(`Invalid key: ${key}. Key should be relative to the root path. Root path: ${this.rootPath}, Full path: ${fullPath}`);
+			const rootPath = node_path.resolve(this.rootPath);
+			const fullPath = node_path.resolve(rootPath, keyAsTxtFile);
+			const relativePath = node_path.relative(rootPath, fullPath);
+			if (relativePath === ".." || relativePath.startsWith(`..${node_path.sep}`) || node_path.isAbsolute(relativePath)) throw new Error(`Invalid key: ${key}. Key should be relative to the root path. Root path: ${this.rootPath}, Full path: ${fullPath}`);
 			return fullPath;
 		} catch (e) {
 			throw new Error(`Error getting full path for key: ${key}.\nError: ${String(e)}`);

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  private keyLocks: Map<string, Promise<void>> = new Map();\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      // oxlint-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    await this.withKeyLock(key, async () => {\n      const fullPath = this.getFullPath(key);\n      try {\n        await this.writeFileAtomically(content, fullPath);\n      } catch (error) {\n        throw new Error(\n          `Error writing file at path: ${fullPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\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   * The last value for duplicate keys will be used.\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    const deduped = new Map<string, Uint8Array>();\n    for (const [key, value] of keyValuePairs) {\n      deduped.set(key, value);\n    }\n\n    await Promise.all(\n      Array.from(deduped.entries(), ([key, value]) =>\n        this.setFileContent(value, key)\n      )\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(\n      keys.map((key) =>\n        this.withKeyLock(key, async () => {\n          try {\n            await fs.unlink(this.getFullPath(key));\n          } catch (error) {\n            // Ignore missing files so deletes remain idempotent.\n            if (!error || (error as { code?: string }).code !== \"ENOENT\") {\n              throw error;\n            }\n          }\n        })\n      )\n    );\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: string[] = await fs.readdir(this.rootPath);\n    const allKeys = allFiles\n      .filter((file) => file.endsWith(\".txt\"))\n      .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    // Clean up orphaned temp files left by interrupted atomic writes.\n    try {\n      const entries = await fs.readdir(rootPath);\n      await Promise.all(\n        entries\n          .filter((file) => file.endsWith(\".tmp\"))\n          .map((tempFile) =>\n            fs.unlink(path.join(rootPath, tempFile)).catch(() => {})\n          )\n      );\n    } catch {\n      // Ignore cleanup errors.\n    }\n\n    return new this({ rootPath });\n  }\n\n  /**\n   * Ensures calls for the same key run sequentially by chaining promises.\n   * @param key Key to serialize operations for.\n   * @param fn Async work to execute while the lock is held.\n   * @returns Promise resolving with the callback result once the lock releases.\n   */\n  private async withKeyLock<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    const previous = this.keyLocks.get(key) ?? Promise.resolve();\n    const waitForPrevious = previous.catch(() => {});\n\n    let resolveCurrent: (() => void) | undefined;\n    const current = new Promise<void>((resolve) => {\n      resolveCurrent = resolve;\n    });\n\n    const tail = waitForPrevious.then(() => current);\n    this.keyLocks.set(key, tail);\n\n    await waitForPrevious;\n    try {\n      return await fn();\n    } finally {\n      resolveCurrent?.();\n      if (this.keyLocks.get(key) === tail) {\n        this.keyLocks.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Writes data to a temporary file before atomically renaming it into place.\n   * @param content Serialized value to persist.\n   * @param fullPath Destination path for the stored key.\n   */\n  private async writeFileAtomically(content: Uint8Array, fullPath: string) {\n    const directory = path.dirname(fullPath);\n    await fs.mkdir(directory, { recursive: true });\n\n    const tempPath = `${fullPath}.${Date.now()}-${Math.random()\n      .toString(16)\n      .slice(2)}.tmp`;\n\n    try {\n      await fs.writeFile(tempPath, content);\n\n      try {\n        await fs.rename(tempPath, fullPath);\n      } catch (renameError) {\n        const code = (renameError as { code?: string }).code;\n        if (renameError && (code === \"EPERM\" || code === \"EACCES\")) {\n          // Fallback for Windows where replacing an existing file can fail if the\n          // destination is locked by another process.\n          await fs.writeFile(fullPath, content);\n          await fs.unlink(tempPath).catch(() => {});\n        } else {\n          throw renameError;\n        }\n      }\n    } catch (error) {\n      await fs.unlink(tempPath).catch(() => {});\n      throw error;\n    }\n  }\n}\n"],"mappings":"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"}
+{"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  private keyLocks: Map<string, Promise<void>> = new Map();\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      // oxlint-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    await this.withKeyLock(key, async () => {\n      const fullPath = this.getFullPath(key);\n      try {\n        await this.writeFileAtomically(content, fullPath);\n      } catch (error) {\n        throw new Error(\n          `Error writing file at path: ${fullPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\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 rootPath = path.resolve(this.rootPath);\n      const fullPath = path.resolve(rootPath, keyAsTxtFile);\n      const relativePath = path.relative(rootPath, fullPath);\n\n      if (\n        relativePath === \"..\" ||\n        relativePath.startsWith(`..${path.sep}`) ||\n        path.isAbsolute(relativePath)\n      ) {\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   * The last value for duplicate keys will be used.\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    const deduped = new Map<string, Uint8Array>();\n    for (const [key, value] of keyValuePairs) {\n      deduped.set(key, value);\n    }\n\n    await Promise.all(\n      Array.from(deduped.entries(), ([key, value]) =>\n        this.setFileContent(value, key)\n      )\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(\n      keys.map((key) =>\n        this.withKeyLock(key, async () => {\n          try {\n            await fs.unlink(this.getFullPath(key));\n          } catch (error) {\n            // Ignore missing files so deletes remain idempotent.\n            if (!error || (error as { code?: string }).code !== \"ENOENT\") {\n              throw error;\n            }\n          }\n        })\n      )\n    );\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: string[] = await fs.readdir(this.rootPath);\n    const allKeys = allFiles\n      .filter((file) => file.endsWith(\".txt\"))\n      .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    // Clean up orphaned temp files left by interrupted atomic writes.\n    try {\n      const entries = await fs.readdir(rootPath);\n      await Promise.all(\n        entries\n          .filter((file) => file.endsWith(\".tmp\"))\n          .map((tempFile) =>\n            fs.unlink(path.join(rootPath, tempFile)).catch(() => {})\n          )\n      );\n    } catch {\n      // Ignore cleanup errors.\n    }\n\n    return new this({ rootPath });\n  }\n\n  /**\n   * Ensures calls for the same key run sequentially by chaining promises.\n   * @param key Key to serialize operations for.\n   * @param fn Async work to execute while the lock is held.\n   * @returns Promise resolving with the callback result once the lock releases.\n   */\n  private async withKeyLock<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    const previous = this.keyLocks.get(key) ?? Promise.resolve();\n    const waitForPrevious = previous.catch(() => {});\n\n    let resolveCurrent: (() => void) | undefined;\n    const current = new Promise<void>((resolve) => {\n      resolveCurrent = resolve;\n    });\n\n    const tail = waitForPrevious.then(() => current);\n    this.keyLocks.set(key, tail);\n\n    await waitForPrevious;\n    try {\n      return await fn();\n    } finally {\n      resolveCurrent?.();\n      if (this.keyLocks.get(key) === tail) {\n        this.keyLocks.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Writes data to a temporary file before atomically renaming it into place.\n   * @param content Serialized value to persist.\n   * @param fullPath Destination path for the stored key.\n   */\n  private async writeFileAtomically(content: Uint8Array, fullPath: string) {\n    const directory = path.dirname(fullPath);\n    await fs.mkdir(directory, { recursive: true });\n\n    const tempPath = `${fullPath}.${Date.now()}-${Math.random()\n      .toString(16)\n      .slice(2)}.tmp`;\n\n    try {\n      await fs.writeFile(tempPath, content);\n\n      try {\n        await fs.rename(tempPath, fullPath);\n      } catch (renameError) {\n        const code = (renameError as { code?: string }).code;\n        if (renameError && (code === \"EPERM\" || code === \"EACCES\")) {\n          // Fallback for Windows where replacing an existing file can fail if the\n          // destination is locked by another process.\n          await fs.writeFile(fullPath, content);\n          await fs.unlink(tempPath).catch(() => {});\n        } else {\n          throw renameError;\n        }\n      }\n    } catch (error) {\n      await fs.unlink(tempPath).catch(() => {});\n      throw error;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/storage/file_system.d.cts

@@ -1,5 +1,4 @@
 import { BaseStore } from "@langchain/core/stores";
-
 //#region src/storage/file_system.d.ts
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
@@ -38,7 +37,16 @@ declare class LocalFileStore extends BaseStore<string, Uint8Array> {
   constructor(fields: {
     rootPath: string;
   });
+  /**
+   * Read and parse the file at the given path.
+   * @param key The key to read the file for.
+   * @returns Promise that resolves to the parsed file content.
+   */
   private getParsedFile;
+  /**
+   * Writes the given key-value pairs to the file at the given path.
+   * @param fileContent An object with the key-value pairs to be written to the file.
+   */
   private setFileContent;
   /**
    * Returns the full path of the file where the value of the given key is stored.
@@ -78,7 +86,18 @@ declare class LocalFileStore extends BaseStore<string, Uint8Array> {
    * @returns Promise that resolves to an instance of the class.
    */
   static fromPath(rootPath: string): Promise<LocalFileStore>;
+  /**
+   * Ensures calls for the same key run sequentially by chaining promises.
+   * @param key Key to serialize operations for.
+   * @param fn Async work to execute while the lock is held.
+   * @returns Promise resolving with the callback result once the lock releases.
+   */
   private withKeyLock;
+  /**
+   * Writes data to a temporary file before atomically renaming it into place.
+   * @param content Serialized value to persist.
+   * @param fullPath Destination path for the stored key.
+   */
   private writeFileAtomically;
 }
 //#endregion

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

@@ -1 +1 @@
-{"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;EAAA,QAEQ,QAAA;EAER,WAAA,CAAY,MAAA;IAAU,QAAA;EAAA;EAAA,QAUR,aAAA;EAAA,QA+BA,cAAA;EAoFA;;;;EAAA,QAjEN,WAAA;EA0GK;;;;;EA1EP,IAAA,CAAK,IAAA,aAAc,OAAA,EAAA,UAAA,CAAA,eAAA;EA8IQ;;;;;;EA/H3B,IAAA,CAAK,aAAA,WAAwB,UAAA,MAAgB,OAAA;;;;;;EAkB7C,OAAA,CAAQ,IAAA,aAAiB,OAAA;;;;;;;EAuBxB,SAAA,CAAU,MAAA,YAAkB,cAAA;;;;;;;SAkBtB,QAAA,CAAS,QAAA,WAAmB,OAAA,CAAQ,cAAA;EAAA,QAwCnC,WAAA;EAAA,QA4BA,mBAAA;AAAA"}
+{"version":3,"file":"file_system.d.cts","names":[],"sources":["../../src/storage/file_system.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,uBAAuB,kBAAkB;EACpD;EAEA;UAEQ;EAER,YAAY;IAAU;;;;;;;UAUR;;;;;UA+BA;;;;;UAmBN;;;;;;EAqCF,KAAK,iBAAc,SAAA,WAAA;;;;;;;EAenB,KAAK,wBAAwB,gBAAgB;;;;;;EAkB7C,QAAQ,iBAAiB;;;;;;;EAuBxB,UAAU,kBAAkB;;;;;;;SAkBtB,SAAS,mBAAmB,QAAQ;;;;;;;UAwCnC;;;;;;UA4BA"}

package/dist/storage/file_system.d.ts

@@ -1,5 +1,4 @@
 import { BaseStore } from "@langchain/core/stores";
-
 //#region src/storage/file_system.d.ts
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
@@ -38,7 +37,16 @@ declare class LocalFileStore extends BaseStore<string, Uint8Array> {
   constructor(fields: {
     rootPath: string;
   });
+  /**
+   * Read and parse the file at the given path.
+   * @param key The key to read the file for.
+   * @returns Promise that resolves to the parsed file content.
+   */
   private getParsedFile;
+  /**
+   * Writes the given key-value pairs to the file at the given path.
+   * @param fileContent An object with the key-value pairs to be written to the file.
+   */
   private setFileContent;
   /**
    * Returns the full path of the file where the value of the given key is stored.
@@ -78,7 +86,18 @@ declare class LocalFileStore extends BaseStore<string, Uint8Array> {
    * @returns Promise that resolves to an instance of the class.
    */
   static fromPath(rootPath: string): Promise<LocalFileStore>;
+  /**
+   * Ensures calls for the same key run sequentially by chaining promises.
+   * @param key Key to serialize operations for.
+   * @param fn Async work to execute while the lock is held.
+   * @returns Promise resolving with the callback result once the lock releases.
+   */
   private withKeyLock;
+  /**
+   * Writes data to a temporary file before atomically renaming it into place.
+   * @param content Serialized value to persist.
+   * @param fullPath Destination path for the stored key.
+   */
   private writeFileAtomically;
 }
 //#endregion

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

@@ -1 +1 @@
-{"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;EAAA,QAEQ,QAAA;EAER,WAAA,CAAY,MAAA;IAAU,QAAA;EAAA;EAAA,QAUR,aAAA;EAAA,QA+BA,cAAA;EAoFA;;;;EAAA,QAjEN,WAAA;EA0GK;;;;;EA1EP,IAAA,CAAK,IAAA,aAAc,OAAA,EAAA,UAAA,CAAA,eAAA;EA8IQ;;;;;;EA/H3B,IAAA,CAAK,aAAA,WAAwB,UAAA,MAAgB,OAAA;;;;;;EAkB7C,OAAA,CAAQ,IAAA,aAAiB,OAAA;;;;;;;EAuBxB,SAAA,CAAU,MAAA,YAAkB,cAAA;;;;;;;SAkBtB,QAAA,CAAS,QAAA,WAAmB,OAAA,CAAQ,cAAA;EAAA,QAwCnC,WAAA;EAAA,QA4BA,mBAAA;AAAA"}
+{"version":3,"file":"file_system.d.ts","names":[],"sources":["../../src/storage/file_system.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,uBAAuB,kBAAkB;EACpD;EAEA;UAEQ;EAER,YAAY;IAAU;;;;;;;UAUR;;;;;UA+BA;;;;;UAmBN;;;;;;EAqCF,KAAK,iBAAc,SAAA,WAAA;;;;;;;EAenB,KAAK,wBAAwB,gBAAgB;;;;;;EAkB7C,QAAQ,iBAAiB;;;;;;;EAuBxB,UAAU,kBAAkB;;;;;;;SAkBtB,SAAS,mBAAmB,QAAQ;;;;;;;UAwCnC;;;;;;UA4BA"}

package/dist/storage/file_system.js

@@ -80,9 +80,10 @@ var LocalFileStore = class extends BaseStore {
 		try {
 			const keyAsTxtFile = `${key}.txt`;
 			if (!/^[a-zA-Z0-9_.\-/]+$/.test(key)) throw new Error(`Invalid characters in key: ${key}`);
-			const fullPath = path.resolve(this.rootPath, keyAsTxtFile);
-			const commonPath = path.resolve(this.rootPath);
-			if (!fullPath.startsWith(commonPath)) throw new Error(`Invalid key: ${key}. Key should be relative to the root path. Root path: ${this.rootPath}, Full path: ${fullPath}`);
+			const rootPath = path.resolve(this.rootPath);
+			const fullPath = path.resolve(rootPath, keyAsTxtFile);
+			const relativePath = path.relative(rootPath, fullPath);
+			if (relativePath === ".." || relativePath.startsWith(`..${path.sep}`) || path.isAbsolute(relativePath)) throw new Error(`Invalid key: ${key}. Key should be relative to the root path. Root path: ${this.rootPath}, Full path: ${fullPath}`);
 			return fullPath;
 		} catch (e) {
 			throw new Error(`Error getting full path for key: ${key}.\nError: ${String(e)}`);

package/dist/storage/file_system.js.map

@@ -1 +1 @@
-{"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  private keyLocks: Map<string, Promise<void>> = new Map();\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      // oxlint-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    await this.withKeyLock(key, async () => {\n      const fullPath = this.getFullPath(key);\n      try {\n        await this.writeFileAtomically(content, fullPath);\n      } catch (error) {\n        throw new Error(\n          `Error writing file at path: ${fullPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\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   * The last value for duplicate keys will be used.\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    const deduped = new Map<string, Uint8Array>();\n    for (const [key, value] of keyValuePairs) {\n      deduped.set(key, value);\n    }\n\n    await Promise.all(\n      Array.from(deduped.entries(), ([key, value]) =>\n        this.setFileContent(value, key)\n      )\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(\n      keys.map((key) =>\n        this.withKeyLock(key, async () => {\n          try {\n            await fs.unlink(this.getFullPath(key));\n          } catch (error) {\n            // Ignore missing files so deletes remain idempotent.\n            if (!error || (error as { code?: string }).code !== \"ENOENT\") {\n              throw error;\n            }\n          }\n        })\n      )\n    );\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: string[] = await fs.readdir(this.rootPath);\n    const allKeys = allFiles\n      .filter((file) => file.endsWith(\".txt\"))\n      .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    // Clean up orphaned temp files left by interrupted atomic writes.\n    try {\n      const entries = await fs.readdir(rootPath);\n      await Promise.all(\n        entries\n          .filter((file) => file.endsWith(\".tmp\"))\n          .map((tempFile) =>\n            fs.unlink(path.join(rootPath, tempFile)).catch(() => {})\n          )\n      );\n    } catch {\n      // Ignore cleanup errors.\n    }\n\n    return new this({ rootPath });\n  }\n\n  /**\n   * Ensures calls for the same key run sequentially by chaining promises.\n   * @param key Key to serialize operations for.\n   * @param fn Async work to execute while the lock is held.\n   * @returns Promise resolving with the callback result once the lock releases.\n   */\n  private async withKeyLock<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    const previous = this.keyLocks.get(key) ?? Promise.resolve();\n    const waitForPrevious = previous.catch(() => {});\n\n    let resolveCurrent: (() => void) | undefined;\n    const current = new Promise<void>((resolve) => {\n      resolveCurrent = resolve;\n    });\n\n    const tail = waitForPrevious.then(() => current);\n    this.keyLocks.set(key, tail);\n\n    await waitForPrevious;\n    try {\n      return await fn();\n    } finally {\n      resolveCurrent?.();\n      if (this.keyLocks.get(key) === tail) {\n        this.keyLocks.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Writes data to a temporary file before atomically renaming it into place.\n   * @param content Serialized value to persist.\n   * @param fullPath Destination path for the stored key.\n   */\n  private async writeFileAtomically(content: Uint8Array, fullPath: string) {\n    const directory = path.dirname(fullPath);\n    await fs.mkdir(directory, { recursive: true });\n\n    const tempPath = `${fullPath}.${Date.now()}-${Math.random()\n      .toString(16)\n      .slice(2)}.tmp`;\n\n    try {\n      await fs.writeFile(tempPath, content);\n\n      try {\n        await fs.rename(tempPath, fullPath);\n      } catch (renameError) {\n        const code = (renameError as { code?: string }).code;\n        if (renameError && (code === \"EPERM\" || code === \"EACCES\")) {\n          // Fallback for Windows where replacing an existing file can fail if the\n          // destination is locked by another process.\n          await fs.writeFile(fullPath, content);\n          await fs.unlink(tempPath).catch(() => {});\n        } else {\n          throw renameError;\n        }\n      }\n    } catch (error) {\n      await fs.unlink(tempPath).catch(() => {});\n      throw error;\n    }\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  private keyLocks: Map<string, Promise<void>> = new Map();\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      // oxlint-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    await this.withKeyLock(key, async () => {\n      const fullPath = this.getFullPath(key);\n      try {\n        await this.writeFileAtomically(content, fullPath);\n      } catch (error) {\n        throw new Error(\n          `Error writing file at path: ${fullPath}.\\nError: ${JSON.stringify(\n            error\n          )}`\n        );\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 rootPath = path.resolve(this.rootPath);\n      const fullPath = path.resolve(rootPath, keyAsTxtFile);\n      const relativePath = path.relative(rootPath, fullPath);\n\n      if (\n        relativePath === \"..\" ||\n        relativePath.startsWith(`..${path.sep}`) ||\n        path.isAbsolute(relativePath)\n      ) {\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   * The last value for duplicate keys will be used.\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    const deduped = new Map<string, Uint8Array>();\n    for (const [key, value] of keyValuePairs) {\n      deduped.set(key, value);\n    }\n\n    await Promise.all(\n      Array.from(deduped.entries(), ([key, value]) =>\n        this.setFileContent(value, key)\n      )\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(\n      keys.map((key) =>\n        this.withKeyLock(key, async () => {\n          try {\n            await fs.unlink(this.getFullPath(key));\n          } catch (error) {\n            // Ignore missing files so deletes remain idempotent.\n            if (!error || (error as { code?: string }).code !== \"ENOENT\") {\n              throw error;\n            }\n          }\n        })\n      )\n    );\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: string[] = await fs.readdir(this.rootPath);\n    const allKeys = allFiles\n      .filter((file) => file.endsWith(\".txt\"))\n      .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    // Clean up orphaned temp files left by interrupted atomic writes.\n    try {\n      const entries = await fs.readdir(rootPath);\n      await Promise.all(\n        entries\n          .filter((file) => file.endsWith(\".tmp\"))\n          .map((tempFile) =>\n            fs.unlink(path.join(rootPath, tempFile)).catch(() => {})\n          )\n      );\n    } catch {\n      // Ignore cleanup errors.\n    }\n\n    return new this({ rootPath });\n  }\n\n  /**\n   * Ensures calls for the same key run sequentially by chaining promises.\n   * @param key Key to serialize operations for.\n   * @param fn Async work to execute while the lock is held.\n   * @returns Promise resolving with the callback result once the lock releases.\n   */\n  private async withKeyLock<T>(key: string, fn: () => Promise<T>): Promise<T> {\n    const previous = this.keyLocks.get(key) ?? Promise.resolve();\n    const waitForPrevious = previous.catch(() => {});\n\n    let resolveCurrent: (() => void) | undefined;\n    const current = new Promise<void>((resolve) => {\n      resolveCurrent = resolve;\n    });\n\n    const tail = waitForPrevious.then(() => current);\n    this.keyLocks.set(key, tail);\n\n    await waitForPrevious;\n    try {\n      return await fn();\n    } finally {\n      resolveCurrent?.();\n      if (this.keyLocks.get(key) === tail) {\n        this.keyLocks.delete(key);\n      }\n    }\n  }\n\n  /**\n   * Writes data to a temporary file before atomically renaming it into place.\n   * @param content Serialized value to persist.\n   * @param fullPath Destination path for the stored key.\n   */\n  private async writeFileAtomically(content: Uint8Array, fullPath: string) {\n    const directory = path.dirname(fullPath);\n    await fs.mkdir(directory, { recursive: true });\n\n    const tempPath = `${fullPath}.${Date.now()}-${Math.random()\n      .toString(16)\n      .slice(2)}.tmp`;\n\n    try {\n      await fs.writeFile(tempPath, content);\n\n      try {\n        await fs.rename(tempPath, fullPath);\n      } catch (renameError) {\n        const code = (renameError as { code?: string }).code;\n        if (renameError && (code === \"EPERM\" || code === \"EACCES\")) {\n          // Fallback for Windows where replacing an existing file can fail if the\n          // destination is locked by another process.\n          await fs.writeFile(fullPath, content);\n          await fs.unlink(tempPath).catch(() => {});\n        } else {\n          throw renameError;\n        }\n      }\n    } catch (error) {\n      await fs.unlink(tempPath).catch(() => {});\n      throw error;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/tools/headless.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 let _langchain_core_tools = require("@langchain/core/tools");
 //#region src/tools/headless.ts
 /**

package/dist/tools/headless.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"headless.cjs","names":[],"sources":["../../src/tools/headless.ts"],"sourcesContent":["/**\n * Unified Tool Primitive for LangChain Agents\n *\n * This module re-exports the `tool` primitive from `@langchain/core/tools` with\n * an additional overload: when called without an implementation function, it\n * creates a **headless tool** that interrupts agent execution and delegates the\n * implementation to the client (e.g. via `useStream({ tools: [...] })`).\n *\n * @module\n */\n\nimport {\n  tool as coreTool,\n  DynamicStructuredTool,\n  type ToolRunnableConfig,\n} from \"@langchain/core/tools\";\nimport type {\n  InteropZodObject,\n  InferInteropZodInput,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\n\n/**\n * Configuration fields for creating a headless tool.\n */\nexport type HeadlessToolFields<\n  SchemaT extends InteropZodObject,\n  NameT extends string = string,\n> = {\n  /** The name of the tool. Used by the client to match implementations. */\n  name: NameT;\n  /** Description of what the tool does. */\n  description: string;\n  /** The Zod schema defining the tool's input. */\n  schema: SchemaT;\n};\n\n/**\n * A tool implementation that pairs a headless tool with its execution function.\n *\n * Created by calling `.implement()` on a {@link HeadlessTool}.\n * Pass to `useStream({ tools: [...] })` on the client side.\n */\nexport type HeadlessToolImplementation<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  OutputT = unknown,\n  NameT extends string = string,\n> = {\n  tool: HeadlessTool<SchemaT, NameT>;\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n\n/**\n * A headless tool that always interrupts agent execution on the server.\n *\n * The implementation is provided separately on the client via\n * `useStream({ tools: [...] })` using `.implement()`.\n */\nexport type HeadlessTool<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  NameT extends string = string,\n> = DynamicStructuredTool<\n  SchemaT,\n  InferInteropZodOutput<SchemaT>,\n  InferInteropZodInput<SchemaT>,\n  unknown,\n  unknown,\n  NameT\n> & {\n  /**\n   * Pairs this headless tool with a client-side implementation.\n   *\n   * The returned object should be passed to `useStream({ tools: [...] })`.\n   * The SDK matches the implementation to the tool by name and calls\n   * `execute` with the typed arguments from the interrupt payload.\n   *\n   * @param execute - The function that implements the tool on the client\n   */\n  implement: <OutputT>(\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n  ) => HeadlessToolImplementation<SchemaT, OutputT, NameT>;\n};\n\nfunction createHeadlessTool<\n  SchemaT extends InteropZodObject,\n  NameT extends string,\n>(fields: HeadlessToolFields<SchemaT, NameT>): HeadlessTool<SchemaT, NameT> {\n  const { name, description, schema } = fields;\n\n  const wrappedTool = coreTool(\n    async (\n      args: InferInteropZodOutput<SchemaT>,\n      config?: ToolRunnableConfig\n    ) => {\n      const { interrupt } = await import(\"@langchain/langgraph\");\n      return interrupt({\n        type: \"tool\",\n        toolCall: {\n          id: config?.toolCall?.id,\n          name,\n          args,\n        },\n      });\n    },\n    {\n      name,\n      description,\n      schema,\n      metadata: {\n        headlessTool: true,\n      },\n    }\n  );\n\n  const headlessTool: HeadlessTool<SchemaT, NameT> = Object.assign(\n    wrappedTool,\n    {\n      implement: <OutputT>(\n        execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n      ): HeadlessToolImplementation<SchemaT, OutputT, NameT> => ({\n        tool: headlessTool,\n        execute,\n      }),\n    }\n  ) as HeadlessTool<SchemaT, NameT>;\n\n  return headlessTool;\n}\n\n/**\n * The headless overload signature added to the core `tool` function.\n *\n * When called **without** an implementation function — just `tool({ name, description, schema })` —\n * returns a {@link HeadlessTool} that interrupts on every agent invocation.\n * The client provides the implementation via `useStream({ tools: [...] })`.\n */\ntype HeadlessToolOverload = {\n  <SchemaT extends InteropZodObject, NameT extends string>(\n    fields: HeadlessToolFields<SchemaT, NameT>\n  ): HeadlessTool<SchemaT, NameT>;\n};\n\n/**\n * Unified tool primitive for LangChain agents.\n *\n * Enhances the `tool` function from `@langchain/core/tools` with a headless\n * overload: when called **without** an implementation function, the tool\n * interrupts agent execution and lets the client supply the implementation.\n *\n * ---\n *\n * **Normal tool** — pass an implementation function as the first argument:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ city }) => `The weather in ${city} is sunny.`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the weather for a city\",\n *     schema: z.object({ city: z.string() }),\n *   }\n * );\n * ```\n *\n * ---\n *\n * **Headless tool** — omit the implementation; the client provides it later:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * // Server: define the tool shape — no implementation needed\n * export const getLocation = tool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n * });\n *\n * // Server: register with the agent\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Client: provide the implementation in useStream\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   tools: [\n *     getLocation.implement(async ({ highAccuracy }) => {\n *       return new Promise((resolve, reject) => {\n *         navigator.geolocation.getCurrentPosition(\n *           (pos) => resolve({\n *             latitude: pos.coords.latitude,\n *             longitude: pos.coords.longitude,\n *           }),\n *           (err) => reject(new Error(err.message)),\n *           { enableHighAccuracy: highAccuracy }\n *         );\n *       });\n *     }),\n *   ],\n * });\n * ```\n */\nexport const tool: HeadlessToolOverload & typeof coreTool = ((\n  funcOrFields: unknown,\n  fields?: unknown\n) => {\n  if (typeof funcOrFields !== \"function\") {\n    return createHeadlessTool(\n      funcOrFields as HeadlessToolFields<InteropZodObject, string>\n    );\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (coreTool as any)(funcOrFields, fields);\n}) as HeadlessToolOverload & typeof coreTool;\n"],"mappings":";;;;;;;;;;;;;AAmFA,SAAS,mBAGP,QAA0E;CAC1E,MAAM,EAAE,MAAM,aAAa,WAAW;CAEtC,MAAM,eAAA,GAAA,sBAAA,MACJ,OACE,MACA,WACG;EACH,MAAM,EAAE,cAAc,MAAM,OAAO;AACnC,SAAO,UAAU;GACf,MAAM;GACN,UAAU;IACR,IAAI,QAAQ,UAAU;IACtB;IACA;IACD;GACF,CAAC;IAEJ;EACE;EACA;EACA;EACA,UAAU,EACR,cAAc,MACf;EACF,CACF;CAED,MAAM,eAA6C,OAAO,OACxD,aACA,EACE,YACE,aACyD;EACzD,MAAM;EACN;EACD,GACF,CACF;AAED,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFT,MAAa,SACX,cACA,WACG;AACH,KAAI,OAAO,iBAAiB,WAC1B,QAAO,mBACL,aACD;AAGH,SAAA,GAAA,sBAAA,MAAyB,cAAc,OAAO"}
+{"version":3,"file":"headless.cjs","names":[],"sources":["../../src/tools/headless.ts"],"sourcesContent":["/**\n * Unified Tool Primitive for LangChain Agents\n *\n * This module re-exports the `tool` primitive from `@langchain/core/tools` with\n * an additional overload: when called without an implementation function, it\n * creates a **headless tool** that interrupts agent execution and delegates the\n * implementation to the client (e.g. via `useStream({ tools: [...] })`).\n *\n * @module\n */\n\nimport {\n  tool as coreTool,\n  DynamicStructuredTool,\n  type ToolRunnableConfig,\n} from \"@langchain/core/tools\";\nimport type {\n  InteropZodObject,\n  InferInteropZodInput,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\n\n/**\n * Configuration fields for creating a headless tool.\n */\nexport type HeadlessToolFields<\n  SchemaT extends InteropZodObject,\n  NameT extends string = string,\n> = {\n  /** The name of the tool. Used by the client to match implementations. */\n  name: NameT;\n  /** Description of what the tool does. */\n  description: string;\n  /** The Zod schema defining the tool's input. */\n  schema: SchemaT;\n};\n\n/**\n * A tool implementation that pairs a headless tool with its execution function.\n *\n * Created by calling `.implement()` on a {@link HeadlessTool}.\n * Pass to `useStream({ tools: [...] })` on the client side.\n */\nexport type HeadlessToolImplementation<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  OutputT = unknown,\n  NameT extends string = string,\n> = {\n  tool: HeadlessTool<SchemaT, NameT>;\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n\n/**\n * A headless tool that always interrupts agent execution on the server.\n *\n * The implementation is provided separately on the client via\n * `useStream({ tools: [...] })` using `.implement()`.\n */\nexport type HeadlessTool<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  NameT extends string = string,\n> = DynamicStructuredTool<\n  SchemaT,\n  InferInteropZodOutput<SchemaT>,\n  InferInteropZodInput<SchemaT>,\n  unknown,\n  unknown,\n  NameT\n> & {\n  /**\n   * Pairs this headless tool with a client-side implementation.\n   *\n   * The returned object should be passed to `useStream({ tools: [...] })`.\n   * The SDK matches the implementation to the tool by name and calls\n   * `execute` with the typed arguments from the interrupt payload.\n   *\n   * @param execute - The function that implements the tool on the client\n   */\n  implement: <OutputT>(\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n  ) => HeadlessToolImplementation<SchemaT, OutputT, NameT>;\n};\n\nfunction createHeadlessTool<\n  SchemaT extends InteropZodObject,\n  NameT extends string,\n>(fields: HeadlessToolFields<SchemaT, NameT>): HeadlessTool<SchemaT, NameT> {\n  const { name, description, schema } = fields;\n\n  const wrappedTool = coreTool(\n    async (\n      args: InferInteropZodOutput<SchemaT>,\n      config?: ToolRunnableConfig\n    ) => {\n      const { interrupt } = await import(\"@langchain/langgraph\");\n      return interrupt({\n        type: \"tool\",\n        toolCall: {\n          id: config?.toolCall?.id,\n          name,\n          args,\n        },\n      });\n    },\n    {\n      name,\n      description,\n      schema,\n      metadata: {\n        headlessTool: true,\n      },\n    }\n  );\n\n  const headlessTool: HeadlessTool<SchemaT, NameT> = Object.assign(\n    wrappedTool,\n    {\n      implement: <OutputT>(\n        execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n      ): HeadlessToolImplementation<SchemaT, OutputT, NameT> => ({\n        tool: headlessTool,\n        execute,\n      }),\n    }\n  ) as HeadlessTool<SchemaT, NameT>;\n\n  return headlessTool;\n}\n\n/**\n * The headless overload signature added to the core `tool` function.\n *\n * When called **without** an implementation function — just `tool({ name, description, schema })` —\n * returns a {@link HeadlessTool} that interrupts on every agent invocation.\n * The client provides the implementation via `useStream({ tools: [...] })`.\n */\ntype HeadlessToolOverload = {\n  <SchemaT extends InteropZodObject, NameT extends string>(\n    fields: HeadlessToolFields<SchemaT, NameT>\n  ): HeadlessTool<SchemaT, NameT>;\n};\n\n/**\n * Unified tool primitive for LangChain agents.\n *\n * Enhances the `tool` function from `@langchain/core/tools` with a headless\n * overload: when called **without** an implementation function, the tool\n * interrupts agent execution and lets the client supply the implementation.\n *\n * ---\n *\n * **Normal tool** — pass an implementation function as the first argument:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ city }) => `The weather in ${city} is sunny.`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the weather for a city\",\n *     schema: z.object({ city: z.string() }),\n *   }\n * );\n * ```\n *\n * ---\n *\n * **Headless tool** — omit the implementation; the client provides it later:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * // Server: define the tool shape — no implementation needed\n * export const getLocation = tool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n * });\n *\n * // Server: register with the agent\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Client: provide the implementation in useStream\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   tools: [\n *     getLocation.implement(async ({ highAccuracy }) => {\n *       return new Promise((resolve, reject) => {\n *         navigator.geolocation.getCurrentPosition(\n *           (pos) => resolve({\n *             latitude: pos.coords.latitude,\n *             longitude: pos.coords.longitude,\n *           }),\n *           (err) => reject(new Error(err.message)),\n *           { enableHighAccuracy: highAccuracy }\n *         );\n *       });\n *     }),\n *   ],\n * });\n * ```\n */\nexport const tool: HeadlessToolOverload & typeof coreTool = ((\n  funcOrFields: unknown,\n  fields?: unknown\n) => {\n  if (typeof funcOrFields !== \"function\") {\n    return createHeadlessTool(\n      funcOrFields as HeadlessToolFields<InteropZodObject, string>\n    );\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (coreTool as any)(funcOrFields, fields);\n}) as HeadlessToolOverload & typeof coreTool;\n"],"mappings":";;;;;;;;;;;;AAmFA,SAAS,mBAGP,QAA0E;CAC1E,MAAM,EAAE,MAAM,aAAa,WAAW;CAEtC,MAAM,eAAA,GAAA,sBAAA,KAAA,CACJ,OACE,MACA,WACG;EACH,MAAM,EAAE,cAAc,MAAM,OAAO;EACnC,OAAO,UAAU;GACf,MAAM;GACN,UAAU;IACR,IAAI,QAAQ,UAAU;IACtB;IACA;GACF;EACF,CAAC;CACH,GACA;EACE;EACA;EACA;EACA,UAAU,EACR,cAAc,KAChB;CACF,CACF;CAEA,MAAM,eAA6C,OAAO,OACxD,aACA,EACE,YACE,aACyD;EACzD,MAAM;EACN;CACF,GACF,CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmFA,MAAa,SACX,cACA,WACG;CACH,IAAI,OAAO,iBAAiB,YAC1B,OAAO,mBACL,YACF;CAGF,QAAA,GAAA,sBAAA,KAAA,CAAyB,cAAc,MAAM;AAC/C"}

package/dist/tools/headless.d.cts

@@ -1,13 +1,15 @@
 import { DynamicStructuredTool, tool } from "@langchain/core/tools";
 import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
-
 //#region src/tools/headless.d.ts
 /**
  * Configuration fields for creating a headless tool.
  */
 type HeadlessToolFields<SchemaT extends InteropZodObject, NameT extends string = string> = {
-  /** The name of the tool. Used by the client to match implementations. */name: NameT; /** Description of what the tool does. */
-  description: string; /** The Zod schema defining the tool's input. */
+  /** The name of the tool. Used by the client to match implementations. */
+  name: NameT;
+  /** Description of what the tool does. */
+  description: string;
+  /** The Zod schema defining the tool's input. */
   schema: SchemaT;
 };
 /**

package/dist/tools/headless.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"headless.d.cts","names":[],"sources":["../../src/tools/headless.ts"],"mappings":";;;;;;;KAyBY,kBAAA,iBACM,gBAAA;EAIV,yEAAN,IAAA,EAAM,KAAA,EAIN;EAFA,WAAA,UAEe;EAAf,MAAA,EAAQ,OAAA;AAAA;;;;;;;KASE,0BAAA,iBACM,gBAAA,GAAmB,gBAAA;EAInC,IAAA,EAAM,YAAA,CAAa,OAAA,EAAS,KAAA;EAC5B,OAAA,GAAU,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAAa,OAAA,CAAQ,OAAA;AAAA;;;;;;;KASjD,YAAA,iBACM,gBAAA,GAAmB,gBAAA,mCAEjC,qBAAA,CACF,OAAA,EACA,qBAAA,CAAsB,OAAA,GACtB,oBAAA,CAAqB,OAAA,qBAGrB,KAAA;EArBA;;;;;;;;;EAgCA,SAAA,YACE,OAAA,GAAU,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAAa,OAAA,CAAQ,OAAA,MACxD,0BAAA,CAA2B,OAAA,EAAS,OAAA,EAAS,KAAA;AAAA;;;AAtBpD;;;;;KA8EK,oBAAA;EAAA,iBACc,gBAAA,wBACf,MAAA,EAAQ,kBAAA,CAAmB,OAAA,EAAS,KAAA,IACnC,YAAA,CAAa,OAAA,EAAS,KAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1DzB;;;;;;;;;;;;;;;;;;;;;;;;AAiIF;;;;;cAAa,MAAA,EAAM,oBAAA,UAA8B,IAAA"}
+{"version":3,"file":"headless.d.cts","names":[],"sources":["../../src/tools/headless.ts"],"mappings":";;;;;;KAyBY,mBACV,gBAAgB,kBAChB;;EAGA,MAAM;;EAEN;;EAEA,QAAQ;;;;;;;;KASE,2BACV,gBAAgB,mBAAmB,kBACnC,mBACA;EAEA,MAAM,aAAa,SAAS;EAC5B,UAAU,MAAM,sBAAsB,aAAa,QAAQ;;;;;;;;KASjD,aACV,gBAAgB,mBAAmB,kBACnC,iCACE,sBACF,SACA,sBAAsB,UACtB,qBAAqB,4BAGrB;;;;;;;;;;EAWA,YAAY,SACV,UAAU,MAAM,sBAAsB,aAAa,QAAQ,aACxD,2BAA2B,SAAS,SAAS;;;;;;;;;KAwD/C;GACF,gBAAgB,kBAAkB,sBACjC,QAAQ,mBAAmB,SAAS,SACnC,aAAa,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuEd,QAAM,8BAA8B"}

package/dist/tools/headless.d.ts

@@ -1,13 +1,15 @@
 import { DynamicStructuredTool, tool } from "@langchain/core/tools";
 import { InferInteropZodInput, InferInteropZodOutput, InteropZodObject } from "@langchain/core/utils/types";
-
 //#region src/tools/headless.d.ts
 /**
  * Configuration fields for creating a headless tool.
  */
 type HeadlessToolFields<SchemaT extends InteropZodObject, NameT extends string = string> = {
-  /** The name of the tool. Used by the client to match implementations. */name: NameT; /** Description of what the tool does. */
-  description: string; /** The Zod schema defining the tool's input. */
+  /** The name of the tool. Used by the client to match implementations. */
+  name: NameT;
+  /** Description of what the tool does. */
+  description: string;
+  /** The Zod schema defining the tool's input. */
   schema: SchemaT;
 };
 /**

package/dist/tools/headless.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headless.d.ts","names":[],"sources":["../../src/tools/headless.ts"],"mappings":";;;;;;;KAyBY,kBAAA,iBACM,gBAAA;EAIV,yEAAN,IAAA,EAAM,KAAA,EAIN;EAFA,WAAA,UAEe;EAAf,MAAA,EAAQ,OAAA;AAAA;;;;;;;KASE,0BAAA,iBACM,gBAAA,GAAmB,gBAAA;EAInC,IAAA,EAAM,YAAA,CAAa,OAAA,EAAS,KAAA;EAC5B,OAAA,GAAU,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAAa,OAAA,CAAQ,OAAA;AAAA;;;;;;;KASjD,YAAA,iBACM,gBAAA,GAAmB,gBAAA,mCAEjC,qBAAA,CACF,OAAA,EACA,qBAAA,CAAsB,OAAA,GACtB,oBAAA,CAAqB,OAAA,qBAGrB,KAAA;EArBA;;;;;;;;;EAgCA,SAAA,YACE,OAAA,GAAU,IAAA,EAAM,qBAAA,CAAsB,OAAA,MAAa,OAAA,CAAQ,OAAA,MACxD,0BAAA,CAA2B,OAAA,EAAS,OAAA,EAAS,KAAA;AAAA;;;AAtBpD;;;;;KA8EK,oBAAA;EAAA,iBACc,gBAAA,wBACf,MAAA,EAAQ,kBAAA,CAAmB,OAAA,EAAS,KAAA,IACnC,YAAA,CAAa,OAAA,EAAS,KAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1DzB;;;;;;;;;;;;;;;;;;;;;;;;AAiIF;;;;;cAAa,MAAA,EAAM,oBAAA,UAA8B,IAAA"}
+{"version":3,"file":"headless.d.ts","names":[],"sources":["../../src/tools/headless.ts"],"mappings":";;;;;;KAyBY,mBACV,gBAAgB,kBAChB;;EAGA,MAAM;;EAEN;;EAEA,QAAQ;;;;;;;;KASE,2BACV,gBAAgB,mBAAmB,kBACnC,mBACA;EAEA,MAAM,aAAa,SAAS;EAC5B,UAAU,MAAM,sBAAsB,aAAa,QAAQ;;;;;;;;KASjD,aACV,gBAAgB,mBAAmB,kBACnC,iCACE,sBACF,SACA,sBAAsB,UACtB,qBAAqB,4BAGrB;;;;;;;;;;EAWA,YAAY,SACV,UAAU,MAAM,sBAAsB,aAAa,QAAQ,aACxD,2BAA2B,SAAS,SAAS;;;;;;;;;KAwD/C;GACF,gBAAgB,kBAAkB,sBACjC,QAAQ,mBAAmB,SAAS,SACnC,aAAa,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuEd,QAAM,8BAA8B"}

package/dist/tools/headless.js.map

@@ -1 +1 @@
-{"version":3,"file":"headless.js","names":["coreTool","tool"],"sources":["../../src/tools/headless.ts"],"sourcesContent":["/**\n * Unified Tool Primitive for LangChain Agents\n *\n * This module re-exports the `tool` primitive from `@langchain/core/tools` with\n * an additional overload: when called without an implementation function, it\n * creates a **headless tool** that interrupts agent execution and delegates the\n * implementation to the client (e.g. via `useStream({ tools: [...] })`).\n *\n * @module\n */\n\nimport {\n  tool as coreTool,\n  DynamicStructuredTool,\n  type ToolRunnableConfig,\n} from \"@langchain/core/tools\";\nimport type {\n  InteropZodObject,\n  InferInteropZodInput,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\n\n/**\n * Configuration fields for creating a headless tool.\n */\nexport type HeadlessToolFields<\n  SchemaT extends InteropZodObject,\n  NameT extends string = string,\n> = {\n  /** The name of the tool. Used by the client to match implementations. */\n  name: NameT;\n  /** Description of what the tool does. */\n  description: string;\n  /** The Zod schema defining the tool's input. */\n  schema: SchemaT;\n};\n\n/**\n * A tool implementation that pairs a headless tool with its execution function.\n *\n * Created by calling `.implement()` on a {@link HeadlessTool}.\n * Pass to `useStream({ tools: [...] })` on the client side.\n */\nexport type HeadlessToolImplementation<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  OutputT = unknown,\n  NameT extends string = string,\n> = {\n  tool: HeadlessTool<SchemaT, NameT>;\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n\n/**\n * A headless tool that always interrupts agent execution on the server.\n *\n * The implementation is provided separately on the client via\n * `useStream({ tools: [...] })` using `.implement()`.\n */\nexport type HeadlessTool<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  NameT extends string = string,\n> = DynamicStructuredTool<\n  SchemaT,\n  InferInteropZodOutput<SchemaT>,\n  InferInteropZodInput<SchemaT>,\n  unknown,\n  unknown,\n  NameT\n> & {\n  /**\n   * Pairs this headless tool with a client-side implementation.\n   *\n   * The returned object should be passed to `useStream({ tools: [...] })`.\n   * The SDK matches the implementation to the tool by name and calls\n   * `execute` with the typed arguments from the interrupt payload.\n   *\n   * @param execute - The function that implements the tool on the client\n   */\n  implement: <OutputT>(\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n  ) => HeadlessToolImplementation<SchemaT, OutputT, NameT>;\n};\n\nfunction createHeadlessTool<\n  SchemaT extends InteropZodObject,\n  NameT extends string,\n>(fields: HeadlessToolFields<SchemaT, NameT>): HeadlessTool<SchemaT, NameT> {\n  const { name, description, schema } = fields;\n\n  const wrappedTool = coreTool(\n    async (\n      args: InferInteropZodOutput<SchemaT>,\n      config?: ToolRunnableConfig\n    ) => {\n      const { interrupt } = await import(\"@langchain/langgraph\");\n      return interrupt({\n        type: \"tool\",\n        toolCall: {\n          id: config?.toolCall?.id,\n          name,\n          args,\n        },\n      });\n    },\n    {\n      name,\n      description,\n      schema,\n      metadata: {\n        headlessTool: true,\n      },\n    }\n  );\n\n  const headlessTool: HeadlessTool<SchemaT, NameT> = Object.assign(\n    wrappedTool,\n    {\n      implement: <OutputT>(\n        execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n      ): HeadlessToolImplementation<SchemaT, OutputT, NameT> => ({\n        tool: headlessTool,\n        execute,\n      }),\n    }\n  ) as HeadlessTool<SchemaT, NameT>;\n\n  return headlessTool;\n}\n\n/**\n * The headless overload signature added to the core `tool` function.\n *\n * When called **without** an implementation function — just `tool({ name, description, schema })` —\n * returns a {@link HeadlessTool} that interrupts on every agent invocation.\n * The client provides the implementation via `useStream({ tools: [...] })`.\n */\ntype HeadlessToolOverload = {\n  <SchemaT extends InteropZodObject, NameT extends string>(\n    fields: HeadlessToolFields<SchemaT, NameT>\n  ): HeadlessTool<SchemaT, NameT>;\n};\n\n/**\n * Unified tool primitive for LangChain agents.\n *\n * Enhances the `tool` function from `@langchain/core/tools` with a headless\n * overload: when called **without** an implementation function, the tool\n * interrupts agent execution and lets the client supply the implementation.\n *\n * ---\n *\n * **Normal tool** — pass an implementation function as the first argument:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ city }) => `The weather in ${city} is sunny.`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the weather for a city\",\n *     schema: z.object({ city: z.string() }),\n *   }\n * );\n * ```\n *\n * ---\n *\n * **Headless tool** — omit the implementation; the client provides it later:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * // Server: define the tool shape — no implementation needed\n * export const getLocation = tool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n * });\n *\n * // Server: register with the agent\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Client: provide the implementation in useStream\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   tools: [\n *     getLocation.implement(async ({ highAccuracy }) => {\n *       return new Promise((resolve, reject) => {\n *         navigator.geolocation.getCurrentPosition(\n *           (pos) => resolve({\n *             latitude: pos.coords.latitude,\n *             longitude: pos.coords.longitude,\n *           }),\n *           (err) => reject(new Error(err.message)),\n *           { enableHighAccuracy: highAccuracy }\n *         );\n *       });\n *     }),\n *   ],\n * });\n * ```\n */\nexport const tool: HeadlessToolOverload & typeof coreTool = ((\n  funcOrFields: unknown,\n  fields?: unknown\n) => {\n  if (typeof funcOrFields !== \"function\") {\n    return createHeadlessTool(\n      funcOrFields as HeadlessToolFields<InteropZodObject, string>\n    );\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (coreTool as any)(funcOrFields, fields);\n}) as HeadlessToolOverload & typeof coreTool;\n"],"mappings":";;;;;;;;;;;;AAmFA,SAAS,mBAGP,QAA0E;CAC1E,MAAM,EAAE,MAAM,aAAa,WAAW;CAEtC,MAAM,cAAcA,KAClB,OACE,MACA,WACG;EACH,MAAM,EAAE,cAAc,MAAM,OAAO;AACnC,SAAO,UAAU;GACf,MAAM;GACN,UAAU;IACR,IAAI,QAAQ,UAAU;IACtB;IACA;IACD;GACF,CAAC;IAEJ;EACE;EACA;EACA;EACA,UAAU,EACR,cAAc,MACf;EACF,CACF;CAED,MAAM,eAA6C,OAAO,OACxD,aACA,EACE,YACE,aACyD;EACzD,MAAM;EACN;EACD,GACF,CACF;AAED,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoFT,MAAaC,WACX,cACA,WACG;AACH,KAAI,OAAO,iBAAiB,WAC1B,QAAO,mBACL,aACD;AAGH,QAAQD,KAAiB,cAAc,OAAO"}
+{"version":3,"file":"headless.js","names":["coreTool","tool"],"sources":["../../src/tools/headless.ts"],"sourcesContent":["/**\n * Unified Tool Primitive for LangChain Agents\n *\n * This module re-exports the `tool` primitive from `@langchain/core/tools` with\n * an additional overload: when called without an implementation function, it\n * creates a **headless tool** that interrupts agent execution and delegates the\n * implementation to the client (e.g. via `useStream({ tools: [...] })`).\n *\n * @module\n */\n\nimport {\n  tool as coreTool,\n  DynamicStructuredTool,\n  type ToolRunnableConfig,\n} from \"@langchain/core/tools\";\nimport type {\n  InteropZodObject,\n  InferInteropZodInput,\n  InferInteropZodOutput,\n} from \"@langchain/core/utils/types\";\n\n/**\n * Configuration fields for creating a headless tool.\n */\nexport type HeadlessToolFields<\n  SchemaT extends InteropZodObject,\n  NameT extends string = string,\n> = {\n  /** The name of the tool. Used by the client to match implementations. */\n  name: NameT;\n  /** Description of what the tool does. */\n  description: string;\n  /** The Zod schema defining the tool's input. */\n  schema: SchemaT;\n};\n\n/**\n * A tool implementation that pairs a headless tool with its execution function.\n *\n * Created by calling `.implement()` on a {@link HeadlessTool}.\n * Pass to `useStream({ tools: [...] })` on the client side.\n */\nexport type HeadlessToolImplementation<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  OutputT = unknown,\n  NameT extends string = string,\n> = {\n  tool: HeadlessTool<SchemaT, NameT>;\n  execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>;\n};\n\n/**\n * A headless tool that always interrupts agent execution on the server.\n *\n * The implementation is provided separately on the client via\n * `useStream({ tools: [...] })` using `.implement()`.\n */\nexport type HeadlessTool<\n  SchemaT extends InteropZodObject = InteropZodObject,\n  NameT extends string = string,\n> = DynamicStructuredTool<\n  SchemaT,\n  InferInteropZodOutput<SchemaT>,\n  InferInteropZodInput<SchemaT>,\n  unknown,\n  unknown,\n  NameT\n> & {\n  /**\n   * Pairs this headless tool with a client-side implementation.\n   *\n   * The returned object should be passed to `useStream({ tools: [...] })`.\n   * The SDK matches the implementation to the tool by name and calls\n   * `execute` with the typed arguments from the interrupt payload.\n   *\n   * @param execute - The function that implements the tool on the client\n   */\n  implement: <OutputT>(\n    execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n  ) => HeadlessToolImplementation<SchemaT, OutputT, NameT>;\n};\n\nfunction createHeadlessTool<\n  SchemaT extends InteropZodObject,\n  NameT extends string,\n>(fields: HeadlessToolFields<SchemaT, NameT>): HeadlessTool<SchemaT, NameT> {\n  const { name, description, schema } = fields;\n\n  const wrappedTool = coreTool(\n    async (\n      args: InferInteropZodOutput<SchemaT>,\n      config?: ToolRunnableConfig\n    ) => {\n      const { interrupt } = await import(\"@langchain/langgraph\");\n      return interrupt({\n        type: \"tool\",\n        toolCall: {\n          id: config?.toolCall?.id,\n          name,\n          args,\n        },\n      });\n    },\n    {\n      name,\n      description,\n      schema,\n      metadata: {\n        headlessTool: true,\n      },\n    }\n  );\n\n  const headlessTool: HeadlessTool<SchemaT, NameT> = Object.assign(\n    wrappedTool,\n    {\n      implement: <OutputT>(\n        execute: (args: InferInteropZodOutput<SchemaT>) => Promise<OutputT>\n      ): HeadlessToolImplementation<SchemaT, OutputT, NameT> => ({\n        tool: headlessTool,\n        execute,\n      }),\n    }\n  ) as HeadlessTool<SchemaT, NameT>;\n\n  return headlessTool;\n}\n\n/**\n * The headless overload signature added to the core `tool` function.\n *\n * When called **without** an implementation function — just `tool({ name, description, schema })` —\n * returns a {@link HeadlessTool} that interrupts on every agent invocation.\n * The client provides the implementation via `useStream({ tools: [...] })`.\n */\ntype HeadlessToolOverload = {\n  <SchemaT extends InteropZodObject, NameT extends string>(\n    fields: HeadlessToolFields<SchemaT, NameT>\n  ): HeadlessTool<SchemaT, NameT>;\n};\n\n/**\n * Unified tool primitive for LangChain agents.\n *\n * Enhances the `tool` function from `@langchain/core/tools` with a headless\n * overload: when called **without** an implementation function, the tool\n * interrupts agent execution and lets the client supply the implementation.\n *\n * ---\n *\n * **Normal tool** — pass an implementation function as the first argument:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ city }) => `The weather in ${city} is sunny.`,\n *   {\n *     name: \"get_weather\",\n *     description: \"Get the weather for a city\",\n *     schema: z.object({ city: z.string() }),\n *   }\n * );\n * ```\n *\n * ---\n *\n * **Headless tool** — omit the implementation; the client provides it later:\n *\n * ```typescript\n * import { tool } from \"langchain/tools\";\n * import { z } from \"zod\";\n *\n * // Server: define the tool shape — no implementation needed\n * export const getLocation = tool({\n *   name: \"get_location\",\n *   description: \"Get the user's current GPS location\",\n *   schema: z.object({\n *     highAccuracy: z.boolean().optional().describe(\"Request high accuracy GPS\"),\n *   }),\n * });\n *\n * // Server: register with the agent\n * const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getLocation],\n * });\n *\n * // Client: provide the implementation in useStream\n * const stream = useStream({\n *   assistantId: \"agent\",\n *   tools: [\n *     getLocation.implement(async ({ highAccuracy }) => {\n *       return new Promise((resolve, reject) => {\n *         navigator.geolocation.getCurrentPosition(\n *           (pos) => resolve({\n *             latitude: pos.coords.latitude,\n *             longitude: pos.coords.longitude,\n *           }),\n *           (err) => reject(new Error(err.message)),\n *           { enableHighAccuracy: highAccuracy }\n *         );\n *       });\n *     }),\n *   ],\n * });\n * ```\n */\nexport const tool: HeadlessToolOverload & typeof coreTool = ((\n  funcOrFields: unknown,\n  fields?: unknown\n) => {\n  if (typeof funcOrFields !== \"function\") {\n    return createHeadlessTool(\n      funcOrFields as HeadlessToolFields<InteropZodObject, string>\n    );\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (coreTool as any)(funcOrFields, fields);\n}) as HeadlessToolOverload & typeof coreTool;\n"],"mappings":";;;;;;;;;;;;AAmFA,SAAS,mBAGP,QAA0E;CAC1E,MAAM,EAAE,MAAM,aAAa,WAAW;CAEtC,MAAM,cAAcA,KAClB,OACE,MACA,WACG;EACH,MAAM,EAAE,cAAc,MAAM,OAAO;EACnC,OAAO,UAAU;GACf,MAAM;GACN,UAAU;IACR,IAAI,QAAQ,UAAU;IACtB;IACA;GACF;EACF,CAAC;CACH,GACA;EACE;EACA;EACA;EACA,UAAU,EACR,cAAc,KAChB;CACF,CACF;CAEA,MAAM,eAA6C,OAAO,OACxD,aACA,EACE,YACE,aACyD;EACzD,MAAM;EACN;CACF,GACF,CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmFA,MAAaC,WACX,cACA,WACG;CACH,IAAI,OAAO,iBAAiB,YAC1B,OAAO,mBACL,YACF;CAGF,OAAQD,KAAiB,cAAc,MAAM;AAC/C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "Typescript bindings for langchain",
   "author": "LangChain",
   "license": "MIT",
@@ -32,39 +32,39 @@
   },
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain/",
   "devDependencies": {
-    "@hono/node-server": "^2.0.10",
-    "@langchain/langgraph-api": "^1.4.1",
-    "@langchain/langgraph-sdk": "^1.9.25",
+    "@hono/node-server": "^2.0.12",
+    "@langchain/langgraph-api": "^1.4.3",
+    "@langchain/langgraph-sdk": "^1.9.28",
     "@tsconfig/recommended": "^1.0.2",
     "@types/js-yaml": "^4",
     "@types/jsdom": "^28.0.3",
     "@types/ws": "^8",
-    "@vitest/coverage-v8": "^4.1.9",
+    "@vitest/coverage-v8": "^4.1.10",
     "cheerio": "1.2.0",
     "dotenv": "^17.4.0",
     "dpdm": "^3.14.0",
-    "hono": "^4.12.25",
+    "hono": "^4.12.33",
     "openai": "^6.41.0",
     "peggy": "^5.1.0",
     "reflect-metadata": "^0.2.2",
     "rimraf": "^6.1.3",
-    "tinybench": "^6.0.2",
+    "tinybench": "^6.1.2",
     "typeorm": "^1.1.0",
-    "typescript": "~6.0.3",
+    "typescript": "~7.0.2",
     "vitest": "^4.1.8",
     "yaml": "^2.9.0",
-    "@langchain/anthropic": "1.5.2",
+    "@langchain/anthropic": "1.5.4",
     "@langchain/aws": "1.4.3",
-    "@langchain/core": "^1.2.3",
-    "@langchain/fireworks": "0.2.5",
-    "@langchain/openai": "1.5.5",
+    "@langchain/core": "^1.2.6",
+    "@langchain/fireworks": "0.2.7",
+    "@langchain/openai": "1.5.7",
     "@langchain/tsconfig": "0.0.1"
   },
   "peerDependencies": {
-    "@langchain/core": "^1.2.3"
+    "@langchain/core": "^1.2.6"
   },
   "dependencies": {
-    "@langchain/langgraph": "^1.4.7",
+    "@langchain/langgraph": "^1.4.8",
     "@langchain/langgraph-checkpoint": "^1.1.3",
     "langsmith": ">=0.5.0 <1.0.0",
     "zod": "^3.25.76 || ^4"