@langchain/core 1.1.4 → 1.1.5-dev-1765432861398

package/dist/singletons/async_local_storage/context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","names":["BaseCallbackHandler","setContextVariable","T","PropertyKey","getContextVariable","_getConfigureHooks","ConfigureHook","registerConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.d.ts"],"sourcesContent":["import { BaseCallbackHandler } from \"../../callbacks/base.js\";\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\nexport declare function setContextVariable<T>(name: PropertyKey, value: T): void;\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\nexport declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;\nexport declare const _getConfigureHooks: () => ConfigureHook[];\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport declare const registerConfigureHook: (config: ConfigureHook) => void;\nexport type ConfigureHook = {\n    contextVar?: string;\n    inheritable?: boolean;\n    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n//# sourceMappingURL=context.d.ts.map"],"mappings":";;;;;;AAmDA;AAkDA;AA+CA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlGwBC,4BAA4BE,oBAAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDhDE,kCAAkCD,cAAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDK,gCAAgCD;KACzCA,aAAAA;;;yCAG+BN"}

package/dist/singletons/async_local_storage/context.d.ts

@@ -102,7 +102,6 @@ declare function setContextVariable<T>(name: PropertyKey, value: T): void;
  *
  * @param name The name of the context variable.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;
 /**
  * Register a callback configure hook to automatically add callback handlers to all runs.
@@ -153,7 +152,6 @@ declare const registerConfigureHook: (config: ConfigureHook) => void;
 type ConfigureHook = {
   contextVar?: string;
   inheritable?: boolean;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   handlerClass?: new (...args: any[]) => BaseCallbackHandler;
   envVar?: string;
 };

package/dist/singletons/async_local_storage/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","names":["BaseCallbackHandler","setContextVariable","T","PropertyKey","getContextVariable","_getConfigureHooks","ConfigureHook","registerConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.d.ts"],"sourcesContent":["import { BaseCallbackHandler } from \"../../callbacks/base.js\";\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\nexport declare function setContextVariable<T>(name: PropertyKey, value: T): void;\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\nexport declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;\nexport declare const _getConfigureHooks: () => ConfigureHook[];\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport declare const registerConfigureHook: (config: ConfigureHook) => void;\nexport type ConfigureHook = {\n    contextVar?: string;\n    inheritable?: boolean;\n    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n//# sourceMappingURL=context.d.ts.map"],"mappings":";;;;;;AAmDA;AAkDA;AA+CA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlGwBC,4BAA4BE,oBAAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDhDE,kCAAkCD,cAAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDK,gCAAgCD;KACzCA,aAAAA;;;yCAG+BN"}

package/dist/singletons/async_local_storage/globals.d.cts

@@ -1,5 +1,4 @@
 //#region src/singletons/async_local_storage/globals.d.ts
-/* eslint-disable @typescript-eslint/no-explicit-any */
 interface AsyncLocalStorageInterface {
   getStore: () => any | undefined;
   run: <T>(store: any, callback: () => T) => T;

package/dist/singletons/async_local_storage/globals.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.cts","names":["AsyncLocalStorageInterface","T","TRACING_ALS_KEY","_CONTEXT_VARIABLES_KEY","setGlobalAsyncLocalStorageInstance","getGlobalAsyncLocalStorageInstance"],"sources":["../../../src/singletons/async_local_storage/globals.d.ts"],"sourcesContent":["export interface AsyncLocalStorageInterface {\n    getStore: () => any | undefined;\n    run: <T>(store: any, callback: () => T) => T;\n    enterWith: (store: any) => void;\n}\nexport declare const TRACING_ALS_KEY: unique symbol;\nexport declare const _CONTEXT_VARIABLES_KEY: unique symbol;\nexport declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;\nexport declare const getGlobalAsyncLocalStorageInstance: () => AsyncLocalStorageInterface | undefined;\n//# sourceMappingURL=globals.d.ts.map"],"mappings":";UAAiBA,0BAAAA;EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,GAAAA,GAAAA,SAA0B;EAMtBG,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAqC,EAAA,GAAA,GAJjBF,CAIiB,EAAA,GAJXA,CAIW;;;cAArCE"}

package/dist/singletons/async_local_storage/globals.d.ts

@@ -1,5 +1,4 @@
 //#region src/singletons/async_local_storage/globals.d.ts
-/* eslint-disable @typescript-eslint/no-explicit-any */
 interface AsyncLocalStorageInterface {
   getStore: () => any | undefined;
   run: <T>(store: any, callback: () => T) => T;

package/dist/singletons/async_local_storage/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","names":["AsyncLocalStorageInterface","T","TRACING_ALS_KEY","_CONTEXT_VARIABLES_KEY","setGlobalAsyncLocalStorageInstance","getGlobalAsyncLocalStorageInstance"],"sources":["../../../src/singletons/async_local_storage/globals.d.ts"],"sourcesContent":["export interface AsyncLocalStorageInterface {\n    getStore: () => any | undefined;\n    run: <T>(store: any, callback: () => T) => T;\n    enterWith: (store: any) => void;\n}\nexport declare const TRACING_ALS_KEY: unique symbol;\nexport declare const _CONTEXT_VARIABLES_KEY: unique symbol;\nexport declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;\nexport declare const getGlobalAsyncLocalStorageInstance: () => AsyncLocalStorageInterface | undefined;\n//# sourceMappingURL=globals.d.ts.map"],"mappings":";UAAiBA,0BAAAA;EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,GAAAA,GAAAA,SAA0B;EAMtBG,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAqC,EAAA,GAAA,GAJjBF,CAIiB,EAAA,GAJXA,CAIW;;;cAArCE"}

package/dist/singletons/async_local_storage/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["AsyncLocalStorageInterface","MockAsyncLocalStorage","T","AsyncLocalStorageProvider","AsyncLocalStorageProviderSingleton"],"sources":["../../../src/singletons/async_local_storage/index.d.ts"],"sourcesContent":["import { AsyncLocalStorageInterface } from \"./globals.js\";\nexport declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n    getStore(): any;\n    run<T>(_store: any, callback: () => T): T;\n    enterWith(_store: any): undefined;\n}\ndeclare class AsyncLocalStorageProvider {\n    getInstance(): AsyncLocalStorageInterface;\n    getRunnableConfig(): any;\n    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;\n    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;\n}\ndeclare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;cACqBC,qBAAAA,YAAiCD;;EAAjCC,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAqB,EAAAC,GAAAA,GAEFA,CAFE,CAAA,EAEEA,CAFF;EAEFA,SAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,SAAAA;;cAG1BC,yBAAAA,CALwCH;EAA0B,WAAA,CAAA,CAAA,EAM7DA,0BAN6D;EAKlEG,iBAAAA,CAAAA,CAAAA,EAAAA,GAAAA;EACKH,aAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAE+BE,CAF/BF,EAAAA,wBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAEuEE,CAFvEF;EAE+BE,wBAAAA,CAAAA,QAAAA,EACXF,0BADWE,CAAAA,EAAAA,IAAAA;;cAGpCE,kCAFyBJ,EAEWG,yBAFXH"}

package/dist/singletons/async_local_storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["AsyncLocalStorageInterface","MockAsyncLocalStorage","T","AsyncLocalStorageProvider","AsyncLocalStorageProviderSingleton"],"sources":["../../../src/singletons/async_local_storage/index.d.ts"],"sourcesContent":["import { AsyncLocalStorageInterface } from \"./globals.js\";\nexport declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n    getStore(): any;\n    run<T>(_store: any, callback: () => T): T;\n    enterWith(_store: any): undefined;\n}\ndeclare class AsyncLocalStorageProvider {\n    getInstance(): AsyncLocalStorageInterface;\n    getRunnableConfig(): any;\n    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;\n    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;\n}\ndeclare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;cACqBC,qBAAAA,YAAiCD;;EAAjCC,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAqB,EAAAC,GAAAA,GAEFA,CAFE,CAAA,EAEEA,CAFF;EAEFA,SAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,SAAAA;;cAG1BC,yBAAAA,CALwCH;EAA0B,WAAA,CAAA,CAAA,EAM7DA,0BAN6D;EAKlEG,iBAAAA,CAAAA,CAAAA,EAAAA,GAAAA;EACKH,aAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAE+BE,CAF/BF,EAAAA,wBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAEuEE,CAFvEF;EAE+BE,wBAAAA,CAAAA,QAAAA,EACXF,0BADWE,CAAAA,EAAAA,IAAAA;;cAGpCE,kCAFyBJ,EAEWG,yBAFXH"}

package/dist/singletons/callbacks.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.cts","names":["PQueueMod","getQueue","consumeCallback","T","Promise","awaitAllCallbacks"],"sources":["../../src/singletons/callbacks.d.ts"],"sourcesContent":["import PQueueMod from \"p-queue\";\nexport declare function getQueue(): PQueueMod<any, any>;\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport declare function awaitAllCallbacks(): Promise<void>;\n//# sourceMappingURL=callbacks.d.ts.map"],"mappings":";;;;;;AAO0G;AAKlFK,iBALAH,eAKqBE,CAAAA,CAAAA,CAAAA,CAAAA,SAAO,EAAA,GAAA,GALQA,OAKR,CALgBD,CAKhB,CAAA,GALqBA,CAKrB,GAAA,IAAA,EAAA,IAAA,EAAA,OAAA,CAAA,EAL+CC,OAK/C,CAAA,IAAA,CAAA;;;;;iBAA5BC,iBAAAA,CAAAA,GAAqBD"}

package/dist/singletons/callbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.ts","names":["PQueueMod","getQueue","consumeCallback","T","Promise","awaitAllCallbacks"],"sources":["../../src/singletons/callbacks.d.ts"],"sourcesContent":["import PQueueMod from \"p-queue\";\nexport declare function getQueue(): PQueueMod<any, any>;\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport declare function awaitAllCallbacks(): Promise<void>;\n//# sourceMappingURL=callbacks.d.ts.map"],"mappings":";;;;;AAOA;;;;AAAmGI,iBAA3EF,eAA2EE,CAAAA,CAAAA,CAAAA,CAAAA,SAAAA,EAAAA,GAAAA,GAAvCA,OAAuCA,CAA/BD,CAA+BC,CAAAA,GAA1BD,CAA0BC,GAAAA,IAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,CAAAA,IAAAA,CAAAA;AAAO;AAK1G;;;iBAAwBC,iBAAAA,CAAAA,GAAqBD"}

package/dist/stores.d.cts

@@ -50,7 +50,6 @@ declare abstract class BaseStore<K, V> extends Serializable {
  * await store.mdelete(await store.yieldKeys("message:id:").toArray());
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class InMemoryStore<T = any> extends BaseStore<string, T> {
   lc_namespace: string[];
   protected store: Record<string, T>;

package/dist/stores.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.cts","names":["Serializable","BaseStore","K","V","Promise","AsyncGenerator","InMemoryStore","T","Record"],"sources":["../src/stores.d.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n/**\n * Abstract interface for a key-value store.\n */\nexport declare abstract class BaseStore<K, V> extends Serializable {\n    /**\n     * Abstract method to get multiple values for a set of keys.\n     * @param {K[]} keys - An array of keys.\n     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n     */\n    abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Abstract method to set a value for multiple keys.\n     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Abstract method to delete multiple keys.\n     * @param {K[]} keys - An array of keys to delete.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mdelete(keys: K[]): Promise<void>;\n    /**\n     * Abstract method to yield keys optionally based on a prefix.\n     * @param {string} prefix - Optional prefix to filter keys.\n     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n     */\n    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\nexport declare class InMemoryStore<T = any> extends BaseStore<string, T> {\n    lc_namespace: string[];\n    protected store: Record<string, T>;\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<T[]>;\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, T][]): 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 | undefined): AsyncGenerator<string>;\n}\n//# sourceMappingURL=stores.d.ts.map"],"mappings":";;;;;;AAIA;AAMwBE,uBANMD,SAMNC,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,SAN8BF,YAAAA,CAM9BE;EAAeC;;;;;EAYZD,SAAAA,IAAAA,CAAAA,IAAAA,EAZHA,CAYGA,EAAAA,CAAAA,EAZGE,OAYHF,CAAAA,CAZYC,CAYZD,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAME;;;;AAlBiC;EA6C7CE,SAAAA,IAAAA,CAAAA,aAAaC,EAAA,CAjCAL,CAiCA,EAjCGC,CAiCH,CAAA,EAAA,CAAA,EAjCUC,OAiCV,CAAA,IAAA,CAAA;EAAoCG;;;;;EAcrCA,SAAAA,OAAAA,CAAAA,IAAAA,EAzCNL,CAyCMK,EAAAA,CAAAA,EAzCAH,OAyCAG,CAAAA,IAAAA,CAAAA;EAAOH;;;;AAdqB;uCArBpBC,eAAeH;;;;;;;;;;;;;;;;;;;;;cAqBnCI,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}

package/dist/stores.d.ts

@@ -50,7 +50,6 @@ declare abstract class BaseStore<K, V> extends Serializable {
  * await store.mdelete(await store.yieldKeys("message:id:").toArray());
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare class InMemoryStore<T = any> extends BaseStore<string, T> {
   lc_namespace: string[];
   protected store: Record<string, T>;

package/dist/stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","names":["Serializable","BaseStore","K","V","Promise","AsyncGenerator","InMemoryStore","T","Record"],"sources":["../src/stores.d.ts"],"sourcesContent":["import { Serializable } from \"./load/serializable.js\";\n/**\n * Abstract interface for a key-value store.\n */\nexport declare abstract class BaseStore<K, V> extends Serializable {\n    /**\n     * Abstract method to get multiple values for a set of keys.\n     * @param {K[]} keys - An array of keys.\n     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.\n     */\n    abstract mget(keys: K[]): Promise<(V | undefined)[]>;\n    /**\n     * Abstract method to set a value for multiple keys.\n     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mset(keyValuePairs: [K, V][]): Promise<void>;\n    /**\n     * Abstract method to delete multiple keys.\n     * @param {K[]} keys - An array of keys to delete.\n     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.\n     */\n    abstract mdelete(keys: K[]): Promise<void>;\n    /**\n     * Abstract method to yield keys optionally based on a prefix.\n     * @param {string} prefix - Optional prefix to filter keys.\n     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.\n     */\n    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;\n}\n/**\n * In-memory implementation of the BaseStore using a dictionary. Used for\n * storing key-value pairs in memory.\n * @example\n * ```typescript\n * const store = new InMemoryStore<BaseMessage>();\n * await store.mset(\n *   Array.from({ length: 5 }).map((_, index) => [\n *     `message:id:${index}`,\n *     index % 2 === 0\n *       ? new AIMessage(\"ai stuff...\")\n *       : new HumanMessage(\"human stuff...\"),\n *   ]),\n * );\n *\n * const retrievedMessages = await store.mget([\"message:id:0\", \"message:id:1\"]);\n * await store.mdelete(await store.yieldKeys(\"message:id:\").toArray());\n * ```\n */\nexport declare class InMemoryStore<T = any> extends BaseStore<string, T> {\n    lc_namespace: string[];\n    protected store: Record<string, T>;\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<T[]>;\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, T][]): 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 | undefined): AsyncGenerator<string>;\n}\n//# sourceMappingURL=stores.d.ts.map"],"mappings":";;;;;;AAIA;AAMwBE,uBANMD,SAMNC,CAAAA,CAAAA,EAAAA,CAAAA,CAAAA,SAN8BF,YAAAA,CAM9BE;EAAeC;;;;;EAYZD,SAAAA,IAAAA,CAAAA,IAAAA,EAZHA,CAYGA,EAAAA,CAAAA,EAZGE,OAYHF,CAAAA,CAZYC,CAYZD,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAME;;;;AAlBiC;EA6C7CE,SAAAA,IAAAA,CAAAA,aAAaC,EAAA,CAjCAL,CAiCA,EAjCGC,CAiCH,CAAA,EAAA,CAAA,EAjCUC,OAiCV,CAAA,IAAA,CAAA;EAAoCG;;;;;EAcrCA,SAAAA,OAAAA,CAAAA,IAAAA,EAzCNL,CAyCMK,EAAAA,CAAAA,EAzCAH,OAyCAG,CAAAA,IAAAA,CAAAA;EAAOH;;;;AAdqB;uCArBpBC,eAAeH;;;;;;;;;;;;;;;;;;;;;cAqBnCI,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}

package/dist/structured_query/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["VectorStore","Comparator","Comparison","Operation","Operator","StructuredQuery","Visitor","VisitorComparisonResult","VisitorOperationResult","VisitorStructuredQueryResult","TranslatorOpts","BaseTranslator","T","BasicTranslator"],"sources":["../../src/structured_query/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from \"./ir.js\";\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n};\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {\n    /**\n     * Formats a given function (either an operator or a comparator) into a\n     * string.\n     * @param func The function to format.\n     * @returns Formatted string representation of the function.\n     */\n    abstract formatFunction(func: Operator | Comparator): string;\n    /**\n     * Merges two filters into one, using a specified merge type.\n     * @param defaultFilter The default filter.\n     * @param generatedFilter The generated filter.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n     * @returns The merged filter, or undefined if both filters are empty.\n     */\n    abstract mergeFilters(defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, mergeType?: \"and\" | \"or\" | \"replace\", forceDefaultFilter?: boolean): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {\n    VisitOperationOutput: VisitorOperationResult;\n    VisitComparisonOutput: VisitorComparisonResult;\n    VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    constructor(opts?: TranslatorOpts);\n    formatFunction(func: Operator | Comparator): string;\n    /**\n     * Visits an operation and returns a result.\n     * @param operation The operation to visit.\n     * @returns The result of visiting the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits a comparison and returns a result.\n     * @param comparison The comparison to visit.\n     * @returns The result of visiting the comparison.\n     */\n    visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and returns a result.\n     * @param query The structured query to visit.\n     * @returns The result of visiting the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    mergeFilters(defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult[\"filter\"] | undefined;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;AAMA;AASA;AAAuDA,KAT3CU,cAAAA,GAS2CV;EAAcA,gBAAAA,EAR/CI,QAQ+CJ,EAAAA;EAA6BY,kBAAAA,EAP1EX,UAO0EW,EAAAA;CAOhER;;;AAP+D;AA0BjG;;AAA6DJ,uBA1B/BW,cA0B+BX,CAAAA,UA1BNA,WA0BMA,GA1BQA,WA0BRA,CAAAA,SA1B6BM,OA0B7BN,CA1BqCY,CA0BrCZ,CAAAA,CAAAA;EAAoCY;;;;;;EAM1EF,SAAAA,cAAAA,CAAAA,IAAAA,EAzBWN,QAyBXM,GAzBsBT,UAyBtBS,CAAAA,EAAAA,MAAAA;EACEN;;;;;;;;EAPyDO,SAAAA,YAAAA,CAAAA,aAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,eAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,SAAAA,CAAAA,EAAAA,KAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,kBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA;AAAc;;;;;;;;;cAA3EE,0BAA0Bb,cAAcA,qBAAqBW,eAAeC;wBACvEJ;yBACCD;8BACKE;oBACVL;sBACEH;qBACDS;uBACEN,WAAWH;;;;;;4BAMNE;;;;;;8BAMED;;;;;;8BAMAG;8BACAI,qEAAqEA,uGAAuGA"}

package/dist/structured_query/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["VectorStore","Comparator","Comparison","Operation","Operator","StructuredQuery","Visitor","VisitorComparisonResult","VisitorOperationResult","VisitorStructuredQueryResult","TranslatorOpts","BaseTranslator","T","BasicTranslator"],"sources":["../../src/structured_query/base.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery, Visitor, VisitorComparisonResult, VisitorOperationResult, VisitorStructuredQueryResult } from \"./ir.js\";\n/**\n * Options object for the BasicTranslator class. Specifies the allowed\n * operators and comparators.\n */\nexport type TranslatorOpts = {\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n};\n/**\n * Abstract class that provides a blueprint for creating specific\n * translator classes. Defines two abstract methods: formatFunction and\n * mergeFilters.\n */\nexport declare abstract class BaseTranslator<T extends VectorStore = VectorStore> extends Visitor<T> {\n    /**\n     * Formats a given function (either an operator or a comparator) into a\n     * string.\n     * @param func The function to format.\n     * @returns Formatted string representation of the function.\n     */\n    abstract formatFunction(func: Operator | Comparator): string;\n    /**\n     * Merges two filters into one, using a specified merge type.\n     * @param defaultFilter The default filter.\n     * @param generatedFilter The generated filter.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'.\n     * @param forceDefaultFilter If true, the default filter will be used even if the generated filter is not empty.\n     * @returns The merged filter, or undefined if both filters are empty.\n     */\n    abstract mergeFilters(defaultFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, generatedFilter: this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined, mergeType?: \"and\" | \"or\" | \"replace\", forceDefaultFilter?: boolean): this[\"VisitStructuredQueryOutput\"][\"filter\"] | undefined;\n}\n/**\n * Class that extends the BaseTranslator class and provides concrete\n * implementations for the abstract methods. Also declares three types:\n * VisitOperationOutput, VisitComparisonOutput, and\n * VisitStructuredQueryOutput, which are used as the return types for the\n * visitOperation, visitComparison, and visitStructuredQuery methods\n * respectively.\n */\nexport declare class BasicTranslator<T extends VectorStore = VectorStore> extends BaseTranslator<T> {\n    VisitOperationOutput: VisitorOperationResult;\n    VisitComparisonOutput: VisitorComparisonResult;\n    VisitStructuredQueryOutput: VisitorStructuredQueryResult;\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    constructor(opts?: TranslatorOpts);\n    formatFunction(func: Operator | Comparator): string;\n    /**\n     * Visits an operation and returns a result.\n     * @param operation The operation to visit.\n     * @returns The result of visiting the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits a comparison and returns a result.\n     * @param comparison The comparison to visit.\n     * @returns The result of visiting the comparison.\n     */\n    visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and returns a result.\n     * @param query The structured query to visit.\n     * @returns The result of visiting the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    mergeFilters(defaultFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, generatedFilter: VisitorStructuredQueryResult[\"filter\"] | undefined, mergeType?: string, forceDefaultFilter?: boolean): VisitorStructuredQueryResult[\"filter\"] | undefined;\n}\n//# sourceMappingURL=base.d.ts.map"],"mappings":";;;;;;;AAMA;AASA;AAAuDA,KAT3CU,cAAAA,GAS2CV;EAAcA,gBAAAA,EAR/CI,QAQ+CJ,EAAAA;EAA6BY,kBAAAA,EAP1EX,UAO0EW,EAAAA;CAOhER;;;AAP+D;AA0BjG;;AAA6DJ,uBA1B/BW,cA0B+BX,CAAAA,UA1BNA,WA0BMA,GA1BQA,WA0BRA,CAAAA,SA1B6BM,OA0B7BN,CA1BqCY,CA0BrCZ,CAAAA,CAAAA;EAAoCY;;;;;;EAM1EF,SAAAA,cAAAA,CAAAA,IAAAA,EAzBWN,QAyBXM,GAzBsBT,UAyBtBS,CAAAA,EAAAA,MAAAA;EACEN;;;;;;;;EAPyDO,SAAAA,YAAAA,CAAAA,aAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,eAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA,EAAAA,SAAAA,CAAAA,EAAAA,KAAAA,GAAAA,IAAAA,GAAAA,SAAAA,EAAAA,kBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAAAA,IAAAA,CAAAA,4BAAAA,CAAAA,CAAAA,QAAAA,CAAAA,GAAAA,SAAAA;AAAc;;;;;;;;;cAA3EE,0BAA0Bb,cAAcA,qBAAqBW,eAAeC;wBACvEJ;yBACCD;8BACKE;oBACVL;sBACEH;qBACDS;uBACEN,WAAWH;;;;;;4BAMNE;;;;;;8BAMED;;;;;;8BAMAG;8BACAI,qEAAqEA,uGAAuGA"}

package/dist/structured_query/functional.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functional.d.cts","names":["Document","Comparator","Comparison","Operation","Operator","StructuredQuery","BaseTranslator","ValueType","FunctionFilter","FunctionalTranslator","C"],"sources":["../../src/structured_query/functional.d.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery } from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n    eq: string | number | boolean;\n    ne: string | number | boolean;\n    lt: string | number;\n    lte: string | number;\n    gt: string | number;\n    gte: string | number;\n};\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport declare class FunctionalTranslator extends BaseTranslator {\n    VisitOperationOutput: FunctionFilter;\n    VisitComparisonOutput: FunctionFilter;\n    VisitStructuredQueryOutput: {\n        filter: FunctionFilter;\n    } | {\n        [k: string]: never;\n    };\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    formatFunction(): string;\n    /**\n     * Returns the allowed comparators for a given data type.\n     * @param input The input value to get the allowed comparators for.\n     * @returns An array of allowed comparators for the input data type.\n     */\n    getAllowedComparatorsForType(inputType: string): Comparator[];\n    /**\n     * Returns a function that performs a comparison based on the provided\n     * comparator.\n     * @param comparator The comparator to base the comparison function on.\n     * @returns A function that takes two arguments and returns a boolean based on the comparison.\n     */\n    getComparatorFunction<C extends Comparator>(comparator: Comparator): (a: string | number, b: ValueType[C]) => boolean;\n    /**\n     * Returns a function that performs an operation based on the provided\n     * operator.\n     * @param operator The operator to base the operation function on.\n     * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n     */\n    getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean;\n    /**\n     * Visits the operation part of a structured query and translates it into\n     * a functional filter.\n     * @param operation The operation part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits the comparison part of a structured query and translates it into\n     * a functional filter.\n     * @param comparison The comparison part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n     */\n    visitComparison(comparison: Comparison<string | number | boolean>): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and translates it into a functional filter.\n     * @param query The structured query to translate.\n     * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    /**\n     * Merges two filters into one, based on the specified merge type.\n     * @param defaultFilter The default filter function.\n     * @param generatedFilter The generated filter function.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n     */\n    mergeFilters(defaultFilter: FunctionFilter, generatedFilter: FunctionFilter, mergeType?: string): FunctionFilter | undefined;\n}\nexport {};\n//# sourceMappingURL=functional.d.ts.map"],"mappings":";;;;;;;;AAE2C;AAkB3C;AAYA;KAxBKO,SAAAA,GAyBqBC;EACCA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAEXA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAIMJ,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EACEH,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAO6BA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAOjBA,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;CAAwBA;;;;;AAqB5BC,KAxDpBM,cAAAA,GAwDoBN,CAAAA,QAAAA,EAxDQF,QAwDRE,EAAAA,GAAAA,OAAAA;;;;;;AA5CgC;;;;;;cAA3CO,oBAAAA,SAA6BH,cAAAA;wBACxBE;yBACCA;;YAEXA;;;;oBAIMJ;sBACEH;;;;;;;mDAO6BA;;;;;;;kCAOjBA,wBAAwBA,qCAAqCM,UAAUG;;;;;;;gCAOzEN;;;;;;;4BAOJD;;;;;;;8BAOED;;;;;;8BAMAG;;;;;;;;8BAQAG,iCAAiCA,qCAAqCA"}

package/dist/structured_query/functional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functional.d.ts","names":["Document","Comparator","Comparison","Operation","Operator","StructuredQuery","BaseTranslator","ValueType","FunctionFilter","FunctionalTranslator","C"],"sources":["../../src/structured_query/functional.d.ts"],"sourcesContent":["import { Document } from \"../documents/document.js\";\nimport { Comparator, Comparison, Operation, Operator, StructuredQuery } from \"./ir.js\";\nimport { BaseTranslator } from \"./base.js\";\n/**\n * A type alias for an object that maps comparison operators to string or\n * number values. This is used in the comparison functions to determine\n * the result of a comparison operation.\n */\ntype ValueType = {\n    eq: string | number | boolean;\n    ne: string | number | boolean;\n    lt: string | number;\n    lte: string | number;\n    gt: string | number;\n    gte: string | number;\n};\n/**\n * A type alias for a function that takes a `Document` as an argument and\n * returns a boolean. This function is used as a filter for documents.\n */\nexport type FunctionFilter = (document: Document) => boolean;\n/**\n * A class that extends `BaseTranslator` to translate structured queries\n * into functional filters.\n * @example\n * ```typescript\n * const functionalTranslator = new FunctionalTranslator();\n * const relevantDocuments = await functionalTranslator.getRelevantDocuments(\n *   \"Which movies are rated higher than 8.5?\",\n * );\n * ```\n */\nexport declare class FunctionalTranslator extends BaseTranslator {\n    VisitOperationOutput: FunctionFilter;\n    VisitComparisonOutput: FunctionFilter;\n    VisitStructuredQueryOutput: {\n        filter: FunctionFilter;\n    } | {\n        [k: string]: never;\n    };\n    allowedOperators: Operator[];\n    allowedComparators: Comparator[];\n    formatFunction(): string;\n    /**\n     * Returns the allowed comparators for a given data type.\n     * @param input The input value to get the allowed comparators for.\n     * @returns An array of allowed comparators for the input data type.\n     */\n    getAllowedComparatorsForType(inputType: string): Comparator[];\n    /**\n     * Returns a function that performs a comparison based on the provided\n     * comparator.\n     * @param comparator The comparator to base the comparison function on.\n     * @returns A function that takes two arguments and returns a boolean based on the comparison.\n     */\n    getComparatorFunction<C extends Comparator>(comparator: Comparator): (a: string | number, b: ValueType[C]) => boolean;\n    /**\n     * Returns a function that performs an operation based on the provided\n     * operator.\n     * @param operator The operator to base the operation function on.\n     * @returns A function that takes two boolean arguments and returns a boolean based on the operation.\n     */\n    getOperatorFunction(operator: Operator): (a: boolean, b: boolean) => boolean;\n    /**\n     * Visits the operation part of a structured query and translates it into\n     * a functional filter.\n     * @param operation The operation part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the operation.\n     */\n    visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    /**\n     * Visits the comparison part of a structured query and translates it into\n     * a functional filter.\n     * @param comparison The comparison part of a structured query.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the comparison.\n     */\n    visitComparison(comparison: Comparison<string | number | boolean>): this[\"VisitComparisonOutput\"];\n    /**\n     * Visits a structured query and translates it into a functional filter.\n     * @param query The structured query to translate.\n     * @returns An object containing a `filter` property, which is a function that takes a `Document` as an argument and returns a boolean based on the structured query.\n     */\n    visitStructuredQuery(query: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n    /**\n     * Merges two filters into one, based on the specified merge type.\n     * @param defaultFilter The default filter function.\n     * @param generatedFilter The generated filter function.\n     * @param mergeType The type of merge to perform. Can be 'and', 'or', or 'replace'. Default is 'and'.\n     * @returns A function that takes a `Document` as an argument and returns a boolean based on the merged filters, or `undefined` if both filters are empty.\n     */\n    mergeFilters(defaultFilter: FunctionFilter, generatedFilter: FunctionFilter, mergeType?: string): FunctionFilter | undefined;\n}\nexport {};\n//# sourceMappingURL=functional.d.ts.map"],"mappings":";;;;;;;;AAE2C;AAkB3C;AAYA;KAxBKO,SAAAA,GAyBqBC;EACCA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAEXA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAIMJ,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EACEH,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAO6BA,EAAAA,EAAAA,MAAAA,GAAAA,MAAAA;EAOjBA,GAAAA,EAAAA,MAAAA,GAAAA,MAAAA;CAAwBA;;;;;AAqB5BC,KAxDpBM,cAAAA,GAwDoBN,CAAAA,QAAAA,EAxDQF,QAwDRE,EAAAA,GAAAA,OAAAA;;;;;;AA5CgC;;;;;;cAA3CO,oBAAAA,SAA6BH,cAAAA;wBACxBE;yBACCA;;YAEXA;;;;oBAIMJ;sBACEH;;;;;;;mDAO6BA;;;;;;;kCAOjBA,wBAAwBA,qCAAqCM,UAAUG;;;;;;;gCAOzEN;;;;;;;4BAOJD;;;;;;;8BAOED;;;;;;8BAMAG;;;;;;;;8BAQAG,iCAAiCA,qCAAqCA"}

package/dist/structured_query/ir.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.cts","names":["VectorStore","AND","OR","NOT","Operator","EQ","NE","LT","GT","LTE","GTE","Comparator","Operators","Comparators","VisitorResult","VisitorOperationResult","VisitorComparisonResult","VisitorStructuredQueryResult","Visitor","T","Operation","Comparison","StructuredQuery","Expression","FilterDirective","ValueTypes"],"sources":["../../src/structured_query/ir.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\nexport declare const Operators: {\n    [key: string]: Operator;\n};\nexport declare const Comparators: {\n    [key: string]: Comparator;\n};\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n    [operator: string]: VisitorResult[];\n};\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n    [attr: string]: {\n        [comparator: string]: string | number | boolean;\n    };\n};\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n    filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport declare abstract class Visitor<T extends VectorStore = VectorStore> {\n    VisitOperationOutput: object;\n    VisitComparisonOutput: object;\n    VisitStructuredQueryOutput: {\n        filter?: T[\"FilterType\"];\n    };\n    abstract allowedOperators: Operator[];\n    abstract allowedComparators: Comparator[];\n    abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    abstract visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    abstract visitStructuredQuery(structuredQuery: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n}\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport declare abstract class Expression {\n    abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n    accept(visitor: Visitor): object;\n}\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport declare abstract class FilterDirective extends Expression {\n}\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Comparison<ValueTypes = string | number> extends FilterDirective {\n    comparator: Comparator;\n    attribute: string;\n    value: ValueTypes;\n    exprName: \"Comparison\";\n    constructor(comparator: Comparator, attribute: string, value: ValueTypes);\n}\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Operation extends FilterDirective {\n    operator: Operator;\n    args?: FilterDirective[] | undefined;\n    exprName: \"Operation\";\n    constructor(operator: Operator, args?: FilterDirective[] | undefined);\n}\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport declare class StructuredQuery extends Expression {\n    query: string;\n    filter?: FilterDirective | undefined;\n    exprName: \"StructuredQuery\";\n    constructor(query: string, filter?: FilterDirective | undefined);\n}\n//# sourceMappingURL=ir.d.ts.map"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAA6BC,KARjBA,EAAAA,GAQiBA,IAAAA;;AAAQ;AAIrC;AAIYI,KAZAH,GAAAA,GAYE,KAAA;AAId;AAIA;AAIA;AAIYO,KAxBAN,QAAAA,GAAWH,GAwBR,GAxBcC,EAwBd,GAxBmBC,GAwBnB;AAKf;;;AAAmCI,KAzBvBF,EAAAA,GAyBuBE,IAAAA;;;;AAAmB,KArB1CD,EAAAA,GAqB0C,IAAA;AACtD;AAGA;AAOA;AAIYS,KAhCAR,EAAAA,GAgCAQ,IAAAA;AAMZ;AAQA;AAOA;AAAgDf,KAjDpCQ,EAAAA,GAiDoCR,IAAAA;;;;AAOfW,KApDrBF,GAAAA,GAoDqBE,KAAAA;;;;AAGiC,KAnDtDD,GAAAA,GAmDsD,KAAA;AAMlE;AAQA;AAMA;;AAGWe,KArECd,UAAAA,GAAaN,EAqEdoB,GArEmBnB,EAqEnBmB,GArEwBlB,EAqExBkB,GArE6BjB,EAqE7BiB,GArEkChB,GAqElCgB,GArEwCf,GAqExCe;AAEiBd,cAtEPC,SAsEOD,EAAAA;EAAsCc,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EArE/CrB,QAqE+CqB;CALID;AAAe,cA9DhEX,WA8DgE,EAAA;EAWhEO,CAAAA,GAAAA,EAAAA,MAAS,CAAA,EAxEXT,UAwEW;CAChBP;;;;;AADwC,KAlE1CU,aAAAA,GAAgBC,sBAkE0B,GAlEDC,uBAkEC;AAUtD;;;AAA6CO,KAxEjCR,sBAAAA,GAwEiCQ;EAAU,CAAA,QAAA,EAAA,MAAA,CAAA,EAvE/BT,aAuE+B,EAAA;;;;;KAlE3CE,uBAAAA;;;;;;;;KAQAC,4BAAAA;WACCD,0BAA0BD;;;;;;uBAMTG,kBAAkBlB,cAAcA;;;;aAI7CmB;;6BAEcf;+BACEO;qCACMS;uCACEC;iDACUC;;;;;;uBAMrBC,UAAAA;;kBAEVL;;;;;;uBAMUM,eAAAA,SAAwBD,UAAU;;;;;cAM3CF,iDAAiDG,eAAAA;cACtDb;;SAELc;;0BAEiBd,sCAAsCc;;;;;;cAM7CL,SAAAA,SAAkBI,eAAAA;YACzBpB;SACHoB;;wBAEepB,iBAAiBoB;;;;;;cAMtBF,eAAAA,SAAwBC,UAAAA;;WAEhCC;;sCAE2BA"}

package/dist/structured_query/ir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir.d.ts","names":["VectorStore","AND","OR","NOT","Operator","EQ","NE","LT","GT","LTE","GTE","Comparator","Operators","Comparators","VisitorResult","VisitorOperationResult","VisitorComparisonResult","VisitorStructuredQueryResult","Visitor","T","Operation","Comparison","StructuredQuery","Expression","FilterDirective","ValueTypes"],"sources":["../../src/structured_query/ir.d.ts"],"sourcesContent":["import { VectorStore } from \"../vectorstores.js\";\n/**\n * Represents logical AND operator.\n */\nexport type AND = \"and\";\n/**\n * Represents logical OR operator.\n */\nexport type OR = \"or\";\n/**\n * Represents logical NOT operator.\n */\nexport type NOT = \"not\";\n/**\n * Represents a logical operator which can be AND, OR, or NOT.\n */\nexport type Operator = AND | OR | NOT;\n/**\n * Represents equality comparison operator.\n */\nexport type EQ = \"eq\";\n/**\n * Represents inequality comparison operator.\n */\nexport type NE = \"ne\";\n/**\n * Represents less than comparison operator.\n */\nexport type LT = \"lt\";\n/**\n * Represents greater than comparison operator.\n */\nexport type GT = \"gt\";\n/**\n * Represents less than or equal to comparison operator.\n */\nexport type LTE = \"lte\";\n/**\n * Represents greater than or equal to comparison operator.\n */\nexport type GTE = \"gte\";\n/**\n * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or\n * GTE.\n */\nexport type Comparator = EQ | NE | LT | GT | LTE | GTE;\nexport declare const Operators: {\n    [key: string]: Operator;\n};\nexport declare const Comparators: {\n    [key: string]: Comparator;\n};\n/**\n * Represents the result of visiting an operation or comparison\n * expression.\n */\nexport type VisitorResult = VisitorOperationResult | VisitorComparisonResult;\n/**\n * Represents the result of visiting an operation expression.\n */\nexport type VisitorOperationResult = {\n    [operator: string]: VisitorResult[];\n};\n/**\n * Represents the result of visiting a comparison expression.\n */\nexport type VisitorComparisonResult = {\n    [attr: string]: {\n        [comparator: string]: string | number | boolean;\n    };\n};\n/**\n * Represents the result of visiting a structured query expression.\n */\nexport type VisitorStructuredQueryResult = {\n    filter?: VisitorComparisonResult | VisitorOperationResult;\n};\n/**\n * Abstract class for visiting expressions. Subclasses must implement\n * visitOperation, visitComparison, and visitStructuredQuery methods.\n */\nexport declare abstract class Visitor<T extends VectorStore = VectorStore> {\n    VisitOperationOutput: object;\n    VisitComparisonOutput: object;\n    VisitStructuredQueryOutput: {\n        filter?: T[\"FilterType\"];\n    };\n    abstract allowedOperators: Operator[];\n    abstract allowedComparators: Comparator[];\n    abstract visitOperation(operation: Operation): this[\"VisitOperationOutput\"];\n    abstract visitComparison(comparison: Comparison): this[\"VisitComparisonOutput\"];\n    abstract visitStructuredQuery(structuredQuery: StructuredQuery): this[\"VisitStructuredQueryOutput\"];\n}\n/**\n * Abstract class representing an expression. Subclasses must implement\n * the exprName property and the accept method.\n */\nexport declare abstract class Expression {\n    abstract exprName: \"Operation\" | \"Comparison\" | \"StructuredQuery\";\n    accept(visitor: Visitor): object;\n}\n/**\n * Abstract class representing a filter directive. It extends the\n * Expression class.\n */\nexport declare abstract class FilterDirective extends Expression {\n}\n/**\n * Class representing a comparison filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Comparison<ValueTypes = string | number> extends FilterDirective {\n    comparator: Comparator;\n    attribute: string;\n    value: ValueTypes;\n    exprName: \"Comparison\";\n    constructor(comparator: Comparator, attribute: string, value: ValueTypes);\n}\n/**\n * Class representing an operation filter directive. It extends the\n * FilterDirective class.\n */\nexport declare class Operation extends FilterDirective {\n    operator: Operator;\n    args?: FilterDirective[] | undefined;\n    exprName: \"Operation\";\n    constructor(operator: Operator, args?: FilterDirective[] | undefined);\n}\n/**\n * Class representing a structured query expression. It extends the\n * Expression class.\n */\nexport declare class StructuredQuery extends Expression {\n    query: string;\n    filter?: FilterDirective | undefined;\n    exprName: \"StructuredQuery\";\n    constructor(query: string, filter?: FilterDirective | undefined);\n}\n//# sourceMappingURL=ir.d.ts.map"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAA6BC,KARjBA,EAAAA,GAQiBA,IAAAA;;AAAQ;AAIrC;AAIYI,KAZAH,GAAAA,GAYE,KAAA;AAId;AAIA;AAIA;AAIYO,KAxBAN,QAAAA,GAAWH,GAwBR,GAxBcC,EAwBd,GAxBmBC,GAwBnB;AAKf;;;AAAmCI,KAzBvBF,EAAAA,GAyBuBE,IAAAA;;;;AAAmB,KArB1CD,EAAAA,GAqB0C,IAAA;AACtD;AAGA;AAOA;AAIYS,KAhCAR,EAAAA,GAgCAQ,IAAAA;AAMZ;AAQA;AAOA;AAAgDf,KAjDpCQ,EAAAA,GAiDoCR,IAAAA;;;;AAOfW,KApDrBF,GAAAA,GAoDqBE,KAAAA;;;;AAGiC,KAnDtDD,GAAAA,GAmDsD,KAAA;AAMlE;AAQA;AAMA;;AAGWe,KArECd,UAAAA,GAAaN,EAqEdoB,GArEmBnB,EAqEnBmB,GArEwBlB,EAqExBkB,GArE6BjB,EAqE7BiB,GArEkChB,GAqElCgB,GArEwCf,GAqExCe;AAEiBd,cAtEPC,SAsEOD,EAAAA;EAAsCc,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EArE/CrB,QAqE+CqB;CALID;AAAe,cA9DhEX,WA8DgE,EAAA;EAWhEO,CAAAA,GAAAA,EAAAA,MAAS,CAAA,EAxEXT,UAwEW;CAChBP;;;;;AADwC,KAlE1CU,aAAAA,GAAgBC,sBAkE0B,GAlEDC,uBAkEC;AAUtD;;;AAA6CO,KAxEjCR,sBAAAA,GAwEiCQ;EAAU,CAAA,QAAA,EAAA,MAAA,CAAA,EAvE/BT,aAuE+B,EAAA;;;;;KAlE3CE,uBAAAA;;;;;;;;KAQAC,4BAAAA;WACCD,0BAA0BD;;;;;;uBAMTG,kBAAkBlB,cAAcA;;;;aAI7CmB;;6BAEcf;+BACEO;qCACMS;uCACEC;iDACUC;;;;;;uBAMrBC,UAAAA;;kBAEVL;;;;;;uBAMUM,eAAAA,SAAwBD,UAAU;;;;;cAM3CF,iDAAiDG,eAAAA;cACtDb;;SAELc;;0BAEiBd,sCAAsCc;;;;;;cAM7CL,SAAAA,SAAkBI,eAAAA;YACzBpB;SACHoB;;wBAEepB,iBAAiBoB;;;;;;cAMtBF,eAAAA,SAAwBC,UAAAA;;WAEhCC;;sCAE2BA"}

package/dist/structured_query/utils.d.cts

@@ -2,15 +2,12 @@
 /**
  * Checks if the provided argument is an object and not an array.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare function isObject(obj: any): obj is object;
 /**
  * Checks if a provided filter is empty. The filter can be a function, an
  * object, a string, or undefined.
  */
-declare function isFilterEmpty(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-filter: ((q: any) => any) | object | string | undefined): filter is undefined;
+declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;
 /**
  * Checks if the provided value is an integer.
  */

package/dist/structured_query/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":["isObject","isFilterEmpty","isInt","isFloat","isString","isBoolean","castValue"],"sources":["../../src/structured_query/utils.d.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\nexport declare function isObject(obj: any): obj is object;\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;\n/**\n * Checks if the provided value is an integer.\n */\nexport declare function isInt(value: unknown): boolean;\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport declare function isFloat(value: unknown): boolean;\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport declare function isString(value: unknown): boolean;\n/**\n * Checks if the provided value is a boolean.\n */\nexport declare function isBoolean(value: unknown): boolean;\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport declare function castValue(input: unknown): string | number | boolean;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;AAGA;AAKA;AAIwBE,iBATAF,QAAAA,CASK,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAI7B;AAKA;AAIA;AAOA;iBAxBwBC,aAAAA;;;;iBAIAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}

package/dist/structured_query/utils.d.ts

@@ -2,15 +2,12 @@
 /**
  * Checks if the provided argument is an object and not an array.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 declare function isObject(obj: any): obj is object;
 /**
  * Checks if a provided filter is empty. The filter can be a function, an
  * object, a string, or undefined.
  */
-declare function isFilterEmpty(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-filter: ((q: any) => any) | object | string | undefined): filter is undefined;
+declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;
 /**
  * Checks if the provided value is an integer.
  */

package/dist/structured_query/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":["isObject","isFilterEmpty","isInt","isFloat","isString","isBoolean","castValue"],"sources":["../../src/structured_query/utils.d.ts"],"sourcesContent":["/**\n * Checks if the provided argument is an object and not an array.\n */\nexport declare function isObject(obj: any): obj is object;\n/**\n * Checks if a provided filter is empty. The filter can be a function, an\n * object, a string, or undefined.\n */\nexport declare function isFilterEmpty(filter: ((q: any) => any) | object | string | undefined): filter is undefined;\n/**\n * Checks if the provided value is an integer.\n */\nexport declare function isInt(value: unknown): boolean;\n/**\n * Checks if the provided value is a floating-point number.\n */\nexport declare function isFloat(value: unknown): boolean;\n/**\n * Checks if the provided value is a string that cannot be parsed into a\n * number.\n */\nexport declare function isString(value: unknown): boolean;\n/**\n * Checks if the provided value is a boolean.\n */\nexport declare function isBoolean(value: unknown): boolean;\n/**\n * Casts a value that might be string or number to actual string or number.\n * Since LLM might return back an integer/float as a string, we need to cast\n * it back to a number, as many vector databases can't handle number as string\n * values as a comparator.\n */\nexport declare function castValue(input: unknown): string | number | boolean;\n//# sourceMappingURL=utils.d.ts.map"],"mappings":";;AAGA;AAKA;AAIwBE,iBATAF,QAAAA,CASK,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAI7B;AAKA;AAIA;AAOA;iBAxBwBC,aAAAA;;;;iBAIAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}

package/dist/tools/index.d.cts

@@ -94,7 +94,6 @@ declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool
    * @param callbacks Optional callbacks for the tool.
    * @returns A Promise that resolves with a string.
    */
-  // Match the base class signature including the generics and conditional return type
   call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
@@ -111,9 +110,7 @@ declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT
    */
   call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
   /** @ignore */
-  _call(input: string,
-  // DynamicTool's _call specifically expects a string after schema transformation
-  runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
+  _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
 }
 /**
  * A tool that can be created dynamically from a function, name, and
@@ -134,7 +131,6 @@ declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT
   /**
    * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
    */
-  // Match the base class signature
   call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, /** @deprecated */
   tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
   protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;
@@ -212,7 +208,6 @@ declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZ
 declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 declare function tool<SchemaT extends JsonSchema7Type, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 declare function tool<SchemaT extends InteropZodObject | InteropZodType<string> | JsonSchema7Type = InteropZodObject, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> | DynamicTool<ToolOutputT>;
-// Overloads with ToolRuntime as CallOptions
 declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
 declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
 declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","RunnableToolLike","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","InteropZodObject","InteropZodType","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","ToolRuntime","JSONSchema","BaseDynamicToolInput","ContentAndArtifact","StructuredToolParams","ToolSchemaBase","isLangChainTool","isRunnableToolLike","isStructuredTool","isStructuredToolParams","StructuredTool","TInput","TConfig","TArg","SchemaT","SchemaOutputT","SchemaInputT","ToolOutputT","Record","Promise","Tool","ZodString","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","input","NonNullable","DynamicTool","DynamicStructuredTool","Parameters","BaseToolkit","ToolWrapperParams","RunInput","tool","TState","TContext","ServerTool","ClientTool"],"sources":["../../src/tools/index.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport { BaseLangChain } from \"../language_models/base.js\";\nimport { type RunnableConfig } from \"../runnables/config.js\";\nimport type { RunnableFunc } from \"../runnables/base.js\";\nimport { ToolCall, ToolMessage } from \"../messages/tool.js\";\nimport type { RunnableToolLike } from \"../runnables/base.js\";\nimport { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodObject, type InteropZodType, type ZodStringV3, type ZodStringV4, type ZodObjectV3, type ZodObjectV4 } from \"../utils/types/zod.js\";\nimport type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, StringInputToolSchema, ToolInterface, ToolOutputType, ToolRuntime } from \"./types.js\";\nimport { type JSONSchema } from \"../utils/json_schema.js\";\nexport type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } from \"./types.js\";\nexport { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, type ToolRuntime, } from \"./types.js\";\nexport { ToolInputParsingException };\n/**\n * Base class for Tools that accept input of any shape defined by a Zod schema.\n */\nexport declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    abstract name: string;\n    abstract description: string;\n    abstract schema: SchemaT;\n    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect: boolean;\n    verboseParsingErrors: boolean;\n    get lc_namespace(): string[];\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Default config object for the tool runnable.\n     */\n    defaultConfig?: ToolRunnableConfig;\n    constructor(fields?: ToolParams);\n    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n    /**\n     * Invokes the tool with the provided input and configuration.\n     * @param input The input for the tool.\n     * @param config Optional configuration for the tool.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(input: TInput, config?: TConfig): Promise<ToolReturnType<TInput, TConfig, ToolOutputT>>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument, configuration, and tags. It\n     * parses the input according to the schema, handles any errors, and\n     * manages callbacks.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration or callbacks for the tool.\n     * @param tags Optional tags for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n}\n/**\n * Base class for Tools that accept input as a string.\n */\nexport declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool<StringInputToolSchema, ToolInputSchemaOutputType<StringInputToolSchema>, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> implements ToolInterface<StringInputToolSchema, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> {\n    schema: z.ZodEffects<z.ZodObject<{\n        input: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        input?: string | undefined;\n    }, {\n        input?: string | undefined;\n    }>, string | undefined, {\n        input?: string | undefined;\n    }>;\n    constructor(fields?: ToolParams);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument and callbacks. It handles\n     * string inputs specifically.\n     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n     * @param callbacks Optional callbacks for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and description.\n */\nexport declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT> {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    func: DynamicToolInput<ToolOutputT>[\"func\"];\n    constructor(fields: DynamicToolInput<ToolOutputT>);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    /** @ignore */\n    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and\n * description, designed to work with structured data. It extends the\n * StructuredTool class and overrides the _call method to execute the\n * provided function when the tool is called.\n *\n * Schema can be passed as Zod or JSON schema. The tool will not validate\n * input if JSON schema is passed.\n */\nexport declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>[\"func\"];\n    schema: SchemaT;\n    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * Abstract base class for toolkits in LangChain. Toolkits are collections\n * of tools that agents can use. Subclasses must implement the `tools`\n * property to provide the specific tools for the toolkit.\n */\nexport declare abstract class BaseToolkit {\n    abstract tools: StructuredToolInterface[];\n    getTools(): StructuredToolInterface[];\n}\n/**\n * Parameters for the tool function.\n * Schema can be provided as Zod or JSON schema.\n * Both schema types will be validated.\n * @template {ToolInputSchemaBase} RunInput The input schema for the tool.\n */\ninterface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined> extends ToolParams {\n    /**\n     * The name of the tool. If using with an LLM, this\n     * will be passed as the tool name.\n     */\n    name: string;\n    /**\n     * The description of the tool.\n     * @default `${fields.name} tool`\n     */\n    description?: string;\n    /**\n     * The input schema for the tool. If using an LLM, this\n     * will be passed as the tool schema to generate arguments\n     * for.\n     */\n    schema?: RunInput;\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect?: boolean;\n}\n/**\n * Creates a new StructuredTool instance with the provided function, name, description, and schema.\n *\n * Schema can be provided as Zod or JSON schema, and both will be validated.\n *\n * @function\n * @template {ToolInputSchemaBase} SchemaT The input schema for the tool.\n * @template {ToolReturnType} ToolOutputT The output type of the tool.\n *\n * @param {RunnableFunc<z.output<SchemaT>, ToolOutputT>} func - The function to invoke when the tool is called.\n * @param {ToolWrapperParams<SchemaT>} fields - An object containing the following properties:\n * @param {string} fields.name The name of the tool.\n * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.\n * @param {z.AnyZodObject | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.\n *\n * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.\n */\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends InteropZodObject | InteropZodType<string> | JSONSchema = InteropZodObject, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> | DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\n//# sourceMappingURL=index.d.ts.map"],"mappings":"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"}

package/dist/tools/index.d.ts

@@ -96,7 +96,6 @@ declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool
    * @param callbacks Optional callbacks for the tool.
    * @returns A Promise that resolves with a string.
    */
-  // Match the base class signature including the generics and conditional return type
   call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
@@ -113,9 +112,7 @@ declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT
    */
   call<TArg extends string | undefined | z.input<this["schema"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
   /** @ignore */
-  _call(input: string,
-  // DynamicTool's _call specifically expects a string after schema transformation
-  runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
+  _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
 }
 /**
  * A tool that can be created dynamically from a function, name, and
@@ -136,7 +133,6 @@ declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT
   /**
    * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
    */
-  // Match the base class signature
   call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, /** @deprecated */
   tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
   protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>["func"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;
@@ -214,7 +210,6 @@ declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZ
 declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 declare function tool<SchemaT extends JsonSchema7Type, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 declare function tool<SchemaT extends InteropZodObject | InteropZodType<string> | JsonSchema7Type = InteropZodObject, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> | DynamicTool<ToolOutputT>;
-// Overloads with ToolRuntime as CallOptions
 declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
 declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
 declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","RunnableToolLike","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","InteropZodObject","InteropZodType","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","ToolRuntime","JSONSchema","BaseDynamicToolInput","ContentAndArtifact","StructuredToolParams","ToolSchemaBase","isLangChainTool","isRunnableToolLike","isStructuredTool","isStructuredToolParams","StructuredTool","TInput","TConfig","TArg","SchemaT","SchemaOutputT","SchemaInputT","ToolOutputT","Record","Promise","Tool","ZodString","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","input","NonNullable","DynamicTool","DynamicStructuredTool","Parameters","BaseToolkit","ToolWrapperParams","RunInput","tool","TState","TContext","ServerTool","ClientTool"],"sources":["../../src/tools/index.d.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport { BaseLangChain } from \"../language_models/base.js\";\nimport { type RunnableConfig } from \"../runnables/config.js\";\nimport type { RunnableFunc } from \"../runnables/base.js\";\nimport { ToolCall, ToolMessage } from \"../messages/tool.js\";\nimport type { RunnableToolLike } from \"../runnables/base.js\";\nimport { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodObject, type InteropZodType, type ZodStringV3, type ZodStringV4, type ZodObjectV3, type ZodObjectV4 } from \"../utils/types/zod.js\";\nimport type { StructuredToolCallInput, ToolInputSchemaBase, ToolReturnType, ResponseFormat, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolParams, ToolRunnableConfig, StructuredToolInterface, DynamicToolInput, DynamicStructuredToolInput, StringInputToolSchema, ToolInterface, ToolOutputType, ToolRuntime } from \"./types.js\";\nimport { type JSONSchema } from \"../utils/json_schema.js\";\nexport type { BaseDynamicToolInput, ContentAndArtifact, DynamicToolInput, DynamicStructuredToolInput, ResponseFormat, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInterface, ToolParams, ToolReturnType, ToolRunnableConfig, ToolInputSchemaBase as ToolSchemaBase, } from \"./types.js\";\nexport { isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, type ToolRuntime, } from \"./types.js\";\nexport { ToolInputParsingException };\n/**\n * Base class for Tools that accept input of any shape defined by a Zod schema.\n */\nexport declare abstract class StructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseLangChain<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\n    abstract name: string;\n    abstract description: string;\n    abstract schema: SchemaT;\n    /**\n     * Optional provider-specific extra fields for the tool.\n     *\n     * This is used to pass provider-specific configuration that doesn't fit into\n     * standard tool fields.\n     */\n    extras?: Record<string, unknown>;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect: boolean;\n    verboseParsingErrors: boolean;\n    get lc_namespace(): string[];\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Default config object for the tool runnable.\n     */\n    defaultConfig?: ToolRunnableConfig;\n    constructor(fields?: ToolParams);\n    protected abstract _call(arg: SchemaOutputT, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n    /**\n     * Invokes the tool with the provided input and configuration.\n     * @param input The input for the tool.\n     * @param config Optional configuration for the tool.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(input: TInput, config?: TConfig): Promise<ToolReturnType<TInput, TConfig, ToolOutputT>>;\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument, configuration, and tags. It\n     * parses the input according to the schema, handles any errors, and\n     * manages callbacks.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration or callbacks for the tool.\n     * @param tags Optional tags for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>>;\n}\n/**\n * Base class for Tools that accept input as a string.\n */\nexport declare abstract class Tool<ToolOutputT = ToolOutputType> extends StructuredTool<StringInputToolSchema, ToolInputSchemaOutputType<StringInputToolSchema>, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> implements ToolInterface<StringInputToolSchema, ToolInputSchemaInputType<StringInputToolSchema>, ToolOutputT> {\n    schema: z.ZodEffects<z.ZodObject<{\n        input: z.ZodOptional<z.ZodString>;\n    }, \"strip\", z.ZodTypeAny, {\n        input?: string | undefined;\n    }, {\n        input?: string | undefined;\n    }>, string | undefined, {\n        input?: string | undefined;\n    }>;\n    constructor(fields?: ToolParams);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     *\n     * Calls the tool with the provided argument and callbacks. It handles\n     * string inputs specifically.\n     * @param arg The input argument for the tool, which can be a string, undefined, or an input of the tool's schema.\n     * @param callbacks Optional callbacks for the tool.\n     * @returns A Promise that resolves with a string.\n     */\n    call<TArg extends string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and description.\n */\nexport declare class DynamicTool<ToolOutputT = ToolOutputType> extends Tool<ToolOutputT> {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    func: DynamicToolInput<ToolOutputT>[\"func\"];\n    constructor(fields: DynamicToolInput<ToolOutputT>);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends string | undefined | z.input<this[\"schema\"]> | ToolCall, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    /** @ignore */\n    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * A tool that can be created dynamically from a function, name, and\n * description, designed to work with structured data. It extends the\n * StructuredTool class and overrides the _call method to execute the\n * provided function when the tool is called.\n *\n * Schema can be passed as Zod or JSON schema. The tool will not validate\n * input if JSON schema is passed.\n */\nexport declare class DynamicStructuredTool<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {\n    static lc_name(): string;\n    name: string;\n    description: string;\n    func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>[\"func\"];\n    schema: SchemaT;\n    constructor(fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>);\n    /**\n     * @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n     */\n    call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig, \n    /** @deprecated */\n    tags?: string[]): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n    protected _call(arg: Parameters<DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]>[0], runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolOutputT>;\n}\n/**\n * Abstract base class for toolkits in LangChain. Toolkits are collections\n * of tools that agents can use. Subclasses must implement the `tools`\n * property to provide the specific tools for the toolkit.\n */\nexport declare abstract class BaseToolkit {\n    abstract tools: StructuredToolInterface[];\n    getTools(): StructuredToolInterface[];\n}\n/**\n * Parameters for the tool function.\n * Schema can be provided as Zod or JSON schema.\n * Both schema types will be validated.\n * @template {ToolInputSchemaBase} RunInput The input schema for the tool.\n */\ninterface ToolWrapperParams<RunInput = ToolInputSchemaBase | undefined> extends ToolParams {\n    /**\n     * The name of the tool. If using with an LLM, this\n     * will be passed as the tool name.\n     */\n    name: string;\n    /**\n     * The description of the tool.\n     * @default `${fields.name} tool`\n     */\n    description?: string;\n    /**\n     * The input schema for the tool. If using an LLM, this\n     * will be passed as the tool schema to generate arguments\n     * for.\n     */\n    schema?: RunInput;\n    /**\n     * The tool response format.\n     *\n     * If \"content\" then the output of the tool is interpreted as the contents of a\n     * ToolMessage. If \"content_and_artifact\" then the output is expected to be a\n     * two-tuple corresponding to the (content, artifact) of a ToolMessage.\n     *\n     * @default \"content\"\n     */\n    responseFormat?: ResponseFormat;\n    /**\n     * Whether to return the tool's output directly.\n     *\n     * Setting this to true means that after the tool is called,\n     * an agent should stop looping.\n     */\n    returnDirect?: boolean;\n}\n/**\n * Creates a new StructuredTool instance with the provided function, name, description, and schema.\n *\n * Schema can be provided as Zod or JSON schema, and both will be validated.\n *\n * @function\n * @template {ToolInputSchemaBase} SchemaT The input schema for the tool.\n * @template {ToolReturnType} ToolOutputT The output type of the tool.\n *\n * @param {RunnableFunc<z.output<SchemaT>, ToolOutputT>} func - The function to invoke when the tool is called.\n * @param {ToolWrapperParams<SchemaT>} fields - An object containing the following properties:\n * @param {string} fields.name The name of the tool.\n * @param {string | undefined} fields.description The description of the tool. Defaults to either the description on the Zod schema, or `${fields.name} tool`.\n * @param {z.AnyZodObject | z.ZodString | undefined} fields.schema The Zod schema defining the input for the tool. If undefined, it will default to a Zod string schema.\n *\n * @returns {DynamicStructuredTool<SchemaT>} A new StructuredTool instance.\n */\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends InteropZodObject | InteropZodType<string> | JSONSchema = InteropZodObject, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> | DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: InferInteropZodOutput<SchemaT>, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV3, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: SchemaOutputT, runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport declare function tool<SchemaT extends JSONSchema, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType, TState = unknown, TContext = unknown>(func: (input: Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0], runtime: ToolRuntime<TState, TContext>) => ToolOutputT | Promise<ToolOutputT>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\nexport type ServerTool = Record<string, unknown>;\nexport type ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\n//# sourceMappingURL=index.d.ts.map"],"mappings":"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"}

package/dist/tools/types.d.cts

@@ -11,9 +11,7 @@ import { z } from "zod/v3";
 
 //#region src/tools/types.d.ts
 type ResponseFormat = "content" | "content_and_artifact" | string;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ToolOutputType = any;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type ContentAndArtifact = [MessageContent, any];
 /**
  * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.
@@ -75,11 +73,7 @@ interface ToolParams extends BaseLangChainParams {
    */
   extras?: Record<string, unknown>;
 }
-type ToolRunnableConfig<
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-ConfigurableFieldType extends Record<string, any> = Record<string, any>,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-ContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {
+type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>, ContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {
   toolCall?: ToolCall;
   context?: ContextSchema;
 };
@@ -134,9 +128,7 @@ type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolI
  * This is primarily used for creating simple string-based tools where the LLM
  * only needs to provide a single text value as input to the tool.
  */
-type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef,
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-any>;
+type StringInputToolSchema = z.ZodType<string | undefined, z.ZodTypeDef, any>;
 /**
  * Interface that defines the shape of a LangChain structured tool.
  *
@@ -211,9 +203,7 @@ interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInpu
    * @param callbacks Optional callbacks for the tool.
    * @returns A Promise that resolves with a string.
    */
-  call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(
-  // TODO: shouldn't this be narrowed based on SchemaT?
-  arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
+  call<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;
 }
 /**
  * Base interface for the input parameters of the {@link DynamicTool} and