npm - @langchain/core - Versions diffs - 1.0.0-alpha.3 → 1.0.0-alpha.4 - Mend

@langchain/core 1.0.0-alpha.3 → 1.0.0-alpha.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (486) hide show

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

	@@ -1 +1 @@
1	- {"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 /\~~n// eslint-disable-next-line @typescript-eslint/no-explicit-any\~~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":";;;;;;~~AAoDA~~;;;;AAAyE;AAmDzE;;;;AAAyE;AA+CzE;AACA~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~iBAnGwBC,4BAA4BC,oBAAoBC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDhDC,kCAAkCF,cAAcC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDI,gCAAgCD;KACzCA,aAAAA;;;;yCAI+BN"}
1	+ {"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/context.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"context.js","names":["name: PropertyKey","value: T","config: ConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n _CONTEXT_VARIABLES_KEY,\n getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\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 /\~~n// eslint-disable-next-line @typescript-eslint/no-explicit-any\~~nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance === undefined) {\n throw new Error(\n `Internal error: Global shared async local storage instance has not been initialized.`\n );\n }\n const runTree = asyncLocalStorageInstance.getStore();\n const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n contextVars[name] = value;\n let newValue = {};\n if (isRunTree(runTree)) {\n newValue = new RunTree(runTree);\n }\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n asyncLocalStorageInstance.enterWith(newValue);\n}\n\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 function getContextVariable<T = any>(name: PropertyKey): T \| undefined {\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance === undefined) {\n return undefined;\n }\n const runTree = asyncLocalStorageInstance.getStore();\n return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) \|\| [];\n\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 const registerConfigureHook = (config: ConfigureHook) => {\n if (config.envVar && !config.handlerClass) {\n throw new Error(\n \"If envVar is set, handlerClass must also be set to a non-None value.\"\n );\n }\n setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~AA0DA~~,SAAgB,mBAAsBA,MAAmBC,OAAgB;CAEvE,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,OAChC,OAAM,IAAI,MACR,CAAC,oFAAoF,CAAC;CAG1F,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAU,wBAAyB;CAC5D,YAAY,QAAQ;CACpB,IAAI,WAAW,CAAE;AACjB,KAAI,UAAU,QAAQ,EACpB,WAAW,IAAI,QAAQ;CAGxB,SAAiB,0BAA0B;CAC5C,0BAA0B,UAAU,SAAS;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,mBAA4BD,MAAkC;CAE5E,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,OAChC,QAAO;CAET,MAAM,UAAU,0BAA0B,UAAU;AACpD,QAAO,UAAU,0BAA0B;AAC5C;AAED,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,qBAAqB,MAChC,mBAAoC,uBAAuB,IAAI,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,wBAAwB,CAACE,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR;CAGJ,mBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,MAAO,EAAC;AAC9E"}
1	+ {"version":3,"file":"context.js","names":["name: PropertyKey","value: T","config: ConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n _CONTEXT_VARIABLES_KEY,\n getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\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 function setContextVariable<T>(name: PropertyKey, value: T): void {\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance === undefined) {\n throw new Error(\n `Internal error: Global shared async local storage instance has not been initialized.`\n );\n }\n const runTree = asyncLocalStorageInstance.getStore();\n const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n contextVars[name] = value;\n let newValue = {};\n if (isRunTree(runTree)) {\n newValue = new RunTree(runTree);\n }\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n asyncLocalStorageInstance.enterWith(newValue);\n}\n\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 function getContextVariable<T = any>(name: PropertyKey): T \| undefined {\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance === undefined) {\n return undefined;\n }\n const runTree = asyncLocalStorageInstance.getStore();\n return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) \|\| [];\n\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 const registerConfigureHook = (config: ConfigureHook) => {\n if (config.envVar && !config.handlerClass) {\n throw new Error(\n \"If envVar is set, handlerClass must also be set to a non-None value.\"\n );\n }\n setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsBA,MAAmBC,OAAgB;CAEvE,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,OAChC,OAAM,IAAI,MACR,CAAC,oFAAoF,CAAC;CAG1F,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAU,wBAAyB;CAC5D,YAAY,QAAQ;CACpB,IAAI,WAAW,CAAE;AACjB,KAAI,UAAU,QAAQ,EACpB,WAAW,IAAI,QAAQ;CAGxB,SAAiB,0BAA0B;CAC5C,0BAA0B,UAAU,SAAS;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,mBAA4BD,MAAkC;CAE5E,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,OAChC,QAAO;CAET,MAAM,UAAU,0BAA0B,UAAU;AACpD,QAAO,UAAU,0BAA0B;AAC5C;AAED,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,qBAAqB,MAChC,mBAAoC,uBAAuB,IAAI,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,wBAAwB,CAACE,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR;CAGJ,mBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,MAAO,EAAC;AAC9E"}

package/dist/singletons/callbacks.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"callbacks.cjs","names":["queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"]","PQueue: any","PQueueMod","promiseFn: () => Promise<T> \| T \| void","wait: boolean","getGlobalAsyncLocalStorageInstance","getDefaultLangChainClientSingleton"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any /\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n/\n Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n /\nfunction createQueue() {\n const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n return new PQueue({\n autoStart: true,\n concurrency: 1,\n });\n}\n\nexport function getQueue() {\n if (typeof queue === \"undefined\") {\n queue = createQueue();\n }\n return queue;\n}\n\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 async function consumeCallback<T>(\n promiseFn: () => Promise<T> \| T \| void,\n wait: boolean\n): Promise<void> {\n if (wait === true) {\n // Clear config since callbacks are not part of the root run\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n } else {\n queue = getQueue();\n void queue.add(async () => {\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n });\n }\n}\n\n/\n Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n const defaultClient = getDefaultLangChainClientSingleton();\n await Promise.allSettled([\n typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n defaultClient.awaitPendingTraceBatches(),\n ]);\n}\n"],"mappings":";;;;;;AAMA,IAAIA;;;;;;AAOJ,SAAS,cAAc;CACrB,MAAMC,SAAc,aAAaC,kBAAYA,gBAAU,UAAUA;AACjE,QAAO,IAAI,OAAO;EAChB,WAAW;EACX,aAAa;CACd;AACF;AAED,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,aACnB,QAAQ,aAAa;AAEvB,QAAO;AACR;;;;;;AAOD,eAAsB,gBACpBC,WACAC,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4BC,oDAAoC;AACtE,MAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;OAEvE,MAAM,WAAW;CAEpB,OAAM;EACL,QAAQ,UAAU;~~EACb~~,MAAM,IAAI,YAAY;GACzB,MAAM,4BAA4BA,oDAAoC;AACtE,OAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;QAEvE,MAAM,WAAW;EAEpB,EAAC;CACH;AACF;;;;;AAMD,eAAsB,oBAAmC;CACvD,MAAM,gBAAgBC,mDAAoC;CAC1D,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,AACzC,EAAC;AACH"}
1	+ {"version":3,"file":"callbacks.cjs","names":["queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"]","PQueue: any","PQueueMod","promiseFn: () => Promise<T> \| T \| void","wait: boolean","getGlobalAsyncLocalStorageInstance","getDefaultLangChainClientSingleton"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any /\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n/\n Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n /\nfunction createQueue() {\n const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n return new PQueue({\n autoStart: true,\n concurrency: 1,\n });\n}\n\nexport function getQueue() {\n if (typeof queue === \"undefined\") {\n queue = createQueue();\n }\n return queue;\n}\n\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 async function consumeCallback<T>(\n promiseFn: () => Promise<T> \| T \| void,\n wait: boolean\n): Promise<void> {\n if (wait === true) {\n // Clear config since callbacks are not part of the root run\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n } else {\n queue = getQueue();\n // eslint-disable-next-line no-void\n void queue.add(async () => {\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n });\n }\n}\n\n/\n Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n const defaultClient = getDefaultLangChainClientSingleton();\n await Promise.allSettled([\n typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n defaultClient.awaitPendingTraceBatches(),\n ]);\n}\n"],"mappings":";;;;;;AAMA,IAAIA;;;;;;AAOJ,SAAS,cAAc;CACrB,MAAMC,SAAc,aAAaC,kBAAYA,gBAAU,UAAUA;AACjE,QAAO,IAAI,OAAO;EAChB,WAAW;EACX,aAAa;CACd;AACF;AAED,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,aACnB,QAAQ,aAAa;AAEvB,QAAO;AACR;;;;;;AAOD,eAAsB,gBACpBC,WACAC,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4BC,oDAAoC;AACtE,MAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;OAEvE,MAAM,WAAW;CAEpB,OAAM;EACL,QAAQ,UAAU;EAEb,MAAM,IAAI,YAAY;GACzB,MAAM,4BAA4BA,oDAAoC;AACtE,OAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;QAEvE,MAAM,WAAW;EAEpB,EAAC;CACH;AACF;;;;;AAMD,eAAsB,oBAAmC;CACvD,MAAM,gBAAgBC,mDAAoC;CAC1D,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,AACzC,EAAC;AACH"}

package/dist/singletons/callbacks.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"callbacks.js","names":["queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"]","PQueue: any","promiseFn: () => Promise<T> \| T \| void","wait: boolean"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any /\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n/\n Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n /\nfunction createQueue() {\n const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n return new PQueue({\n autoStart: true,\n concurrency: 1,\n });\n}\n\nexport function getQueue() {\n if (typeof queue === \"undefined\") {\n queue = createQueue();\n }\n return queue;\n}\n\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 async function consumeCallback<T>(\n promiseFn: () => Promise<T> \| T \| void,\n wait: boolean\n): Promise<void> {\n if (wait === true) {\n // Clear config since callbacks are not part of the root run\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n } else {\n queue = getQueue();\n void queue.add(async () => {\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n });\n }\n}\n\n/\n Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n const defaultClient = getDefaultLangChainClientSingleton();\n await Promise.allSettled([\n typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n defaultClient.awaitPendingTraceBatches(),\n ]);\n}\n"],"mappings":";;;;;AAMA,IAAIA;;;;;;AAOJ,SAAS,cAAc;CACrB,MAAMC,SAAc,aAAa,YAAY,UAAU,UAAU;AACjE,QAAO,IAAI,OAAO;EAChB,WAAW;EACX,aAAa;CACd;AACF;AAED,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,aACnB,QAAQ,aAAa;AAEvB,QAAO;AACR;;;;;;AAOD,eAAsB,gBACpBC,WACAC,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4B,oCAAoC;AACtE,MAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;OAEvE,MAAM,WAAW;CAEpB,OAAM;EACL,QAAQ,UAAU;~~EACb~~,MAAM,IAAI,YAAY;GACzB,MAAM,4BAA4B,oCAAoC;AACtE,OAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;QAEvE,MAAM,WAAW;EAEpB,EAAC;CACH;AACF;;;;;AAMD,eAAsB,oBAAmC;CACvD,MAAM,gBAAgB,oCAAoC;CAC1D,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,AACzC,EAAC;AACH"}
1	+ {"version":3,"file":"callbacks.js","names":["queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"]","PQueue: any","promiseFn: () => Promise<T> \| T \| void","wait: boolean"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any /\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n/\n Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n /\nfunction createQueue() {\n const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n return new PQueue({\n autoStart: true,\n concurrency: 1,\n });\n}\n\nexport function getQueue() {\n if (typeof queue === \"undefined\") {\n queue = createQueue();\n }\n return queue;\n}\n\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 async function consumeCallback<T>(\n promiseFn: () => Promise<T> \| T \| void,\n wait: boolean\n): Promise<void> {\n if (wait === true) {\n // Clear config since callbacks are not part of the root run\n // Avoid using global singleton due to circuluar dependency issues\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n } else {\n queue = getQueue();\n // eslint-disable-next-line no-void\n void queue.add(async () => {\n const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n if (asyncLocalStorageInstance !== undefined) {\n await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n } else {\n await promiseFn();\n }\n });\n }\n}\n\n/\n Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n const defaultClient = getDefaultLangChainClientSingleton();\n await Promise.allSettled([\n typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n defaultClient.awaitPendingTraceBatches(),\n ]);\n}\n"],"mappings":";;;;;AAMA,IAAIA;;;;;;AAOJ,SAAS,cAAc;CACrB,MAAMC,SAAc,aAAa,YAAY,UAAU,UAAU;AACjE,QAAO,IAAI,OAAO;EAChB,WAAW;EACX,aAAa;CACd;AACF;AAED,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,aACnB,QAAQ,aAAa;AAEvB,QAAO;AACR;;;;;;AAOD,eAAsB,gBACpBC,WACAC,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4B,oCAAoC;AACtE,MAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;OAEvE,MAAM,WAAW;CAEpB,OAAM;EACL,QAAQ,UAAU;EAEb,MAAM,IAAI,YAAY;GACzB,MAAM,4BAA4B,oCAAoC;AACtE,OAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;QAEvE,MAAM,WAAW;EAEpB,EAAC;CACH;AACF;;;;;AAMD,eAAsB,oBAAmC;CACvD,MAAM,gBAAgB,oCAAoC;CAC1D,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,AACzC,EAAC;AACH"}

package/dist/tools/index.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.cjs","names":["BaseLangChain","fields?: ToolParams","input: TInput","config?: TConfig","toolInput: Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >","enrichedConfig: ToolRunnableConfig","ensureConfig","mergeConfigs","_isToolCall","arg: TArg","configArg?: TConfig","tags?: string[]","parsed: SchemaOutputT","isInteropZodSchema","interopParseAsync","ToolInputParsingException","result","parseCallbackConfigArg","CallbackManager","toolCallId: string \| undefined","_configHasToolCallId","z","callbacks?: TConfig","fields: DynamicToolInput<ToolOutputT>","input: string","runManager?: CallbackManagerForToolRun","parentConfig?: ToolRunnableConfig","fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>","arg: Parameters<\n DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]\n >[0]","parentConfig?: RunnableConfig","func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>","fields: ToolWrapperParams<SchemaT>","isSimpleStringZodSchema","validatesOnlyStrings","patchConfig","AsyncLocalStorageProviderSingleton","pickRunnableConfigKeys","getAbortSignalError","params: {\n content: TOutput;\n name: string;\n artifact?: unknown;\n toolCallId?: string;\n}","isDirectToolOutput","ToolMessage","content: unknown"],"sources":["../../src/tools/index.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport {\n validate,\n type Schema as ValidationSchema,\n} from \"@cfworker/json-schema\";\nimport {\n CallbackManager,\n CallbackManagerForToolRun,\n parseCallbackConfigArg,\n} from \"../callbacks/manager.js\";\nimport { BaseLangChain } from \"../language_models/base.js\";\nimport {\n mergeConfigs,\n ensureConfig,\n patchConfig,\n pickRunnableConfigKeys,\n type RunnableConfig,\n} from \"../runnables/config.js\";\nimport type { RunnableFunc } from \"../runnables/base.js\";\nimport { isDirectToolOutput, ToolCall, ToolMessage } from \"../messages/tool.js\";\nimport { AsyncLocalStorageProviderSingleton } from \"../singletons/index.js\";\nimport {\n _configHasToolCallId,\n _isToolCall,\n ToolInputParsingException,\n} from \"./utils.js\";\nimport {\n type InferInteropZodInput,\n type InferInteropZodOutput,\n type InteropZodObject,\n type InteropZodType,\n interopParseAsync,\n isSimpleStringZodSchema,\n isInteropZodSchema,\n type ZodStringV3,\n type ZodStringV4,\n type ZodObjectV3,\n type ZodObjectV4,\n} from \"../utils/types/zod.js\";\nimport { getAbortSignalError } from \"../utils/signal.js\";\nimport type {\n StructuredToolCallInput,\n ToolInputSchemaBase,\n ToolReturnType,\n ResponseFormat,\n ToolInputSchemaInputType,\n ToolInputSchemaOutputType,\n ToolParams,\n ToolRunnableConfig,\n StructuredToolInterface,\n DynamicToolInput,\n DynamicStructuredToolInput,\n StringInputToolSchema,\n ToolInterface,\n ToolOutputType,\n} from \"./types.js\";\nimport { type JSONSchema, validatesOnlyStrings } from \"../utils/json_schema.js\";\n\nexport type {\n BaseDynamicToolInput,\n ContentAndArtifact,\n DynamicToolInput,\n DynamicStructuredToolInput,\n ResponseFormat,\n StructuredToolCallInput,\n StructuredToolInterface,\n StructuredToolParams,\n ToolInterface,\n ToolParams,\n ToolReturnType,\n ToolRunnableConfig,\n ToolInputSchemaBase as ToolSchemaBase,\n} from \"./types.js\";\n\nexport {\n isLangChainTool,\n isRunnableToolLike,\n isStructuredTool,\n isStructuredToolParams,\n} from \"./types.js\";\n\nexport { ToolInputParsingException };\n/*\n Base class for Tools that accept input of any shape defined by a Zod schema.\n /\nexport abstract class StructuredTool<\n SchemaT = ToolInputSchemaBase,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n >\n extends BaseLangChain<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolOutputT \| ToolMessage\n >\n implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT>\n{\n abstract name: string;\n\n abstract description: string;\n\n abstract schema: SchemaT;\n\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 = false;\n\n verboseParsingErrors = false;\n\n get lc_namespace() {\n return [\"langchain\", \"tools\"];\n }\n\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 = \"content\";\n\n /\n Default config object for the tool runnable.\n /\n defaultConfig?: ToolRunnableConfig;\n\n constructor(fields?: ToolParams) {\n super(fields ?? {});\n\n this.verboseParsingErrors =\n fields?.verboseParsingErrors ?? this.verboseParsingErrors;\n this.responseFormat = fields?.responseFormat ?? this.responseFormat;\n this.defaultConfig = fields?.defaultConfig ?? this.defaultConfig;\n }\n\n protected abstract _call(\n arg: SchemaOutputT,\n runManager?: CallbackManagerForToolRun,\n parentConfig?: ToolRunnableConfig\n ): Promise<ToolOutputT>;\n\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 async invoke<\n TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n input: TInput,\n config?: TConfig\n ): Promise<ToolReturnType<TInput, TConfig, ToolOutputT>> {\n let toolInput: Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >;\n\n let enrichedConfig: ToolRunnableConfig = ensureConfig(\n mergeConfigs(this.defaultConfig, config)\n );\n if (_isToolCall(input)) {\n toolInput = input.args as Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >;\n enrichedConfig = {\n ...enrichedConfig,\n toolCall: input,\n };\n } else {\n toolInput = input as Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >;\n }\n\n return this.call(toolInput, enrichedConfig) as Promise<\n ToolReturnType<TInput, TConfig, ToolOutputT>\n >;\n }\n\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 async call<\n TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n configArg?: TConfig,\n /* @deprecated /\n tags?: string[]\n ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>> {\n // Determine the actual input that needs parsing/validation.\n // If arg is a ToolCall, use its args; otherwise, use arg directly.\n const inputForValidation = _isToolCall(arg) ? arg.args : arg;\n\n let parsed: SchemaOutputT; // This will hold the successfully parsed input of the expected output type.\n if (isInteropZodSchema(this.schema)) {\n try {\n // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check\n parsed = await interopParseAsync(\n this.schema as InteropZodType,\n inputForValidation as Exclude<TArg, ToolCall>\n );\n } catch (e) {\n let message = `Received tool input did not match expected schema`;\n if (this.verboseParsingErrors) {\n message = `${message}\\nDetails: ${(e as Error).message}`;\n }\n // Pass the original raw input arg to the exception\n throw new ToolInputParsingException(message, JSON.stringify(arg));\n }\n } else {\n const result = validate(\n inputForValidation,\n this.schema as ValidationSchema\n );\n if (!result.valid) {\n let message = `Received tool input did not match expected schema`;\n if (this.verboseParsingErrors) {\n message = `${message}\\nDetails: ${result.errors\n .map((e) => `${e.keywordLocation}: ${e.error}`)\n .join(\"\\n\")}`;\n }\n // Pass the original raw input arg to the exception\n throw new ToolInputParsingException(message, JSON.stringify(arg));\n }\n // Assign the validated input to parsed\n // We cast here because validate() doesn't narrow the type sufficiently for TS, but we know it's valid.\n parsed = inputForValidation as SchemaOutputT;\n }\n\n const config = parseCallbackConfigArg(configArg);\n const callbackManager_ = CallbackManager.configure(\n config.callbacks,\n this.callbacks,\n config.tags \|\| tags,\n this.tags,\n config.metadata,\n this.metadata,\n { verbose: this.verbose }\n );\n const runManager = await callbackManager_?.handleToolStart(\n this.toJSON(),\n // Log the original raw input arg\n typeof arg === \"string\" ? arg : JSON.stringify(arg),\n config.runId,\n undefined,\n undefined,\n undefined,\n config.runName\n );\n delete config.runId;\n let result;\n try {\n // Pass the correctly typed parsed input to _call\n result = await this._call(parsed, runManager, config);\n } catch (e) {\n await runManager?.handleToolError(e);\n throw e;\n }\n let content;\n let artifact;\n if (this.responseFormat === \"content_and_artifact\") {\n if (Array.isArray(result) && result.length === 2) {\n [content, artifact] = result;\n } else {\n throw new Error(\n `Tool response format is \"content_and_artifact\" but the output was not a two-tuple.\\nResult: ${JSON.stringify(\n result\n )}`\n );\n }\n } else {\n content = result;\n }\n\n let toolCallId: string \| undefined;\n // Extract toolCallId ONLY if the original arg was a ToolCall\n if (_isToolCall(arg)) {\n toolCallId = arg.id;\n }\n // Or if it was provided in the config's toolCall property\n if (!toolCallId && _configHasToolCallId(config)) {\n toolCallId = config.toolCall.id;\n }\n\n const formattedOutput = _formatToolOutput<ToolOutputT>({\n content,\n artifact,\n toolCallId,\n name: this.name,\n });\n await runManager?.handleToolEnd(formattedOutput);\n return formattedOutput as ToolReturnType<TArg, TConfig, ToolOutputT>;\n }\n}\n\n/\n Base class for Tools that accept input as a string.\n /\nexport abstract class Tool<ToolOutputT = ToolOutputType>\n extends StructuredTool<\n StringInputToolSchema,\n ToolInputSchemaOutputType<StringInputToolSchema>,\n ToolInputSchemaInputType<StringInputToolSchema>,\n ToolOutputT\n >\n implements\n ToolInterface<\n StringInputToolSchema,\n ToolInputSchemaInputType<StringInputToolSchema>,\n ToolOutputT\n >\n{\n schema = z\n .object({ input: z.string().optional() })\n .transform((obj) => obj.input);\n\n constructor(fields?: ToolParams) {\n super(fields);\n }\n\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<\n TArg extends string \| undefined \| z.input<this[\"schema\"]> \| ToolCall,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n callbacks?: TConfig\n ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>> {\n // Prepare the input for the base class call method.\n // If arg is string or undefined, wrap it; otherwise, pass ToolCall or { input: ... } directly.\n const structuredArg =\n typeof arg === \"string\" \|\| arg == null ? { input: arg } : arg;\n\n // Ensure TConfig is passed to super.call\n return super.call(structuredArg, callbacks);\n }\n}\n\n/\n A tool that can be created dynamically from a function, name, and description.\n /\nexport class DynamicTool<\n ToolOutputT = ToolOutputType\n> extends Tool<ToolOutputT> {\n static lc_name() {\n return \"DynamicTool\";\n }\n\n name: string;\n\n description: string;\n\n func: DynamicToolInput<ToolOutputT>[\"func\"];\n\n constructor(fields: DynamicToolInput<ToolOutputT>) {\n super(fields);\n this.name = fields.name;\n this.description = fields.description;\n this.func = fields.func;\n this.returnDirect = fields.returnDirect ?? this.returnDirect;\n }\n\n /\n @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n /\n async call<\n TArg extends string \| undefined \| z.input<this[\"schema\"]> \| ToolCall,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n configArg?: TConfig\n ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>> {\n const config = parseCallbackConfigArg(configArg);\n if (config.runName === undefined) {\n config.runName = this.name;\n }\n // Call the Tool class's call method, passing generics through\n // Cast config to TConfig to satisfy the super.call signature\n return super.call<TArg, TConfig>(arg, config as TConfig);\n }\n\n /* @ignore /\n async _call(\n input: string, // DynamicTool's _call specifically expects a string after schema transformation\n runManager?: CallbackManagerForToolRun,\n parentConfig?: ToolRunnableConfig\n ): Promise<ToolOutputT> {\n return this.func(input, runManager, parentConfig);\n }\n}\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 class DynamicStructuredTool<\n SchemaT = ToolInputSchemaBase,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {\n static lc_name() {\n return \"DynamicStructuredTool\";\n }\n\n name: string;\n\n description: string;\n\n func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>[\"func\"];\n\n schema: SchemaT;\n\n constructor(\n fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>\n ) {\n super(fields);\n this.name = fields.name;\n this.description = fields.description;\n this.func = fields.func;\n this.returnDirect = fields.returnDirect ?? this.returnDirect;\n this.schema = fields.schema;\n }\n\n /\n @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n /\n // Match the base class signature\n async call<\n TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n configArg?: TConfig,\n /* @deprecated /\n tags?: string[]\n ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>> {\n const config = parseCallbackConfigArg(configArg);\n if (config.runName === undefined) {\n config.runName = this.name;\n }\n\n // Call the base class method, passing generics through\n // Cast config to TConfig to satisfy the super.call signature\n return super.call<TArg, TConfig>(arg, config as TConfig, tags);\n }\n\n protected _call(\n arg: Parameters<\n DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]\n >[0],\n runManager?: CallbackManagerForToolRun,\n parentConfig?: RunnableConfig\n ): Promise<ToolOutputT> {\n return this.func(arg, runManager, parentConfig);\n }\n}\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 abstract class BaseToolkit {\n abstract tools: StructuredToolInterface[];\n\n getTools(): StructuredToolInterface[] {\n return this.tools;\n }\n}\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>\n 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/\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 function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(\n func: RunnableFunc<\n InferInteropZodOutput<SchemaT>,\n ToolOutputT,\n ToolRunnableConfig\n >,\n fields: ToolWrapperParams<SchemaT>\n): DynamicTool<ToolOutputT>;\n\nexport function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(\n func: RunnableFunc<\n InferInteropZodOutput<SchemaT>,\n ToolOutputT,\n ToolRunnableConfig\n >,\n fields: ToolWrapperParams<SchemaT>\n): DynamicTool<ToolOutputT>;\n\nexport function tool<\n SchemaT extends ZodObjectV3,\n SchemaOutputT = InferInteropZodOutput<SchemaT>,\n SchemaInputT = InferInteropZodInput<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>,\n fields: ToolWrapperParams<SchemaT>\n): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\n\nexport function tool<\n SchemaT extends ZodObjectV4,\n SchemaOutputT = InferInteropZodOutput<SchemaT>,\n SchemaInputT = InferInteropZodInput<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>,\n fields: ToolWrapperParams<SchemaT>\n): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\n\nexport function tool<\n SchemaT extends JSONSchema,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<\n Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0],\n ToolOutputT,\n ToolRunnableConfig\n >,\n fields: ToolWrapperParams<SchemaT>\n): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\n\nexport function tool<\n SchemaT extends\n \| InteropZodObject\n \| InteropZodType<string>\n \| JSONSchema = InteropZodObject,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>,\n fields: ToolWrapperParams<SchemaT>\n):\n \| DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>\n \| DynamicTool<ToolOutputT> {\n const isSimpleStringSchema = isSimpleStringZodSchema(fields.schema);\n const isStringJSONSchema = validatesOnlyStrings(fields.schema);\n\n // If the schema is not provided, or it's a simple string schema, create a DynamicTool\n if (!fields.schema \|\| isSimpleStringSchema \|\| isStringJSONSchema) {\n return new DynamicTool<ToolOutputT>({\n ...fields,\n description:\n fields.description ??\n (fields.schema as { description?: string } \| undefined)?.description ??\n `${fields.name} tool`,\n func: async (input, runManager, config) => {\n return new Promise<ToolOutputT>((resolve, reject) => {\n const childConfig = patchConfig(config, {\n callbacks: runManager?.getChild(),\n });\n void AsyncLocalStorageProviderSingleton.runWithConfig(\n pickRunnableConfigKeys(childConfig),\n async () => {\n try {\n // TS doesn't restrict the type here based on the guard above\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n resolve(func(input as any, childConfig));\n } catch (e) {\n reject(e);\n }\n }\n );\n });\n },\n });\n }\n\n const schema = fields.schema as InteropZodObject \| JSONSchema;\n\n const description =\n fields.description ??\n (fields.schema as { description?: string }).description ??\n `${fields.name} tool`;\n\n return new DynamicStructuredTool<\n typeof schema,\n SchemaOutputT,\n SchemaInputT,\n ToolOutputT\n >({\n ...fields,\n description,\n schema,\n func: async (input, runManager, config) => {\n return new Promise<ToolOutputT>((resolve, reject) => {\n if (config?.signal) {\n config.signal.addEventListener(\"abort\", () => {\n return reject(getAbortSignalError(config.signal));\n });\n }\n\n const childConfig = patchConfig(config, {\n callbacks: runManager?.getChild(),\n });\n void AsyncLocalStorageProviderSingleton.runWithConfig(\n pickRunnableConfigKeys(childConfig),\n async () => {\n try {\n const result = await func(input, childConfig);\n\n /\n If the signal is aborted, we don't want to resolve the promise\n * as the promise is already rejected.\n */\n if (config?.signal?.aborted) {\n return;\n }\n\n resolve(result);\n } catch (e) {\n reject(e);\n }\n }\n );\n });\n },\n }) as DynamicStructuredTool<\n SchemaT,\n SchemaOutputT,\n SchemaInputT,\n ToolOutputT\n >;\n}\n\nfunction _formatToolOutput<TOutput extends ToolOutputType>(params: {\n content: TOutput;\n name: string;\n artifact?: unknown;\n toolCallId?: string;\n}): ToolMessage \| TOutput {\n const { content, artifact, toolCallId } = params;\n if (toolCallId && !isDirectToolOutput(content)) {\n if (\n typeof content === \"string\" \|\|\n (Array.isArray(content) &&\n content.every((item) => typeof item === \"object\"))\n ) {\n return new ToolMessage({\n content,\n artifact,\n tool_call_id: toolCallId,\n name: params.name,\n });\n } else {\n return new ToolMessage({\n content: _stringify(content),\n artifact,\n tool_call_id: toolCallId,\n name: params.name,\n });\n }\n } else {\n return content;\n }\n}\n\nfunction _stringify(content: unknown): string {\n try {\n return JSON.stringify(content, null, 2) ?? \"\";\n } catch (_noOp) {\n return `${content}`;\n }\n}\n"],"mappings":"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"}
1	+ {"version":3,"file":"index.cjs","names":["BaseLangChain","fields?: ToolParams","input: TInput","config?: TConfig","toolInput: Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >","enrichedConfig: ToolRunnableConfig","ensureConfig","mergeConfigs","_isToolCall","arg: TArg","configArg?: TConfig","tags?: string[]","parsed: SchemaOutputT","isInteropZodSchema","interopParseAsync","ToolInputParsingException","result","parseCallbackConfigArg","CallbackManager","toolCallId: string \| undefined","_configHasToolCallId","z","callbacks?: TConfig","fields: DynamicToolInput<ToolOutputT>","input: string","runManager?: CallbackManagerForToolRun","parentConfig?: ToolRunnableConfig","fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>","arg: Parameters<\n DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]\n >[0]","parentConfig?: RunnableConfig","func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>","fields: ToolWrapperParams<SchemaT>","isSimpleStringZodSchema","validatesOnlyStrings","patchConfig","AsyncLocalStorageProviderSingleton","pickRunnableConfigKeys","getAbortSignalError","params: {\n content: TOutput;\n name: string;\n artifact?: unknown;\n toolCallId?: string;\n}","isDirectToolOutput","ToolMessage","content: unknown"],"sources":["../../src/tools/index.ts"],"sourcesContent":["import { z } from \"zod/v3\";\nimport {\n validate,\n type Schema as ValidationSchema,\n} from \"@cfworker/json-schema\";\nimport {\n CallbackManager,\n CallbackManagerForToolRun,\n parseCallbackConfigArg,\n} from \"../callbacks/manager.js\";\nimport { BaseLangChain } from \"../language_models/base.js\";\nimport {\n mergeConfigs,\n ensureConfig,\n patchConfig,\n pickRunnableConfigKeys,\n type RunnableConfig,\n} from \"../runnables/config.js\";\nimport type { RunnableFunc } from \"../runnables/base.js\";\nimport { isDirectToolOutput, ToolCall, ToolMessage } from \"../messages/tool.js\";\nimport { AsyncLocalStorageProviderSingleton } from \"../singletons/index.js\";\nimport {\n _configHasToolCallId,\n _isToolCall,\n ToolInputParsingException,\n} from \"./utils.js\";\nimport {\n type InferInteropZodInput,\n type InferInteropZodOutput,\n type InteropZodObject,\n type InteropZodType,\n interopParseAsync,\n isSimpleStringZodSchema,\n isInteropZodSchema,\n type ZodStringV3,\n type ZodStringV4,\n type ZodObjectV3,\n type ZodObjectV4,\n} from \"../utils/types/zod.js\";\nimport { getAbortSignalError } from \"../utils/signal.js\";\nimport type {\n StructuredToolCallInput,\n ToolInputSchemaBase,\n ToolReturnType,\n ResponseFormat,\n ToolInputSchemaInputType,\n ToolInputSchemaOutputType,\n ToolParams,\n ToolRunnableConfig,\n StructuredToolInterface,\n DynamicToolInput,\n DynamicStructuredToolInput,\n StringInputToolSchema,\n ToolInterface,\n ToolOutputType,\n} from \"./types.js\";\nimport { type JSONSchema, validatesOnlyStrings } from \"../utils/json_schema.js\";\n\nexport type {\n BaseDynamicToolInput,\n ContentAndArtifact,\n DynamicToolInput,\n DynamicStructuredToolInput,\n ResponseFormat,\n StructuredToolCallInput,\n StructuredToolInterface,\n StructuredToolParams,\n ToolInterface,\n ToolParams,\n ToolReturnType,\n ToolRunnableConfig,\n ToolInputSchemaBase as ToolSchemaBase,\n} from \"./types.js\";\n\nexport {\n isLangChainTool,\n isRunnableToolLike,\n isStructuredTool,\n isStructuredToolParams,\n} from \"./types.js\";\n\nexport { ToolInputParsingException };\n/*\n Base class for Tools that accept input of any shape defined by a Zod schema.\n /\nexport abstract class StructuredTool<\n SchemaT = ToolInputSchemaBase,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n >\n extends BaseLangChain<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolOutputT \| ToolMessage\n >\n implements StructuredToolInterface<SchemaT, SchemaInputT, ToolOutputT>\n{\n abstract name: string;\n\n abstract description: string;\n\n abstract schema: SchemaT;\n\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 = false;\n\n verboseParsingErrors = false;\n\n get lc_namespace() {\n return [\"langchain\", \"tools\"];\n }\n\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 = \"content\";\n\n /\n Default config object for the tool runnable.\n /\n defaultConfig?: ToolRunnableConfig;\n\n constructor(fields?: ToolParams) {\n super(fields ?? {});\n\n this.verboseParsingErrors =\n fields?.verboseParsingErrors ?? this.verboseParsingErrors;\n this.responseFormat = fields?.responseFormat ?? this.responseFormat;\n this.defaultConfig = fields?.defaultConfig ?? this.defaultConfig;\n }\n\n protected abstract _call(\n arg: SchemaOutputT,\n runManager?: CallbackManagerForToolRun,\n parentConfig?: ToolRunnableConfig\n ): Promise<ToolOutputT>;\n\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 async invoke<\n TInput extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n input: TInput,\n config?: TConfig\n ): Promise<ToolReturnType<TInput, TConfig, ToolOutputT>> {\n let toolInput: Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >;\n\n let enrichedConfig: ToolRunnableConfig = ensureConfig(\n mergeConfigs(this.defaultConfig, config)\n );\n if (_isToolCall(input)) {\n toolInput = input.args as Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >;\n enrichedConfig = {\n ...enrichedConfig,\n toolCall: input,\n };\n } else {\n toolInput = input as Exclude<\n StructuredToolCallInput<SchemaT, SchemaInputT>,\n ToolCall\n >;\n }\n\n return this.call(toolInput, enrichedConfig) as Promise<\n ToolReturnType<TInput, TConfig, ToolOutputT>\n >;\n }\n\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 async call<\n TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n configArg?: TConfig,\n /* @deprecated /\n tags?: string[]\n ): Promise<ToolReturnType<TArg, TConfig, ToolOutputT>> {\n // Determine the actual input that needs parsing/validation.\n // If arg is a ToolCall, use its args; otherwise, use arg directly.\n const inputForValidation = _isToolCall(arg) ? arg.args : arg;\n\n let parsed: SchemaOutputT; // This will hold the successfully parsed input of the expected output type.\n if (isInteropZodSchema(this.schema)) {\n try {\n // Validate the inputForValidation - TS needs help here as it can't exclude ToolCall based on the check\n parsed = await interopParseAsync(\n this.schema as InteropZodType,\n inputForValidation as Exclude<TArg, ToolCall>\n );\n } catch (e) {\n let message = `Received tool input did not match expected schema`;\n if (this.verboseParsingErrors) {\n message = `${message}\\nDetails: ${(e as Error).message}`;\n }\n // Pass the original raw input arg to the exception\n throw new ToolInputParsingException(message, JSON.stringify(arg));\n }\n } else {\n const result = validate(\n inputForValidation,\n this.schema as ValidationSchema\n );\n if (!result.valid) {\n let message = `Received tool input did not match expected schema`;\n if (this.verboseParsingErrors) {\n message = `${message}\\nDetails: ${result.errors\n .map((e) => `${e.keywordLocation}: ${e.error}`)\n .join(\"\\n\")}`;\n }\n // Pass the original raw input arg to the exception\n throw new ToolInputParsingException(message, JSON.stringify(arg));\n }\n // Assign the validated input to parsed\n // We cast here because validate() doesn't narrow the type sufficiently for TS, but we know it's valid.\n parsed = inputForValidation as SchemaOutputT;\n }\n\n const config = parseCallbackConfigArg(configArg);\n const callbackManager_ = CallbackManager.configure(\n config.callbacks,\n this.callbacks,\n config.tags \|\| tags,\n this.tags,\n config.metadata,\n this.metadata,\n { verbose: this.verbose }\n );\n const runManager = await callbackManager_?.handleToolStart(\n this.toJSON(),\n // Log the original raw input arg\n typeof arg === \"string\" ? arg : JSON.stringify(arg),\n config.runId,\n undefined,\n undefined,\n undefined,\n config.runName\n );\n delete config.runId;\n let result;\n try {\n // Pass the correctly typed parsed input to _call\n result = await this._call(parsed, runManager, config);\n } catch (e) {\n await runManager?.handleToolError(e);\n throw e;\n }\n let content;\n let artifact;\n if (this.responseFormat === \"content_and_artifact\") {\n if (Array.isArray(result) && result.length === 2) {\n [content, artifact] = result;\n } else {\n throw new Error(\n `Tool response format is \"content_and_artifact\" but the output was not a two-tuple.\\nResult: ${JSON.stringify(\n result\n )}`\n );\n }\n } else {\n content = result;\n }\n\n let toolCallId: string \| undefined;\n // Extract toolCallId ONLY if the original arg was a ToolCall\n if (_isToolCall(arg)) {\n toolCallId = arg.id;\n }\n // Or if it was provided in the config's toolCall property\n if (!toolCallId && _configHasToolCallId(config)) {\n toolCallId = config.toolCall.id;\n }\n\n const formattedOutput = _formatToolOutput<ToolOutputT>({\n content,\n artifact,\n toolCallId,\n name: this.name,\n });\n await runManager?.handleToolEnd(formattedOutput);\n return formattedOutput as ToolReturnType<TArg, TConfig, ToolOutputT>;\n }\n}\n\n/\n Base class for Tools that accept input as a string.\n /\nexport abstract class Tool<ToolOutputT = ToolOutputType>\n extends StructuredTool<\n StringInputToolSchema,\n ToolInputSchemaOutputType<StringInputToolSchema>,\n ToolInputSchemaInputType<StringInputToolSchema>,\n ToolOutputT\n >\n implements\n ToolInterface<\n StringInputToolSchema,\n ToolInputSchemaInputType<StringInputToolSchema>,\n ToolOutputT\n >\n{\n schema = z\n .object({ input: z.string().optional() })\n .transform((obj) => obj.input);\n\n constructor(fields?: ToolParams) {\n super(fields);\n }\n\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<\n TArg extends string \| undefined \| z.input<this[\"schema\"]> \| ToolCall,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n callbacks?: TConfig\n ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>> {\n // Prepare the input for the base class call method.\n // If arg is string or undefined, wrap it; otherwise, pass ToolCall or { input: ... } directly.\n const structuredArg =\n typeof arg === \"string\" \|\| arg == null ? { input: arg } : arg;\n\n // Ensure TConfig is passed to super.call\n return super.call(structuredArg, callbacks);\n }\n}\n\n/\n A tool that can be created dynamically from a function, name, and description.\n /\nexport class DynamicTool<\n ToolOutputT = ToolOutputType\n> extends Tool<ToolOutputT> {\n static lc_name() {\n return \"DynamicTool\";\n }\n\n name: string;\n\n description: string;\n\n func: DynamicToolInput<ToolOutputT>[\"func\"];\n\n constructor(fields: DynamicToolInput<ToolOutputT>) {\n super(fields);\n this.name = fields.name;\n this.description = fields.description;\n this.func = fields.func;\n this.returnDirect = fields.returnDirect ?? this.returnDirect;\n }\n\n /\n @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n /\n async call<\n TArg extends string \| undefined \| z.input<this[\"schema\"]> \| ToolCall,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n configArg?: TConfig\n ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>> {\n const config = parseCallbackConfigArg(configArg);\n if (config.runName === undefined) {\n config.runName = this.name;\n }\n // Call the Tool class's call method, passing generics through\n // Cast config to TConfig to satisfy the super.call signature\n return super.call<TArg, TConfig>(arg, config as TConfig);\n }\n\n /* @ignore /\n async _call(\n input: string, // DynamicTool's _call specifically expects a string after schema transformation\n runManager?: CallbackManagerForToolRun,\n parentConfig?: ToolRunnableConfig\n ): Promise<ToolOutputT> {\n return this.func(input, runManager, parentConfig);\n }\n}\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 class DynamicStructuredTool<\n SchemaT = ToolInputSchemaBase,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n> extends StructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT> {\n static lc_name() {\n return \"DynamicStructuredTool\";\n }\n\n name: string;\n\n description: string;\n\n func: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>[\"func\"];\n\n schema: SchemaT;\n\n constructor(\n fields: DynamicStructuredToolInput<SchemaT, SchemaOutputT, ToolOutputT>\n ) {\n super(fields);\n this.name = fields.name;\n this.description = fields.description;\n this.func = fields.func;\n this.returnDirect = fields.returnDirect ?? this.returnDirect;\n this.schema = fields.schema;\n }\n\n /\n @deprecated Use .invoke() instead. Will be removed in 0.3.0.\n /\n // Match the base class signature\n async call<\n TArg extends StructuredToolCallInput<SchemaT, SchemaInputT>,\n TConfig extends ToolRunnableConfig \| undefined\n >(\n arg: TArg,\n configArg?: TConfig,\n /* @deprecated /\n tags?: string[]\n ): Promise<ToolReturnType<NonNullable<TArg>, TConfig, ToolOutputT>> {\n const config = parseCallbackConfigArg(configArg);\n if (config.runName === undefined) {\n config.runName = this.name;\n }\n\n // Call the base class method, passing generics through\n // Cast config to TConfig to satisfy the super.call signature\n return super.call<TArg, TConfig>(arg, config as TConfig, tags);\n }\n\n protected _call(\n arg: Parameters<\n DynamicStructuredToolInput<SchemaT, SchemaOutputT>[\"func\"]\n >[0],\n runManager?: CallbackManagerForToolRun,\n parentConfig?: RunnableConfig\n ): Promise<ToolOutputT> {\n return this.func(arg, runManager, parentConfig);\n }\n}\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 abstract class BaseToolkit {\n abstract tools: StructuredToolInterface[];\n\n getTools(): StructuredToolInterface[] {\n return this.tools;\n }\n}\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>\n 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/\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 function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>(\n func: RunnableFunc<\n InferInteropZodOutput<SchemaT>,\n ToolOutputT,\n ToolRunnableConfig\n >,\n fields: ToolWrapperParams<SchemaT>\n): DynamicTool<ToolOutputT>;\n\nexport function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(\n func: RunnableFunc<\n InferInteropZodOutput<SchemaT>,\n ToolOutputT,\n ToolRunnableConfig\n >,\n fields: ToolWrapperParams<SchemaT>\n): DynamicTool<ToolOutputT>;\n\nexport function tool<\n SchemaT extends ZodObjectV3,\n SchemaOutputT = InferInteropZodOutput<SchemaT>,\n SchemaInputT = InferInteropZodInput<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>,\n fields: ToolWrapperParams<SchemaT>\n): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\n\nexport function tool<\n SchemaT extends ZodObjectV4,\n SchemaOutputT = InferInteropZodOutput<SchemaT>,\n SchemaInputT = InferInteropZodInput<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>,\n fields: ToolWrapperParams<SchemaT>\n): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\n\nexport function tool<\n SchemaT extends JSONSchema,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<\n Parameters<DynamicStructuredToolInput<SchemaT>[\"func\"]>[0],\n ToolOutputT,\n ToolRunnableConfig\n >,\n fields: ToolWrapperParams<SchemaT>\n): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;\n\nexport function tool<\n SchemaT extends\n \| InteropZodObject\n \| InteropZodType<string>\n \| JSONSchema = InteropZodObject,\n SchemaOutputT = ToolInputSchemaOutputType<SchemaT>,\n SchemaInputT = ToolInputSchemaInputType<SchemaT>,\n ToolOutputT = ToolOutputType\n>(\n func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>,\n fields: ToolWrapperParams<SchemaT>\n):\n \| DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>\n \| DynamicTool<ToolOutputT> {\n const isSimpleStringSchema = isSimpleStringZodSchema(fields.schema);\n const isStringJSONSchema = validatesOnlyStrings(fields.schema);\n\n // If the schema is not provided, or it's a simple string schema, create a DynamicTool\n if (!fields.schema \|\| isSimpleStringSchema \|\| isStringJSONSchema) {\n return new DynamicTool<ToolOutputT>({\n ...fields,\n description:\n fields.description ??\n (fields.schema as { description?: string } \| undefined)?.description ??\n `${fields.name} tool`,\n func: async (input, runManager, config) => {\n return new Promise<ToolOutputT>((resolve, reject) => {\n const childConfig = patchConfig(config, {\n callbacks: runManager?.getChild(),\n });\n // eslint-disable-next-line no-void\n void AsyncLocalStorageProviderSingleton.runWithConfig(\n pickRunnableConfigKeys(childConfig),\n async () => {\n try {\n // TS doesn't restrict the type here based on the guard above\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n resolve(func(input as any, childConfig));\n } catch (e) {\n reject(e);\n }\n }\n );\n });\n },\n });\n }\n\n const schema = fields.schema as InteropZodObject \| JSONSchema;\n\n const description =\n fields.description ??\n (fields.schema as { description?: string }).description ??\n `${fields.name} tool`;\n\n return new DynamicStructuredTool<\n typeof schema,\n SchemaOutputT,\n SchemaInputT,\n ToolOutputT\n >({\n ...fields,\n description,\n schema,\n func: async (input, runManager, config) => {\n return new Promise<ToolOutputT>((resolve, reject) => {\n if (config?.signal) {\n config.signal.addEventListener(\"abort\", () => {\n return reject(getAbortSignalError(config.signal));\n });\n }\n\n const childConfig = patchConfig(config, {\n callbacks: runManager?.getChild(),\n });\n // eslint-disable-next-line no-void\n void AsyncLocalStorageProviderSingleton.runWithConfig(\n pickRunnableConfigKeys(childConfig),\n async () => {\n try {\n const result = await func(input, childConfig);\n\n /\n If the signal is aborted, we don't want to resolve the promise\n * as the promise is already rejected.\n */\n if (config?.signal?.aborted) {\n return;\n }\n\n resolve(result);\n } catch (e) {\n reject(e);\n }\n }\n );\n });\n },\n }) as DynamicStructuredTool<\n SchemaT,\n SchemaOutputT,\n SchemaInputT,\n ToolOutputT\n >;\n}\n\nfunction _formatToolOutput<TOutput extends ToolOutputType>(params: {\n content: TOutput;\n name: string;\n artifact?: unknown;\n toolCallId?: string;\n}): ToolMessage \| TOutput {\n const { content, artifact, toolCallId } = params;\n if (toolCallId && !isDirectToolOutput(content)) {\n if (\n typeof content === \"string\" \|\|\n (Array.isArray(content) &&\n content.every((item) => typeof item === \"object\"))\n ) {\n return new ToolMessage({\n content,\n artifact,\n tool_call_id: toolCallId,\n name: params.name,\n });\n } else {\n return new ToolMessage({\n content: _stringify(content),\n artifact,\n tool_call_id: toolCallId,\n name: params.name,\n });\n }\n } else {\n return content;\n }\n}\n\nfunction _stringify(content: unknown): string {\n try {\n return JSON.stringify(content, null, 2) ?? \"\";\n } catch (_noOp) {\n return `${content}`;\n }\n}\n"],"mappings":"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"}

package/dist/tools/index.d.cts CHANGED Viewed

@@ -3,7 +3,7 @@ import { InferInteropZodInput, InferInteropZodOutput, ZodObjectV3, ZodObjectV4,
 import { CallbackManagerForToolRun } from "../callbacks/manager.cjs";
 import { RunnableConfig } from "../runnables/types.cjs";
 import { RunnableFunc } from "../runnables/base.cjs";
-import { JSONSchema } from "../utils/json_schema.cjs";
+import { JsonSchema7Type } from "../utils/zod-to-json-schema/parseTypes.cjs";
 import { BaseLangChain } from "../language_models/base.cjs";
 import { ToolInputParsingException } from "./utils.cjs";
 import { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams } from "./types.cjs";
@@ -203,7 +203,7 @@ declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>
 declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
 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>;
 declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
-declare function tool<SchemaT extends 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>;
+declare function tool<SchemaT extends JsonSchema7Type, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 //#endregion
 export { type BaseDynamicToolInput, BaseToolkit, type ContentAndArtifact, DynamicStructuredTool, type DynamicStructuredToolInput, DynamicTool, type DynamicToolInput, type ResponseFormat, StructuredTool, type StructuredToolCallInput, type StructuredToolInterface, type StructuredToolParams, Tool, ToolInputParsingException, type ToolInterface, type ToolParams, type ToolReturnType, type ToolRunnableConfig, type ToolInputSchemaBase as ToolSchemaBase, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, tool };
 //# sourceMappingURL=index.d.cts.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.cts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","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"],"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 { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, 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 } 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, } 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>;\n"],"mappings":"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"}
1	+ {"version":3,"file":"index.d.cts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","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"],"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 { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, 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 } 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, } 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>;\n"],"mappings":"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"}

package/dist/tools/index.d.ts CHANGED Viewed

@@ -3,7 +3,7 @@ import { InferInteropZodInput, InferInteropZodOutput, ZodObjectV3, ZodObjectV4,
 import { CallbackManagerForToolRun } from "../callbacks/manager.js";
 import { RunnableConfig } from "../runnables/types.js";
 import { RunnableFunc } from "../runnables/base.js";
-import { JSONSchema } from "../utils/json_schema.js";
+import { JsonSchema7Type } from "../utils/zod-to-json-schema/parseTypes.js";
 import { BaseLangChain } from "../language_models/base.js";
 import { ToolInputParsingException } from "./utils.js";
 import { BaseDynamicToolInput, ContentAndArtifact, DynamicStructuredToolInput, DynamicToolInput, ResponseFormat, StringInputToolSchema, StructuredToolCallInput, StructuredToolInterface, StructuredToolParams, ToolInputSchemaBase, ToolInputSchemaInputType, ToolInputSchemaOutputType, ToolInterface, ToolOutputType, ToolParams, ToolReturnType, ToolRunnableConfig, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams } from "./types.js";
@@ -203,7 +203,7 @@ declare function tool<SchemaT extends ZodStringV3, ToolOutputT = ToolOutputType>
 declare function tool<SchemaT extends ZodStringV4, ToolOutputT = ToolOutputType>(func: RunnableFunc<InferInteropZodOutput<SchemaT>, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicTool<ToolOutputT>;
 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>;
 declare function tool<SchemaT extends ZodObjectV4, SchemaOutputT = InferInteropZodOutput<SchemaT>, SchemaInputT = InferInteropZodInput<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<SchemaOutputT, ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
-declare function tool<SchemaT extends 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>;
+declare function tool<SchemaT extends JsonSchema7Type, SchemaOutputT = ToolInputSchemaOutputType<SchemaT>, SchemaInputT = ToolInputSchemaInputType<SchemaT>, ToolOutputT = ToolOutputType>(func: RunnableFunc<Parameters<DynamicStructuredToolInput<SchemaT>["func"]>[0], ToolOutputT, ToolRunnableConfig>, fields: ToolWrapperParams<SchemaT>): DynamicStructuredTool<SchemaT, SchemaOutputT, SchemaInputT, ToolOutputT>;
 //#endregion
 export { type BaseDynamicToolInput, BaseToolkit, type ContentAndArtifact, DynamicStructuredTool, type DynamicStructuredToolInput, DynamicTool, type DynamicToolInput, type ResponseFormat, StructuredTool, type StructuredToolCallInput, type StructuredToolInterface, type StructuredToolParams, Tool, ToolInputParsingException, type ToolInterface, type ToolParams, type ToolReturnType, type ToolRunnableConfig, type ToolInputSchemaBase as ToolSchemaBase, isLangChainTool, isRunnableToolLike, isStructuredTool, isStructuredToolParams, tool };
 //# sourceMappingURL=index.d.ts.map

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

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","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"],"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 { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, 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 } 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, } 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>;\n"],"mappings":"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"}
1	+ {"version":3,"file":"index.d.ts","names":["z","CallbackManagerForToolRun","BaseLangChain","RunnableConfig","RunnableFunc","ToolCall","ToolMessage","ToolInputParsingException","InferInteropZodInput","InferInteropZodOutput","ZodStringV3","ZodStringV4","ZodObjectV3","ZodObjectV4","StructuredToolCallInput","ToolInputSchemaBase","ToolReturnType","ResponseFormat","ToolInputSchemaInputType","ToolInputSchemaOutputType","ToolParams","ToolRunnableConfig","StructuredToolInterface","DynamicToolInput","DynamicStructuredToolInput","StringInputToolSchema","ToolInterface","ToolOutputType","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"],"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 { ToolInputParsingException } from \"./utils.js\";\nimport { type InferInteropZodInput, type InferInteropZodOutput, 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 } 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, } 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>;\n"],"mappings":"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"}