@langchain/core 1.0.6 → 1.1.0

package/dist/runnables/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":["SerializableInterface","BaseCallbackConfig","IterableReadableStreamInterface","InteropZodType","RunnableBatchOptions","RunnableIOSchema","RunnableInterface","RunnableConfig","RunInput","CallOptions","Partial","RunOutput","Promise","Error","AsyncGenerator","Edge","Node","Record","ConfigurableFieldType","AbortSignal"],"sources":["../../src/runnables/types.d.ts"],"sourcesContent":["import type { SerializableInterface } from \"../load/serializable.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport type { IterableReadableStreamInterface } from \"../types/_internal.js\";\nimport { InteropZodType } from \"../utils/types/zod.js\";\nexport type RunnableBatchOptions = {\n    /** @deprecated Pass in via the standard runnable config object instead */\n    maxConcurrency?: number;\n    returnExceptions?: boolean;\n};\nexport type RunnableIOSchema = {\n    name?: string;\n    schema: InteropZodType;\n};\n/**\n * Base interface implemented by all runnables.\n * Used for cross-compatibility between different versions of LangChain core.\n *\n * Should not change on patch releases.\n */\nexport interface RunnableInterface<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunInput = any, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nRunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends SerializableInterface {\n    lc_serializable: boolean;\n    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions?: false;\n    }): Promise<RunOutput[]>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions: true;\n    }): Promise<(RunOutput | Error)[]>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;\n    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;\n    getName(suffix?: string): string;\n}\nexport interface Edge {\n    source: string;\n    target: string;\n    data?: string;\n    conditional?: boolean;\n}\nexport interface Node {\n    id: string;\n    name: string;\n    data: RunnableIOSchema | RunnableInterface;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    metadata?: Record<string, any>;\n}\nexport interface RunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>> extends BaseCallbackConfig {\n    /**\n     * Runtime values for attributes previously made configurable on this Runnable,\n     * or sub-Runnables.\n     */\n    configurable?: ConfigurableFieldType;\n    /**\n     * Maximum number of times a call can recurse. If not provided, defaults to 25.\n     */\n    recursionLimit?: number;\n    /** Maximum number of parallel calls to make. */\n    maxConcurrency?: number;\n    /**\n     * Timeout for this call in milliseconds.\n     */\n    timeout?: number;\n    /**\n     * Abort signal for this call.\n     * If provided, the call will be aborted when the signal is aborted.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal\n     */\n    signal?: AbortSignal;\n}\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.cts","names":["BaseCallbackHandler","setContextVariable","PropertyKey","T","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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n"],"mappings":";;;;;;AAmDA;;;;AAAyE;AAmDzE;;;;AAAyE;AA+CzE;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAnGwBC,4BAA4BC,oBAAoBC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDhDC,kCAAkCF,cAAcC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDI,gCAAgCD;KACzCA,aAAAA;;;;yCAI+BN"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","names":["BaseCallbackHandler","setContextVariable","PropertyKey","T","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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n"],"mappings":";;;;;;AAmDA;;;;AAAyE;AAmDzE;;;;AAAyE;AA+CzE;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAnGwBC,4BAA4BC,oBAAoBC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDhDC,kCAAkCF,cAAcC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDI,gCAAgCD;KACzCA,aAAAA;;;;yCAI+BN"}

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

@@ -1 +0,0 @@
-{"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":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport 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"],"mappings":";;AACiBA,UAAAA,0BAAAA,CAA0B;EAAA,QAAA,EAAA,GAAA,GAAA,GAAA,GAAA,SAAA;EAAA,GAEFC,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,CAAAA,EAAAA,GAAMA,CAANA;EAAC,SAAKA,EAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,GAAAA,IAAAA;AAAC;cAI3BE"}

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

@@ -1 +0,0 @@
-{"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":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport 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"],"mappings":";;AACiBA,UAAAA,0BAAAA,CAA0B;EAAA,QAAA,EAAA,GAAA,GAAA,GAAA,GAAA,SAAA;EAAA,GAEFC,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,CAAAA,EAAAA,GAAMA,CAANA;EAAC,SAAKA,EAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,GAAAA,IAAAA;AAAC;cAI3BE"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;cACqBC,qBAAAA,YAAiCD;;EAAjCC,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAqB,EAAA,GAAA,GAEFC,CAFE,CAAA,EAEEA,CAFF;EAAA,SAAA,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,SAAA;;cAK5BC,yBAAAA,CAH8BD;EAAC,WAFSF,CAAAA,CAAAA,EAMnCA,0BANmCA;EAA0B,iBAAA,CAAA,CAAA,EAAA,GAAA;EAKlEG,aAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAyB,EAAA,QAAA,EAAA,GAAA,GAGWD,CAHX,EAAA,wBAAA,CAAA,EAAA,OAAA,CAAA,EAGmDA,CAHnD;EAAA,wBAAA,CAAA,QAAA,EAIAF,0BAJA,CAAA,EAAA,IAAA;;cAMzBI,kCAHoCF,EAGAC,yBAHAD"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;cACqBC,qBAAAA,YAAiCD;;EAAjCC,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAqB,EAAA,GAAA,GAEFC,CAFE,CAAA,EAEEA,CAFF;EAAA,SAAA,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,SAAA;;cAK5BC,yBAAAA,CAH8BD;EAAC,WAFSF,CAAAA,CAAAA,EAMnCA,0BANmCA;EAA0B,iBAAA,CAAA,CAAA,EAAA,GAAA;EAKlEG,aAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAyB,EAAA,QAAA,EAAA,GAAA,GAGWD,CAHX,EAAA,wBAAA,CAAA,EAAA,OAAA,CAAA,EAGmDA,CAHnD;EAAA,wBAAA,CAAA,QAAA,EAIAF,0BAJA,CAAA,EAAA,IAAA;;cAMzBI,kCAHoCF,EAGAC,yBAHAD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"callbacks.d.cts","names":["PQueueMod","getQueue","consumeCallback","T","Promise","awaitAllCallbacks"],"sources":["../../src/singletons/callbacks.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport 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"],"mappings":";;;;;;AAQ0G;AAKlFK,iBALAH,eAKqBE,CAAAA,CAAAA,CAAAA,CAAO,SAAA,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

@@ -1 +0,0 @@
-{"version":3,"file":"callbacks.d.ts","names":["PQueueMod","getQueue","consumeCallback","T","Promise","awaitAllCallbacks"],"sources":["../../src/singletons/callbacks.d.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport 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"],"mappings":";;;;AAQA;;;;;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.map

@@ -1 +0,0 @@
-{"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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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"],"mappings":";;;;;;AAIA;AAAuC,uBAATC,SAAS,CAAA,CAAA,EAAA,CAAA,CAAA,SAAeD,YAAAA,CAAf;EAAA;;;;;EAYD,SAAMI,IAAAA,CAAAA,IAAAA,EANpBF,CAMoBE,EAAAA,CAAAA,EANdA,OAMcA,CAAAA,CANLD,CAMKC,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAO;;;;;EAZe,SAAA,IAAA,CAAA,aAAA,EAAA,CAYhCF,CAZgC,EAY7BC,CAZ6B,CAAA,EAAA,CAAA,EAYtBC,OAZsB,CAAA,IAAA,CAAA;EA8C7CE;;;;;EAEM,SAMOC,OAAAA,CAAAA,IAAAA,EApCPL,CAoCOK,EAAAA,CAAAA,EApCDH,OAoCCG,CAAAA,IAAAA,CAAAA;EAAC;;;;;EAmBuB,SA3BNN,SAAAA,CAAAA,MAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAtBXI,cAsBWJ,CAtBIC,CAsBJD,GAAAA,MAAAA,CAAAA;AAAS;;;;;;;;;;;;;;;;;;;;;cAAxCK,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}

package/dist/stores.d.ts.map

@@ -1 +0,0 @@
-{"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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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"],"mappings":";;;;;;AAIA;AAAuC,uBAATC,SAAS,CAAA,CAAA,EAAA,CAAA,CAAA,SAAeD,YAAAA,CAAf;EAAA;;;;;EAYD,SAAMI,IAAAA,CAAAA,IAAAA,EANpBF,CAMoBE,EAAAA,CAAAA,EANdA,OAMcA,CAAAA,CANLD,CAMKC,GAAAA,SAAAA,CAAAA,EAAAA,CAAAA;EAAO;;;;;EAZe,SAAA,IAAA,CAAA,aAAA,EAAA,CAYhCF,CAZgC,EAY7BC,CAZ6B,CAAA,EAAA,CAAA,EAYtBC,OAZsB,CAAA,IAAA,CAAA;EA8C7CE;;;;;EAEM,SAMOC,OAAAA,CAAAA,IAAAA,EApCPL,CAoCOK,EAAAA,CAAAA,EApCDH,OAoCCG,CAAAA,IAAAA,CAAAA;EAAC;;;;;EAmBuB,SA3BNN,SAAAA,CAAAA,MAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAtBXI,cAsBWJ,CAtBIC,CAsBJD,GAAAA,MAAAA,CAAAA;AAAS;;;;;;;;;;;;;;;;;;;;;cAAxCK,+BAA+BL,kBAAkBM;;mBAEjDC,eAAeD;;;;;;wBAMVH,QAAQG;;;;;;+BAMDA,OAAOH;;;;;;2BAMXA;;;;;;;0CAOeC"}

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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;AAMA;;AACsBI,KADVM,cAAAA,GACUN;EAAQ,gBACNH,EADFG,QACEH,EAAAA;EAAU,kBAAA,EAAVA,UAAU,EAAA;AAOlC,CAAA;;;;;;AAO6CA,uBAPfU,cAOeV,CAAAA,UAPUD,WAOVC,GAPwBD,WAOxBC,CAAAA,SAP6CK,OAO7CL,CAPqDW,CAOrDX,CAAAA,CAAAA;EAAU;AAP0C;AA0BjG;;;;EAAwE,SAAyBW,cAAAA,CAAAA,IAAAA,EAnB/DR,QAmB+DQ,GAnBpDX,UAmBoDW,CAAAA,EAAAA,MAAAA;EAAC;;;;;;;;EAOpD,SAMhBT,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;;;;;;;AAbkE;;;cAA3EU,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;AAMA;;AACsBI,KADVM,cAAAA,GACUN;EAAQ,gBACNH,EADFG,QACEH,EAAAA;EAAU,kBAAA,EAAVA,UAAU,EAAA;AAOlC,CAAA;;;;;;AAO6CA,uBAPfU,cAOeV,CAAAA,UAPUD,WAOVC,GAPwBD,WAOxBC,CAAAA,SAP6CK,OAO7CL,CAPqDW,CAOrDX,CAAAA,CAAAA;EAAU;AAP0C;AA0BjG;;;;EAAwE,SAAyBW,cAAAA,CAAAA,IAAAA,EAnB/DR,QAmB+DQ,GAnBpDX,UAmBoDW,CAAAA,EAAAA,MAAAA;EAAC;;;;;;;;EAOpD,SAMhBT,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;;;;;;;AAbkE;;;cAA3EU,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;AAE2C;AAkB3C;AAYA;KAxBKO,SAAAA,GAwBoC;EAAA,EAAA,EACfC,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAc,EAAA,EACbA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAc,EAAA,EAEzBA,MAAAA,GAAAA,MAAAA;EAAc,GAIRJ,EAAAA,MAAAA,GAAAA,MAAAA;EAAQ,EAAA,EACNH,MAAAA,GAAAA,MAAAA;EAAU,GAOmBA,EAAAA,MAAAA,GAAAA,MAAAA;CAAU;;;;;AAqBjCE,KAjDlBK,cAAAA,GAiDkBL,CAAAA,QAAAA,EAjDUH,QAiDVG,EAAAA,GAAAA,OAAAA;;;;;;;AArCkC;;;;;cAA3CM,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;;;AAE2C;AAkB3C;AAYA;KAxBKO,SAAAA,GAwBoC;EAAA,EAAA,EACfC,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAc,EAAA,EACbA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAc,EAAA,EAEzBA,MAAAA,GAAAA,MAAAA;EAAc,GAIRJ,EAAAA,MAAAA,GAAAA,MAAAA;EAAQ,EAAA,EACNH,MAAAA,GAAAA,MAAAA;EAAU,GAOmBA,EAAAA,MAAAA,GAAAA,MAAAA;CAAU;;;;;AAqBjCE,KAjDlBK,cAAAA,GAiDkBL,CAAAA,QAAAA,EAjDUH,QAiDVG,EAAAA,GAAAA,OAAAA;;;;;;;AArCkC;;;;;cAA3CM,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAAuBA,KARXC,EAAAA,GAQWD,IAAAA;;;AAAc;AAIzBI,KARAF,GAAAA,GAQE,KAAA;AAId;AAIA;AAIA;AAIYM,KApBAL,QAAAA,GAAWH,GAoBR,GApBcC,EAoBd,GApBmBC,GAoBnB;AAIf;AAKA;;AAAyBE,KAzBbA,EAAAA,GAyBaA,IAAAA;;;;AAAoBI,KArBjCH,EAAAA,GAqBiCG,IAAAA;;AAAS;AACtD;AAGqBI,KArBTN,EAAAA,GAqBSM,IAEpB;AAKD;;;AAAqDG,KAxBzCR,EAAAA,GAwByCQ,IAAAA;AAAuB;AAI5E;AAMA;AAQYC,KAtCAR,GAAAA,GAsCAQ,KAAAA;;;;AACiD,KAnCjDP,GAAAA,GAmCiD,KAAA;AAM7D;;;;AAIiBS,KAxCLR,UAAAA,GAAaN,EAwCRc,GAxCab,EAwCba,GAxCkBZ,EAwClBY,GAxCuBX,EAwCvBW,GAxC4BV,GAwC5BU,GAxCkCT,GAwClCS;AAEcf,cAzCVQ,SAyCUR,EAAAA;EAAQ,CAAA,GACNO,EAAAA,MAAAA,CAAAA,EAzCdP,QAyCcO;CAAU;AAEFU,cAzCpBR,WAyCoBQ,EAAAA;EAAU,CAAA,GACAC,EAAAA,MAAAA,CAAAA,EAzChCX,UAyCgCW;AAAe,CAAA;AAMlE;AAQA;AAMA;;AACgBX,KAxDJG,aAAAA,GAAgBC,sBAwDZJ,GAxDqCK,uBAwDrCL;;;;AADsDa,KAnD1DT,sBAAAA,GAmD0DS;EAAe,CAAA,QAAA,EAAA,MAAA,CAAA,EAlD7DV,aAkD6D,EAAA;AAWrF,CAAA;;;;AAI0BV,KA5DdY,uBAAAA,GA4DcZ;EAAQ,CAAA,IAASoB,EAAAA,MAAAA,CAAAA,EAAAA;IAJJA,CAAAA,UAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAe,CAAA;AAUtD,CAAA;;;;AAA6CD,KA1DjCN,4BAAAA,GA0DiCM;EAAU,MAAA,CAAA,EAzD1CP,uBAyD0C,GAzDhBD,sBAyDgB;;;;;;uBAnDzBG,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

@@ -1 +0,0 @@
-{"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"],"mappings":";;;;;;AAIA;AAIYE,KAJAD,GAAAA,GAIE,KAAA;AAId;AAIA;;AAAuBA,KARXC,EAAAA,GAQWD,IAAAA;;;AAAc;AAIzBI,KARAF,GAAAA,GAQE,KAAA;AAId;AAIA;AAIA;AAIYM,KApBAL,QAAAA,GAAWH,GAoBR,GApBcC,EAoBd,GApBmBC,GAoBnB;AAIf;AAKA;;AAAyBE,KAzBbA,EAAAA,GAyBaA,IAAAA;;;;AAAoBI,KArBjCH,EAAAA,GAqBiCG,IAAAA;;AAAS;AACtD;AAGqBI,KArBTN,EAAAA,GAqBSM,IAEpB;AAKD;;;AAAqDG,KAxBzCR,EAAAA,GAwByCQ,IAAAA;AAAuB;AAI5E;AAMA;AAQYC,KAtCAR,GAAAA,GAsCAQ,KAAAA;;;;AACiD,KAnCjDP,GAAAA,GAmCiD,KAAA;AAM7D;;;;AAIiBS,KAxCLR,UAAAA,GAAaN,EAwCRc,GAxCab,EAwCba,GAxCkBZ,EAwClBY,GAxCuBX,EAwCvBW,GAxC4BV,GAwC5BU,GAxCkCT,GAwClCS;AAEcf,cAzCVQ,SAyCUR,EAAAA;EAAQ,CAAA,GACNO,EAAAA,MAAAA,CAAAA,EAzCdP,QAyCcO;CAAU;AAEFU,cAzCpBR,WAyCoBQ,EAAAA;EAAU,CAAA,GACAC,EAAAA,MAAAA,CAAAA,EAzChCX,UAyCgCW;AAAe,CAAA;AAMlE;AAQA;AAMA;;AACgBX,KAxDJG,aAAAA,GAAgBC,sBAwDZJ,GAxDqCK,uBAwDrCL;;;;AADsDa,KAnD1DT,sBAAAA,GAmD0DS;EAAe,CAAA,QAAA,EAAA,MAAA,CAAA,EAlD7DV,aAkD6D,EAAA;AAWrF,CAAA;;;;AAI0BV,KA5DdY,uBAAAA,GA4DcZ;EAAQ,CAAA,IAASoB,EAAAA,MAAAA,CAAAA,EAAAA;IAJJA,CAAAA,UAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA,GAAAA,MAAAA,GAAAA,OAAAA;EAAe,CAAA;AAUtD,CAAA;;;;AAA6CD,KA1DjCN,4BAAAA,GA0DiCM;EAAU,MAAA,CAAA,EAzD1CP,uBAyD0C,GAzDhBD,sBAyDgB;;;;;;uBAnDzBG,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.map

@@ -1 +0,0 @@
-{"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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfilter: ((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"],"mappings":";;AAIA;AAKA;AAMA;AAIwBG,iBAfAH,QAAAA,CAeO,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAK/B;AAIA;AAOA;;iBA1BwBC,aAAAA;;;;;;iBAMAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}

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

@@ -1 +0,0 @@
-{"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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\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(\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfilter: ((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"],"mappings":";;AAIA;AAKA;AAMA;AAIwBG,iBAfAH,QAAAA,CAeO,GAAA,EAAA,GAAA,CAAA,EAAA,GAAA,IAAA,MAAA;AAK/B;AAIA;AAOA;;iBA1BwBC,aAAAA;;;;;;iBAMAC,KAAAA;;;;iBAIAC,OAAAA;;;;;iBAKAC,QAAAA;;;;iBAIAC,SAAAA;;;;;;;iBAOAC,SAAAA"}

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

@@ -1 +0,0 @@
-{"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","SchemaT","SchemaInputT","ToolOutputT","SchemaOutputT","Promise","TInput","TConfig","TArg","Tool","ZodString","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","input","NonNullable","DynamicTool","DynamicStructuredTool","Parameters","BaseToolkit","ToolWrapperParams","RunInput","tool","TState","TContext","ServerTool","Record","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     * 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    // Match the base class signature including the generics and conditional return type\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, // DynamicTool's _call specifically expects a string after schema transformation\n    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    // Match the base class signature\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>;\n// Overloads with ToolRuntime as CallOptions\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"],"mappings":";;;;;;;;;;;;;;;;AAiBwK0C,uBAA1ID,cAA0IC,CAAAA,UAAjHxB,mBAAiHwB,EAAAA,gBAA5EpB,yBAA4EoB,CAAlDA,OAAkDA,CAAAA,EAAAA,eAAzBrB,wBAAyBqB,CAAAA,OAAAA,CAAAA,EAAAA,cAAwBZ,cAAxBY,CAAAA,SAAgDxC,aAAhDwC,CAA8DzB,uBAA9DyB,CAAsFA,OAAtFA,EAA+FC,YAA/FD,CAAAA,EAA8GE,WAA9GF,GAA4HpC,WAA5HoC,CAAAA,YAAoJjB,uBAApJiB,CAA4KA,OAA5KA,EAAqLC,YAArLD,EAAmME,WAAnMF,CAAAA,CAAAA;EAAO,SAAhCrB,IAAAA,EAAAA,MAAAA;EAAwB,SAAyBS,WAAAA,EAAAA,MAAAA;EAAc,SAAgDY,MAAAA,EAGzOA,OAHyOA;EAAO;;;;;;EAAoG,YAAEE,EAAAA,OAAAA;EAAW,oBAGjWF,EAAAA,OAAAA;EAAO,IAmBPtB,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAc;;;;;;;;;EAaoC,cAA7CH,CAAAA,EAbLG,cAaKH;EAAuB;;;EAAwG,aAA0B8B,CAAAA,EAT/JvB,kBAS+JuB;EAAM,WAAEC,CAAAA,MAAAA,CAAAA,EARlKzB,UAQkKyB;EAAO,mBAAEJ,KAAAA,CAAAA,GAAAA,EAPlKC,aAOkKD,EAAAA,UAAAA,CAAAA,EAPtI3C,yBAOsI2C,EAAAA,YAAAA,CAAAA,EAP5FpB,kBAO4FoB,CAAAA,EAPvEE,OAOuEF,CAP/DA,WAO+DA,CAAAA;EAAW;;;;;;EAYvG,MAAmBK,CAAAA,eAZjGhC,uBAYiGgC,CAZzEP,OAYyEO,EAZhEN,YAYgEM,CAAAA,EAAAA,gBAZjCzB,kBAYiCyB,GAAAA,SAAAA,CAAAA,CAAAA,KAAAA,EAZMF,MAYNE,EAAAA,MAAAA,CAAAA,EAZuBD,OAYvBC,CAAAA,EAZiCH,OAYjCG,CAZyC9B,cAYzC8B,CAZwDF,MAYxDE,EAZgED,OAYhEC,EAZyEL,WAYzEK,CAAAA,CAAAA;EAAI;;;;;;;;AA/CoN;AAsDnV;;EAAkC,IAAenB,CAAAA,aAP3Bb,uBAO2Ba,CAPHY,OAOGZ,EAPMa,YAONb,CAAAA,EAAAA,gBAPqCN,kBAOrCM,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAP0EmB,IAO1EnB,EAAAA,SAAAA,CAAAA,EAP4FkB,OAO5FlB,EAAc;EAA8C,IAA4BF,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EALnHkB,OAKmHlB,CAL3GT,cAK2GS,CAL5FqB,IAK4FrB,EALtFoB,OAKsFpB,EAL7EgB,WAK6EhB,CAAAA,CAAAA;;;;;AAA+GA,uBAA1NsB,IAA0NtB,CAAAA,cAAvME,cAAuMF,CAAAA,SAA/Ka,cAA+Kb,CAAhKA,qBAAgKA,EAAzIN,yBAAyIM,CAA/GA,qBAA+GA,CAAAA,EAAvFP,wBAAuFO,CAA9DA,qBAA8DA,CAAAA,EAAtCgB,WAAsChB,CAAAA,YAAdC,aAAcD,CAAAA,qBAAAA,EAAuBP,wBAAvBO,CAAgDA,qBAAhDA,CAAAA,EAAwEgB,WAAxEhB,CAAAA,CAAAA;EAAqB,MAA2BA,EAC5R5B,CAAAA,CAAEuD,UAD0R3B,CAC/Q5B,CAAAA,CAAEsD,SAD6Q1B,CAAAA;IAAzBP,KAAAA,EAEhQrB,CAAAA,CAAEoD,WAF8P/B,CAElPrB,CAAAA,CAAEmD,SAFgP9B,CAAAA;EAAwB,CAAA,EAAyBuB,OAAAA,EAGhT5C,CAAAA,CAAEqD,UAH8ST,EAAAA;IAEnS5C,KAAEmD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,CAAA,EAAzBnD;IACCA,KAAEqD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA,EAFHrD,MAAEsD,GAAAA,SAAAA,EAAAA;IAAftD,KAAEuD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA;EASW,WAWUC,CAAAA,MAAAA,CAAAA,EAXpBjC,UAWoBiC;EAAK;;;;;;;;;EAAoI;EAAf,IArB9Ff,CAAAA,aAAAA,MAAAA,GAAAA,SAAAA,GAqB9BzC,CAAAA,CAAEwD,KArB4Bf,CAAAA,IAAAA,CAAAA,QAAAA,CAAAA,CAAAA,GAqBJpC,QArBIoC,EAAAA,gBAqBsBjB,kBArBtBiB,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAqB2DQ,IArB3DR,EAAAA,SAAAA,CAAAA,EAqB6EO,OArB7EP,CAAAA,EAqBuFK,OArBvFL,CAqB+FtB,cArB/FsB,CAqB8GgB,WArB9GhB,CAqB0HQ,IArB1HR,CAAAA,EAqBiIO,OArBjIP,EAqB0IG,WArB1IH,CAAAA,CAAAA;;AAA8K;AA0BvP;;AAA+CX,cAA1B4B,WAA0B5B,CAAAA,cAAAA,cAAAA,CAAAA,SAAwBoB,IAAxBpB,CAA6Bc,WAA7Bd,CAAAA,CAAAA;EAAc,OAAec,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,IAI5DA,EAAAA,MAAAA;EAAW,WAA5BlB,EAAAA,MAAAA;EAAgB,IACekB,EAD/BlB,gBAC+BkB,CADdA,WACcA,CAAAA,CAAAA,MAAAA,CAAAA;EAAW,WAA5BlB,CAAAA,MAAAA,EAAAA,gBAAAA,CAAiBkB,WAAjBlB,CAAAA;EAAgB;;;EAIyE,IAAmBuB,CAAAA,aAAAA,MAAAA,GAAAA,SAAAA,GAAzFjD,CAAAA,CAAEwD,KAAuFP,CAAAA,IAAAA,CAAAA,QAAAA,CAAAA,CAAAA,GAA/D5C,QAA+D4C,EAAAA,gBAArCzB,kBAAqCyB,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAAAA,IAAAA,EAAAA,SAAAA,CAAAA,EAAkBD,OAAlBC,CAAAA,EAA4BH,OAA5BG,CAAoC9B,cAApC8B,CAAmDQ,WAAnDR,CAA+DA,IAA/DA,CAAAA,EAAsED,OAAtEC,EAA+EL,WAA/EK,CAAAA,CAAAA;EAAI;EAAqB,KAAsCA,CAAAA,KAAAA,EAAAA,MAAAA;EAAAA;EAAI,UAAhBQ,CAAAA,EAGtKxD,yBAHsKwD,EAAAA,YAAAA,CAAAA,EAG5HjC,kBAH4HiC,CAAAA,EAGvGX,OAHuGW,CAG/Fb,WAH+Fa,CAAAA;;;;;;;;;;AAT5G;AAuBtDE,cAAAA,qBAAqB,CAAA,UAAWzC,mBAAX,EAAA,gBAAgDI,yBAAhD,CAA0EoB,OAA1E,CAAA,EAAA,eAAmGrB,wBAAnG,CAA4HqB,OAA5H,CAAA,EAAA,cAAoJZ,cAApJ,CAAA,SAA4KW,cAA5K,CAA2LC,OAA3L,EAAoMG,aAApM,EAAmNF,YAAnN,EAAiOC,WAAjO,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,IAAW1B,EAAAA,MAAAA;EAAmB,WAA4CwB,EAAAA,MAAAA;EAAO,IAAjCpB,EAIhFK,0BAJgFL,CAIrDoB,OAJqDpB,EAI5CuB,aAJ4CvB,EAI7BsB,WAJ6BtB,CAAAA,CAAAA,MAAAA,CAAAA;EAAyB,MAAmDoB,EAK1JA,OAL0JA;EAAO,WAAhCrB,CAAAA,MAAAA,EAMrHM,0BANqHN,CAM1FqB,OAN0FrB,EAMjFwB,aANiFxB,EAMlEuB,WANkEvB,CAAAA;EAAwB;;;EAAsF;EAAc,IAAEuB,CAAAA,aAWrP3B,uBAXqP2B,CAW7NF,OAX6NE,EAWpND,YAXoNC,CAAAA,EAAAA,gBAWrLpB,kBAXqLoB,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAWhJK,IAXgJL,EAAAA,SAAAA,CAAAA,EAW9HI,OAX8HJ,EAAW;EAI1O,IAAEC,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EASxBC,OATwBD,CAShB1B,cATgB0B,CASDY,WATCZ,CASWI,IATXJ,CAAAA,EASkBG,OATlBH,EAS2BD,WAT3BC,CAAAA,CAAAA;EAAa,UAAED,KAAAA,CAAAA,GAAAA,EAUpCgB,UAVoChB,CAUzBjB,0BAVyBiB,CAUEF,OAVFE,EAUWC,aAVXD,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAAAA,UAAAA,CAAAA,EAUoD3C,yBAVpD2C,EAAAA,YAAAA,CAAAA,EAU8FzC,cAV9FyC,CAAAA,EAU+GE,OAV/GF,CAUuHA,WAVvHA,CAAAA;;;;;;;AAOfF,uBAUhBmB,WAAAA,CAVgBnB;EAAO,SAAEC,KAAAA,EAWnClB,uBAXmCkB,EAAAA;EAAY,QAA7C1B,CAAAA,CAAAA,EAYNQ,uBAZMR,EAAAA;;;;;;;;UAoBZ6C,iBAlBoB3C,CAAAA,WAkBSD,mBAlBTC,GAAAA,SAAAA,CAAAA,SAkBkDI,UAlBlDJ,CAAAA;EAAc;;;;EACkB,IAArCyC,EAAAA,MAAAA;EAAU;;;;EAAgJ,WAdmCnB,CAAAA,EAAAA,MAAAA;EAAc;AAqBpO;;;;EAEuC,MAAA,CAAA,EAwB1BsB,QAxB0B;EAQ7BD;;;;;;AAAgF;AAoD1F;;EAA4B,cAAiBjD,CAAAA,EA1BxBO,cA0BwBP;EAAW;;;;;;EAAkD,YAA6F6B,CAAAA,EAAAA,OAAAA;;;;AAAsB;AAC7N;;;;;;;;;;;;;AAA6N;AACrMsB,iBAFAA,IAEI,CAAA,gBAFiBnD,WAEjB,EAAA,cAF4CiB,cAE5C,CAAA,CAAA,IAAA,EAFkE1B,YAElE,CAF+EM,qBAE/E,CAFqGgC,OAErG,CAAA,EAF+GE,WAE/G,EAF4HpB,kBAE5H,CAAA,EAAA,MAAA,EAFyJsC,iBAEzJ,CAF2KpB,OAE3K,CAAA,CAAA,EAFsLgB,WAEtL,CAFkMd,WAElM,CAAA;AAAA,iBADJoB,IACI,CAAA,gBADiBlD,WACjB,EAAA,cAD4CgB,cAC5C,CAAA,CAAA,IAAA,EADkE1B,YAClE,CAD+EM,qBAC/E,CADqGgC,OACrG,CAAA,EAD+GE,WAC/G,EAD4HpB,kBAC5H,CAAA,EAAA,MAAA,EADyJsC,iBACzJ,CAD2KpB,OAC3K,CAAA,CAAA,EADsLgB,WACtL,CADkMd,WAClM,CAAA;AAAiB7B,iBAArBiD,IAAqBjD,CAAAA,gBAAAA,WAAAA,EAAAA,gBAA6BL,qBAA7BK,CAAmD2B,OAAnD3B,CAAAA,EAAAA,eAA4EN,oBAA5EM,CAAiG2B,OAAjG3B,CAAAA,EAAAA,cAAyHe,cAAzHf,CAAAA,CAAAA,IAAAA,EAA+IX,YAA/IW,CAA4J8B,aAA5J9B,EAA2K6B,WAA3K7B,EAAwLS,kBAAxLT,CAAAA,EAAAA,MAAAA,EAAqN+C,iBAArN/C,CAAuO2B,OAAvO3B,CAAAA,CAAAA,EAAkP4C,qBAAlP5C,CAAwQ2B,OAAxQ3B,EAAiR8B,aAAjR9B,EAAgS4B,YAAhS5B,EAA8S6B,WAA9S7B,CAAAA;AAAmD2B,iBACxEsB,IADwEtB,CAAAA,gBACnD1B,WADmD0B,EAAAA,gBACtBhC,qBADsBgC,CACAA,OADAA,CAAAA,EAAAA,eACyBjC,oBADzBiC,CAC8CA,OAD9CA,CAAAA,EAAAA,cACsEZ,cADtEY,CAAAA,CAAAA,IAAAA,EAC4FtC,YAD5FsC,CACyGG,aADzGH,EACwHE,WADxHF,EACqIlB,kBADrIkB,CAAAA,EAAAA,MAAAA,EACkKoB,iBADlKpB,CACoLA,OADpLA,CAAAA,CAAAA,EAC+LiB,qBAD/LjB,CACqNA,OADrNA,EAC8NG,aAD9NH,EAC6OC,YAD7OD,EAC2PE,WAD3PF,CAAAA;AAAtBhC,iBAElDsD,IAFkDtD,CAAAA,gBAE7BsB,eAF6BtB,EAAAA,gBAEDY,yBAFCZ,CAEyBgC,OAFzBhC,CAAAA,EAAAA,eAEkDW,wBAFlDX,CAE2EgC,OAF3EhC,CAAAA,EAAAA,cAEmGoB,cAFnGpB,CAAAA,CAAAA,IAAAA,EAEyHN,YAFzHM,CAEsIkD,UAFtIlD,CAEiJiB,0BAFjJjB,CAE4KgC,OAF5KhC,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAEkMkC,WAFlMlC,EAE+Mc,kBAF/Md,CAAAA,EAAAA,MAAAA,EAE4OoD,iBAF5OpD,CAE8PgC,OAF9PhC,CAAAA,CAAAA,EAEyQiD,qBAFzQjD,CAE+RgC,OAF/RhC,EAEwSmC,aAFxSnC,EAEuTiC,YAFvTjC,EAEqUkC,WAFrUlC,CAAAA;AAAoEgC,iBAGtHsB,IAHsHtB,CAAAA,gBAGjG/B,gBAHiG+B,GAG9E9B,cAH8E8B,CAAAA,MAAAA,CAAAA,GAGrDV,eAHqDU,GAGxC/B,gBAHwC+B,EAAAA,gBAGNpB,yBAHMoB,CAGoBA,OAHpBA,CAAAA,EAAAA,eAG6CrB,wBAH7CqB,CAGsEA,OAHtEA,CAAAA,EAAAA,cAG8FZ,cAH9FY,CAAAA,CAAAA,IAAAA,EAGoHtC,YAHpHsC,CAGiIG,aAHjIH,EAGgJE,WAHhJF,EAG6JlB,kBAH7JkB,CAAAA,EAAAA,MAAAA,EAG0LoB,iBAH1LpB,CAG4MA,OAH5MA,CAAAA,CAAAA,EAGuNiB,qBAHvNjB,CAG6OA,OAH7OA,EAGsPG,aAHtPH,EAGqQC,YAHrQD,EAGmRE,WAHnRF,CAAAA,GAGkSgB,WAHlShB,CAG8SE,WAH9SF,CAAAA;;AAAwBZ,iBAK9IkC,IAL8IlC,CAAAA,gBAKzHjB,WALyHiB,EAAAA,cAK9FA,cAL8FA,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAK1BpB,qBAL0BoB,CAKJY,OALIZ,CAAAA,EAAAA,OAAAA,EAKeC,WALfD,CAK2BmC,MAL3BnC,EAKmCoC,QALnCpC,CAAAA,EAAAA,GAKiDc,WALjDd,GAK+DgB,OAL/DhB,CAKuEc,WALvEd,CAAAA,EAAAA,MAAAA,EAK6FgC,iBAL7FhC,CAK+GY,OAL/GZ,CAAAA,CAAAA,EAK0H4B,WAL1H5B,CAKsIc,WALtId,CAAAA;AAAmCe,iBAMjLmB,IANiLnB,CAAAA,gBAM5J/B,WAN4J+B,EAAAA,cAMjIf,cANiIe,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAM7DnC,qBAN6DmC,CAMvCH,OANuCG,CAAAA,EAAAA,OAAAA,EAMpBd,WANoBc,CAMRoB,MANQpB,EAMAqB,QANArB,CAAAA,EAAAA,GAMcD,WANdC,GAM4BC,OAN5BD,CAMoCD,WANpCC,CAAAA,EAAAA,MAAAA,EAM0DiB,iBAN1DjB,CAM4EH,OAN5EG,CAAAA,CAAAA,EAMuFa,WANvFb,CAMmGD,WANnGC,CAAAA;AAAeD,iBAOhMoB,IAPgMpB,CAAAA,gBAO3K7B,WAP2K6B,EAAAA,gBAO9IlC,qBAP8IkC,CAOxHF,OAPwHE,CAAAA,EAAAA,eAO/FnC,oBAP+FmC,CAO1EF,OAP0EE,CAAAA,EAAAA,cAOlDd,cAPkDc,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAOkBC,aAPlBD,EAAAA,OAAAA,EAO0Cb,WAP1Ca,CAOsDqB,MAPtDrB,EAO8DsB,QAP9DtB,CAAAA,EAAAA,GAO4EA,WAP5EA,GAO0FE,OAP1FF,CAOkGA,WAPlGA,CAAAA,EAAAA,MAAAA,EAOwHkB,iBAPxHlB,CAO0IF,OAP1IE,CAAAA,CAAAA,EAOqJe,qBAPrJf,CAO2KF,OAP3KE,EAOoLC,aAPpLD,EAOmMD,YAPnMC,EAOiNA,WAPjNA,CAAAA;AAAapB,iBAQ7MwC,IAR6MxC,CAAAA,gBAQxLR,WARwLQ,EAAAA,gBAQ3Jd,qBAR2Jc,CAQrIkB,OARqIlB,CAAAA,EAAAA,eAQ5Gf,oBAR4Ge,CAQvFkB,OARuFlB,CAAAA,EAAAA,cAQ/DM,cAR+DN,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAQKqB,aARLrB,EAAAA,OAAAA,EAQ6BO,WAR7BP,CAQyCyC,MARzCzC,EAQiD0C,QARjD1C,CAAAA,EAAAA,GAQ+DoB,WAR/DpB,GAQ6EsB,OAR7EtB,CAQqFoB,WARrFpB,CAAAA,EAAAA,MAAAA,EAQ2GsC,iBAR3GtC,CAQ6HkB,OAR7HlB,CAAAA,CAAAA,EAQwImC,qBARxInC,CAQ8JkB,OAR9JlB,EAQuKqB,aARvKrB,EAQsLmB,YARtLnB,EAQoMoB,WARpMpB,CAAAA;AAAzCpB,iBASpK4D,IAToK5D,CAAAA,gBAS/I4B,eAT+I5B,EAAAA,gBASnHkB,yBATmHlB,CASzFsC,OATyFtC,CAAAA,EAAAA,eAShEiB,wBATgEjB,CASvCsC,OATuCtC,CAAAA,EAAAA,cASf0B,cATe1B,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EASqDwD,UATrDxD,CASgEuB,0BAThEvB,CAS2FsC,OAT3FtC,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAAAA,OAAAA,EAS0H2B,WAT1H3B,CASsI6D,MATtI7D,EAS8I8D,QAT9I9D,CAAAA,EAAAA,GAS4JwC,WAT5JxC,GAS0K0C,OAT1K1C,CASkLwC,WATlLxC,CAAAA,EAAAA,MAAAA,EASwM0D,iBATxM1D,CAS0NsC,OAT1NtC,CAAAA,CAAAA,EASqOuD,qBATrOvD,CAS2PsC,OAT3PtC,EASoQyC,aATpQzC,EASmRuC,YATnRvC,EASiSwC,WATjSxC,CAAAA;AAAwFsC,KAUxQyB,UAAAA,GAAaC,MAV2P1B,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;AAAlBoB,KAWtPO,UAAAA,GAAa5C,uBAXyOqC,GAW/MJ,WAX+MI,GAWjMvD,gBAXiMuD"}

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

@@ -1 +0,0 @@
-{"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","SchemaT","SchemaInputT","ToolOutputT","SchemaOutputT","Promise","TInput","TConfig","TArg","Tool","ZodString","ZodOptional","ZodTypeAny","ZodObject","ZodEffects","input","NonNullable","DynamicTool","DynamicStructuredTool","Parameters","BaseToolkit","ToolWrapperParams","RunInput","tool","TState","TContext","ServerTool","Record","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     * 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    // Match the base class signature including the generics and conditional return type\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, // DynamicTool's _call specifically expects a string after schema transformation\n    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    // Match the base class signature\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>;\n// Overloads with ToolRuntime as CallOptions\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"],"mappings":";;;;;;;;;;;;;;;;AAiBwK0C,uBAA1ID,cAA0IC,CAAAA,UAAjHxB,mBAAiHwB,EAAAA,gBAA5EpB,yBAA4EoB,CAAlDA,OAAkDA,CAAAA,EAAAA,eAAzBrB,wBAAyBqB,CAAAA,OAAAA,CAAAA,EAAAA,cAAwBZ,cAAxBY,CAAAA,SAAgDxC,aAAhDwC,CAA8DzB,uBAA9DyB,CAAsFA,OAAtFA,EAA+FC,YAA/FD,CAAAA,EAA8GE,WAA9GF,GAA4HpC,WAA5HoC,CAAAA,YAAoJjB,uBAApJiB,CAA4KA,OAA5KA,EAAqLC,YAArLD,EAAmME,WAAnMF,CAAAA,CAAAA;EAAO,SAAhCrB,IAAAA,EAAAA,MAAAA;EAAwB,SAAyBS,WAAAA,EAAAA,MAAAA;EAAc,SAAgDY,MAAAA,EAGzOA,OAHyOA;EAAO;;;;;;EAAoG,YAAEE,EAAAA,OAAAA;EAAW,oBAGjWF,EAAAA,OAAAA;EAAO,IAmBPtB,YAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAc;;;;;;;;;EAaoC,cAA7CH,CAAAA,EAbLG,cAaKH;EAAuB;;;EAAwG,aAA0B8B,CAAAA,EAT/JvB,kBAS+JuB;EAAM,WAAEC,CAAAA,MAAAA,CAAAA,EARlKzB,UAQkKyB;EAAO,mBAAEJ,KAAAA,CAAAA,GAAAA,EAPlKC,aAOkKD,EAAAA,UAAAA,CAAAA,EAPtI3C,yBAOsI2C,EAAAA,YAAAA,CAAAA,EAP5FpB,kBAO4FoB,CAAAA,EAPvEE,OAOuEF,CAP/DA,WAO+DA,CAAAA;EAAW;;;;;;EAYvG,MAAmBK,CAAAA,eAZjGhC,uBAYiGgC,CAZzEP,OAYyEO,EAZhEN,YAYgEM,CAAAA,EAAAA,gBAZjCzB,kBAYiCyB,GAAAA,SAAAA,CAAAA,CAAAA,KAAAA,EAZMF,MAYNE,EAAAA,MAAAA,CAAAA,EAZuBD,OAYvBC,CAAAA,EAZiCH,OAYjCG,CAZyC9B,cAYzC8B,CAZwDF,MAYxDE,EAZgED,OAYhEC,EAZyEL,WAYzEK,CAAAA,CAAAA;EAAI;;;;;;;;AA/CoN;AAsDnV;;EAAkC,IAAenB,CAAAA,aAP3Bb,uBAO2Ba,CAPHY,OAOGZ,EAPMa,YAONb,CAAAA,EAAAA,gBAPqCN,kBAOrCM,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAP0EmB,IAO1EnB,EAAAA,SAAAA,CAAAA,EAP4FkB,OAO5FlB,EAAc;EAA8C,IAA4BF,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EALnHkB,OAKmHlB,CAL3GT,cAK2GS,CAL5FqB,IAK4FrB,EALtFoB,OAKsFpB,EAL7EgB,WAK6EhB,CAAAA,CAAAA;;;;;AAA+GA,uBAA1NsB,IAA0NtB,CAAAA,cAAvME,cAAuMF,CAAAA,SAA/Ka,cAA+Kb,CAAhKA,qBAAgKA,EAAzIN,yBAAyIM,CAA/GA,qBAA+GA,CAAAA,EAAvFP,wBAAuFO,CAA9DA,qBAA8DA,CAAAA,EAAtCgB,WAAsChB,CAAAA,YAAdC,aAAcD,CAAAA,qBAAAA,EAAuBP,wBAAvBO,CAAgDA,qBAAhDA,CAAAA,EAAwEgB,WAAxEhB,CAAAA,CAAAA;EAAqB,MAA2BA,EAC5R5B,CAAAA,CAAEuD,UAD0R3B,CAC/Q5B,CAAAA,CAAEsD,SAD6Q1B,CAAAA;IAAzBP,KAAAA,EAEhQrB,CAAAA,CAAEoD,WAF8P/B,CAElPrB,CAAAA,CAAEmD,SAFgP9B,CAAAA;EAAwB,CAAA,EAAyBuB,OAAAA,EAGhT5C,CAAAA,CAAEqD,UAH8ST,EAAAA;IAEnS5C,KAAEmD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAS,CAAA,EAAzBnD;IACCA,KAAEqD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA,EAFHrD,MAAEsD,GAAAA,SAAAA,EAAAA;IAAftD,KAAEuD,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAU,CAAA,CAAA;EASW,WAWUC,CAAAA,MAAAA,CAAAA,EAXpBjC,UAWoBiC;EAAK;;;;;;;;;EAAoI;EAAf,IArB9Ff,CAAAA,aAAAA,MAAAA,GAAAA,SAAAA,GAqB9BzC,CAAAA,CAAEwD,KArB4Bf,CAAAA,IAAAA,CAAAA,QAAAA,CAAAA,CAAAA,GAqBJpC,QArBIoC,EAAAA,gBAqBsBjB,kBArBtBiB,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAqB2DQ,IArB3DR,EAAAA,SAAAA,CAAAA,EAqB6EO,OArB7EP,CAAAA,EAqBuFK,OArBvFL,CAqB+FtB,cArB/FsB,CAqB8GgB,WArB9GhB,CAqB0HQ,IArB1HR,CAAAA,EAqBiIO,OArBjIP,EAqB0IG,WArB1IH,CAAAA,CAAAA;;AAA8K;AA0BvP;;AAA+CX,cAA1B4B,WAA0B5B,CAAAA,cAAAA,cAAAA,CAAAA,SAAwBoB,IAAxBpB,CAA6Bc,WAA7Bd,CAAAA,CAAAA;EAAc,OAAec,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAW,IAI5DA,EAAAA,MAAAA;EAAW,WAA5BlB,EAAAA,MAAAA;EAAgB,IACekB,EAD/BlB,gBAC+BkB,CADdA,WACcA,CAAAA,CAAAA,MAAAA,CAAAA;EAAW,WAA5BlB,CAAAA,MAAAA,EAAAA,gBAAAA,CAAiBkB,WAAjBlB,CAAAA;EAAgB;;;EAIyE,IAAmBuB,CAAAA,aAAAA,MAAAA,GAAAA,SAAAA,GAAzFjD,CAAAA,CAAEwD,KAAuFP,CAAAA,IAAAA,CAAAA,QAAAA,CAAAA,CAAAA,GAA/D5C,QAA+D4C,EAAAA,gBAArCzB,kBAAqCyB,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAAAA,IAAAA,EAAAA,SAAAA,CAAAA,EAAkBD,OAAlBC,CAAAA,EAA4BH,OAA5BG,CAAoC9B,cAApC8B,CAAmDQ,WAAnDR,CAA+DA,IAA/DA,CAAAA,EAAsED,OAAtEC,EAA+EL,WAA/EK,CAAAA,CAAAA;EAAI;EAAqB,KAAsCA,CAAAA,KAAAA,EAAAA,MAAAA;EAAAA;EAAI,UAAhBQ,CAAAA,EAGtKxD,yBAHsKwD,EAAAA,YAAAA,CAAAA,EAG5HjC,kBAH4HiC,CAAAA,EAGvGX,OAHuGW,CAG/Fb,WAH+Fa,CAAAA;;;;;;;;;;AAT5G;AAuBtDE,cAAAA,qBAAqB,CAAA,UAAWzC,mBAAX,EAAA,gBAAgDI,yBAAhD,CAA0EoB,OAA1E,CAAA,EAAA,eAAmGrB,wBAAnG,CAA4HqB,OAA5H,CAAA,EAAA,cAAoJZ,cAApJ,CAAA,SAA4KW,cAA5K,CAA2LC,OAA3L,EAAoMG,aAApM,EAAmNF,YAAnN,EAAiOC,WAAjO,CAAA,CAAA;EAAA,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EAAA,IAAW1B,EAAAA,MAAAA;EAAmB,WAA4CwB,EAAAA,MAAAA;EAAO,IAAjCpB,EAIhFK,0BAJgFL,CAIrDoB,OAJqDpB,EAI5CuB,aAJ4CvB,EAI7BsB,WAJ6BtB,CAAAA,CAAAA,MAAAA,CAAAA;EAAyB,MAAmDoB,EAK1JA,OAL0JA;EAAO,WAAhCrB,CAAAA,MAAAA,EAMrHM,0BANqHN,CAM1FqB,OAN0FrB,EAMjFwB,aANiFxB,EAMlEuB,WANkEvB,CAAAA;EAAwB;;;EAAsF;EAAc,IAAEuB,CAAAA,aAWrP3B,uBAXqP2B,CAW7NF,OAX6NE,EAWpND,YAXoNC,CAAAA,EAAAA,gBAWrLpB,kBAXqLoB,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EAWhJK,IAXgJL,EAAAA,SAAAA,CAAAA,EAW9HI,OAX8HJ,EAAW;EAI1O,IAAEC,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EASxBC,OATwBD,CAShB1B,cATgB0B,CASDY,WATCZ,CASWI,IATXJ,CAAAA,EASkBG,OATlBH,EAS2BD,WAT3BC,CAAAA,CAAAA;EAAa,UAAED,KAAAA,CAAAA,GAAAA,EAUpCgB,UAVoChB,CAUzBjB,0BAVyBiB,CAUEF,OAVFE,EAUWC,aAVXD,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAAAA,UAAAA,CAAAA,EAUoD3C,yBAVpD2C,EAAAA,YAAAA,CAAAA,EAU8FzC,cAV9FyC,CAAAA,EAU+GE,OAV/GF,CAUuHA,WAVvHA,CAAAA;;;;;;;AAOfF,uBAUhBmB,WAAAA,CAVgBnB;EAAO,SAAEC,KAAAA,EAWnClB,uBAXmCkB,EAAAA;EAAY,QAA7C1B,CAAAA,CAAAA,EAYNQ,uBAZMR,EAAAA;;;;;;;;UAoBZ6C,iBAlBoB3C,CAAAA,WAkBSD,mBAlBTC,GAAAA,SAAAA,CAAAA,SAkBkDI,UAlBlDJ,CAAAA;EAAc;;;;EACkB,IAArCyC,EAAAA,MAAAA;EAAU;;;;EAAgJ,WAdmCnB,CAAAA,EAAAA,MAAAA;EAAc;AAqBpO;;;;EAEuC,MAAA,CAAA,EAwB1BsB,QAxB0B;EAQ7BD;;;;;;AAAgF;AAoD1F;;EAA4B,cAAiBjD,CAAAA,EA1BxBO,cA0BwBP;EAAW;;;;;;EAAkD,YAA6F6B,CAAAA,EAAAA,OAAAA;;;;AAAsB;AAC7N;;;;;;;;;;;;;AAA6N;AACrMsB,iBAFAA,IAEI,CAAA,gBAFiBnD,WAEjB,EAAA,cAF4CiB,cAE5C,CAAA,CAAA,IAAA,EAFkE1B,YAElE,CAF+EM,qBAE/E,CAFqGgC,OAErG,CAAA,EAF+GE,WAE/G,EAF4HpB,kBAE5H,CAAA,EAAA,MAAA,EAFyJsC,iBAEzJ,CAF2KpB,OAE3K,CAAA,CAAA,EAFsLgB,WAEtL,CAFkMd,WAElM,CAAA;AAAA,iBADJoB,IACI,CAAA,gBADiBlD,WACjB,EAAA,cAD4CgB,cAC5C,CAAA,CAAA,IAAA,EADkE1B,YAClE,CAD+EM,qBAC/E,CADqGgC,OACrG,CAAA,EAD+GE,WAC/G,EAD4HpB,kBAC5H,CAAA,EAAA,MAAA,EADyJsC,iBACzJ,CAD2KpB,OAC3K,CAAA,CAAA,EADsLgB,WACtL,CADkMd,WAClM,CAAA;AAAiB7B,iBAArBiD,IAAqBjD,CAAAA,gBAAAA,WAAAA,EAAAA,gBAA6BL,qBAA7BK,CAAmD2B,OAAnD3B,CAAAA,EAAAA,eAA4EN,oBAA5EM,CAAiG2B,OAAjG3B,CAAAA,EAAAA,cAAyHe,cAAzHf,CAAAA,CAAAA,IAAAA,EAA+IX,YAA/IW,CAA4J8B,aAA5J9B,EAA2K6B,WAA3K7B,EAAwLS,kBAAxLT,CAAAA,EAAAA,MAAAA,EAAqN+C,iBAArN/C,CAAuO2B,OAAvO3B,CAAAA,CAAAA,EAAkP4C,qBAAlP5C,CAAwQ2B,OAAxQ3B,EAAiR8B,aAAjR9B,EAAgS4B,YAAhS5B,EAA8S6B,WAA9S7B,CAAAA;AAAmD2B,iBACxEsB,IADwEtB,CAAAA,gBACnD1B,WADmD0B,EAAAA,gBACtBhC,qBADsBgC,CACAA,OADAA,CAAAA,EAAAA,eACyBjC,oBADzBiC,CAC8CA,OAD9CA,CAAAA,EAAAA,cACsEZ,cADtEY,CAAAA,CAAAA,IAAAA,EAC4FtC,YAD5FsC,CACyGG,aADzGH,EACwHE,WADxHF,EACqIlB,kBADrIkB,CAAAA,EAAAA,MAAAA,EACkKoB,iBADlKpB,CACoLA,OADpLA,CAAAA,CAAAA,EAC+LiB,qBAD/LjB,CACqNA,OADrNA,EAC8NG,aAD9NH,EAC6OC,YAD7OD,EAC2PE,WAD3PF,CAAAA;AAAtBhC,iBAElDsD,IAFkDtD,CAAAA,gBAE7BsB,eAF6BtB,EAAAA,gBAEDY,yBAFCZ,CAEyBgC,OAFzBhC,CAAAA,EAAAA,eAEkDW,wBAFlDX,CAE2EgC,OAF3EhC,CAAAA,EAAAA,cAEmGoB,cAFnGpB,CAAAA,CAAAA,IAAAA,EAEyHN,YAFzHM,CAEsIkD,UAFtIlD,CAEiJiB,0BAFjJjB,CAE4KgC,OAF5KhC,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAEkMkC,WAFlMlC,EAE+Mc,kBAF/Md,CAAAA,EAAAA,MAAAA,EAE4OoD,iBAF5OpD,CAE8PgC,OAF9PhC,CAAAA,CAAAA,EAEyQiD,qBAFzQjD,CAE+RgC,OAF/RhC,EAEwSmC,aAFxSnC,EAEuTiC,YAFvTjC,EAEqUkC,WAFrUlC,CAAAA;AAAoEgC,iBAGtHsB,IAHsHtB,CAAAA,gBAGjG/B,gBAHiG+B,GAG9E9B,cAH8E8B,CAAAA,MAAAA,CAAAA,GAGrDV,eAHqDU,GAGxC/B,gBAHwC+B,EAAAA,gBAGNpB,yBAHMoB,CAGoBA,OAHpBA,CAAAA,EAAAA,eAG6CrB,wBAH7CqB,CAGsEA,OAHtEA,CAAAA,EAAAA,cAG8FZ,cAH9FY,CAAAA,CAAAA,IAAAA,EAGoHtC,YAHpHsC,CAGiIG,aAHjIH,EAGgJE,WAHhJF,EAG6JlB,kBAH7JkB,CAAAA,EAAAA,MAAAA,EAG0LoB,iBAH1LpB,CAG4MA,OAH5MA,CAAAA,CAAAA,EAGuNiB,qBAHvNjB,CAG6OA,OAH7OA,EAGsPG,aAHtPH,EAGqQC,YAHrQD,EAGmRE,WAHnRF,CAAAA,GAGkSgB,WAHlShB,CAG8SE,WAH9SF,CAAAA;;AAAwBZ,iBAK9IkC,IAL8IlC,CAAAA,gBAKzHjB,WALyHiB,EAAAA,cAK9FA,cAL8FA,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAK1BpB,qBAL0BoB,CAKJY,OALIZ,CAAAA,EAAAA,OAAAA,EAKeC,WALfD,CAK2BmC,MAL3BnC,EAKmCoC,QALnCpC,CAAAA,EAAAA,GAKiDc,WALjDd,GAK+DgB,OAL/DhB,CAKuEc,WALvEd,CAAAA,EAAAA,MAAAA,EAK6FgC,iBAL7FhC,CAK+GY,OAL/GZ,CAAAA,CAAAA,EAK0H4B,WAL1H5B,CAKsIc,WALtId,CAAAA;AAAmCe,iBAMjLmB,IANiLnB,CAAAA,gBAM5J/B,WAN4J+B,EAAAA,cAMjIf,cANiIe,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAM7DnC,qBAN6DmC,CAMvCH,OANuCG,CAAAA,EAAAA,OAAAA,EAMpBd,WANoBc,CAMRoB,MANQpB,EAMAqB,QANArB,CAAAA,EAAAA,GAMcD,WANdC,GAM4BC,OAN5BD,CAMoCD,WANpCC,CAAAA,EAAAA,MAAAA,EAM0DiB,iBAN1DjB,CAM4EH,OAN5EG,CAAAA,CAAAA,EAMuFa,WANvFb,CAMmGD,WANnGC,CAAAA;AAAeD,iBAOhMoB,IAPgMpB,CAAAA,gBAO3K7B,WAP2K6B,EAAAA,gBAO9IlC,qBAP8IkC,CAOxHF,OAPwHE,CAAAA,EAAAA,eAO/FnC,oBAP+FmC,CAO1EF,OAP0EE,CAAAA,EAAAA,cAOlDd,cAPkDc,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAOkBC,aAPlBD,EAAAA,OAAAA,EAO0Cb,WAP1Ca,CAOsDqB,MAPtDrB,EAO8DsB,QAP9DtB,CAAAA,EAAAA,GAO4EA,WAP5EA,GAO0FE,OAP1FF,CAOkGA,WAPlGA,CAAAA,EAAAA,MAAAA,EAOwHkB,iBAPxHlB,CAO0IF,OAP1IE,CAAAA,CAAAA,EAOqJe,qBAPrJf,CAO2KF,OAP3KE,EAOoLC,aAPpLD,EAOmMD,YAPnMC,EAOiNA,WAPjNA,CAAAA;AAAapB,iBAQ7MwC,IAR6MxC,CAAAA,gBAQxLR,WARwLQ,EAAAA,gBAQ3Jd,qBAR2Jc,CAQrIkB,OARqIlB,CAAAA,EAAAA,eAQ5Gf,oBAR4Ge,CAQvFkB,OARuFlB,CAAAA,EAAAA,cAQ/DM,cAR+DN,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EAQKqB,aARLrB,EAAAA,OAAAA,EAQ6BO,WAR7BP,CAQyCyC,MARzCzC,EAQiD0C,QARjD1C,CAAAA,EAAAA,GAQ+DoB,WAR/DpB,GAQ6EsB,OAR7EtB,CAQqFoB,WARrFpB,CAAAA,EAAAA,MAAAA,EAQ2GsC,iBAR3GtC,CAQ6HkB,OAR7HlB,CAAAA,CAAAA,EAQwImC,qBARxInC,CAQ8JkB,OAR9JlB,EAQuKqB,aARvKrB,EAQsLmB,YARtLnB,EAQoMoB,WARpMpB,CAAAA;AAAzCpB,iBASpK4D,IAToK5D,CAAAA,gBAS/I4B,eAT+I5B,EAAAA,gBASnHkB,yBATmHlB,CASzFsC,OATyFtC,CAAAA,EAAAA,eAShEiB,wBATgEjB,CASvCsC,OATuCtC,CAAAA,EAAAA,cASf0B,cATe1B,EAAAA,SAAAA,OAAAA,EAAAA,WAAAA,OAAAA,CAAAA,CAAAA,IAAAA,EAAAA,CAAAA,KAAAA,EASqDwD,UATrDxD,CASgEuB,0BAThEvB,CAS2FsC,OAT3FtC,CAAAA,CAAAA,MAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,EAAAA,OAAAA,EAS0H2B,WAT1H3B,CASsI6D,MATtI7D,EAS8I8D,QAT9I9D,CAAAA,EAAAA,GAS4JwC,WAT5JxC,GAS0K0C,OAT1K1C,CASkLwC,WATlLxC,CAAAA,EAAAA,MAAAA,EASwM0D,iBATxM1D,CAS0NsC,OAT1NtC,CAAAA,CAAAA,EASqOuD,qBATrOvD,CAS2PsC,OAT3PtC,EASoQyC,aATpQzC,EASmRuC,YATnRvC,EASiSwC,WATjSxC,CAAAA;AAAwFsC,KAUxQyB,UAAAA,GAAaC,MAV2P1B,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;AAAlBoB,KAWtPO,UAAAA,GAAa5C,uBAXyOqC,GAW/MJ,WAX+MI,GAWjMvD,gBAXiMuD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.cts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool","ToolRuntime","TState","TContext"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType, type InteropZodObject } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\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    /**\n     * Whether to show full details in the thrown parsing errors.\n     *\n     * @default false\n     */\n    verboseParsingErrors?: boolean;\n    /**\n     * Metadata for the tool.\n     */\n    metadata?: Record<string, unknown>;\n}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\n}\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\n    /**\n     * Invokes the tool with the provided argument and configuration.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration for the tool call.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, 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     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\n    description: string;\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 * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\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 StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n    name: string;\n    description: string;\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 * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\n}\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    /**\n     * Tool handler function - the function that will be called when the tool is invoked.\n     *\n     * @param input - The input to the tool.\n     * @param runManager - The run manager for the tool.\n     * @param config - The configuration for the tool.\n     * @returns The result of the tool.\n     */\n    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\n}\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n/**\n * Runtime context automatically injected into tools.\n *\n * When a tool function has a parameter named `tool_runtime` with type hint\n * `ToolRuntime`, the tool execution system will automatically inject an instance\n * containing:\n *\n * - `state`: The current graph state\n * - `toolCallId`: The ID of the current tool call\n * - `config`: `RunnableConfig` for the current execution\n * - `context`: Runtime context\n * - `store`: `BaseStore` instance for persistent storage\n * - `writer`: Stream writer for streaming output\n *\n * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`\n * as a parameter.\n *\n * @example\n * ```typescript\n * import { tool, ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const stateSchema = z.object({\n *   messages: z.array(z.any()),\n *   userId: z.string().optional(),\n * });\n *\n * const greet = tool(\n *   async ({ name }, runtime) => {\n *     // Access state\n *     const messages = runtime.state.messages;\n *\n *     // Access tool_call_id\n *     console.log(`Tool call ID: ${runtime.toolCallId}`);\n *\n *     // Access config\n *     console.log(`Run ID: ${runtime.config.runId}`);\n *\n *     // Access runtime context\n *     const userId = runtime.context?.userId;\n *\n *     // Access store\n *     await runtime.store?.mset([[\"key\", \"value\"]]);\n *\n *     // Stream output\n *     runtime.writer?.(\"Processing...\");\n *\n *     return `Hello! User ID: ${runtime.state.userId || \"unknown\"} ${name}`;\n *   },\n *   {\n *     name: \"greet\",\n *     description: \"Use this to greet the user once you found their info.\",\n *     schema: z.object({ name: z.string() }),\n *     stateSchema,\n *   }\n * );\n * ```\n *\n * @template StateT - The type of the state schema (inferred from stateSchema)\n * @template ContextT - The type of the context schema (inferred from contextSchema)\n */\nexport type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {\n    /**\n     * The current graph state.\n     */\n    state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : unknown;\n    /**\n     * The ID of the current tool call.\n     */\n    toolCallId: string;\n    /**\n     * The current tool call.\n     */\n    toolCall?: ToolCall;\n    /**\n     * RunnableConfig for the current execution.\n     */\n    config: ToolRunnableConfig;\n    /**\n     * Runtime context (from langgraph `Runtime`).\n     */\n    context: TContext extends InteropZodObject ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : unknown;\n    /**\n     * BaseStore instance for persistent storage (from langgraph `Runtime`).\n     */\n    store: BaseStore<string, unknown> | null;\n    /**\n     * Stream writer for streaming output (from langgraph `Runtime`).\n     */\n    writer: ((chunk: unknown) => void) | null;\n};\n"],"mappings":";;;;;;;;;;;;KAUYkB,cAAAA;;AAAAA,KAEAC,cAAAA,GAFc,GAAA;AAE1B;AAEYC,KAAAA,kBAAAA,GAAkB,CAAIT,cAAAA,EAAAA,GAAc,CAAA;AAOhD;;;;;;AAIID,KAJQW,cAIRX,CAAAA,MAAAA,EAAAA,OAAAA,EAAAA,OAAAA,CAAAA,GAJmDY,OAInDZ,SAJmEF,gBAInEE,GAJsFY,OAItFZ,GAJgGa,OAIhGb,SAAAA;EAAW,QAAGa,EAAAA;IAIdD,EAAAA,EAAAA,MAAAA;EAAO,CAAA;CAAU,GAJjBZ,WAQAY,GARcC,OAQdD,SAAAA;EAAO,QAAGZ,EAAAA;IAAcc,EAAAA,EAAAA,SAAAA;EAAM,CAAA;CAAiB,GAJ/CF,OAIkDZ,GAJxCa,OAIwCb,SAAAA;EAAW,QAAGY,EAAAA;IAAO,EAAA,CAAA,EAAA,MAAA;EAK/DG,CAAAA;CAAmB,GAL3BH,OAK2B,GALjBZ,WAKiB,GALHc,MAKG,SALYf,QAKZ,GALuBC,WAKvB,GALqCY,OAKrC;;;AAA6B;AAI5D;AAA2B,KAJfG,mBAAAA,GAAsBxB,CAAAA,CAAGyB,UAIV,GAJuBV,eAIvB;;;;AAASb,UAAnBwB,UAAAA,SAAmBxB,mBAAAA,CAAAA;EAAmB;AA0BvD;;;;;;;;EAM2B,cAAA,CAAA,EAtBNe,cAsBM;EAOVc;;;EAAyD,aAA5BE,CAAAA,EAzB1BN,kBAyB0BM;EAAI;AAiBlD;;;;EAAmE,oBAAyBE,CAAAA,EAAAA,OAAAA;EAAC;;;EAAwB,QAAA,CAAA,EAhCtGP,MAgCsG,CAAA,MAAA,EAAA,OAAA,CAAA;AAYrH;AAAoC,KA1CxBD,kBA0CwB;;8BAxCNC,MAwCsBf,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,GAxCAe,MAwCAf,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;;gBAAiBF,GAAAA,CAAAA,GAtC9CP,cAsC8CO,CAtC/BkB,qBAsC+BlB,CAAAA,GAAAA;EAAoB,QAAMwB,CAAAA,EArChF3B,QAqCgF2B;EAAC,OAASpB,CAAAA,EApC3Fe,aAoC2Ff;AAAU,CAAA;AAOnH;;;;;AAAkJuB,UApCjIP,oBAAAA,SAA6BE,IAoCoGK,CApC/FN,uBAoC+FM,EAAAA,MAAAA,GAAAA,QAAAA,CAAAA,CAAAA;EAAO;;;EAA4D,WAAA,CAAA,EAAA,MAAA;AAUrN;;;;AAA8C;AAyB9C;;;;;;;AAAmNC,KAtDvML,yBAsDuMK,CAAAA,CAAAA,CAAAA,GAtDxKJ,CAsDwKI,SAtD9J1B,cAsD8J0B,GAtD7I3B,qBAsD6I2B,CAtDvHJ,CAsDuHI,CAAAA,GAtDlHJ,CAsDkHI,SAtDxGxB,eAsDwGwB,GAAAA,OAAAA,GAAAA,KAAAA;;;;;;;;;;;;AAY7BjB,KAtD1Kc,wBAsD0Kd,CAAAA,CAAAA,CAAAA,GAtD5Ia,CAsD4Ib,SAtDlIT,cAsDkIS,GAtDjHX,oBAsDiHW,CAtD5Fa,CAsD4Fb,CAAAA,GAtDvFa,CAsDuFb,SAtD7EP,eAsD6EO,GAAAA,OAAAA,GAAAA,KAAAA;;;;;;;AAYhGK,KA3D1EU,uBA2D0EV,CAAAA,UA3DxCH,mBA2DwCG,EAAAA,eA3DJS,wBA2DIT,CA3DqBW,OA2DrBX,CAAAA,CAAAA,GAAAA,CA3DkCO,yBA2DlCP,CA3D4DW,OA2D5DX,CAAAA,SAAAA,MAAAA,GAAAA,MAAAA,GAAAA,KAAAA,CAAAA,GA3DwGY,YA2DxGZ,GA3DuHnB,QA2DvHmB;;;;;;;;;AAxB2F;AAiDhKoB,KA1ELP,qBAAAA,GAAwBxC,CAAAA,CAAG0C,OA0ET,CAAA,MAAA,GAAA,SAAA,EA1EqC1C,CAAAA,CAAGyC,UA0ExC;;GAAA,CAAA;;;;;;;;;;;;;;;;;;;;AAAiJ;AAkB/K;AAcA;AAAiC,UAjFhBT,uBAiFgB,CAAA,UAjFkBR,mBAiFlB,EAAA,eAjFsDY,wBAiFtD,CAjF+EE,OAiF/E,CAAA,EAAA,cAjFuGpB,cAiFvG,CAAA,SAjF+HZ,iBAiF/H,CAjFiJ+B,uBAiFjJ,CAjFyKC,OAiFzK,EAjFkLC,YAiFlL,CAAA,EAjFiMK,WAiFjM,GAjF+MnC,WAiF/M,CAAA,CAAA;EAAA,YAAeS,EAAAA,MAAAA,EAAAA;EAAc;;;EACuD,MAAnB4B,EA7EtFR,OA6EsFQ;EAAO;AADb;AAS5F;;;;EAA4H,MAAjCZ,CAAAA,aA9EnEG,uBA8EmEH,CA9E3CI,OA8E2CJ,EA9ElCK,YA8EkCL,CAAAA,EAAAA,gBA9EHP,kBA8EGO,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EA9EkCW,IA8ElCX,EAAAA,SAAAA,CAAAA,EA9EoDZ,OA8EpDY,CAAAA,EA9E8DY,OA8E9DZ,CA9EsEd,cA8EtEc,CA9EqFW,IA8ErFX,EA9E2FZ,OA8E3FY,EA9EoGU,WA8EpGV,CAAAA,CAAAA;EAAyB;;;;;;;;AAAqE;AAkBzL;;EAAwC,IAAQF,CAAAA,aApF1BK,uBAoF0BL,CApFFM,OAoFEN,EApFOO,YAoFPP,CAAAA,EAAAA,gBApFsCL,kBAoFtCK,GAAAA,SAAAA,CAAAA,CAAAA,GAAAA,EApF2Ea,IAoF3Eb,EAAAA,SAAAA,CAAAA,EApF6FV,OAoF7FU,EAAuB;EAAiB,IAAGjB,CAAAA,EAAAA,MAAAA,EAAAA,CAAAA,EAlFrE+B,OAkFqE/B,CAlF7DK,cAkF6DL,CAlF9C8B,IAkF8C9B,EAlFxCO,OAkFwCP,EAlF/B6B,WAkF+B7B,CAAAA,CAAAA;EAAU;AAAkC;AAOvI;EAOwBwC,IAAAA,EAAAA,MAAAA;EASAC;AA8DxB;;EAAuB,WAAyCpD,EAAAA,MAAAA;EAAc;;;;;;EAIoB,YAAoBsD,EAAAA,OAAAA;;;;;;;;AAgBlB9B,UApKnFmB,aAoKmFnB,CAAAA,UApK3DY,qBAoK2DZ,EAAAA,eApKrBQ,wBAoKqBR,CApKIU,OAoKJV,CAAAA,EAAAA,cApK4BV,cAoK5BU,CAAAA,SApKoDI,uBAoKpDJ,CApK4EU,OAoK5EV,EApKqFW,YAoKrFX,EApKmGgB,WAoKnGhB,CAAAA,CAAAA;EAAM;;AAItF;;;;;;;oBA9JES,wBAAwBC,SAASC,+BAA+BZ;;OAE7EkB,kBAAkBvB,UAAUwB,QAAQ1B,eAAe4B,YAAYH,OAAOvB,SAASsB;;;;;;UAMvEK,oBAAAA,SAA6BvB;;;;;;;;;;;;;;UAc7BwB,+BAA+BhC,wBAAwB+B;qCACjChD,oCAAoC0B,uBAAuBmB,QAAQF;;;;;;;;UAQzFO,qCAAqC3B,qCAAqCU,0BAA0BI,wBAAwBpB,wBAAwB+B;;;;;;;;;gBASnJG,4BAA4BnD,oCAAoCG,mBAAmB0C,QAAQF;UACjGN;;;;;;;;iBAQYe,gBAAAA,QAAwBrB,0BAA0B7B,iBAAiBY,0BAAqBiB;;;;;;;iBAOxFsB,kBAAAA,0BAA4CjD;;;;;;;iBAO5CkD,sBAAAA,0BAAgDxB;;;;;;;;;iBAShDyB,eAAAA,0BAAyCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8DrD0B,oDAAoDrD;;;;SAIrDsD,eAAe5C,mBAAmBF,sBAAsB8C,UAAUA,eAAe9B,0BAA0B8B;;;;;;;;aAQvGlD;;;;UAIHmB;;;;WAICgC,iBAAiB7C,mBAAmBF,sBAAsB+C,YAAYA,iBAAiB/B,0BAA0B+B;;;;SAInH3C"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","names":["z","z3","CallbackManagerForToolRun","BaseLangChainParams","ToolDefinition","RunnableConfig","RunnableToolLike","RunnableInterface","DirectToolOutput","ToolCall","ToolMessage","MessageContent","InferInteropZodInput","InferInteropZodOutput","InteropZodType","InteropZodObject","JSONSchema","BaseStore","ResponseFormat","ToolOutputType","ContentAndArtifact","ToolReturnType","TOutput","TConfig","TInput","ToolInputSchemaBase","ZodTypeAny","ToolParams","ToolRunnableConfig","Record","ConfigurableFieldType","ContextSchema","StructuredToolParams","StructuredToolInterface","Pick","ToolInputSchemaOutputType","T","ToolInputSchemaInputType","StructuredToolCallInput","SchemaT","SchemaInputT","StringInputToolSchema","ZodTypeDef","ZodType","ToolCallInput","ToolOutputT","TArg","Promise","ToolInterface","NonNullable","BaseDynamicToolInput","DynamicToolInput","DynamicStructuredToolInput","SchemaOutputT","isStructuredTool","isRunnableToolLike","isStructuredToolParams","isLangChainTool","ToolRuntime","TState","TContext"],"sources":["../../src/tools/types.d.ts"],"sourcesContent":["import type { z as z3 } from \"zod/v3\";\nimport { CallbackManagerForToolRun } from \"../callbacks/manager.js\";\nimport type { BaseLangChainParams, ToolDefinition } from \"../language_models/base.js\";\nimport type { RunnableConfig } from \"../runnables/config.js\";\nimport { RunnableToolLike, type RunnableInterface } from \"../runnables/base.js\";\nimport { type DirectToolOutput, type ToolCall, type ToolMessage } from \"../messages/tool.js\";\nimport type { MessageContent } from \"../messages/base.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, type InteropZodType, type InteropZodObject } from \"../utils/types/zod.js\";\nimport { JSONSchema } from \"../utils/json_schema.js\";\nimport type { BaseStore } from \"../stores.js\";\nexport type ResponseFormat = \"content\" | \"content_and_artifact\" | string;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ToolOutputType = any;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ContentAndArtifact = [MessageContent, any];\n/**\n * Conditional type that determines the return type of the {@link StructuredTool.invoke} method.\n * - If the input is a ToolCall, it returns a ToolMessage\n * - If the config is a runnable config and contains a toolCall property, it returns a ToolMessage\n * - Otherwise, it returns the original output type\n */\nexport type ToolReturnType<TInput, TConfig, TOutput> = TOutput extends DirectToolOutput ? TOutput : TConfig extends {\n    toolCall: {\n        id: string;\n    };\n} ? ToolMessage : TConfig extends {\n    toolCall: {\n        id: undefined;\n    };\n} ? TOutput : TConfig extends {\n    toolCall: {\n        id?: string;\n    };\n} ? TOutput | ToolMessage : TInput extends ToolCall ? ToolMessage : TOutput;\n/**\n * Base type that establishes the types of input schemas that can be used for LangChain tool\n * definitions.\n */\nexport type ToolInputSchemaBase = z3.ZodTypeAny | JSONSchema;\n/**\n * Parameters for the Tool classes.\n */\nexport interface ToolParams extends BaseLangChainParams {\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    /**\n     * Whether to show full details in the thrown parsing errors.\n     *\n     * @default false\n     */\n    verboseParsingErrors?: boolean;\n    /**\n     * Metadata for the tool.\n     */\n    metadata?: Record<string, unknown>;\n}\nexport type ToolRunnableConfig<\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nConfigurableFieldType extends Record<string, any> = Record<string, any>, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nContextSchema = any> = RunnableConfig<ConfigurableFieldType> & {\n    toolCall?: ToolCall;\n    context?: ContextSchema;\n};\n/**\n * Schema for defining tools.\n *\n * @version 0.2.19\n */\nexport interface StructuredToolParams extends Pick<StructuredToolInterface, \"name\" | \"schema\"> {\n    /**\n     * An optional description of the tool to pass to the model.\n     */\n    description?: string;\n}\n/**\n * Utility type that resolves the output type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaOutputType<T> = T extends InteropZodType ? InferInteropZodOutput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Utility type that resolves the input type of a tool input schema.\n *\n * Input & Output types are a concept used with Zod schema, as Zod allows for transforms to occur\n * during parsing. When using JSONSchema, input and output types are the same.\n *\n * The input type for a given schema should match the structure of the arguments that the LLM\n * generates as part of its {@link ToolCall}. The output type will be the type that results from\n * applying any transforms defined in your schema. If there are no transforms, the input and output\n * types will be the same.\n */\nexport type ToolInputSchemaInputType<T> = T extends InteropZodType ? InferInteropZodInput<T> : T extends JSONSchema ? unknown : never;\n/**\n * Defines the type that will be passed into a tool handler function as a result of a tool call.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport type StructuredToolCallInput<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>> = (ToolInputSchemaOutputType<SchemaT> extends string ? string : never) | SchemaInputT | ToolCall;\n/**\n * An input schema type for tools that accept a single string input.\n *\n * This schema defines a tool that takes an optional string parameter named \"input\".\n * It uses Zod's effects to transform the input and strip any extra properties.\n *\n * This is primarily used for creating simple string-based tools where the LLM\n * only needs to provide a single text value as input to the tool.\n */\nexport type StringInputToolSchema = z3.ZodType<string | undefined, z3.ZodTypeDef, \n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nany>;\n/**\n * Defines the type for input to a tool's call method.\n *\n * This type is a convenience alias for StructuredToolCallInput with the input type\n * derived from the schema. It represents the possible inputs that can be passed to a tool,\n * which can be either:\n * - A string (if the tool accepts string input)\n * - A structured input matching the tool's schema\n * - A ToolCall object (typically from an LLM)\n *\n * @param SchemaT - The schema type for the tool input, defaults to StringInputToolSchema\n */\nexport type ToolCallInput<SchemaT = StringInputToolSchema> = StructuredToolCallInput<SchemaT, ToolInputSchemaInputType<SchemaT>>;\n/**\n * Interface that defines the shape of a LangChain structured tool.\n *\n * A structured tool is a tool that uses a schema to define the structure of the arguments that the\n * LLM generates as part of its {@link ToolCall}.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface StructuredToolInterface<SchemaT = ToolInputSchemaBase, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends RunnableInterface<StructuredToolCallInput<SchemaT, SchemaInputT>, ToolOutputT | ToolMessage> {\n    lc_namespace: string[];\n    /**\n     * A Zod schema representing the parameters of the tool.\n     */\n    schema: SchemaT;\n    /**\n     * Invokes the tool with the provided argument and configuration.\n     * @param arg The input argument for the tool.\n     * @param configArg Optional configuration for the tool call.\n     * @returns A Promise that resolves with the tool's output.\n     */\n    invoke<TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(arg: TArg, configArg?: TConfig): Promise<ToolReturnType<TArg, 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     * The name of the tool.\n     */\n    name: string;\n    /**\n     * A description of the tool.\n     */\n    description: string;\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 * A special interface for tools that accept a string input, usually defined with the {@link Tool} class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaInputT - The TypeScript type representing the structure of the tool arguments generated by the LLM. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface ToolInterface<SchemaT = StringInputToolSchema, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType> extends StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT> {\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 StructuredToolCallInput<SchemaT, SchemaInputT>, TConfig extends ToolRunnableConfig | undefined>(\n    // TODO: shouldn't this be narrowed based on SchemaT?\n    arg: TArg, callbacks?: TConfig): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>>;\n}\n/**\n * Base interface for the input parameters of the {@link DynamicTool} and\n * {@link DynamicStructuredTool} classes.\n */\nexport interface BaseDynamicToolInput extends ToolParams {\n    name: string;\n    description: string;\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 * Interface for the input parameters of the DynamicTool class.\n */\nexport interface DynamicToolInput<ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolOutputT>;\n}\n/**\n * Interface for the input parameters of the DynamicStructuredTool class.\n *\n * @param SchemaT - The type of the tool input schema. Usually you don't need to specify this.\n * @param SchemaOutputT - The TypeScript type representing the result of applying the schema to the tool arguments. Useful for type checking tool handler functions when using JSONSchema.\n */\nexport interface DynamicStructuredToolInput<SchemaT = ToolInputSchemaBase, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, ToolOutputT = ToolOutputType> extends BaseDynamicToolInput {\n    /**\n     * Tool handler function - the function that will be called when the tool is invoked.\n     *\n     * @param input - The input to the tool.\n     * @param runManager - The run manager for the tool.\n     * @param config - The configuration for the tool.\n     * @returns The result of the tool.\n     */\n    func: (input: SchemaOutputT, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolOutputT>;\n    schema: SchemaT;\n}\n/**\n * Confirm whether the inputted tool is an instance of `StructuredToolInterface`.\n *\n * @param {StructuredToolInterface | JSONSchema | undefined} tool The tool to check if it is an instance of `StructuredToolInterface`.\n * @returns {tool is StructuredToolInterface} Whether the inputted tool is an instance of `StructuredToolInterface`.\n */\nexport declare function isStructuredTool(tool?: StructuredToolInterface | ToolDefinition | JSONSchema): tool is StructuredToolInterface;\n/**\n * Confirm whether the inputted tool is an instance of `RunnableToolLike`.\n *\n * @param {unknown | undefined} tool The tool to check if it is an instance of `RunnableToolLike`.\n * @returns {tool is RunnableToolLike} Whether the inputted tool is an instance of `RunnableToolLike`.\n */\nexport declare function isRunnableToolLike(tool?: unknown): tool is RunnableToolLike;\n/**\n * Confirm whether or not the tool contains the necessary properties to be considered a `StructuredToolParams`.\n *\n * @param {unknown | undefined} tool The object to check if it is a `StructuredToolParams`.\n * @returns {tool is StructuredToolParams} Whether the inputted object is a `StructuredToolParams`.\n */\nexport declare function isStructuredToolParams(tool?: unknown): tool is StructuredToolParams;\n/**\n * Whether or not the tool is one of StructuredTool, RunnableTool or StructuredToolParams.\n * It returns `is StructuredToolParams` since that is the most minimal interface of the three,\n * while still containing the necessary properties to be passed to a LLM for tool calling.\n *\n * @param {unknown | undefined} tool The tool to check if it is a LangChain tool.\n * @returns {tool is StructuredToolParams} Whether the inputted tool is a LangChain tool.\n */\nexport declare function isLangChainTool(tool?: unknown): tool is StructuredToolParams;\n/**\n * Runtime context automatically injected into tools.\n *\n * When a tool function has a parameter named `tool_runtime` with type hint\n * `ToolRuntime`, the tool execution system will automatically inject an instance\n * containing:\n *\n * - `state`: The current graph state\n * - `toolCallId`: The ID of the current tool call\n * - `config`: `RunnableConfig` for the current execution\n * - `context`: Runtime context\n * - `store`: `BaseStore` instance for persistent storage\n * - `writer`: Stream writer for streaming output\n *\n * No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`\n * as a parameter.\n *\n * @example\n * ```typescript\n * import { tool, ToolRuntime } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n *\n * const stateSchema = z.object({\n *   messages: z.array(z.any()),\n *   userId: z.string().optional(),\n * });\n *\n * const greet = tool(\n *   async ({ name }, runtime) => {\n *     // Access state\n *     const messages = runtime.state.messages;\n *\n *     // Access tool_call_id\n *     console.log(`Tool call ID: ${runtime.toolCallId}`);\n *\n *     // Access config\n *     console.log(`Run ID: ${runtime.config.runId}`);\n *\n *     // Access runtime context\n *     const userId = runtime.context?.userId;\n *\n *     // Access store\n *     await runtime.store?.mset([[\"key\", \"value\"]]);\n *\n *     // Stream output\n *     runtime.writer?.(\"Processing...\");\n *\n *     return `Hello! User ID: ${runtime.state.userId || \"unknown\"} ${name}`;\n *   },\n *   {\n *     name: \"greet\",\n *     description: \"Use this to greet the user once you found their info.\",\n *     schema: z.object({ name: z.string() }),\n *     stateSchema,\n *   }\n * );\n * ```\n *\n * @template StateT - The type of the state schema (inferred from stateSchema)\n * @template ContextT - The type of the context schema (inferred from contextSchema)\n */\nexport type ToolRuntime<TState = unknown, TContext = unknown> = RunnableConfig & {\n    /**\n     * The current graph state.\n     */\n    state: TState extends InteropZodObject ? InferInteropZodOutput<TState> : TState extends Record<string, unknown> ? TState : unknown;\n    /**\n     * The ID of the current tool call.\n     */\n    toolCallId: string;\n    /**\n     * The current tool call.\n     */\n    toolCall?: ToolCall;\n    /**\n     * RunnableConfig for the current execution.\n     */\n    config: ToolRunnableConfig;\n    /**\n     * Runtime context (from langgraph `Runtime`).\n     */\n    context: TContext extends InteropZodObject ? InferInteropZodOutput<TContext> : TContext extends Record<string, unknown> ? TContext : unknown;\n    /**\n     * BaseStore instance for persistent storage (from langgraph `Runtime`).\n     */\n    store: BaseStore<string, unknown> | null;\n    /**\n     * Stream writer for streaming output (from langgraph `Runtime`).\n     */\n    writer: ((chunk: unknown) => void) | null;\n};\n"],"mappings":"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"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.cts","names":["ToolCall","_isToolCall","_configHasToolCallId","ToolInputParsingException","Error"],"sources":["../../src/tools/utils.d.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\nexport declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;\nexport declare function _configHasToolCallId(config?: unknown): config is {\n    toolCall: {\n        id?: string;\n    };\n};\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport declare class ToolInputParsingException extends Error {\n    output?: string;\n    constructor(message: string, output?: string);\n}\n"],"mappings":";;;;;;;cAYqBG,yBAAAA,SAAkCC,KAAK"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","names":["ToolCall","_isToolCall","_configHasToolCallId","ToolInputParsingException","Error"],"sources":["../../src/tools/utils.d.ts"],"sourcesContent":["import { ToolCall } from \"../messages/tool.js\";\nexport declare function _isToolCall(toolCall?: unknown): toolCall is ToolCall;\nexport declare function _configHasToolCallId(config?: unknown): config is {\n    toolCall: {\n        id?: string;\n    };\n};\n/**\n * Custom error class used to handle exceptions related to tool input parsing.\n * It extends the built-in `Error` class and adds an optional `output`\n * property that can hold the output that caused the exception.\n */\nexport declare class ToolInputParsingException extends Error {\n    output?: string;\n    constructor(message: string, output?: string);\n}\n"],"mappings":";;;;;;;cAYqBG,yBAAAA,SAAkCC,KAAK"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.cts","names":["KVMap","BaseRun","RunTree","ChainValues","AgentAction","AgentFinish","LLMResult","BaseMessage","Serialized","BaseCallbackHandler","BaseCallbackHandlerInput","HandleLLMNewTokenCallbackFields","NewTokenIndices","Document","RunType","Run","Record","Array","AgentRun","isBaseTracer","BaseTracer","Map","Promise","langsmith_schemas0","Attachments"],"sources":["../../src/tracers/base.d.ts"],"sourcesContent":["import { KVMap, BaseRun } from \"langsmith/schemas\";\nimport { RunTree } from \"langsmith/run_trees\";\nimport type { ChainValues } from \"../utils/types/index.js\";\nimport type { AgentAction, AgentFinish } from \"../agents.js\";\nimport type { LLMResult } from \"../outputs.js\";\nimport type { BaseMessage } from \"../messages/base.js\";\nimport { Serialized } from \"../load/serializable.js\";\nimport { BaseCallbackHandler, BaseCallbackHandlerInput, HandleLLMNewTokenCallbackFields, NewTokenIndices } from \"../callbacks/base.js\";\nimport type { Document } from \"../documents/document.js\";\nexport type RunType = string;\n// TODO: Remove this type and just use the base LangSmith Run type.\nexport interface Run extends BaseRun {\n    // some optional fields are always present here\n    id: string;\n    start_time: number;\n    end_time?: number;\n    execution_order: number;\n    // some additional fields that don't exist in sdk runs\n    child_runs: this[];\n    child_execution_order: number;\n    events: Array<{\n        name: string;\n        time: string;\n        kwargs?: Record<string, unknown>;\n    }>;\n    trace_id?: string;\n    dotted_order?: string;\n    /** @internal */\n    _serialized_start_time?: string;\n}\nexport interface AgentRun extends Run {\n    actions: AgentAction[];\n}\nexport declare function isBaseTracer(x: BaseCallbackHandler): x is BaseTracer;\nexport declare abstract class BaseTracer extends BaseCallbackHandler {\n    /** @deprecated Use `runTreeMap` instead. */\n    protected runMap: Map<string, Run>;\n    protected runTreeMap: Map<string, RunTree>;\n    protected usesRunTreeMap: boolean;\n    constructor(_fields?: BaseCallbackHandlerInput);\n    copy(): this;\n    protected getRunById(runId?: string): Run | undefined;\n    protected stringifyError(error: unknown): string;\n    protected abstract persistRun(run: Run): Promise<void>;\n    protected _addChildRun(parentRun: Run, childRun: Run): void;\n    _addRunToRunMap(run: Run): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        // some optional fields are always present here\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        // some additional fields that don't exist in sdk runs\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    protected _endTrace(run: Run): Promise<void>;\n    protected _getExecutionOrder(parentRunId: string | undefined): number;\n    /**\n     * Create and add a run to the run map for LLM start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        // some optional fields are always present here\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        // some additional fields that don't exist in sdk runs\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    /**\n     * Create and add a run to the run map for chat model start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        // some optional fields are always present here\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        // some additional fields that don't exist in sdk runs\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleLLMEnd(output: LLMResult, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;\n    handleLLMError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], extraParams?: Record<string, unknown>): Promise<Run>;\n    /**\n     * Create and add a run to the run map for chain start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        // some optional fields are always present here\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        // some additional fields that don't exist in sdk runs\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;\n    handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {\n        inputs?: Record<string, unknown>;\n    }): Promise<Run>;\n    handleChainError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {\n        inputs?: Record<string, unknown>;\n    }): Promise<Run>;\n    /**\n     * Create and add a run to the run map for tool start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        // some optional fields are always present here\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        // some additional fields that don't exist in sdk runs\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    handleToolEnd(output: any, runId: string): Promise<Run>;\n    handleToolError(error: unknown, runId: string): Promise<Run>;\n    handleAgentAction(action: AgentAction, runId: string): Promise<void>;\n    handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;\n    /**\n     * Create and add a run to the run map for retriever start events.\n     * This must sometimes be done synchronously to avoid race conditions\n     * when callbacks are backgrounded, so we expose it as a separate method here.\n     */\n    _createRunForRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {\n        name: string;\n        run_type: string;\n        extra?: KVMap | undefined;\n        error?: string | undefined;\n        serialized?: object | undefined;\n        inputs: KVMap;\n        outputs?: KVMap | undefined;\n        reference_example_id?: string | undefined;\n        parent_run_id?: string | undefined;\n        tags?: string[] | undefined;\n        attachments?: import(\"langsmith/schemas\").Attachments | undefined;\n        // some optional fields are always present here\n        id: string;\n        start_time: number;\n        end_time?: number | undefined;\n        execution_order: number;\n        // some additional fields that don't exist in sdk runs\n        child_runs: Run[];\n        child_execution_order: number;\n        events: {\n            name: string;\n            time: string;\n            kwargs?: Record<string, unknown> | undefined;\n        }[];\n        trace_id?: string | undefined;\n        dotted_order?: string | undefined;\n        /** @internal */\n        _serialized_start_time?: string | undefined;\n    };\n    handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;\n    handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;\n    handleRetrieverError(error: unknown, runId: string): Promise<Run>;\n    handleText(text: string, runId: string): Promise<void>;\n    handleLLMNewToken(token: string, idx: NewTokenIndices, runId: string, _parentRunId?: string, _tags?: string[], fields?: HandleLLMNewTokenCallbackFields): Promise<Run>;\n    // custom event handlers\n    onRunCreate?(run: Run): void | Promise<void>;\n    onRunUpdate?(run: Run): void | Promise<void>;\n    onLLMStart?(run: Run): void | Promise<void>;\n    onLLMEnd?(run: Run): void | Promise<void>;\n    onLLMError?(run: Run): void | Promise<void>;\n    onChainStart?(run: Run): void | Promise<void>;\n    onChainEnd?(run: Run): void | Promise<void>;\n    onChainError?(run: Run): void | Promise<void>;\n    onToolStart?(run: Run): void | Promise<void>;\n    onToolEnd?(run: Run): void | Promise<void>;\n    onToolError?(run: Run): void | Promise<void>;\n    onAgentAction?(run: Run): void | Promise<void>;\n    onAgentEnd?(run: Run): void | Promise<void>;\n    onRetrieverStart?(run: Run): void | Promise<void>;\n    onRetrieverEnd?(run: Run): void | Promise<void>;\n    onRetrieverError?(run: Run): void | Promise<void>;\n    onText?(run: Run): void | Promise<void>;\n    onLLMNewToken?(run: Run, token: string, \n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    kwargs?: {\n        chunk: any;\n    }): void | Promise<void>;\n}\n"],"mappings":";;;;;;;;;;;;KASYc,OAAAA;;UAEKC,GAAAA,SAAYd;EAFjBa;EAEKC,EAAAA,EAAAA,MAAG;EAAA,UAAA,EAAA,MAAA;EAAA,QAYHC,CAAAA,EAAAA,MAAAA;EAAM,eAHXC,EAAAA,MAAAA;EAAK;EATmB,UAAA,EAAA,IAAA,EAAA;EAmBnBC,qBAAQ,EAAA,MAAA;EAAA,MAAA,EAVbD,KAUa,CAAA;IACZb,IAAAA,EAAAA,MAAAA;IADqBW,IAAAA,EAAAA,MAAAA;IAAG,MAAA,CAAA,EAPpBC,MAOoB,CAAA,MAAA,EAAA,OAAA,CAAA;EAGbG,CAAAA,CAAAA;EAAY,QAAA,CAAA,EAAA,MAAA;EAAA,YAAIV,CAAAA,EAAAA,MAAAA;EAAmB;EAAkB,sBAAA,CAAA,EAAA,MAAA;AAC7E;AAAwC,UAJvBS,QAAAA,SAAiBH,GAIM,CAAA;EAAA,OAENA,EALrBX,WAKqBW,EAAAA;;AACIb,iBAJdiB,YAAAA,CAIcjB,CAAAA,EAJEO,mBAIFP,CAAAA,EAAAA,CAAAA,IAJ6BkB,UAI7BlB;AAAZmB,uBAHID,UAAAA,SAAmBX,mBAAAA,CAGvBY;EAAG;EAEqB,UAERN,MAAAA,EALpBM,GAKoBN,CAAAA,MAAAA,EALRA,GAKQA,CAAAA;EAAG,UAENA,UAAAA,EANbM,GAMaN,CAAAA,MAAAA,EANDb,OAMCa,CAAAA;EAAG,UAAGO,cAAAA,EAAAA,OAAAA;EAAO,WACdP,CAAAA,OAAAA,CAAAA,EALZL,wBAKYK;EAAG,IAAYA,CAAAA,CAAAA,EAAAA,IAAAA;EAAG,UAC/BA,UAAAA,CAAAA,KAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAJiBA,GAIjBA,GAAAA,SAAAA;EAAG,UAGZf,cAAAA,CAAAA,KAAAA,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA;EAAK,mBAGLA,UAAAA,CAAAA,GAAAA,EARuBe,GAQvBf,CAAAA,EAR6BsB,OAQ7BtB,CAAAA,IAAAA,CAAAA;EAAK,UACHA,YAAAA,CAAAA,SAAAA,EARoBe,GAQpBf,EAAAA,QAAAA,EARmCe,GAQnCf,CAAAA,EAAAA,IAAAA;EAAK,eAAAuB,CAAAA,GAAAA,EAPER,GAWyBS,CAAAA,EAAAA;IAO9BT,IAAAA,EAAAA,MAAAA;IAKCC,QAAAA,EAAAA,MAAAA;IAOQD,KAAAA,CAAAA,EA3Bbf,KA2Bae,GAAAA,SAAAA;IAAMO,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAOJd,UAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAkFR,MAAAA,EA/BjGA,KA+BiGA;IAAmCA,OAAAA,CAAAA,EA9BlIA,KA8BkIA,GAAAA,SAAAA;IAGpIA,oBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAGAA,aAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACEA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;IAAKuB,WAAAA,CAAAA,EArCAA,kBAAAA,CAI2BC,WAAAA,GAqCAA,SAAAA;IAO9BT;IAKCC,EAAAA,EAAAA,MAAAA;IAOGR,UAAAA,EAAAA,MAAAA;IAAkFR,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAmCA,eAAAA,EAAAA,MAAAA;IAA+Be;IAARO,UAAAA,EAjDhJP,GAiDgJO,EAAAA;IAM/Hd,qBAAAA,EAAAA,MAAAA;IAAsBD,MAAAA,EAAAA;MAAoEP,IAAAA,EAAAA,MAAAA;MAAmCA,IAAAA,EAAAA,MAAAA;MAGlJA,MAAAA,CAAAA,EArDKgB,MAqDLhB,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;IAGAA,CAAAA,EAAAA;IACEA,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAKuB,YAAAA,CAAAA,EAAAA,MAI2BC,GAAAA,SAAAA;IAO9BT;IAKCC,sBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAM,CAAA;EAOa,UAAYT,SAAAA,CAAAA,GAAAA,EAzEvBQ,GAyEuBR,CAAAA,EAzEjBe,OAyEiBf,CAAAA,IAAAA,CAAAA;EAAW,UAAyDP,kBAAAA,CAAAA,WAAAA,EAAAA,MAAAA,GAAAA,SAAAA,CAAAA,EAAAA,MAAAA;EAAK;;;;;EACb,qBAA4Be,CAAAA,GAAAA,EAnE7GP,UAmE6GO,EAAAA,OAAAA,EAAAA,MAAAA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAnE3Bf,KAmE2Be,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,QAAAA,CAAAA,EAnEQf,KAmERe,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA;IAARO,IAAAA,EAAAA,MAAAA;IAC3BN,QAAAA,EAAAA,MAAAA;IAAkCD,KAAAA,CAAAA,EAjE3Hf,KAiE2He,GAAAA,SAAAA;IAARO,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAMhGd,UAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAoBL,MAAAA,EApEvCH,KAoEuCG;IAA8EH,OAAAA,CAAAA,EAnEnHA,KAmEmHA,GAAAA,SAAAA;IAGrHA,oBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAGAA,aAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACEA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;IAAKuB,WAAAA,CAAAA,EA1EAA,kBAAAA,CAI2BC,WAAAA,GA0EAA,SAAAA;IAO9BT;IAKCC,EAAAA,EAAAA,MAAAA;IAOOR,UAAAA,EAAAA,MAAAA;IAAoBL,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAA8EH,eAAAA,EAAAA,MAAAA;IAAiDe;IAARO,UAAAA,EAtFnJP,GAsFmJO,EAAAA;IAC3InB,qBAAAA,EAAAA,MAAAA;IACXa,MAAAA,EAAAA;MACDD,IAAAA,EAAAA,MAAAA;MAARO,IAAAA,EAAAA,MAAAA;MAESN,MAAAA,CAAAA,EAtFIA,MAsFJA,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;IACDD,CAAAA,EAAAA;IAARO,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAMyBd,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAA4FR;IAG7GA,sBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAK,CAAA;EAGA,cACHA,CAAAA,GAAAA,EA7FMQ,UA6FNR,EAAAA,OAAAA,EAAAA,MAAAA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EA7FwFA,KA6FxFA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,QAAAA,CAAAA,EA7F2HA,KA6F3HA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EA7FkJsB,OA6FlJtB,CA7F0Je,GA6F1Jf,CAAAA;EAAK;;;;;EAuBoG,2BAA0Be,CAAAA,GAAAA,EA9GhHP,UA8GgHO,EAAAA,QAAAA,EA9G1FR,WA8G0FQ,EAAAA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EA9GtBf,KA8GsBe,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,QAAAA,CAAAA,EA9Gaf,KA8Gbe,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA;IAARO,IAAAA,EAAAA,MAAAA;IAEtFP,QAAAA,EAAAA,MAAAA;IAARO,KAAAA,CAAAA,EA7G/BtB,KA6G+BsB,GAAAA,SAAAA;IACaP,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAARO,UAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACtBlB,MAAAA,EA5GdJ,KA4GcI;IAA6BkB,OAAAA,CAAAA,EA3GzCtB,KA2GyCsB,GAAAA,SAAAA;IAChCjB,oBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAA6BiB,aAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAMbd,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;IAA4FR,WAAAA,CAAAA,EAlHhHuB,kBAAAA,CAI2BC,WAAAA,GA8GqFxB,SAAAA;IAGvHA;IAGAA,EAAAA,EAAAA,MAAAA;IACEA,UAAAA,EAAAA,MAAAA;IAAKuB,QAAAA,CAAAA,EAAAA,MAAAA,GAI2BC,SAAAA;IAO9BT,eAAAA,EAAAA,MAAAA;IAKCC;IAOeR,UAAAA,EArIhBO,GAqIgBP,EAAAA;IAA4FR,qBAAAA,EAAAA,MAAAA;IAA+Be,MAAAA,EAAAA;MAARO,IAAAA,EAAAA,MAAAA;MAC5GN,IAAAA,EAAAA,MAAAA;MAATH,MAAAA,CAAAA,EAjIbG,MAiIaH,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;IAA6DE,CAAAA,EAAAA;IAARO,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACtBP,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAARO;IACZA,sBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,CAAA;EACK,oBAAmEX,CAAAA,GAAAA,EA7H9FH,UA6H8FG,EAAAA,QAAAA,EA7HxEJ,WA6HwEI,EAAAA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EA7HJX,KA6HIW,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,QAAAA,CAAAA,EA7H+BX,KA6H/BW,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EA7HsDW,OA6HtDX,CA7H8DI,GA6H9DJ,CAAAA;EAA+B,YAAWI,CAAAA,MAAAA,EA5H7IT,SA4H6IS,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,WAAAA,CAAAA,EA5H5DC,MA4H4DD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,EA5HlCO,OA4HkCP,CA5H1BA,GA4H0BA,CAAAA;EAAG,cAAXO,CAAAA,KAAAA,EAAAA,OAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,WAAAA,CAAAA,EA3HrDN,MA2HqDM,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,EA3H3BA,OA2H2BA,CA3HnBP,GA2HmBO,CAAAA;EAAO;;;;;EAI7I,uBAAUA,CAAAA,KAAAA,EAzHCd,UAyHDc,EAAAA,MAAAA,EAzHqBnB,WAyHrBmB,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAAA,MAAAA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,QAAAA,CAAAA,EAzHmGtB,KAyHnGsB,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAAA;IACfP,IAAAA,EAAAA,MAAAA;IAAaO,QAAAA,EAAAA,MAAAA;IACXP,KAAAA,CAAAA,EAxHLf,KAwHKe,GAAAA,SAAAA;IAAaO,KAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACXP,UAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAaO,MAAAA,EAtHpBtB,KAsHoBsB;IACfP,OAAAA,CAAAA,EAtHHf,KAsHGe,GAAAA,SAAAA;IAAaO,oBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACXP,aAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAaO,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAAAA,SAAAA;IACdP,WAAAA,CAAAA,EAxHCQ,kBAAAA,CAI2BC,WAAAA,GAoH5BT,SAAAA;IAAaO;IACfP,EAAAA,EAAAA,MAAAA;IAAaO,UAAAA,EAAAA,MAAAA;IACXP,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAaO,eAAAA,EAAAA,MAAAA;IACXP;IAAaO,UAAAA,EAhHjBP,GAgHiBO,EAAAA;IAChBP,qBAAAA,EAAAA,MAAAA;IAAaO,MAAAA,EAAAA;MACPP,IAAAA,EAAAA,MAAAA;MAAaO,IAAAA,EAAAA,MAAAA;MACfP,MAAAA,CAAAA,EA9GJC,MA8GID,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,GAAAA,SAAAA;IAAaO,CAAAA,EAAAA;IACXP,QAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IAAaO,YAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;IACvBP;IAAaO,sBAAAA,CAAAA,EAAAA,MAAAA,GAAAA,SAAAA;EAAO,CAAA;EACV,gBAIZA,CAAAA,KAAAA,EA9Gad,UA8Gbc,EAAAA,MAAAA,EA9GiCnB,WA8GjCmB,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,WAAAA,CAAAA,EAAAA,MAAAA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,QAAAA,CAAAA,EA9G+GtB,KA8G/GsB,EAAAA,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EA9GwJA,OA8GxJA,CA9GgKP,GA8GhKO,CAAAA;EAAO,cAtQ2Bb,CAAAA,OAAAA,EAyJrBN,WAzJqBM,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA,KAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,OAAAA,EAAAA;IAAmB,MAAA,CAAA,EA0JnDO,MA1JmD,CAAA,MAAA,EAAA,OAAA,CAAA;MA2J5DM,QAAQP;;aAECC;MACTM,QAAQP;;;;;;+BAMiBP,4FAA4FR;;;YAG7GA;;;YAGAA;cACEA;;;;kBAAKuB,kBAAAA,CAI2BC,WAAAA;;;;;;;gBAO9BT;;;;;eAKCC;;;;;;;wBAOKR,4FAA4FR,uBAAuBsB,QAAQP;;6CAEtGO,QAAQP;kDACHO,QAAQP;4BAC9BX,6BAA6BkB;yBAChCjB,6BAA6BiB;;;;;;yCAMbd,4FAA4FR;;;YAGvHA;;;YAGAA;cACEA;;;;kBAAKuB,kBAAAA,CAI2BC,WAAAA;;;;;;;gBAO9BT;;;;;eAKCC;;;;;;;kCAOeR,4FAA4FR,uBAAuBsB,QAAQP;gCAC7HF,SAASG,4CAA4CM,QAAQP;uDACtCO,QAAQP;2CACpBO;wCACHV,kFAAkFD,kCAAkCW,QAAQP;;oBAEhJA,aAAaO;oBACbP,aAAaO;mBACdP,aAAaO;iBACfP,aAAaO;mBACXP,aAAaO;qBACXP,aAAaO;mBACfP,aAAaO;qBACXP,aAAaO;oBACdP,aAAaO;kBACfP,aAAaO;oBACXP,aAAaO;sBACXP,aAAaO;mBAChBP,aAAaO;yBACPP,aAAaO;uBACfP,aAAaO;yBACXP,aAAaO;eACvBP,aAAaO;sBACNP;;;;aAITO"}