@langchain/classic 1.0.5 → 1.0.6-dev-1765432861398

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoder_backed.d.cts","names":["Document","BaseStore","EncoderBackedStore","K","V","SerializedType","Promise","AsyncGenerator","createDocumentStoreFromByteStore","Uint8Array","Record","ArrayBufferLike"],"sources":["../../src/storage/encoder_backed.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\nexport declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {\n    lc_namespace: string[];\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n    constructor(fields: {\n        store: BaseStore<string, SerializedType>;\n        keyEncoder: (key: K) => string;\n        valueSerializer: (value: V) => SerializedType;\n        valueDeserializer: (value: SerializedType) => V;\n    });\n    /**\n     * Method to get multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keys Array of keys to get\n     * @returns Promise that resolves with an array of values or undefined for each key\n     */\n    mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Method to set multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keyValuePairs Array of key-value pairs to set\n     * @returns Promise that resolves when the operation is complete\n     */\n    mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Method to delete multiple keys at once. It works with the encoded keys.\n     * @param keys Array of keys to delete\n     * @returns Promise that resolves when the operation is complete\n     */\n    mdelete(keys: K[]): Promise<void>;\n    /**\n     * Method to yield keys. It works with the encoded keys.\n     * @param prefix Optional prefix to filter keys\n     * @returns AsyncGenerator that yields keys\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;\n}\nexport declare function createDocumentStoreFromByteStore(store: BaseStore<string, Uint8Array>): EncoderBackedStore<string, Document<Record<string, any>>, Uint8Array<ArrayBufferLike>>;\n//# sourceMappingURL=encoder_backed.d.ts.map"],"mappings":";;;;;;;AAOA;;;AAE6BK,cAFRH,kBAEQG,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,iBAAAA,GAAAA,CAAAA,SAF+CJ,SAE/CI,CAFyDF,CAEzDE,EAF4DD,CAE5DC,CAAAA,CAAAA;EAAlBJ,YAAAA,EAAAA,MAAAA,EAAAA;EACWE,KAAAA,EADXF,SACWE,CAAAA,MAAAA,EADOE,cACPF,CAAAA;EACOC,UAAAA,EAAAA,CAAAA,GAAAA,EADPD,CACOC,EAAAA,GAAAA,MAAAA;EAAMC,eAAAA,EAAAA,CAAAA,KAAAA,EAAND,CAAMC,EAAAA,GAAAA,cAAAA;EACJA,iBAAAA,EAAAA,CAAAA,KAAAA,EAAAA,cAAAA,EAAAA,GAAmBD,CAAnBC;EAAmBD,WAAAA,CAAAA,MAAAA,EAAAA;IAEjBC,KAAAA,EAAlBJ,SAAkBI,CAAAA,MAAAA,EAAAA,cAAAA,CAAAA;IAAlBJ,UAAAA,EAAAA,CAAAA,GAAAA,EACWE,CADXF,EAAAA,GAAAA,MAAAA;IACWE,eAAAA,EAAAA,CAAAA,KAAAA,EACOC,CADPD,EAAAA,GACaE,cADbF;IACOC,iBAAAA,EAAAA,CAAAA,KAAAA,EACEC,cADFD,EAAAA,GACqBA,CADrBA;EAAMC,CAAAA;EACJA;;;;;;EAePD,IAAAA,CAAAA,IAAAA,EAPbD,CAOaC,EAAAA,CAAAA,EAPPE,OAOOF,CAAAA,CAPEA,CAOFA,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAOE;;;;;;EAzBkD,IAAA,CAAA,aAAA,EAAA,CAyB5DH,CAzB4D,EAyBzDC,CAzByD,CAAA,EAAA,CAAA,EAyBlDE,OAzBkD,CAAA,IAAA,CAAA;EAuC7DE;;;;;EAA6IG,OAAAA,CAAAA,IAAAA,EARnJR,CAQmJQ,EAAAA,CAAAA,EAR7IL,OAQ6IK,CAAAA,IAAAA,CAAAA;EAAXF;;AAAxC;;;0CAFtEF,wBAAwBJ;;iBAE5CK,gCAAAA,QAAwCP,kBAAkBQ,cAAcP,2BAA2BF,SAASU,sBAAsBD,WAAWE"}

package/dist/storage/encoder_backed.d.ts

@@ -8,7 +8,6 @@ import { BaseStore } from "@langchain/core/stores";
  * allowing for the encoding and decoding of keys and values. It extends
  * the BaseStore class.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {
   lc_namespace: string[];
   store: BaseStore<string, SerializedType>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"encoder_backed.d.ts","names":["Document","BaseStore","EncoderBackedStore","K","V","SerializedType","Promise","AsyncGenerator","createDocumentStoreFromByteStore","Uint8Array","Record","ArrayBufferLike"],"sources":["../../src/storage/encoder_backed.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStore } from \"@langchain/core/stores\";\n/**\n * Class that provides a layer of abstraction over the base storage,\n * allowing for the encoding and decoding of keys and values. It extends\n * the BaseStore class.\n */\nexport declare class EncoderBackedStore<K, V, SerializedType = any> extends BaseStore<K, V> {\n    lc_namespace: string[];\n    store: BaseStore<string, SerializedType>;\n    keyEncoder: (key: K) => string;\n    valueSerializer: (value: V) => SerializedType;\n    valueDeserializer: (value: SerializedType) => V;\n    constructor(fields: {\n        store: BaseStore<string, SerializedType>;\n        keyEncoder: (key: K) => string;\n        valueSerializer: (value: V) => SerializedType;\n        valueDeserializer: (value: SerializedType) => V;\n    });\n    /**\n     * Method to get multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keys Array of keys to get\n     * @returns Promise that resolves with an array of values or undefined for each key\n     */\n    mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Method to set multiple keys at once. It works with the encoded keys and\n     * serialized values.\n     * @param keyValuePairs Array of key-value pairs to set\n     * @returns Promise that resolves when the operation is complete\n     */\n    mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Method to delete multiple keys at once. It works with the encoded keys.\n     * @param keys Array of keys to delete\n     * @returns Promise that resolves when the operation is complete\n     */\n    mdelete(keys: K[]): Promise<void>;\n    /**\n     * Method to yield keys. It works with the encoded keys.\n     * @param prefix Optional prefix to filter keys\n     * @returns AsyncGenerator that yields keys\n     */\n    yieldKeys(prefix?: string | undefined): AsyncGenerator<string | K>;\n}\nexport declare function createDocumentStoreFromByteStore(store: BaseStore<string, Uint8Array>): EncoderBackedStore<string, Document<Record<string, any>>, Uint8Array<ArrayBufferLike>>;\n//# sourceMappingURL=encoder_backed.d.ts.map"],"mappings":";;;;;;;AAOA;;;AAE6BK,cAFRH,kBAEQG,CAAAA,CAAAA,EAAAA,CAAAA,EAAAA,iBAAAA,GAAAA,CAAAA,SAF+CJ,SAE/CI,CAFyDF,CAEzDE,EAF4DD,CAE5DC,CAAAA,CAAAA;EAAlBJ,YAAAA,EAAAA,MAAAA,EAAAA;EACWE,KAAAA,EADXF,SACWE,CAAAA,MAAAA,EADOE,cACPF,CAAAA;EACOC,UAAAA,EAAAA,CAAAA,GAAAA,EADPD,CACOC,EAAAA,GAAAA,MAAAA;EAAMC,eAAAA,EAAAA,CAAAA,KAAAA,EAAND,CAAMC,EAAAA,GAAAA,cAAAA;EACJA,iBAAAA,EAAAA,CAAAA,KAAAA,EAAAA,cAAAA,EAAAA,GAAmBD,CAAnBC;EAAmBD,WAAAA,CAAAA,MAAAA,EAAAA;IAEjBC,KAAAA,EAAlBJ,SAAkBI,CAAAA,MAAAA,EAAAA,cAAAA,CAAAA;IAAlBJ,UAAAA,EAAAA,CAAAA,GAAAA,EACWE,CADXF,EAAAA,GAAAA,MAAAA;IACWE,eAAAA,EAAAA,CAAAA,KAAAA,EACOC,CADPD,EAAAA,GACaE,cADbF;IACOC,iBAAAA,EAAAA,CAAAA,KAAAA,EACEC,cADFD,EAAAA,GACqBA,CADrBA;EAAMC,CAAAA;EACJA;;;;;;EAePD,IAAAA,CAAAA,IAAAA,EAPbD,CAOaC,EAAAA,CAAAA,EAPPE,OAOOF,CAAAA,CAPEA,CAOFA,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAOE;;;;;;EAzBkD,IAAA,CAAA,aAAA,EAAA,CAyB5DH,CAzB4D,EAyBzDC,CAzByD,CAAA,EAAA,CAAA,EAyBlDE,OAzBkD,CAAA,IAAA,CAAA;EAuC7DE;;;;;EAA6IG,OAAAA,CAAAA,IAAAA,EARnJR,CAQmJQ,EAAAA,CAAAA,EAR7IL,OAQ6IK,CAAAA,IAAAA,CAAAA;EAAXF;;AAAxC;;;0CAFtEF,wBAAwBJ;;iBAE5CK,gCAAAA,QAAwCP,kBAAkBQ,cAAcP,2BAA2BF,SAASU,sBAAsBD,WAAWE"}

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

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

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

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

package/dist/stores/doc/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["Document","Docstore","Promise","Record"],"sources":["../../../src/stores/doc/base.d.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport declare abstract class Docstore {\n    abstract search(search: string): Promise<Document>;\n    abstract add(texts: Record<string, Document>): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AACqCE,uBADPD,QAAAA,CACOC;EACEF,SAAAA,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EADFE,OACEF,CADMA,QACNA,CAAAA;EAAfG,SAAAA,GAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,MAAAA,EAAeH,QAAfG,CAAAA,CAAAA,EAA2BD,OAA3BC,CAAAA,IAAAA,CAAAA"}

package/dist/stores/doc/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Document","Docstore","Promise","Record"],"sources":["../../../src/stores/doc/base.d.ts"],"sourcesContent":["import { type Document } from \"@langchain/core/documents\";\n/**\n * Abstract class for a document store. All document stores should extend\n * this class.\n */\nexport declare abstract class Docstore {\n    abstract search(search: string): Promise<Document>;\n    abstract add(texts: Record<string, Document>): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AACqCE,uBADPD,QAAAA,CACOC;EACEF,SAAAA,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EADFE,OACEF,CADMA,QACNA,CAAAA;EAAfG,SAAAA,GAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,MAAAA,EAAeH,QAAfG,CAAAA,CAAAA,EAA2BD,OAA3BC,CAAAA,IAAAA,CAAAA"}

package/dist/stores/doc/in_memory.d.cts

@@ -26,7 +26,6 @@ declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<st
   mget(keys: string[]): Promise<Document[]>;
   mset(keyValuePairs: [string, Document][]): Promise<void>;
   mdelete(_keys: string[]): Promise<void>;
-  // eslint-disable-next-line require-yield
   yieldKeys(_prefix?: string): AsyncGenerator<string>;
 }
 /**

package/dist/stores/doc/in_memory.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.d.cts","names":["Document","BaseStoreInterface","Docstore","InMemoryDocstore","Map","Promise","Record","AsyncGenerator","SynchronousInMemoryDocstore"],"sources":["../../../src/stores/doc/in_memory.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<string, Document> {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Promise<Document>;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): Promise<void>;\n    mget(keys: string[]): Promise<Document[]>;\n    mset(keyValuePairs: [string, Document][]): Promise<void>;\n    mdelete(_keys: string[]): Promise<void>;\n    yieldKeys(_prefix?: string): AsyncGenerator<string>;\n}\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport declare class SynchronousInMemoryDocstore {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Document;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): void;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;;;AAOA;;AACuBA,cADFG,gBAAAA,SAAyBD,QAAAA,YAAoBD,kBAC3CD,CAAAA,MAAAA,EADsEA,QACtEA,CAAAA,CAAAA;EAAZI,KAAAA,EAAAA,GAAAA,CAAAA,MAAAA,EAAYJ,QAAZI,CAAAA;EACwBJ,WAAAA,CAAAA,IAAAA,CAAAA,EAAZI,GAAYJ,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA;EAAZI;;;;;EAYmBC,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANdA,OAMcA,CANNL,QAMMK,CAAAA;EACRL;;;;;EAGDO,GAAAA,CAAAA,KAAAA,EAJlBD,MAIkBC,CAAAA,MAAAA,EAJHP,QAIGO,CAAAA,CAAAA,EAJSF,OAITE,CAAAA,IAAAA,CAAAA;EAlBaL,IAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAepBG,OAfoBH,CAeZF,QAfYE,EAAAA,CAAAA;EAAoBD,IAAAA,CAAAA,aAAAA,EAAAA,CAAAA,MAAAA,EAgBjCD,QAhBiCC,CAAAA,EAAAA,CAAAA,EAgBnBI,OAhBmBJ,CAAAA,IAAAA,CAAAA;EAAkB,OAAA,CAAA,KAAA,EAAA,MAAA,EAAA,CAAA,EAiBtDI,OAjBsD,CAAA,IAAA,CAAA;EAuB/DG,SAAAA,CAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EALYD,cAKe,CAAA,MAAA,CAAA;;;;;AAQpBP,cARPQ,2BAAAA,CAQOR;EAMEA,KAAAA,EAbnBI,GAamBJ,CAAAA,MAAAA,EAbPA,QAaOA,CAAAA;EAAfM,WAAAA,CAAAA,IAAAA,CAAAA,EAZQF,GAYRE,CAAAA,MAAAA,EAZoBN,QAYpBM,CAAAA;EAAM;;;;;0BANON;;;;;;aAMbM,eAAeN"}

package/dist/stores/doc/in_memory.d.ts

@@ -26,7 +26,6 @@ declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<st
   mget(keys: string[]): Promise<Document[]>;
   mset(keyValuePairs: [string, Document][]): Promise<void>;
   mdelete(_keys: string[]): Promise<void>;
-  // eslint-disable-next-line require-yield
   yieldKeys(_prefix?: string): AsyncGenerator<string>;
 }
 /**

package/dist/stores/doc/in_memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.d.ts","names":["Document","BaseStoreInterface","Docstore","InMemoryDocstore","Map","Promise","Record","AsyncGenerator","SynchronousInMemoryDocstore"],"sources":["../../../src/stores/doc/in_memory.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { BaseStoreInterface } from \"@langchain/core/stores\";\nimport { Docstore } from \"./base.js\";\n/**\n * Class for storing and retrieving documents in memory asynchronously.\n * Extends the Docstore class.\n */\nexport declare class InMemoryDocstore extends Docstore implements BaseStoreInterface<string, Document> {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Promise<Document>;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): Promise<void>;\n    mget(keys: string[]): Promise<Document[]>;\n    mset(keyValuePairs: [string, Document][]): Promise<void>;\n    mdelete(_keys: string[]): Promise<void>;\n    yieldKeys(_prefix?: string): AsyncGenerator<string>;\n}\n/**\n * Class for storing and retrieving documents in memory synchronously.\n */\nexport declare class SynchronousInMemoryDocstore {\n    _docs: Map<string, Document>;\n    constructor(docs?: Map<string, Document>);\n    /**\n     * Searches for a document in the store based on its ID.\n     * @param search The ID of the document to search for.\n     * @returns The document with the given ID.\n     */\n    search(search: string): Document;\n    /**\n     * Adds new documents to the store.\n     * @param texts An object where the keys are document IDs and the values are the documents themselves.\n     * @returns Void\n     */\n    add(texts: Record<string, Document>): void;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;;;AAOA;;AACuBA,cADFG,gBAAAA,SAAyBD,QAAAA,YAAoBD,kBAC3CD,CAAAA,MAAAA,EADsEA,QACtEA,CAAAA,CAAAA;EAAZI,KAAAA,EAAAA,GAAAA,CAAAA,MAAAA,EAAYJ,QAAZI,CAAAA;EACwBJ,WAAAA,CAAAA,IAAAA,CAAAA,EAAZI,GAAYJ,CAAAA,MAAAA,EAAAA,QAAAA,CAAAA;EAAZI;;;;;EAYmBC,MAAAA,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,EANdA,OAMcA,CANNL,QAMMK,CAAAA;EACRL;;;;;EAGDO,GAAAA,CAAAA,KAAAA,EAJlBD,MAIkBC,CAAAA,MAAAA,EAJHP,QAIGO,CAAAA,CAAAA,EAJSF,OAITE,CAAAA,IAAAA,CAAAA;EAlBaL,IAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAepBG,OAfoBH,CAeZF,QAfYE,EAAAA,CAAAA;EAAoBD,IAAAA,CAAAA,aAAAA,EAAAA,CAAAA,MAAAA,EAgBjCD,QAhBiCC,CAAAA,EAAAA,CAAAA,EAgBnBI,OAhBmBJ,CAAAA,IAAAA,CAAAA;EAAkB,OAAA,CAAA,KAAA,EAAA,MAAA,EAAA,CAAA,EAiBtDI,OAjBsD,CAAA,IAAA,CAAA;EAuB/DG,SAAAA,CAAAA,OAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EALYD,cAKe,CAAA,MAAA,CAAA;;;;;AAQpBP,cARPQ,2BAAAA,CAQOR;EAMEA,KAAAA,EAbnBI,GAamBJ,CAAAA,MAAAA,EAbPA,QAaOA,CAAAA;EAAfM,WAAAA,CAAAA,IAAAA,CAAAA,EAZQF,GAYRE,CAAAA,MAAAA,EAZoBN,QAYpBM,CAAAA;EAAM;;;;;0BANON;;;;;;aAMbM,eAAeN"}

package/dist/stores/file/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["Serializable","BaseFileStore","Promise"],"sources":["../../../src/stores/file/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport declare abstract class BaseFileStore extends Serializable {\n    abstract readFile(path: string): Promise<string>;\n    abstract writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEwDE,uBAF1BD,aAAAA,SAAsBD,YAAAA,CAEIE;EAFJF,SAAAA,QAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EACfE,OADeF,CAAAA,MAAAA,CAAAA;EAAY,SAAA,SAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,CAAA,EAERE,OAFQ,CAAA,IAAA,CAAA"}

package/dist/stores/file/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Serializable","BaseFileStore","Promise"],"sources":["../../../src/stores/file/base.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\n/**\n * Base class for all file stores. All file stores should extend this\n * class.\n */\nexport declare abstract class BaseFileStore extends Serializable {\n    abstract readFile(path: string): Promise<string>;\n    abstract writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;AAKA;;AAEwDE,uBAF1BD,aAAAA,SAAsBD,YAAAA,CAEIE;EAFJF,SAAAA,QAAAA,CAAAA,IAAAA,EAAAA,MAAAA,CAAAA,EACfE,OADeF,CAAAA,MAAAA,CAAAA;EAAY,SAAA,SAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,EAAA,MAAA,CAAA,EAERE,OAFQ,CAAA,IAAA,CAAA"}

package/dist/stores/file/in_memory.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.d.cts","names":["BaseFileStore","InMemoryFileStore","Promise"],"sources":["../../../src/stores/file/in_memory.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport declare class InMemoryFileStore extends BaseFileStore {\n    lc_namespace: string[];\n    private files;\n    /**\n     * Retrieves the contents of a file given its path. If the file does not\n     * exist, it throws an error.\n     * @param path The path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes contents to a file at a given path. If the file already exists,\n     * it overwrites the existing contents.\n     * @param path The path of the file to write.\n     * @param contents The contents to write to the file.\n     * @returns Void\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;AAQA;;;;AAA4D;cAAvCC,iBAAAA,SAA0BD,aAAAA;;;;;;;;;0BASnBE;;;;;;;;6CAQmBA"}

package/dist/stores/file/in_memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in_memory.d.ts","names":["BaseFileStore","InMemoryFileStore","Promise"],"sources":["../../../src/stores/file/in_memory.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Class that provides an in-memory file storage system. It extends the\n * BaseFileStore class and implements its readFile and writeFile methods.\n * This class is typically used in scenarios where temporary, in-memory\n * file storage is needed, such as during testing or for caching files in\n * memory for quick access.\n */\nexport declare class InMemoryFileStore extends BaseFileStore {\n    lc_namespace: string[];\n    private files;\n    /**\n     * Retrieves the contents of a file given its path. If the file does not\n     * exist, it throws an error.\n     * @param path The path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes contents to a file at a given path. If the file already exists,\n     * it overwrites the existing contents.\n     * @param path The path of the file to write.\n     * @param contents The contents to write to the file.\n     * @returns Void\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=in_memory.d.ts.map"],"mappings":";;;;;;AAQA;;;;AAA4D;cAAvCC,iBAAAA,SAA0BD,aAAAA;;;;;;;;;0BASnBE;;;;;;;;6CAQmBA"}

package/dist/stores/file/node.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.cts","names":["BaseFileStore","NodeFileStore","Promise"],"sources":["../../../src/stores/file/node.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport declare class NodeFileStore extends BaseFileStore {\n    basePath: string;\n    lc_namespace: string[];\n    constructor(basePath?: string);\n    /**\n     * Reads the contents of a file at the given path.\n     * @param path Path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes the given contents to a file at the specified path.\n     * @param path Path of the file to write to.\n     * @param contents Contents to write to the file.\n     * @returns Promise that resolves when the file has been written.\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=node.d.ts.map"],"mappings":";;;;;;AAKA;;AAgB+CE,cAhB1BD,aAAAA,SAAsBD,aAAAA,CAgBIE;EAhBJF,QAAAA,EAAAA,MAAAA;EAAa,YAAA,EAAA,MAAA,EAAA;;;;;;;0BAS5BE;;;;;;;6CAOmBA"}

package/dist/stores/file/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","names":["BaseFileStore","NodeFileStore","Promise"],"sources":["../../../src/stores/file/node.d.ts"],"sourcesContent":["import { BaseFileStore } from \"./base.js\";\n/**\n * Specific implementation of the `BaseFileStore` class for Node.js.\n * Provides methods to read and write files in a specific base path.\n */\nexport declare class NodeFileStore extends BaseFileStore {\n    basePath: string;\n    lc_namespace: string[];\n    constructor(basePath?: string);\n    /**\n     * Reads the contents of a file at the given path.\n     * @param path Path of the file to read.\n     * @returns The contents of the file as a string.\n     */\n    readFile(path: string): Promise<string>;\n    /**\n     * Writes the given contents to a file at the specified path.\n     * @param path Path of the file to write to.\n     * @param contents Contents to write to the file.\n     * @returns Promise that resolves when the file has been written.\n     */\n    writeFile(path: string, contents: string): Promise<void>;\n}\n//# sourceMappingURL=node.d.ts.map"],"mappings":";;;;;;AAKA;;AAgB+CE,cAhB1BD,aAAAA,SAAsBD,aAAAA,CAgBIE;EAhBJF,QAAAA,EAAAA,MAAAA;EAAa,YAAA,EAAA,MAAA,EAAA;;;;;;;0BAS5BE;;;;;;;6CAOmBA"}

package/dist/text_splitter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text_splitter.d.cts","names":[],"sources":["../src/text_splitter.d.ts"],"sourcesContent":["export * from \"@langchain/textsplitters\";\n//# sourceMappingURL=text_splitter.d.ts.map"],"mappings":""}

package/dist/text_splitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text_splitter.d.ts","names":[],"sources":["../src/text_splitter.d.ts"],"sourcesContent":["export * from \"@langchain/textsplitters\";\n//# sourceMappingURL=text_splitter.d.ts.map"],"mappings":""}

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.cts","names":["DynamicTool","DynamicToolInput","BaseChain","ChainToolInput","Omit","ChainTool","chain"],"sources":["../../src/tools/chain.d.ts"],"sourcesContent":["import { DynamicTool, DynamicToolInput } from \"@langchain/core/tools\";\nimport { BaseChain } from \"../chains/base.js\";\n/**\n * Interface for the input parameters of the ChainTool constructor.\n * Extends the DynamicToolInput interface, replacing the 'func' property\n * with a 'chain' property.\n */\nexport interface ChainToolInput extends Omit<DynamicToolInput, \"func\"> {\n    chain: BaseChain;\n}\n/**\n * Class that extends DynamicTool for creating tools that can run chains.\n * Takes an instance of a class that extends BaseChain as a parameter in\n * its constructor and uses it to run the chain when its 'func' method is\n * called.\n */\nexport declare class ChainTool extends DynamicTool {\n    static lc_name(): string;\n    chain: BaseChain;\n    constructor({ chain, ...rest }: ChainToolInput);\n}\n//# sourceMappingURL=chain.d.ts.map"],"mappings":";;;;;;;AAOA;;;AAAwCI,UAAvBD,cAAAA,SAAuBC,IAAAA,CAAKH,gBAALG,EAAAA,MAAAA,CAAAA,CAAAA;EAAI,KAAA,EACjCF,SADiC;AAS5C;;;;;AAAkD;;cAA7BG,SAAAA,SAAkBL,WAAAA;;SAE5BE;;;;KACyBC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","names":["DynamicTool","DynamicToolInput","BaseChain","ChainToolInput","Omit","ChainTool","chain"],"sources":["../../src/tools/chain.d.ts"],"sourcesContent":["import { DynamicTool, DynamicToolInput } from \"@langchain/core/tools\";\nimport { BaseChain } from \"../chains/base.js\";\n/**\n * Interface for the input parameters of the ChainTool constructor.\n * Extends the DynamicToolInput interface, replacing the 'func' property\n * with a 'chain' property.\n */\nexport interface ChainToolInput extends Omit<DynamicToolInput, \"func\"> {\n    chain: BaseChain;\n}\n/**\n * Class that extends DynamicTool for creating tools that can run chains.\n * Takes an instance of a class that extends BaseChain as a parameter in\n * its constructor and uses it to run the chain when its 'func' method is\n * called.\n */\nexport declare class ChainTool extends DynamicTool {\n    static lc_name(): string;\n    chain: BaseChain;\n    constructor({ chain, ...rest }: ChainToolInput);\n}\n//# sourceMappingURL=chain.d.ts.map"],"mappings":";;;;;;;AAOA;;;AAAwCI,UAAvBD,cAAAA,SAAuBC,IAAAA,CAAKH,gBAALG,EAAAA,MAAAA,CAAAA,CAAAA;EAAI,KAAA,EACjCF,SADiC;AAS5C;;;;;AAAkD;;cAA7BG,SAAAA,SAAkBL,WAAAA;;SAE5BE;;;;KACyBC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.cts","names":["z","StructuredTool","ToolParams","InferInteropZodOutput","BaseFileStore","ReadFileParams","readSchema","ZodString","ZodTypeAny","ZodObject","ReadToolSchema","ReadFileTool","store","file_path","Promise","WriteFileParams","writeSchema","WriteToolSchema","WriteFileTool","text"],"sources":["../../src/tools/fs.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { StructuredTool, ToolParams } from \"@langchain/core/tools\";\nimport { InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport { BaseFileStore } from \"../stores/file/base.js\";\n/**\n * Interface for parameters required by the ReadFileTool class.\n */\ninterface ReadFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const readSchema: z.ZodObject<{\n    file_path: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n}, {\n    file_path: string;\n}>;\ntype ReadToolSchema = typeof readSchema;\n/**\n * Class for reading files from the disk. Extends the StructuredTool\n * class.\n */\nexport declare class ReadFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n    }, {\n        file_path: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store }: ReadFileParams);\n    _call({ file_path }: InferInteropZodOutput<ReadToolSchema>): Promise<string>;\n}\n/**\n * Interface for parameters required by the WriteFileTool class.\n */\ninterface WriteFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const writeSchema: z.ZodObject<{\n    file_path: z.ZodString;\n    text: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n    text: string;\n}, {\n    file_path: string;\n    text: string;\n}>;\ntype WriteToolSchema = typeof writeSchema;\n/**\n * Class for writing data to files on the disk. Extends the StructuredTool\n * class.\n */\nexport declare class WriteFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n        text: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n        text: string;\n    }, {\n        file_path: string;\n        text: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store, ...rest }: WriteFileParams);\n    _call({ file_path, text }: InferInteropZodOutput<WriteToolSchema>): Promise<string>;\n}\nexport {};\n//# sourceMappingURL=fs.d.ts.map"],"mappings":";;;;;;;;;AAGuD;AAIZ,UAAjCK,cAAAA,SAAuBH,UAS/B,CAAA;EALeK,KAAAA,EAHNH,aAGMG;;cADHD,UAAcG,EAAFT,CAAAA,CAAES,SAAAA,CAAAA;EAAS,SAAA,EACtBT,CAAAA,CAAEO,SADoB;AAAA,CAAA,EAAA,OAOhCG,EALOV,CAAAA,CAAEQ,UAKK,EAAA;EAKEG,SAAAA,EAAAA,MAAY;CAGdX,EAAEO;EACHC,SAAAA,EAAAA,MAAAA;CAFNR,CAAAA;KAPPU,cAAAA,GAgBMN,OAhBkBE,UAgBlBF;;;;;AAEcD,cAbJQ,YAAAA,SAAqBV,cAAAA,CAajBE;EAAwCW,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAbvBb,MAAAA,EAE9BD,CAAAA,CAAES,SAF4BR,CAAAA;IAAc,SAAA,EAGrCD,CAAAA,CAAEO,SAHmC;EAkB9CQ,CAAAA,EAAAA,OAAAA,EAdMf,CAAAA,CAAEQ,UAcO,EAAA;IAGXQ,SAAAA,EASZ,MAAA;EAReT,CAAAA,EAAAA;IACLA,SAAAA,EAAAA,MAAAA;EACEC,CAAAA,CAAAA;EAHeC,IAAAA,EAAAA,MAAAA;EAAS,WAAA,EAAA,MAAA;EAUjCQ,KAAAA,EApBMb,aAoBS;EAKCc,WAAAA,CAAAA;IAAAA;EAAa,CAAA,EAxBPb,cAwBO;EAGbE,KAAAA,CAAAA;IAAAA;EAAAA,CAAAA,EA1BIJ,qBA0BJI,CA1B0BG,cA0B1BH,CAAAA,CAAAA,EA1B4CO,OA0B5CP,CAAAA,MAAAA,CAAAA;;;;;UArBXQ,eAAAA,SAAwBb,UAiChBU,CAAAA;EAAkBG,KAAAA,EAhCzBX,aAgCyBW;;cA9BtBC,WA+BSG,EA/BInB,CAAAA,CAAES,SA+BNU,CAAAA;EAA8BF,SAAAA,EA9BtCjB,CAAAA,CAAEO,SA8BoCU;EAAtBd,IAAAA,EA7BrBH,CAAAA,CAAEO,SA6BmBJ;CAAyCW,EAAAA,OAAAA,EA5B5Dd,CAAAA,CAAEQ,UA4B0DM,EAAAA;EAhB7Bb,SAAAA,EAAAA,MAAAA;EAAc,IAAA,EAAA,MAAA;;;;;KALpDgB,eAAAA,UAAyBD;;;;;cAKTE,aAAAA,SAAsBjB,cAAAA;;UAE/BD,CAAAA,CAAES;eACKT,CAAAA,CAAEO;UACPP,CAAAA,CAAEO;cACAP,CAAAA,CAAEQ;;;;;;;;;SASPJ;;;;KACyBW;;;;KACLZ,sBAAsBc,mBAAmBH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","names":["z","StructuredTool","ToolParams","InferInteropZodOutput","BaseFileStore","ReadFileParams","readSchema","ZodString","ZodTypeAny","ZodObject","ReadToolSchema","ReadFileTool","store","file_path","Promise","WriteFileParams","writeSchema","WriteToolSchema","WriteFileTool","text"],"sources":["../../src/tools/fs.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { StructuredTool, ToolParams } from \"@langchain/core/tools\";\nimport { InferInteropZodOutput } from \"@langchain/core/utils/types\";\nimport { BaseFileStore } from \"../stores/file/base.js\";\n/**\n * Interface for parameters required by the ReadFileTool class.\n */\ninterface ReadFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const readSchema: z.ZodObject<{\n    file_path: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n}, {\n    file_path: string;\n}>;\ntype ReadToolSchema = typeof readSchema;\n/**\n * Class for reading files from the disk. Extends the StructuredTool\n * class.\n */\nexport declare class ReadFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n    }, {\n        file_path: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store }: ReadFileParams);\n    _call({ file_path }: InferInteropZodOutput<ReadToolSchema>): Promise<string>;\n}\n/**\n * Interface for parameters required by the WriteFileTool class.\n */\ninterface WriteFileParams extends ToolParams {\n    store: BaseFileStore;\n}\ndeclare const writeSchema: z.ZodObject<{\n    file_path: z.ZodString;\n    text: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    file_path: string;\n    text: string;\n}, {\n    file_path: string;\n    text: string;\n}>;\ntype WriteToolSchema = typeof writeSchema;\n/**\n * Class for writing data to files on the disk. Extends the StructuredTool\n * class.\n */\nexport declare class WriteFileTool extends StructuredTool {\n    static lc_name(): string;\n    schema: z.ZodObject<{\n        file_path: z.ZodString;\n        text: z.ZodString;\n    }, \"strip\", z.ZodTypeAny, {\n        file_path: string;\n        text: string;\n    }, {\n        file_path: string;\n        text: string;\n    }>;\n    name: string;\n    description: string;\n    store: BaseFileStore;\n    constructor({ store, ...rest }: WriteFileParams);\n    _call({ file_path, text }: InferInteropZodOutput<WriteToolSchema>): Promise<string>;\n}\nexport {};\n//# sourceMappingURL=fs.d.ts.map"],"mappings":";;;;;;;;;AAGuD;AAIZ,UAAjCK,cAAAA,SAAuBH,UAS/B,CAAA;EALeK,KAAAA,EAHNH,aAGMG;;cADHD,UAAcG,EAAFT,CAAAA,CAAES,SAAAA,CAAAA;EAAS,SAAA,EACtBT,CAAAA,CAAEO,SADoB;AAAA,CAAA,EAAA,OAOhCG,EALOV,CAAAA,CAAEQ,UAKK,EAAA;EAKEG,SAAAA,EAAAA,MAAY;CAGdX,EAAEO;EACHC,SAAAA,EAAAA,MAAAA;CAFNR,CAAAA;KAPPU,cAAAA,GAgBMN,OAhBkBE,UAgBlBF;;;;;AAEcD,cAbJQ,YAAAA,SAAqBV,cAAAA,CAajBE;EAAwCW,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAbvBb,MAAAA,EAE9BD,CAAAA,CAAES,SAF4BR,CAAAA;IAAc,SAAA,EAGrCD,CAAAA,CAAEO,SAHmC;EAkB9CQ,CAAAA,EAAAA,OAAAA,EAdMf,CAAAA,CAAEQ,UAcO,EAAA;IAGXQ,SAAAA,EASZ,MAAA;EAReT,CAAAA,EAAAA;IACLA,SAAAA,EAAAA,MAAAA;EACEC,CAAAA,CAAAA;EAHeC,IAAAA,EAAAA,MAAAA;EAAS,WAAA,EAAA,MAAA;EAUjCQ,KAAAA,EApBMb,aAoBS;EAKCc,WAAAA,CAAAA;IAAAA;EAAa,CAAA,EAxBPb,cAwBO;EAGbE,KAAAA,CAAAA;IAAAA;EAAAA,CAAAA,EA1BIJ,qBA0BJI,CA1B0BG,cA0B1BH,CAAAA,CAAAA,EA1B4CO,OA0B5CP,CAAAA,MAAAA,CAAAA;;;;;UArBXQ,eAAAA,SAAwBb,UAiChBU,CAAAA;EAAkBG,KAAAA,EAhCzBX,aAgCyBW;;cA9BtBC,WA+BSG,EA/BInB,CAAAA,CAAES,SA+BNU,CAAAA;EAA8BF,SAAAA,EA9BtCjB,CAAAA,CAAEO,SA8BoCU;EAAtBd,IAAAA,EA7BrBH,CAAAA,CAAEO,SA6BmBJ;CAAyCW,EAAAA,OAAAA,EA5B5Dd,CAAAA,CAAEQ,UA4B0DM,EAAAA;EAhB7Bb,SAAAA,EAAAA,MAAAA;EAAc,IAAA,EAAA,MAAA;;;;;KALpDgB,eAAAA,UAAyBD;;;;;cAKTE,aAAAA,SAAsBjB,cAAAA;;UAE/BD,CAAAA,CAAES;eACKT,CAAAA,CAAEO;UACPP,CAAAA,CAAEO;cACAP,CAAAA,CAAEQ;;;;;;;;;SASPJ;;;;KACyBW;;;;KACLZ,sBAAsBc,mBAAmBH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.cts","names":["Serializable","Tool","ToolParams","Json","JsonObject","JsonSpec","JsonToolFields","JsonListKeysTool","Promise","JsonGetValueTool"],"sources":["../../src/tools/json.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nexport type Json = string | number | boolean | null | {\n    [key: string]: Json;\n} | Json[];\nexport type JsonObject = {\n    [key: string]: Json;\n};\n/**\n * Represents a JSON object in the LangChain framework. Provides methods\n * to get keys and values from the JSON object.\n */\nexport declare class JsonSpec extends Serializable {\n    lc_namespace: string[];\n    obj: JsonObject;\n    maxValueLength: number;\n    constructor(obj: JsonObject, max_value_length?: number);\n    /**\n     * Retrieves all keys at a given path in the JSON object.\n     * @param input The path to the keys in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns A string containing all keys at the given path, separated by commas.\n     */\n    getKeys(input: string): string;\n    /**\n     * Retrieves the value at a given path in the JSON object.\n     * @param input The path to the value in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns The value at the given path in the JSON object, as a string. If the value is a large dictionary or exceeds the maximum length, a message is returned instead.\n     */\n    getValue(input: string): string;\n}\nexport interface JsonToolFields extends ToolParams {\n    jsonSpec: JsonSpec;\n}\n/**\n * A tool in the LangChain framework that lists all keys at a given path\n * in a JSON object.\n */\nexport declare class JsonListKeysTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    jsonSpec: JsonSpec;\n    constructor(jsonSpec: JsonSpec);\n    constructor(fields: JsonToolFields);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool in the LangChain framework that retrieves the value at a given\n * path in a JSON object.\n */\nexport declare class JsonGetValueTool extends Tool {\n    jsonSpec: JsonSpec;\n    static lc_name(): string;\n    name: string;\n    constructor(jsonSpec: JsonSpec);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;KAEYG,IAAAA;iBACOA;AADnB,CAAA,GAEIA,IAFQA,EAAAA;AAGAC,KAAAA,UAAAA,GAAU;EAODC,CAAAA,GAAAA,EAAAA,MAAQ,CAAA,EANVF,IAMU;CAEpBC;;;AAFyC;AAkBlD;AAOqBG,cAzBAF,QAAAA,SAAiBL,YAAAA,CAyBD;EAGvBK,YAAAA,EAAAA,MAAAA,EAAAA;EACYA,GAAAA,EA3BjBD,UA2BiBC;EACFC,cAAAA,EAAAA,MAAAA;EAEEE,WAAAA,CAAAA,GAAAA,EA5BLJ,UA4BKI,EAAAA,gBAAAA,CAAAA,EAAAA,MAAAA;EAPoBP;AAAI;AAclD;;;EAM0BO,OAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EANoBP;AAAI;;;;;;UArBjCK,cAAAA,SAAuBJ;YAC1BG;;;;;;cAMOE,gBAAAA,SAAyBN,IAAAA;;;YAGhCI;wBACYA;sBACFC;;wBAEEE;;;;;;;cAOLC,gBAAAA,SAAyBR,IAAAA;YAChCI;;;wBAGYA;;wBAEAG"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","names":["Serializable","Tool","ToolParams","Json","JsonObject","JsonSpec","JsonToolFields","JsonListKeysTool","Promise","JsonGetValueTool"],"sources":["../../src/tools/json.d.ts"],"sourcesContent":["import { Serializable } from \"@langchain/core/load/serializable\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nexport type Json = string | number | boolean | null | {\n    [key: string]: Json;\n} | Json[];\nexport type JsonObject = {\n    [key: string]: Json;\n};\n/**\n * Represents a JSON object in the LangChain framework. Provides methods\n * to get keys and values from the JSON object.\n */\nexport declare class JsonSpec extends Serializable {\n    lc_namespace: string[];\n    obj: JsonObject;\n    maxValueLength: number;\n    constructor(obj: JsonObject, max_value_length?: number);\n    /**\n     * Retrieves all keys at a given path in the JSON object.\n     * @param input The path to the keys in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns A string containing all keys at the given path, separated by commas.\n     */\n    getKeys(input: string): string;\n    /**\n     * Retrieves the value at a given path in the JSON object.\n     * @param input The path to the value in the JSON object, provided as a string in JSON pointer syntax.\n     * @returns The value at the given path in the JSON object, as a string. If the value is a large dictionary or exceeds the maximum length, a message is returned instead.\n     */\n    getValue(input: string): string;\n}\nexport interface JsonToolFields extends ToolParams {\n    jsonSpec: JsonSpec;\n}\n/**\n * A tool in the LangChain framework that lists all keys at a given path\n * in a JSON object.\n */\nexport declare class JsonListKeysTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    jsonSpec: JsonSpec;\n    constructor(jsonSpec: JsonSpec);\n    constructor(fields: JsonToolFields);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool in the LangChain framework that retrieves the value at a given\n * path in a JSON object.\n */\nexport declare class JsonGetValueTool extends Tool {\n    jsonSpec: JsonSpec;\n    static lc_name(): string;\n    name: string;\n    constructor(jsonSpec: JsonSpec);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n//# sourceMappingURL=json.d.ts.map"],"mappings":";;;;KAEYG,IAAAA;iBACOA;AADnB,CAAA,GAEIA,IAFQA,EAAAA;AAGAC,KAAAA,UAAAA,GAAU;EAODC,CAAAA,GAAAA,EAAAA,MAAQ,CAAA,EANVF,IAMU;CAEpBC;;;AAFyC;AAkBlD;AAOqBG,cAzBAF,QAAAA,SAAiBL,YAAAA,CAyBD;EAGvBK,YAAAA,EAAAA,MAAAA,EAAAA;EACYA,GAAAA,EA3BjBD,UA2BiBC;EACFC,cAAAA,EAAAA,MAAAA;EAEEE,WAAAA,CAAAA,GAAAA,EA5BLJ,UA4BKI,EAAAA,gBAAAA,CAAAA,EAAAA,MAAAA;EAPoBP;AAAI;AAclD;;;EAM0BO,OAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;EANoBP;AAAI;;;;;;UArBjCK,cAAAA,SAAuBJ;YAC1BG;;;;;;cAMOE,gBAAAA,SAAyBN,IAAAA;;;YAGhCI;wBACYA;sBACFC;;wBAEEE;;;;;;;cAOLC,gBAAAA,SAAyBR,IAAAA;YAChCI;;;wBAGYA;;wBAEAG"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.cts","names":["StructuredToolInterface","ToolDefinition","renderTextDescription","renderTextDescriptionAndArgs"],"sources":["../../src/tools/render.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\n/**\n * Render the tool name and description in plain text.\n *\n * Output will be in the format of:\n * ```\n * search: This tool is used for search\n * calculator: This tool is used for math\n * ```\n * @param tools\n * @returns a string of all tools and their descriptions\n */\nexport declare function renderTextDescription(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n/**\n * Render the tool name, description, and args in plain text.\n * Output will be in the format of:'\n * ```\n * search: This tool is used for search, args: {\"query\": {\"type\": \"string\"}}\n * calculator: This tool is used for math,\n * args: {\"expression\": {\"type\": \"string\"}}\n * ```\n * @param tools\n * @returns a string of all tools, their descriptions and a stringified version of their schemas\n */\nexport declare function renderTextDescriptionAndArgs(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n//# sourceMappingURL=render.d.ts.map"],"mappings":";;;;;;;AAaA;AAYA;;;;;;;;iBAZwBE,qBAAAA,QAA6BF,4BAA4BC;;;;;;;;;;;;iBAYzDE,4BAAAA,QAAoCH,4BAA4BC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","names":["StructuredToolInterface","ToolDefinition","renderTextDescription","renderTextDescriptionAndArgs"],"sources":["../../src/tools/render.d.ts"],"sourcesContent":["import { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\n/**\n * Render the tool name and description in plain text.\n *\n * Output will be in the format of:\n * ```\n * search: This tool is used for search\n * calculator: This tool is used for math\n * ```\n * @param tools\n * @returns a string of all tools and their descriptions\n */\nexport declare function renderTextDescription(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n/**\n * Render the tool name, description, and args in plain text.\n * Output will be in the format of:'\n * ```\n * search: This tool is used for search, args: {\"query\": {\"type\": \"string\"}}\n * calculator: This tool is used for math,\n * args: {\"expression\": {\"type\": \"string\"}}\n * ```\n * @param tools\n * @returns a string of all tools, their descriptions and a stringified version of their schemas\n */\nexport declare function renderTextDescriptionAndArgs(tools: StructuredToolInterface[] | ToolDefinition[]): string;\n//# sourceMappingURL=render.d.ts.map"],"mappings":";;;;;;;AAaA;AAYA;;;;;;;;iBAZwBE,qBAAAA,QAA6BF,4BAA4BC;;;;;;;;;;;;iBAYzDE,4BAAAA,QAAoCH,4BAA4BC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"requests.d.cts","names":["Tool","Headers","RequestTool","RequestsGetTool","maxOutputLength","Promise","RequestsPostTool"],"sources":["../../src/tools/requests.d.ts"],"sourcesContent":["import { Tool } from \"@langchain/core/tools\";\nexport interface Headers {\n    [key: string]: string;\n}\n/**\n * Interface for HTTP request tools. Contains properties for headers and\n * maximum output length.\n */\nexport interface RequestTool {\n    headers: Headers;\n    maxOutputLength: number;\n}\n/**\n * Class for making GET requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a URL string, and the\n * output will be the text response of the GET request.\n */\nexport declare class RequestsGetTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * Class for making POST requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a JSON string with two\n * keys: 'url' and 'data'. The output will be the text response of the\n * POST request.\n */\nexport declare class RequestsPostTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n//# sourceMappingURL=requests.d.ts.map"],"mappings":";;;UACiBC,OAAAA;;AAAjB;AAOA;AASA;;;AAKqCG,UAdpBF,WAAAA,CAcoBE;EAIXC,OAAAA,EAjBbJ,OAiBaI;EATmBL,eAAAA,EAAAA,MAAAA;;AAA2B;AAkBxE;;;;AAS0BK,cA3BLF,eAAAA,SAAwBH,IAAAA,YAAgBE,WA2BnCG,CAAAA;EAToBL,OAAAA,EAjBjCC,OAiBiCD;EAAgBE,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,IAAA,EAAA,MAAA;;wBAb/CD;;;;;;wBAIAI;;;;;;;;;cASLC,gBAAAA,SAAyBN,IAAAA,YAAgBE;WACjDD;;;;wBAIaA;;;;;;wBAIAI"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"requests.d.ts","names":["Tool","Headers","RequestTool","RequestsGetTool","maxOutputLength","Promise","RequestsPostTool"],"sources":["../../src/tools/requests.d.ts"],"sourcesContent":["import { Tool } from \"@langchain/core/tools\";\nexport interface Headers {\n    [key: string]: string;\n}\n/**\n * Interface for HTTP request tools. Contains properties for headers and\n * maximum output length.\n */\nexport interface RequestTool {\n    headers: Headers;\n    maxOutputLength: number;\n}\n/**\n * Class for making GET requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a URL string, and the\n * output will be the text response of the GET request.\n */\nexport declare class RequestsGetTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * Class for making POST requests. Extends the Tool class and implements\n * the RequestTool interface. The input should be a JSON string with two\n * keys: 'url' and 'data'. The output will be the text response of the\n * POST request.\n */\nexport declare class RequestsPostTool extends Tool implements RequestTool {\n    headers: Headers;\n    static lc_name(): string;\n    name: string;\n    maxOutputLength: number;\n    constructor(headers?: Headers, { maxOutputLength }?: {\n        maxOutputLength?: number;\n    });\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n//# sourceMappingURL=requests.d.ts.map"],"mappings":";;;UACiBC,OAAAA;;AAAjB;AAOA;AASA;;;AAKqCG,UAdpBF,WAAAA,CAcoBE;EAIXC,OAAAA,EAjBbJ,OAiBaI;EATmBL,eAAAA,EAAAA,MAAAA;;AAA2B;AAkBxE;;;;AAS0BK,cA3BLF,eAAAA,SAAwBH,IAAAA,YAAgBE,WA2BnCG,CAAAA;EAToBL,OAAAA,EAjBjCC,OAiBiCD;EAAgBE,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,IAAA,EAAA,MAAA;;wBAb/CD;;;;;;wBAIAI;;;;;;;;;cASLC,gBAAAA,SAAyBN,IAAAA,YAAgBE;WACjDD;;;;wBAIaA;;;;;;wBAIAI"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.d.cts","names":["BaseRetrieverInterface","z","DynamicStructuredTool","DynamicStructuredToolInput","createRetrieverTool","Omit","ZodString","ZodTypeAny","ZodObject"],"sources":["../../src/tools/retriever.d.ts"],"sourcesContent":["import type { BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { z } from \"zod/v3\";\nimport { DynamicStructuredTool, type DynamicStructuredToolInput } from \"@langchain/core/tools\";\nexport declare function createRetrieverTool(retriever: BaseRetrieverInterface, input: Omit<DynamicStructuredToolInput, \"func\" | \"schema\">): DynamicStructuredTool<z.ZodObject<{\n    query: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    query: string;\n}, {\n    query: string;\n}>, {\n    query: string;\n}, {\n    query: string;\n}, string>;\n//# sourceMappingURL=retriever.d.ts.map"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAYJ,KAAAA,EAAAA,MAAAA;CAAoCG,EAAAA;EAALE,KAAAA,EAAAA,MAAAA;CAC3EJ,CAAAA,EAAEK;EACCC,KAAAA,EAAAA,MAAAA;CAFoJN,EAAEO;EAAxBN,KAAAA,EAAAA,MAAAA;AAAqB,CAAA,EAAA,MAAA,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"retriever.d.ts","names":["BaseRetrieverInterface","z","DynamicStructuredTool","DynamicStructuredToolInput","createRetrieverTool","Omit","ZodString","ZodTypeAny","ZodObject"],"sources":["../../src/tools/retriever.d.ts"],"sourcesContent":["import type { BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { z } from \"zod/v3\";\nimport { DynamicStructuredTool, type DynamicStructuredToolInput } from \"@langchain/core/tools\";\nexport declare function createRetrieverTool(retriever: BaseRetrieverInterface, input: Omit<DynamicStructuredToolInput, \"func\" | \"schema\">): DynamicStructuredTool<z.ZodObject<{\n    query: z.ZodString;\n}, \"strip\", z.ZodTypeAny, {\n    query: string;\n}, {\n    query: string;\n}>, {\n    query: string;\n}, {\n    query: string;\n}, string>;\n//# sourceMappingURL=retriever.d.ts.map"],"mappings":";;;;;iBAGwBI,mBAAAA,YAA+BJ,+BAA+BK,KAAKF,iDAAiDD,sBAAsBD,CAAAA,CAAEO;SACzJP,CAAAA,CAAEK;AADb,CAAA,EAAA,OAAwBF,EAEZH,CAAAA,CAAEM,UAFUH,EAAmB;EAAYJ,KAAAA,EAAAA,MAAAA;CAAoCG,EAAAA;EAALE,KAAAA,EAAAA,MAAAA;CAC3EJ,CAAAA,EAAEK;EACCC,KAAAA,EAAAA,MAAAA;CAFoJN,EAAEO;EAAxBN,KAAAA,EAAAA,MAAAA;AAAqB,CAAA,EAAA,MAAA,CAAA"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.cts","names":["BaseLanguageModelInterface","Tool","LLMChain","SqlDatabase","SqlTool","QuerySqlTool","Promise","InfoSqlTool","ListTablesSqlTool","QueryCheckerToolArgs","QueryCheckerTool"],"sources":["../../src/tools/sql.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { SqlDatabase } from \"../sql_db.js\";\n/**\n * Interface for SQL tools. It has a `db` property which is a SQL\n * database.\n */\ninterface SqlTool {\n    db: SqlDatabase;\n}\n/**\n * A tool for executing SQL queries. It takes a SQL database as a\n * parameter and assigns it to the `db` property. The `_call` method is\n * used to run the SQL query and return the result. If the query is\n * incorrect, an error message is returned.\n */\nexport declare class QuerySqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for retrieving information about SQL tables. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to retrieve the schema and sample rows for the\n * specified tables. If the tables do not exist, an error message is\n * returned.\n */\nexport declare class InfoSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for listing all tables in a SQL database. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to return a comma-separated list of all tables\n * in the database.\n */\nexport declare class ListTablesSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    _call(_: string): Promise<string>;\n    description: string;\n}\n/**\n * Arguments for the QueryCheckerTool class.\n */\ntype QueryCheckerToolArgs = {\n    llmChain?: LLMChain;\n    llm: BaseLanguageModelInterface;\n    _chainType?: never;\n};\n/**\n * A tool for checking SQL queries for common mistakes. It takes a\n * LLMChain or QueryCheckerToolArgs as a parameter. The `_call` method is\n * used to check the input query for common mistakes and returns a\n * prediction.\n */\nexport declare class QueryCheckerTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    template: string;\n    llmChain: LLMChain;\n    constructor(llmChainOrOptions?: LLMChain | QueryCheckerToolArgs);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\nexport {};\n//# sourceMappingURL=sql.d.ts.map"],"mappings":";;;;;;;;;AAGgD;AAchD;UATUI,OAAAA,CAYFD;EACYA,EAAAA,EAZZA,WAYYA;;;;AAJ6C;AAgBjE;;;AAM0BG,cAtBLD,YAAAA,SAAqBJ,IAAAA,YAAgBG,OAsBhCE,CAAAA;EANeL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAgBG,IAAAA,EAAAA,MAAAA;EAAO,EAAA,EAbxDD,WAawD;EAe3CK,WAAAA,CAAAA,EAAAA,EA3BDL,WA2BkB;EAG9BA;EACYA,KAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EA7BMG,OA6BNH,CAAAA,MAAAA,CAAAA;EACEG,WAAAA,EAAAA,MAAAA;;;AALgD;AAOrE;AAeD;;;;AAO0BA,cA5CLC,WAAAA,SAAoBN,IAAAA,YAAgBG,OA4C/BE,CAAAA;EAPoBL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,IAAA,EAAA,MAAA;MAlC1CE;kBACYA;;wBAEMG;;;;;;;;;cASLE,iBAAAA,SAA0BP,IAAAA,YAAgBG;;;MAGvDD;kBACYA;oBACEG;;;;;;KAMjBG,oBAAAA;aACUP;OACNF;;;;;;;;;cASYU,gBAAAA,SAAyBT,IAAAA;;;;YAIhCC;kCACsBA,WAAWO;;wBAErBH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","names":["BaseLanguageModelInterface","Tool","LLMChain","SqlDatabase","SqlTool","QuerySqlTool","Promise","InfoSqlTool","ListTablesSqlTool","QueryCheckerToolArgs","QueryCheckerTool"],"sources":["../../src/tools/sql.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { SqlDatabase } from \"../sql_db.js\";\n/**\n * Interface for SQL tools. It has a `db` property which is a SQL\n * database.\n */\ninterface SqlTool {\n    db: SqlDatabase;\n}\n/**\n * A tool for executing SQL queries. It takes a SQL database as a\n * parameter and assigns it to the `db` property. The `_call` method is\n * used to run the SQL query and return the result. If the query is\n * incorrect, an error message is returned.\n */\nexport declare class QuerySqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for retrieving information about SQL tables. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to retrieve the schema and sample rows for the\n * specified tables. If the tables do not exist, an error message is\n * returned.\n */\nexport declare class InfoSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\n/**\n * A tool for listing all tables in a SQL database. It takes a SQL\n * database as a parameter and assigns it to the `db` property. The\n * `_call` method is used to return a comma-separated list of all tables\n * in the database.\n */\nexport declare class ListTablesSqlTool extends Tool implements SqlTool {\n    static lc_name(): string;\n    name: string;\n    db: SqlDatabase;\n    constructor(db: SqlDatabase);\n    _call(_: string): Promise<string>;\n    description: string;\n}\n/**\n * Arguments for the QueryCheckerTool class.\n */\ntype QueryCheckerToolArgs = {\n    llmChain?: LLMChain;\n    llm: BaseLanguageModelInterface;\n    _chainType?: never;\n};\n/**\n * A tool for checking SQL queries for common mistakes. It takes a\n * LLMChain or QueryCheckerToolArgs as a parameter. The `_call` method is\n * used to check the input query for common mistakes and returns a\n * prediction.\n */\nexport declare class QueryCheckerTool extends Tool {\n    static lc_name(): string;\n    name: string;\n    template: string;\n    llmChain: LLMChain;\n    constructor(llmChainOrOptions?: LLMChain | QueryCheckerToolArgs);\n    /** @ignore */\n    _call(input: string): Promise<string>;\n    description: string;\n}\nexport {};\n//# sourceMappingURL=sql.d.ts.map"],"mappings":";;;;;;;;;AAGgD;AAchD;UATUI,OAAAA,CAYFD;EACYA,EAAAA,EAZZA,WAYYA;;;;AAJ6C;AAgBjE;;;AAM0BG,cAtBLD,YAAAA,SAAqBJ,IAAAA,YAAgBG,OAsBhCE,CAAAA;EANeL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAgBG,IAAAA,EAAAA,MAAAA;EAAO,EAAA,EAbxDD,WAawD;EAe3CK,WAAAA,CAAAA,EAAAA,EA3BDL,WA2BkB;EAG9BA;EACYA,KAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EA7BMG,OA6BNH,CAAAA,MAAAA,CAAAA;EACEG,WAAAA,EAAAA,MAAAA;;;AALgD;AAOrE;AAeD;;;;AAO0BA,cA5CLC,WAAAA,SAAoBN,IAAAA,YAAgBG,OA4C/BE,CAAAA;EAPoBL,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,IAAA,EAAA,MAAA;MAlC1CE;kBACYA;;wBAEMG;;;;;;;;;cASLE,iBAAAA,SAA0BP,IAAAA,YAAgBG;;;MAGvDD;kBACYA;oBACEG;;;;;;KAMjBG,oBAAAA;aACUP;OACNF;;;;;;;;;cASYU,gBAAAA,SAAyBT,IAAAA;;;;YAIhCC;kCACsBA,WAAWO;;wBAErBH"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"vectorstore.d.cts","names":["BaseLanguageModelInterface","VectorStoreInterface","Tool","VectorDBQAChain","VectorStoreTool","VectorStoreQATool","Promise"],"sources":["../../src/tools/vectorstore.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { VectorDBQAChain } from \"../chains/vector_db_qa.js\";\n/**\n * Interface for tools that interact with a Vector Store.\n */\ninterface VectorStoreTool {\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n}\n/**\n * A tool for the VectorDBQA chain to interact with a Vector Store. It is\n * used to answer questions about a specific topic. The input to this tool\n * should be a fully formed question.\n */\nexport declare class VectorStoreQATool extends Tool implements VectorStoreTool {\n    static lc_name(): string;\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n    name: string;\n    description: string;\n    chain: VectorDBQAChain;\n    constructor(name: string, description: string, fields: VectorStoreTool);\n    /**\n     * Returns a string that describes what the tool does.\n     * @param name The name of the tool.\n     * @param description A description of what the tool does.\n     * @returns A string that describes what the tool does.\n     */\n    static getDescription(name: string, description: string): string;\n    /** @ignore */\n    _call(input: string): Promise<string>;\n}\nexport {};\n//# sourceMappingURL=vectorstore.d.ts.map"],"mappings":";;;;;;;;;AAG4D;AAa5D,UATUI,eAAAA,CAS4B;EAErBH,WAAAA,EAVAA,oBAUAA;EACRD,GAAAA,EAVAA,0BAUAA;;;;;;AAHqE;cAAzDK,iBAAAA,SAA0BH,IAAAA,YAAgBE;;eAE9CH;OACRD;;;SAGEG;yDACgDC;;;;;;;;;wBASjCE"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"vectorstore.d.ts","names":["BaseLanguageModelInterface","VectorStoreInterface","Tool","VectorDBQAChain","VectorStoreTool","VectorStoreQATool","Promise"],"sources":["../../src/tools/vectorstore.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Tool } from \"@langchain/core/tools\";\nimport { VectorDBQAChain } from \"../chains/vector_db_qa.js\";\n/**\n * Interface for tools that interact with a Vector Store.\n */\ninterface VectorStoreTool {\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n}\n/**\n * A tool for the VectorDBQA chain to interact with a Vector Store. It is\n * used to answer questions about a specific topic. The input to this tool\n * should be a fully formed question.\n */\nexport declare class VectorStoreQATool extends Tool implements VectorStoreTool {\n    static lc_name(): string;\n    vectorStore: VectorStoreInterface;\n    llm: BaseLanguageModelInterface;\n    name: string;\n    description: string;\n    chain: VectorDBQAChain;\n    constructor(name: string, description: string, fields: VectorStoreTool);\n    /**\n     * Returns a string that describes what the tool does.\n     * @param name The name of the tool.\n     * @param description A description of what the tool does.\n     * @returns A string that describes what the tool does.\n     */\n    static getDescription(name: string, description: string): string;\n    /** @ignore */\n    _call(input: string): Promise<string>;\n}\nexport {};\n//# sourceMappingURL=vectorstore.d.ts.map"],"mappings":";;;;;;;;;AAG4D;AAa5D,UATUI,eAAAA,CAS4B;EAErBH,WAAAA,EAVAA,oBAUAA;EACRD,GAAAA,EAVAA,0BAUAA;;;;;;AAHqE;cAAzDK,iBAAAA,SAA0BH,IAAAA,YAAgBE;;eAE9CH;OACRD;;;SAGEG;yDACgDC;;;;;;;;;wBASjCE"}

package/dist/tools/webbrowser.d.cts

@@ -7,7 +7,6 @@ import { EmbeddingsInterface } from "@langchain/core/embeddings";
 //#region src/tools/webbrowser.d.ts
 declare const parseInputs: (inputs: string) => [string, string];
 declare const getText: (html: string, baseUrl: string, summary: boolean) => string;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Headers = Record<string, any>;
 /**
  * Configuration options for fetch requests, similar to axios config but for fetch

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

@@ -0,0 +1 @@
+{"version":3,"file":"webbrowser.d.cts","names":["BaseLanguageModelInterface","EmbeddingsInterface","CallbackManager","CallbackManagerForToolRun","Tool","ToolParams","TextSplitter","parseInputs","getText","Headers","Record","RequestConfig","RequestInit","Omit","WebBrowserArgs","WebBrowser","model","headers","embeddings","requestConfig","textSplitter","Promise"],"sources":["../../src/tools/webbrowser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { CallbackManager, CallbackManagerForToolRun } from \"@langchain/core/callbacks/manager\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nimport { TextSplitter } from \"@langchain/textsplitters\";\nexport declare const parseInputs: (inputs: string) => [string, string];\nexport declare const getText: (html: string, baseUrl: string, summary: boolean) => string;\ntype Headers = Record<string, any>;\n/**\n * Configuration options for fetch requests, similar to axios config but for fetch\n */\nexport interface RequestConfig extends Omit<RequestInit, \"headers\"> {\n    withCredentials?: boolean;\n}\n/**\n * Defines the arguments that can be passed to the WebBrowser constructor.\n * It extends the ToolParams interface and includes properties for a\n * language model, embeddings, HTTP headers, an Axios configuration, a\n * callback manager, and a text splitter.\n */\nexport interface WebBrowserArgs extends ToolParams {\n    model: BaseLanguageModelInterface;\n    embeddings: EmbeddingsInterface;\n    headers?: Headers;\n    requestConfig?: RequestConfig;\n    /** @deprecated */\n    callbackManager?: CallbackManager;\n    textSplitter?: TextSplitter;\n}\n/**\n * A class designed to interact with web pages, either to extract\n * information from them or to summarize their content. It uses the native\n * fetch API to send HTTP requests and the cheerio library to parse the\n * returned HTML.\n * @example\n * ```typescript\n * const browser = new WebBrowser({\n *   model: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   embeddings: new OpenAIEmbeddings({}),\n * });\n * const result = await browser.invoke(\"https:exampleurl.com\");\n * ```\n */\nexport declare class WebBrowser extends Tool {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    private model;\n    private embeddings;\n    private headers;\n    private requestConfig;\n    private textSplitter;\n    constructor({ model, headers, embeddings, requestConfig, textSplitter }: WebBrowserArgs);\n    /** @ignore */\n    _call(inputs: string, runManager?: CallbackManagerForToolRun): Promise<string>;\n    name: string;\n    description: string;\n}\nexport {};\n//# sourceMappingURL=webbrowser.d.ts.map"],"mappings":";;;;;;;cAKqBO;cACAC;AADrB,KAEKC,OAAAA,GAAUC,MAFuD,CAAA,MAAA,EAAA,GAAA,CAAA;AACtE;AAA0F;AAK1F;AASiBI,UATAH,aAAAA,SAAsBE,IASR,CATaD,WASb,EAAA,SAAA,CAAA,CAAA;EACpBZ,eAAAA,CAAAA,EAAAA,OAAAA;;;;;;;AADuC;AAuB7Be,UAvBJD,cAAAA,SAAuBT,UAuBT,CAAA;EAQbW,KAAAA,EA9BPhB,0BA8BOgB;EAAOC,UAAAA,EA7BThB,mBA6BSgB;EAASC,OAAAA,CAAAA,EA5BpBT,OA4BoBS;EAAYC,aAAAA,CAAAA,EA3B1BR,aA2B0BQ;EAAeC;EAAgBN,eAAAA,CAAAA,EAzBvDZ,eAyBuDY;EAEtCX,YAAAA,CAAAA,EA1BpBG,YA0BoBH;;;AAVK;;;;;;;;;;;;;cAAvBY,UAAAA,SAAmBX,IAAAA;;;;;;;;;;;;;;KAQqCU;;qCAEtCX,4BAA4BkB"}

package/dist/tools/webbrowser.d.ts

@@ -7,7 +7,6 @@ import { EmbeddingsInterface } from "@langchain/core/embeddings";
 //#region src/tools/webbrowser.d.ts
 declare const parseInputs: (inputs: string) => [string, string];
 declare const getText: (html: string, baseUrl: string, summary: boolean) => string;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Headers = Record<string, any>;
 /**
  * Configuration options for fetch requests, similar to axios config but for fetch

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

@@ -0,0 +1 @@
+{"version":3,"file":"webbrowser.d.ts","names":["BaseLanguageModelInterface","EmbeddingsInterface","CallbackManager","CallbackManagerForToolRun","Tool","ToolParams","TextSplitter","parseInputs","getText","Headers","Record","RequestConfig","RequestInit","Omit","WebBrowserArgs","WebBrowser","model","headers","embeddings","requestConfig","textSplitter","Promise"],"sources":["../../src/tools/webbrowser.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { CallbackManager, CallbackManagerForToolRun } from \"@langchain/core/callbacks/manager\";\nimport { Tool, ToolParams } from \"@langchain/core/tools\";\nimport { TextSplitter } from \"@langchain/textsplitters\";\nexport declare const parseInputs: (inputs: string) => [string, string];\nexport declare const getText: (html: string, baseUrl: string, summary: boolean) => string;\ntype Headers = Record<string, any>;\n/**\n * Configuration options for fetch requests, similar to axios config but for fetch\n */\nexport interface RequestConfig extends Omit<RequestInit, \"headers\"> {\n    withCredentials?: boolean;\n}\n/**\n * Defines the arguments that can be passed to the WebBrowser constructor.\n * It extends the ToolParams interface and includes properties for a\n * language model, embeddings, HTTP headers, an Axios configuration, a\n * callback manager, and a text splitter.\n */\nexport interface WebBrowserArgs extends ToolParams {\n    model: BaseLanguageModelInterface;\n    embeddings: EmbeddingsInterface;\n    headers?: Headers;\n    requestConfig?: RequestConfig;\n    /** @deprecated */\n    callbackManager?: CallbackManager;\n    textSplitter?: TextSplitter;\n}\n/**\n * A class designed to interact with web pages, either to extract\n * information from them or to summarize their content. It uses the native\n * fetch API to send HTTP requests and the cheerio library to parse the\n * returned HTML.\n * @example\n * ```typescript\n * const browser = new WebBrowser({\n *   model: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0 }),\n *   embeddings: new OpenAIEmbeddings({}),\n * });\n * const result = await browser.invoke(\"https:exampleurl.com\");\n * ```\n */\nexport declare class WebBrowser extends Tool {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    private model;\n    private embeddings;\n    private headers;\n    private requestConfig;\n    private textSplitter;\n    constructor({ model, headers, embeddings, requestConfig, textSplitter }: WebBrowserArgs);\n    /** @ignore */\n    _call(inputs: string, runManager?: CallbackManagerForToolRun): Promise<string>;\n    name: string;\n    description: string;\n}\nexport {};\n//# sourceMappingURL=webbrowser.d.ts.map"],"mappings":";;;;;;;cAKqBO;cACAC;AADrB,KAEKC,OAAAA,GAAUC,MAFuD,CAAA,MAAA,EAAA,GAAA,CAAA;AACtE;AAA0F;AAK1F;AASiBI,UATAH,aAAAA,SAAsBE,IASR,CATaD,WASb,EAAA,SAAA,CAAA,CAAA;EACpBZ,eAAAA,CAAAA,EAAAA,OAAAA;;;;;;;AADuC;AAuB7Be,UAvBJD,cAAAA,SAAuBT,UAuBT,CAAA;EAQbW,KAAAA,EA9BPhB,0BA8BOgB;EAAOC,UAAAA,EA7BThB,mBA6BSgB;EAASC,OAAAA,CAAAA,EA5BpBT,OA4BoBS;EAAYC,aAAAA,CAAAA,EA3B1BR,aA2B0BQ;EAAeC;EAAgBN,eAAAA,CAAAA,EAzBvDZ,eAyBuDY;EAEtCX,YAAAA,CAAAA,EA1BpBG,YA0BoBH;;;AAVK;;;;;;;;;;;;;cAAvBY,UAAAA,SAAmBX,IAAAA;;;;;;;;;;;;;;KAQqCU;;qCAEtCX,4BAA4BkB"}

package/dist/types/expression-parser.d.cts

@@ -2,15 +2,12 @@
 interface ParseOptions {
   filename?: string;
   startRule?: "Start";
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   tracer?: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [key: string]: any;
 }
 type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {
   startRule: infer StartRule;
 } ? StartRule extends "Start" ? Start : Start : Start;
-// These types were autogenerated by ts-pegjs
 type Start = Program;
 type Identifier = IdentifierName;
 type IdentifierName = {

package/dist/types/expression-parser.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-parser.d.cts","names":["ParseOptions","ParseFunction","Options","StartRule","Start","Program","Identifier","IdentifierName","Literal","NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","DecimalLiteral","PrimaryExpression","ArrayExpression","ObjectExpression","Expression","ElementList","PropertyNameAndValueList","PropertyAssignment","PropertyName","MemberExpression","CallExpression","Arguments","ExpressionStatement","ExpressionNode"],"sources":["../../src/types/expression-parser.d.ts"],"sourcesContent":["export interface ParseOptions {\n    filename?: string;\n    startRule?: \"Start\";\n    tracer?: any;\n    [key: string]: any;\n}\nexport type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {\n    startRule: infer StartRule;\n} ? StartRule extends \"Start\" ? Start : Start : Start;\nexport type Start = Program;\nexport type Identifier = IdentifierName;\nexport type IdentifierName = {\n    type: \"Identifier\";\n    name: string;\n};\nexport type Literal = NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral;\nexport type NullLiteral = {\n    type: \"NullLiteral\";\n    value: null;\n};\nexport type BooleanLiteral = {\n    type: \"BooleanLiteral\";\n    value: true;\n} | {\n    type: \"BooleanLiteral\";\n    value: false;\n};\nexport type NumericLiteral = DecimalLiteral;\nexport type DecimalLiteral = {\n    type: \"NumericLiteral\";\n    value: number;\n};\nexport type StringLiteral = {\n    type: \"StringLiteral\";\n    value: string;\n};\nexport type PrimaryExpression = Identifier | Literal | ArrayExpression | ObjectExpression | Expression;\nexport type ArrayExpression = {\n    type: \"ArrayExpression\";\n    elements: ElementList;\n};\nexport type ElementList = PrimaryExpression[];\nexport type ObjectExpression = {\n    type: \"ObjectExpression\";\n    properties: [];\n} | {\n    type: \"ObjectExpression\";\n    properties: PropertyNameAndValueList;\n};\nexport type PropertyNameAndValueList = PrimaryExpression[];\nexport type PropertyAssignment = {\n    type: \"PropertyAssignment\";\n    key: PropertyName;\n    value: Expression;\n    kind: \"init\";\n};\nexport type PropertyName = IdentifierName | StringLiteral | NumericLiteral;\nexport type MemberExpression = {\n    type: \"MemberExpression\";\n    property: StringLiteral;\n    computed: true;\n    object: MemberExpression | Identifier | StringLiteral;\n} | {\n    type: \"MemberExpression\";\n    property: Identifier;\n    computed: false;\n    object: MemberExpression | Identifier | StringLiteral;\n};\nexport type CallExpression = {\n    type: \"CallExpression\";\n    arguments: Arguments;\n    callee: MemberExpression | Identifier;\n};\nexport type Arguments = PrimaryExpression[];\nexport type Expression = CallExpression | MemberExpression;\nexport type ExpressionStatement = {\n    type: \"ExpressionStatement\";\n    expression: Expression;\n};\nexport type Program = {\n    type: \"Program\";\n    body: ExpressionStatement;\n};\nexport type ExpressionNode = Program | ExpressionStatement | ArrayExpression | BooleanLiteral | CallExpression | Identifier | MemberExpression | NumericLiteral | ObjectExpression | PropertyAssignment | NullLiteral | StringLiteral;\n//# sourceMappingURL=expression-parser.d.ts.map"],"mappings":"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"}

package/dist/types/expression-parser.d.ts

@@ -2,15 +2,12 @@
 interface ParseOptions {
   filename?: string;
   startRule?: "Start";
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   tracer?: any;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [key: string]: any;
 }
 type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {
   startRule: infer StartRule;
 } ? StartRule extends "Start" ? Start : Start : Start;
-// These types were autogenerated by ts-pegjs
 type Start = Program;
 type Identifier = IdentifierName;
 type IdentifierName = {

package/dist/types/expression-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-parser.d.ts","names":["ParseOptions","ParseFunction","Options","StartRule","Start","Program","Identifier","IdentifierName","Literal","NullLiteral","BooleanLiteral","NumericLiteral","StringLiteral","DecimalLiteral","PrimaryExpression","ArrayExpression","ObjectExpression","Expression","ElementList","PropertyNameAndValueList","PropertyAssignment","PropertyName","MemberExpression","CallExpression","Arguments","ExpressionStatement","ExpressionNode"],"sources":["../../src/types/expression-parser.d.ts"],"sourcesContent":["export interface ParseOptions {\n    filename?: string;\n    startRule?: \"Start\";\n    tracer?: any;\n    [key: string]: any;\n}\nexport type ParseFunction = <Options extends ParseOptions>(input: string, options?: Options) => Options extends {\n    startRule: infer StartRule;\n} ? StartRule extends \"Start\" ? Start : Start : Start;\nexport type Start = Program;\nexport type Identifier = IdentifierName;\nexport type IdentifierName = {\n    type: \"Identifier\";\n    name: string;\n};\nexport type Literal = NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral;\nexport type NullLiteral = {\n    type: \"NullLiteral\";\n    value: null;\n};\nexport type BooleanLiteral = {\n    type: \"BooleanLiteral\";\n    value: true;\n} | {\n    type: \"BooleanLiteral\";\n    value: false;\n};\nexport type NumericLiteral = DecimalLiteral;\nexport type DecimalLiteral = {\n    type: \"NumericLiteral\";\n    value: number;\n};\nexport type StringLiteral = {\n    type: \"StringLiteral\";\n    value: string;\n};\nexport type PrimaryExpression = Identifier | Literal | ArrayExpression | ObjectExpression | Expression;\nexport type ArrayExpression = {\n    type: \"ArrayExpression\";\n    elements: ElementList;\n};\nexport type ElementList = PrimaryExpression[];\nexport type ObjectExpression = {\n    type: \"ObjectExpression\";\n    properties: [];\n} | {\n    type: \"ObjectExpression\";\n    properties: PropertyNameAndValueList;\n};\nexport type PropertyNameAndValueList = PrimaryExpression[];\nexport type PropertyAssignment = {\n    type: \"PropertyAssignment\";\n    key: PropertyName;\n    value: Expression;\n    kind: \"init\";\n};\nexport type PropertyName = IdentifierName | StringLiteral | NumericLiteral;\nexport type MemberExpression = {\n    type: \"MemberExpression\";\n    property: StringLiteral;\n    computed: true;\n    object: MemberExpression | Identifier | StringLiteral;\n} | {\n    type: \"MemberExpression\";\n    property: Identifier;\n    computed: false;\n    object: MemberExpression | Identifier | StringLiteral;\n};\nexport type CallExpression = {\n    type: \"CallExpression\";\n    arguments: Arguments;\n    callee: MemberExpression | Identifier;\n};\nexport type Arguments = PrimaryExpression[];\nexport type Expression = CallExpression | MemberExpression;\nexport type ExpressionStatement = {\n    type: \"ExpressionStatement\";\n    expression: Expression;\n};\nexport type Program = {\n    type: \"Program\";\n    body: ExpressionStatement;\n};\nexport type ExpressionNode = Program | ExpressionStatement | ArrayExpression | BooleanLiteral | CallExpression | Identifier | MemberExpression | NumericLiteral | ObjectExpression | PropertyAssignment | NullLiteral | StringLiteral;\n//# sourceMappingURL=expression-parser.d.ts.map"],"mappings":"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"}

package/dist/types/type-utils.d.cts

@@ -1,6 +1,4 @@
 //#region src/types/type-utils.d.ts
-// Utility for marking only some keys of an interface as optional
-// Compare to Partial<T> which marks all keys as optional
 type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 //#endregion
 export { Optional };

package/dist/types/type-utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.cts","names":["Optional","T","K","Omit","Pick","Partial"],"sources":["../../src/types/type-utils.d.ts"],"sourcesContent":["export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n//# sourceMappingURL=type-utils.d.ts.map"],"mappings":";KAAYA,4BAA4BC,KAAKE,KAAKF,GAAGC,KAAKG,QAAQD,KAAKH,GAAGC"}

package/dist/types/type-utils.d.ts

@@ -1,6 +1,4 @@
 //#region src/types/type-utils.d.ts
-// Utility for marking only some keys of an interface as optional
-// Compare to Partial<T> which marks all keys as optional
 type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 //#endregion
 export { Optional };

package/dist/types/type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.ts","names":["Optional","T","K","Omit","Pick","Partial"],"sources":["../../src/types/type-utils.d.ts"],"sourcesContent":["export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;\n//# sourceMappingURL=type-utils.d.ts.map"],"mappings":";KAAYA,4BAA4BC,KAAKE,KAAKF,GAAGC,KAAKG,QAAQD,KAAKH,GAAGC"}

package/dist/util/document.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.cts","names":["Document","formatDocumentsAsString","Record"],"sources":["../../src/util/document.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\n/**\n * Given a list of documents, this util formats their contents\n * into a string, separated by newlines.\n *\n * @param documents\n * @returns A string of the documents page content, separated by newlines.\n */\nexport declare const formatDocumentsAsString: (documents: Document<Record<string, any>>[]) => string;\n//# sourceMappingURL=document.d.ts.map"],"mappings":";;;;;;AAQA;;;;;cAAqBC,qCAAqCD,SAASE"}

package/dist/util/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","names":["Document","formatDocumentsAsString","Record"],"sources":["../../src/util/document.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\n/**\n * Given a list of documents, this util formats their contents\n * into a string, separated by newlines.\n *\n * @param documents\n * @returns A string of the documents page content, separated by newlines.\n */\nexport declare const formatDocumentsAsString: (documents: Document<Record<string, any>>[]) => string;\n//# sourceMappingURL=document.d.ts.map"],"mappings":";;;;;;AAQA;;;;;cAAqBC,qCAAqCD,SAASE"}

package/dist/util/hub.cjs

@@ -1,6 +1,6 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('./p-retry/index.cjs');
 const require_extname = require('./extname.cjs');
-const p_retry = require_rolldown_runtime.__toESM(require("p-retry"));
 const __langchain_core_utils_env = require_rolldown_runtime.__toESM(require("@langchain/core/utils/env"));
 
 //#region src/util/hub.ts
@@ -29,7 +29,7 @@ const loadFromHub = async (uri, loader, validPrefix, validSuffixes, values = {})
 		ref,
 		remotePath
 	].join("/");
-	const res = await (0, p_retry.default)(() => fetchWithTimeout(url, { timeout: 5e3 }), { retries: 6 });
+	const res = await require_index.pRetry(() => fetchWithTimeout(url, { timeout: 5e3 }), { retries: 6 });
 	if (res.status !== 200) throw new Error(`Could not find file at ${url}`);
 	return loader(await res.text(), remotePath, values);
 };

package/dist/util/hub.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hub.cjs","names":["url: string","init: Omit<RequestInit, \"signal\"> & { timeout: number }","uri: string","loader: FileLoader<T>","validPrefix: string","validSuffixes: Set<string>","values: LoadValues","extname"],"sources":["../../src/util/hub.ts"],"sourcesContent":["import pRetry from \"p-retry\";\n\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { FileLoader, LoadValues } from \"./load.js\";\nimport { extname } from \"./extname.js\";\n\nconst fetchWithTimeout = async (\n  url: string,\n  init: Omit<RequestInit, \"signal\"> & { timeout: number }\n) => {\n  const { timeout, ...rest } = init;\n  const res = await fetch(url, {\n    ...rest,\n    signal: AbortSignal.timeout(timeout),\n  });\n  return res;\n};\n\nconst HUB_PATH_REGEX = /lc(@[^:]+)?:\\/\\/(.*)/;\n\nconst URL_PATH_SEPARATOR = \"/\";\n\nexport const loadFromHub = async <T>(\n  uri: string,\n  loader: FileLoader<T>,\n  validPrefix: string,\n  validSuffixes: Set<string>,\n  values: LoadValues = {}\n): Promise<T | undefined> => {\n  const LANGCHAIN_HUB_DEFAULT_REF =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_DEFAULT_REF\") ?? \"master\";\n  const LANGCHAIN_HUB_URL_BASE =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_URL_BASE\") ??\n    \"https://raw.githubusercontent.com/hwchase17/langchain-hub/\";\n\n  const match = uri.match(HUB_PATH_REGEX);\n  if (!match) {\n    return undefined;\n  }\n  const [rawRef, remotePath] = match.slice(1);\n  const ref = rawRef ? rawRef.slice(1) : LANGCHAIN_HUB_DEFAULT_REF;\n  const parts = remotePath.split(URL_PATH_SEPARATOR);\n  if (parts[0] !== validPrefix) {\n    return undefined;\n  }\n\n  if (!validSuffixes.has(extname(remotePath).slice(1))) {\n    throw new Error(\"Unsupported file type.\");\n  }\n\n  const url = [LANGCHAIN_HUB_URL_BASE, ref, remotePath].join(\"/\");\n  const res = await pRetry(() => fetchWithTimeout(url, { timeout: 5000 }), {\n    retries: 6,\n  });\n  if (res.status !== 200) {\n    throw new Error(`Could not find file at ${url}`);\n  }\n\n  return loader(await res.text(), remotePath, values);\n};\n"],"mappings":";;;;;;AAMA,MAAM,mBAAmB,OACvBA,KACAC,SACG;CACH,MAAM,EAAE,QAAS,GAAG,MAAM,GAAG;CAC7B,MAAM,MAAM,MAAM,MAAM,KAAK;EAC3B,GAAG;EACH,QAAQ,YAAY,QAAQ,QAAQ;CACrC,EAAC;AACF,QAAO;AACR;AAED,MAAM,iBAAiB;AAEvB,MAAM,qBAAqB;AAE3B,MAAa,cAAc,OACzBC,KACAC,QACAC,aACAC,eACAC,SAAqB,CAAE,MACI;CAC3B,MAAM,mFACmB,4BAA4B,IAAI;CACzD,MAAM,gFACmB,yBAAyB,IAChD;CAEF,MAAM,QAAQ,IAAI,MAAM,eAAe;AACvC,KAAI,CAAC,MACH,QAAO;CAET,MAAM,CAAC,QAAQ,WAAW,GAAG,MAAM,MAAM,EAAE;CAC3C,MAAM,MAAM,SAAS,OAAO,MAAM,EAAE,GAAG;CACvC,MAAM,QAAQ,WAAW,MAAM,mBAAmB;AAClD,KAAI,MAAM,OAAO,YACf,QAAO;AAGT,KAAI,CAAC,cAAc,IAAIC,wBAAQ,WAAW,CAAC,MAAM,EAAE,CAAC,CAClD,OAAM,IAAI,MAAM;CAGlB,MAAM,MAAM;EAAC;EAAwB;EAAK;CAAW,EAAC,KAAK,IAAI;CAC/D,MAAM,MAAM,2BAAa,MAAM,iBAAiB,KAAK,EAAE,SAAS,IAAM,EAAC,EAAE,EACvE,SAAS,EACV,EAAC;AACF,KAAI,IAAI,WAAW,IACjB,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAE,KAAK;AAGjD,QAAO,OAAO,MAAM,IAAI,MAAM,EAAE,YAAY,OAAO;AACpD"}
+{"version":3,"file":"hub.cjs","names":["url: string","init: Omit<RequestInit, \"signal\"> & { timeout: number }","uri: string","loader: FileLoader<T>","validPrefix: string","validSuffixes: Set<string>","values: LoadValues","extname","pRetry"],"sources":["../../src/util/hub.ts"],"sourcesContent":["import pRetry from \"./p-retry/index.js\";\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { FileLoader, LoadValues } from \"./load.js\";\nimport { extname } from \"./extname.js\";\n\nconst fetchWithTimeout = async (\n  url: string,\n  init: Omit<RequestInit, \"signal\"> & { timeout: number }\n) => {\n  const { timeout, ...rest } = init;\n  const res = await fetch(url, {\n    ...rest,\n    signal: AbortSignal.timeout(timeout),\n  });\n  return res;\n};\n\nconst HUB_PATH_REGEX = /lc(@[^:]+)?:\\/\\/(.*)/;\n\nconst URL_PATH_SEPARATOR = \"/\";\n\nexport const loadFromHub = async <T>(\n  uri: string,\n  loader: FileLoader<T>,\n  validPrefix: string,\n  validSuffixes: Set<string>,\n  values: LoadValues = {}\n): Promise<T | undefined> => {\n  const LANGCHAIN_HUB_DEFAULT_REF =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_DEFAULT_REF\") ?? \"master\";\n  const LANGCHAIN_HUB_URL_BASE =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_URL_BASE\") ??\n    \"https://raw.githubusercontent.com/hwchase17/langchain-hub/\";\n\n  const match = uri.match(HUB_PATH_REGEX);\n  if (!match) {\n    return undefined;\n  }\n  const [rawRef, remotePath] = match.slice(1);\n  const ref = rawRef ? rawRef.slice(1) : LANGCHAIN_HUB_DEFAULT_REF;\n  const parts = remotePath.split(URL_PATH_SEPARATOR);\n  if (parts[0] !== validPrefix) {\n    return undefined;\n  }\n\n  if (!validSuffixes.has(extname(remotePath).slice(1))) {\n    throw new Error(\"Unsupported file type.\");\n  }\n\n  const url = [LANGCHAIN_HUB_URL_BASE, ref, remotePath].join(\"/\");\n  const res = await pRetry(() => fetchWithTimeout(url, { timeout: 5000 }), {\n    retries: 6,\n  });\n  if (res.status !== 200) {\n    throw new Error(`Could not find file at ${url}`);\n  }\n\n  return loader(await res.text(), remotePath, values);\n};\n"],"mappings":";;;;;;AAKA,MAAM,mBAAmB,OACvBA,KACAC,SACG;CACH,MAAM,EAAE,QAAS,GAAG,MAAM,GAAG;CAC7B,MAAM,MAAM,MAAM,MAAM,KAAK;EAC3B,GAAG;EACH,QAAQ,YAAY,QAAQ,QAAQ;CACrC,EAAC;AACF,QAAO;AACR;AAED,MAAM,iBAAiB;AAEvB,MAAM,qBAAqB;AAE3B,MAAa,cAAc,OACzBC,KACAC,QACAC,aACAC,eACAC,SAAqB,CAAE,MACI;CAC3B,MAAM,mFACmB,4BAA4B,IAAI;CACzD,MAAM,gFACmB,yBAAyB,IAChD;CAEF,MAAM,QAAQ,IAAI,MAAM,eAAe;AACvC,KAAI,CAAC,MACH,QAAO;CAET,MAAM,CAAC,QAAQ,WAAW,GAAG,MAAM,MAAM,EAAE;CAC3C,MAAM,MAAM,SAAS,OAAO,MAAM,EAAE,GAAG;CACvC,MAAM,QAAQ,WAAW,MAAM,mBAAmB;AAClD,KAAI,MAAM,OAAO,YACf,QAAO;AAGT,KAAI,CAAC,cAAc,IAAIC,wBAAQ,WAAW,CAAC,MAAM,EAAE,CAAC,CAClD,OAAM,IAAI,MAAM;CAGlB,MAAM,MAAM;EAAC;EAAwB;EAAK;CAAW,EAAC,KAAK,IAAI;CAC/D,MAAM,MAAM,MAAMC,qBAAO,MAAM,iBAAiB,KAAK,EAAE,SAAS,IAAM,EAAC,EAAE,EACvE,SAAS,EACV,EAAC;AACF,KAAI,IAAI,WAAW,IACjB,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAE,KAAK;AAGjD,QAAO,OAAO,MAAM,IAAI,MAAM,EAAE,YAAY,OAAO;AACpD"}

package/dist/util/hub.js

@@ -1,5 +1,5 @@
+import { pRetry } from "./p-retry/index.js";
 import { extname } from "./extname.js";
-import pRetry from "p-retry";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 
 //#region src/util/hub.ts

package/dist/util/hub.js.map

@@ -1 +1 @@
-{"version":3,"file":"hub.js","names":["url: string","init: Omit<RequestInit, \"signal\"> & { timeout: number }","uri: string","loader: FileLoader<T>","validPrefix: string","validSuffixes: Set<string>","values: LoadValues"],"sources":["../../src/util/hub.ts"],"sourcesContent":["import pRetry from \"p-retry\";\n\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { FileLoader, LoadValues } from \"./load.js\";\nimport { extname } from \"./extname.js\";\n\nconst fetchWithTimeout = async (\n  url: string,\n  init: Omit<RequestInit, \"signal\"> & { timeout: number }\n) => {\n  const { timeout, ...rest } = init;\n  const res = await fetch(url, {\n    ...rest,\n    signal: AbortSignal.timeout(timeout),\n  });\n  return res;\n};\n\nconst HUB_PATH_REGEX = /lc(@[^:]+)?:\\/\\/(.*)/;\n\nconst URL_PATH_SEPARATOR = \"/\";\n\nexport const loadFromHub = async <T>(\n  uri: string,\n  loader: FileLoader<T>,\n  validPrefix: string,\n  validSuffixes: Set<string>,\n  values: LoadValues = {}\n): Promise<T | undefined> => {\n  const LANGCHAIN_HUB_DEFAULT_REF =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_DEFAULT_REF\") ?? \"master\";\n  const LANGCHAIN_HUB_URL_BASE =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_URL_BASE\") ??\n    \"https://raw.githubusercontent.com/hwchase17/langchain-hub/\";\n\n  const match = uri.match(HUB_PATH_REGEX);\n  if (!match) {\n    return undefined;\n  }\n  const [rawRef, remotePath] = match.slice(1);\n  const ref = rawRef ? rawRef.slice(1) : LANGCHAIN_HUB_DEFAULT_REF;\n  const parts = remotePath.split(URL_PATH_SEPARATOR);\n  if (parts[0] !== validPrefix) {\n    return undefined;\n  }\n\n  if (!validSuffixes.has(extname(remotePath).slice(1))) {\n    throw new Error(\"Unsupported file type.\");\n  }\n\n  const url = [LANGCHAIN_HUB_URL_BASE, ref, remotePath].join(\"/\");\n  const res = await pRetry(() => fetchWithTimeout(url, { timeout: 5000 }), {\n    retries: 6,\n  });\n  if (res.status !== 200) {\n    throw new Error(`Could not find file at ${url}`);\n  }\n\n  return loader(await res.text(), remotePath, values);\n};\n"],"mappings":";;;;;AAMA,MAAM,mBAAmB,OACvBA,KACAC,SACG;CACH,MAAM,EAAE,QAAS,GAAG,MAAM,GAAG;CAC7B,MAAM,MAAM,MAAM,MAAM,KAAK;EAC3B,GAAG;EACH,QAAQ,YAAY,QAAQ,QAAQ;CACrC,EAAC;AACF,QAAO;AACR;AAED,MAAM,iBAAiB;AAEvB,MAAM,qBAAqB;AAE3B,MAAa,cAAc,OACzBC,KACAC,QACAC,aACAC,eACAC,SAAqB,CAAE,MACI;CAC3B,MAAM,4BACJ,uBAAuB,4BAA4B,IAAI;CACzD,MAAM,yBACJ,uBAAuB,yBAAyB,IAChD;CAEF,MAAM,QAAQ,IAAI,MAAM,eAAe;AACvC,KAAI,CAAC,MACH,QAAO;CAET,MAAM,CAAC,QAAQ,WAAW,GAAG,MAAM,MAAM,EAAE;CAC3C,MAAM,MAAM,SAAS,OAAO,MAAM,EAAE,GAAG;CACvC,MAAM,QAAQ,WAAW,MAAM,mBAAmB;AAClD,KAAI,MAAM,OAAO,YACf,QAAO;AAGT,KAAI,CAAC,cAAc,IAAI,QAAQ,WAAW,CAAC,MAAM,EAAE,CAAC,CAClD,OAAM,IAAI,MAAM;CAGlB,MAAM,MAAM;EAAC;EAAwB;EAAK;CAAW,EAAC,KAAK,IAAI;CAC/D,MAAM,MAAM,MAAM,OAAO,MAAM,iBAAiB,KAAK,EAAE,SAAS,IAAM,EAAC,EAAE,EACvE,SAAS,EACV,EAAC;AACF,KAAI,IAAI,WAAW,IACjB,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAE,KAAK;AAGjD,QAAO,OAAO,MAAM,IAAI,MAAM,EAAE,YAAY,OAAO;AACpD"}
+{"version":3,"file":"hub.js","names":["url: string","init: Omit<RequestInit, \"signal\"> & { timeout: number }","uri: string","loader: FileLoader<T>","validPrefix: string","validSuffixes: Set<string>","values: LoadValues"],"sources":["../../src/util/hub.ts"],"sourcesContent":["import pRetry from \"./p-retry/index.js\";\nimport { getEnvironmentVariable } from \"@langchain/core/utils/env\";\nimport { FileLoader, LoadValues } from \"./load.js\";\nimport { extname } from \"./extname.js\";\n\nconst fetchWithTimeout = async (\n  url: string,\n  init: Omit<RequestInit, \"signal\"> & { timeout: number }\n) => {\n  const { timeout, ...rest } = init;\n  const res = await fetch(url, {\n    ...rest,\n    signal: AbortSignal.timeout(timeout),\n  });\n  return res;\n};\n\nconst HUB_PATH_REGEX = /lc(@[^:]+)?:\\/\\/(.*)/;\n\nconst URL_PATH_SEPARATOR = \"/\";\n\nexport const loadFromHub = async <T>(\n  uri: string,\n  loader: FileLoader<T>,\n  validPrefix: string,\n  validSuffixes: Set<string>,\n  values: LoadValues = {}\n): Promise<T | undefined> => {\n  const LANGCHAIN_HUB_DEFAULT_REF =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_DEFAULT_REF\") ?? \"master\";\n  const LANGCHAIN_HUB_URL_BASE =\n    getEnvironmentVariable(\"LANGCHAIN_HUB_URL_BASE\") ??\n    \"https://raw.githubusercontent.com/hwchase17/langchain-hub/\";\n\n  const match = uri.match(HUB_PATH_REGEX);\n  if (!match) {\n    return undefined;\n  }\n  const [rawRef, remotePath] = match.slice(1);\n  const ref = rawRef ? rawRef.slice(1) : LANGCHAIN_HUB_DEFAULT_REF;\n  const parts = remotePath.split(URL_PATH_SEPARATOR);\n  if (parts[0] !== validPrefix) {\n    return undefined;\n  }\n\n  if (!validSuffixes.has(extname(remotePath).slice(1))) {\n    throw new Error(\"Unsupported file type.\");\n  }\n\n  const url = [LANGCHAIN_HUB_URL_BASE, ref, remotePath].join(\"/\");\n  const res = await pRetry(() => fetchWithTimeout(url, { timeout: 5000 }), {\n    retries: 6,\n  });\n  if (res.status !== 200) {\n    throw new Error(`Could not find file at ${url}`);\n  }\n\n  return loader(await res.text(), remotePath, values);\n};\n"],"mappings":";;;;;AAKA,MAAM,mBAAmB,OACvBA,KACAC,SACG;CACH,MAAM,EAAE,QAAS,GAAG,MAAM,GAAG;CAC7B,MAAM,MAAM,MAAM,MAAM,KAAK;EAC3B,GAAG;EACH,QAAQ,YAAY,QAAQ,QAAQ;CACrC,EAAC;AACF,QAAO;AACR;AAED,MAAM,iBAAiB;AAEvB,MAAM,qBAAqB;AAE3B,MAAa,cAAc,OACzBC,KACAC,QACAC,aACAC,eACAC,SAAqB,CAAE,MACI;CAC3B,MAAM,4BACJ,uBAAuB,4BAA4B,IAAI;CACzD,MAAM,yBACJ,uBAAuB,yBAAyB,IAChD;CAEF,MAAM,QAAQ,IAAI,MAAM,eAAe;AACvC,KAAI,CAAC,MACH,QAAO;CAET,MAAM,CAAC,QAAQ,WAAW,GAAG,MAAM,MAAM,EAAE;CAC3C,MAAM,MAAM,SAAS,OAAO,MAAM,EAAE,GAAG;CACvC,MAAM,QAAQ,WAAW,MAAM,mBAAmB;AAClD,KAAI,MAAM,OAAO,YACf,QAAO;AAGT,KAAI,CAAC,cAAc,IAAI,QAAQ,WAAW,CAAC,MAAM,EAAE,CAAC,CAClD,OAAM,IAAI,MAAM;CAGlB,MAAM,MAAM;EAAC;EAAwB;EAAK;CAAW,EAAC,KAAK,IAAI;CAC/D,MAAM,MAAM,MAAM,OAAO,MAAM,iBAAiB,KAAK,EAAE,SAAS,IAAM,EAAC,EAAE,EACvE,SAAS,EACV,EAAC;AACF,KAAI,IAAI,WAAW,IACjB,OAAM,IAAI,MAAM,CAAC,uBAAuB,EAAE,KAAK;AAGjD,QAAO,OAAO,MAAM,IAAI,MAAM,EAAE,YAAY,OAAO;AACpD"}

package/dist/util/is-network-error/index.cjs

@@ -0,0 +1,27 @@
+
+//#region src/util/is-network-error/index.js
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = new Set([
+	"network error",
+	"Failed to fetch",
+	"NetworkError when attempting to fetch resource.",
+	"The Internet connection appears to be offline.",
+	"Network request failed",
+	"fetch failed",
+	"terminated",
+	" A network error occurred.",
+	"Network connection lost"
+]);
+function isNetworkError(error) {
+	const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+	if (!isValid) return false;
+	const { message, stack } = error;
+	if (message === "Load failed") return stack === void 0 || "__sentry_captured__" in error;
+	if (message.startsWith("error sending request for url")) return true;
+	return errorMessages.has(message);
+}
+
+//#endregion
+exports.isNetworkError = isNetworkError;
+//# sourceMappingURL=index.cjs.map

package/dist/util/is-network-error/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../../../src/util/is-network-error/index.js"],"sourcesContent":["/* eslint-disable */\nconst objectToString = Object.prototype.toString;\n\nconst isError = (value) => objectToString.call(value) === \"[object Error]\";\n\nconst errorMessages = new Set([\n  \"network error\", // Chrome\n  \"Failed to fetch\", // Chrome\n  \"NetworkError when attempting to fetch resource.\", // Firefox\n  \"The Internet connection appears to be offline.\", // Safari 16\n  \"Network request failed\", // `cross-fetch`\n  \"fetch failed\", // Undici (Node.js)\n  \"terminated\", // Undici (Node.js)\n  \" A network error occurred.\", // Bun (WebKit)\n  \"Network connection lost\", // Cloudflare Workers (fetch)\n]);\n\nexport default function isNetworkError(error) {\n  const isValid =\n    error &&\n    isError(error) &&\n    error.name === \"TypeError\" &&\n    typeof error.message === \"string\";\n\n  if (!isValid) {\n    return false;\n  }\n\n  const { message, stack } = error;\n\n  // Safari 17+ has generic message but no stack for network errors\n  if (message === \"Load failed\") {\n    return (\n      stack === undefined ||\n      // Sentry adds its own stack trace to the fetch error, so also check for that\n      \"__sentry_captured__\" in error\n    );\n  }\n\n  // Deno network errors start with specific text\n  if (message.startsWith(\"error sending request for url\")) {\n    return true;\n  }\n\n  // Standard network error messages\n  return errorMessages.has(message);\n}\n"],"mappings":";;AACA,MAAM,iBAAiB,OAAO,UAAU;AAExC,MAAM,UAAU,CAAC,UAAU,eAAe,KAAK,MAAM,KAAK;AAE1D,MAAM,gBAAgB,IAAI,IAAI;CAC5B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD;AAED,SAAwB,eAAe,OAAO;CAC5C,MAAM,UACJ,SACA,QAAQ,MAAM,IACd,MAAM,SAAS,eACf,OAAO,MAAM,YAAY;AAE3B,KAAI,CAAC,QACH,QAAO;CAGT,MAAM,EAAE,SAAS,OAAO,GAAG;AAG3B,KAAI,YAAY,cACd,QACE,UAAU,UAEV,yBAAyB;AAK7B,KAAI,QAAQ,WAAW,gCAAgC,CACrD,QAAO;AAIT,QAAO,cAAc,IAAI,QAAQ;AAClC"}

package/dist/util/is-network-error/index.js

@@ -0,0 +1,26 @@
+//#region src/util/is-network-error/index.js
+const objectToString = Object.prototype.toString;
+const isError = (value) => objectToString.call(value) === "[object Error]";
+const errorMessages = new Set([
+	"network error",
+	"Failed to fetch",
+	"NetworkError when attempting to fetch resource.",
+	"The Internet connection appears to be offline.",
+	"Network request failed",
+	"fetch failed",
+	"terminated",
+	" A network error occurred.",
+	"Network connection lost"
+]);
+function isNetworkError(error) {
+	const isValid = error && isError(error) && error.name === "TypeError" && typeof error.message === "string";
+	if (!isValid) return false;
+	const { message, stack } = error;
+	if (message === "Load failed") return stack === void 0 || "__sentry_captured__" in error;
+	if (message.startsWith("error sending request for url")) return true;
+	return errorMessages.has(message);
+}
+
+//#endregion
+export { isNetworkError };
+//# sourceMappingURL=index.js.map

package/dist/util/is-network-error/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/util/is-network-error/index.js"],"sourcesContent":["/* eslint-disable */\nconst objectToString = Object.prototype.toString;\n\nconst isError = (value) => objectToString.call(value) === \"[object Error]\";\n\nconst errorMessages = new Set([\n  \"network error\", // Chrome\n  \"Failed to fetch\", // Chrome\n  \"NetworkError when attempting to fetch resource.\", // Firefox\n  \"The Internet connection appears to be offline.\", // Safari 16\n  \"Network request failed\", // `cross-fetch`\n  \"fetch failed\", // Undici (Node.js)\n  \"terminated\", // Undici (Node.js)\n  \" A network error occurred.\", // Bun (WebKit)\n  \"Network connection lost\", // Cloudflare Workers (fetch)\n]);\n\nexport default function isNetworkError(error) {\n  const isValid =\n    error &&\n    isError(error) &&\n    error.name === \"TypeError\" &&\n    typeof error.message === \"string\";\n\n  if (!isValid) {\n    return false;\n  }\n\n  const { message, stack } = error;\n\n  // Safari 17+ has generic message but no stack for network errors\n  if (message === \"Load failed\") {\n    return (\n      stack === undefined ||\n      // Sentry adds its own stack trace to the fetch error, so also check for that\n      \"__sentry_captured__\" in error\n    );\n  }\n\n  // Deno network errors start with specific text\n  if (message.startsWith(\"error sending request for url\")) {\n    return true;\n  }\n\n  // Standard network error messages\n  return errorMessages.has(message);\n}\n"],"mappings":";AACA,MAAM,iBAAiB,OAAO,UAAU;AAExC,MAAM,UAAU,CAAC,UAAU,eAAe,KAAK,MAAM,KAAK;AAE1D,MAAM,gBAAgB,IAAI,IAAI;CAC5B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD;AAED,SAAwB,eAAe,OAAO;CAC5C,MAAM,UACJ,SACA,QAAQ,MAAM,IACd,MAAM,SAAS,eACf,OAAO,MAAM,YAAY;AAE3B,KAAI,CAAC,QACH,QAAO;CAGT,MAAM,EAAE,SAAS,OAAO,GAAG;AAG3B,KAAI,YAAY,cACd,QACE,UAAU,UAEV,yBAAyB;AAK7B,KAAI,QAAQ,WAAW,gCAAgC,CACrD,QAAO;AAIT,QAAO,cAAc,IAAI,QAAQ;AAClC"}

package/dist/util/load.d.cts

@@ -1,5 +1,4 @@
 //#region src/util/load.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type LoadValues = Record<string, any>;
 //#endregion
 export { LoadValues };