@langchain/core 0.3.21 → 0.3.23

package/dist/singletons/async_local_storage/context.js

@@ -0,0 +1,182 @@
+import { isRunTree, RunTree } from "langsmith/run_trees";
+import { _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance, } from "./globals.js";
+/**
+ * Set a context variable. Context variables are scoped to any
+ * child runnables called by the current runnable, or globally if set outside
+ * of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ * @param value The value to set.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function setContextVariable(name, value) {
+    // Avoid using global singleton due to circuluar dependency issues
+    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
+    if (asyncLocalStorageInstance === undefined) {
+        throw new Error(`Internal error: Global shared async local storage instance has not been initialized.`);
+    }
+    const runTree = asyncLocalStorageInstance.getStore();
+    const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };
+    contextVars[name] = value;
+    let newValue = {};
+    if (isRunTree(runTree)) {
+        newValue = new RunTree(runTree);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    newValue[_CONTEXT_VARIABLES_KEY] = contextVars;
+    asyncLocalStorageInstance.enterWith(newValue);
+}
+/**
+ * Get the value of a previously set context variable. Context variables
+ * are scoped to any child runnables called by the current runnable,
+ * or globally if set outside of any runnable.
+ *
+ * @remarks
+ * This function is only supported in environments that support AsyncLocalStorage,
+ * including Node.js, Deno, and Cloudflare Workers.
+ *
+ * @example
+ * ```ts
+ * import { RunnableLambda } from "@langchain/core/runnables";
+ * import {
+ *   getContextVariable,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const nested = RunnableLambda.from(() => {
+ *   // "bar" because it was set by a parent
+ *   console.log(getContextVariable("foo"));
+ *
+ *   // Override to "baz", but only for child runnables
+ *   setContextVariable("foo", "baz");
+ *
+ *   // Now "baz", but only for child runnables
+ *   return getContextVariable("foo");
+ * });
+ *
+ * const runnable = RunnableLambda.from(async () => {
+ *   // Set a context variable named "foo"
+ *   setContextVariable("foo", "bar");
+ *
+ *   const res = await nested.invoke({});
+ *
+ *   // Still "bar" since child changes do not affect parents
+ *   console.log(getContextVariable("foo"));
+ *
+ *   return res;
+ * });
+ *
+ * // undefined, because context variable has not been set yet
+ * console.log(getContextVariable("foo"));
+ *
+ * // Final return value is "baz"
+ * const result = await runnable.invoke({});
+ * ```
+ *
+ * @param name The name of the context variable.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getContextVariable(name) {
+    // Avoid using global singleton due to circuluar dependency issues
+    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
+    if (asyncLocalStorageInstance === undefined) {
+        return undefined;
+    }
+    const runTree = asyncLocalStorageInstance.getStore();
+    return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
+}
+const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
+export const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
+/**
+ * Register a callback configure hook to automatically add callback handlers to all runs.
+ *
+ * There are two ways to use this:
+ *
+ * 1. Using a context variable:
+ *    - Set `contextVar` to specify the variable name
+ *    - Use `setContextVariable()` to store your handler instance
+ *
+ * 2. Using an environment variable:
+ *    - Set both `envVar` and `handlerClass`
+ *    - The handler will be instantiated when the env var is set to "true".
+ *
+ * @example
+ * ```typescript
+ * // Method 1: Using context variable
+ * import {
+ *   registerConfigureHook,
+ *   setContextVariable
+ * } from "@langchain/core/context";
+ *
+ * const tracer = new MyCallbackHandler();
+ * registerConfigureHook({
+ *   contextVar: "my_tracer",
+ * });
+ * setContextVariable("my_tracer", tracer);
+ *
+ * // ...run code here
+ *
+ * // Method 2: Using environment variable
+ * registerConfigureHook({
+ *   handlerClass: MyCallbackHandler,
+ *   envVar: "MY_TRACER_ENABLED",
+ * });
+ * process.env.MY_TRACER_ENABLED = "true";
+ *
+ * // ...run code here
+ * ```
+ *
+ * @param config Configuration object for the hook
+ * @param config.contextVar Name of the context variable containing the handler instance
+ * @param config.inheritable Whether child runs should inherit this handler
+ * @param config.handlerClass Optional callback handler class (required if using envVar)
+ * @param config.envVar Optional environment variable name to control handler activation
+ */
+export const registerConfigureHook = (config) => {
+    if (config.envVar && !config.handlerClass) {
+        throw new Error("If envVar is set, handlerClass must also be set to a non-None value.");
+    }
+    setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);
+};

package/dist/singletons/async_local_storage/globals.cjs

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobalAsyncLocalStorageInstance = exports.setGlobalAsyncLocalStorageInstance = exports.TRACING_ALS_KEY = void 0;
+exports.getGlobalAsyncLocalStorageInstance = exports.setGlobalAsyncLocalStorageInstance = exports._CONTEXT_VARIABLES_KEY = exports.TRACING_ALS_KEY = void 0;
 exports.TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+exports._CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
 const setGlobalAsyncLocalStorageInstance = (instance) => {
     globalThis[exports.TRACING_ALS_KEY] = instance;
 };

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

@@ -4,5 +4,6 @@ export interface AsyncLocalStorageInterface {
     enterWith: (store: any) => void;
 }
 export declare const TRACING_ALS_KEY: unique symbol;
+export declare const _CONTEXT_VARIABLES_KEY: unique symbol;
 export declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;
-export declare const getGlobalAsyncLocalStorageInstance: () => any;
+export declare const getGlobalAsyncLocalStorageInstance: () => AsyncLocalStorageInterface | undefined;

package/dist/singletons/async_local_storage/globals.js

@@ -1,4 +1,5 @@
 export const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+export const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
 export const setGlobalAsyncLocalStorageInstance = (instance) => {
     globalThis[TRACING_ALS_KEY] = instance;
 };

package/dist/singletons/async_local_storage/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageProviderSingleton = exports._CONTEXT_VARIABLES_KEY = exports.MockAsyncLocalStorage = void 0;
+exports.AsyncLocalStorageProviderSingleton = exports.MockAsyncLocalStorage = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const langsmith_1 = require("langsmith");
 const globals_js_1 = require("./globals.cjs");
@@ -19,7 +19,6 @@ class MockAsyncLocalStorage {
 exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 const LC_CHILD_KEY = Symbol.for("lc:child_config");
-exports._CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
 class AsyncLocalStorageProvider {
     getInstance() {
         return (0, globals_js_1.getGlobalAsyncLocalStorageInstance)() ?? mockAsyncLocalStorage;
@@ -51,9 +50,9 @@ class AsyncLocalStorageProvider {
             runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
         }
         if (previousValue !== undefined &&
-            previousValue[exports._CONTEXT_VARIABLES_KEY] !== undefined) {
-            runTree[exports._CONTEXT_VARIABLES_KEY] =
-                previousValue[exports._CONTEXT_VARIABLES_KEY];
+            previousValue[globals_js_1._CONTEXT_VARIABLES_KEY] !== undefined) {
+            runTree[globals_js_1._CONTEXT_VARIABLES_KEY] =
+                previousValue[globals_js_1._CONTEXT_VARIABLES_KEY];
         }
         return storage.run(runTree, callback);
     }

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

@@ -4,7 +4,6 @@ export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface
     run<T>(_store: any, callback: () => T): T;
     enterWith(_store: any): undefined;
 }
-export declare const _CONTEXT_VARIABLES_KEY: unique symbol;
 declare class AsyncLocalStorageProvider {
     getInstance(): AsyncLocalStorageInterface;
     getRunnableConfig(): any;

package/dist/singletons/async_local_storage/index.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { RunTree } from "langsmith";
-import { getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance, } from "./globals.js";
+import { getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance, _CONTEXT_VARIABLES_KEY, } from "./globals.js";
 import { CallbackManager } from "../../callbacks/manager.js";
 export class MockAsyncLocalStorage {
     getStore() {
@@ -15,7 +15,6 @@ export class MockAsyncLocalStorage {
 }
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 const LC_CHILD_KEY = Symbol.for("lc:child_config");
-export const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
 class AsyncLocalStorageProvider {
     getInstance() {
         return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;

package/dist/singletons/callbacks.cjs

@@ -36,8 +36,9 @@ async function consumeCallback(promiseFn, wait) {
     if (wait === true) {
         // Clear config since callbacks are not part of the root run
         // Avoid using global singleton due to circuluar dependency issues
-        if ((0, globals_js_1.getGlobalAsyncLocalStorageInstance)() !== undefined) {
-            await (0, globals_js_1.getGlobalAsyncLocalStorageInstance)().run(undefined, async () => promiseFn());
+        const asyncLocalStorageInstance = (0, globals_js_1.getGlobalAsyncLocalStorageInstance)();
+        if (asyncLocalStorageInstance !== undefined) {
+            await asyncLocalStorageInstance.run(undefined, async () => promiseFn());
         }
         else {
             await promiseFn();
@@ -46,8 +47,9 @@ async function consumeCallback(promiseFn, wait) {
     else {
         queue = getQueue();
         void queue.add(async () => {
-            if ((0, globals_js_1.getGlobalAsyncLocalStorageInstance)() !== undefined) {
-                await (0, globals_js_1.getGlobalAsyncLocalStorageInstance)().run(undefined, async () => promiseFn());
+            const asyncLocalStorageInstance = (0, globals_js_1.getGlobalAsyncLocalStorageInstance)();
+            if (asyncLocalStorageInstance !== undefined) {
+                await asyncLocalStorageInstance.run(undefined, async () => promiseFn());
             }
             else {
                 await promiseFn();

package/dist/singletons/callbacks.js

@@ -29,8 +29,9 @@ export async function consumeCallback(promiseFn, wait) {
     if (wait === true) {
         // Clear config since callbacks are not part of the root run
         // Avoid using global singleton due to circuluar dependency issues
-        if (getGlobalAsyncLocalStorageInstance() !== undefined) {
-            await getGlobalAsyncLocalStorageInstance().run(undefined, async () => promiseFn());
+        const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
+        if (asyncLocalStorageInstance !== undefined) {
+            await asyncLocalStorageInstance.run(undefined, async () => promiseFn());
         }
         else {
             await promiseFn();
@@ -39,8 +40,9 @@ export async function consumeCallback(promiseFn, wait) {
     else {
         queue = getQueue();
         void queue.add(async () => {
-            if (getGlobalAsyncLocalStorageInstance() !== undefined) {
-                await getGlobalAsyncLocalStorageInstance().run(undefined, async () => promiseFn());
+            const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
+            if (asyncLocalStorageInstance !== undefined) {
+                await asyncLocalStorageInstance.run(undefined, async () => promiseFn());
             }
             else {
                 await promiseFn();

package/dist/singletons/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockAsyncLocalStorage = exports._CONTEXT_VARIABLES_KEY = exports.AsyncLocalStorageProviderSingleton = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
+exports._CONTEXT_VARIABLES_KEY = exports.MockAsyncLocalStorage = exports.AsyncLocalStorageProviderSingleton = void 0;
 const index_js_1 = require("./async_local_storage/index.cjs");
 Object.defineProperty(exports, "AsyncLocalStorageProviderSingleton", { enumerable: true, get: function () { return index_js_1.AsyncLocalStorageProviderSingleton; } });
-Object.defineProperty(exports, "_CONTEXT_VARIABLES_KEY", { enumerable: true, get: function () { return index_js_1._CONTEXT_VARIABLES_KEY; } });
 Object.defineProperty(exports, "MockAsyncLocalStorage", { enumerable: true, get: function () { return index_js_1.MockAsyncLocalStorage; } });
+const globals_js_1 = require("./async_local_storage/globals.cjs");
+Object.defineProperty(exports, "_CONTEXT_VARIABLES_KEY", { enumerable: true, get: function () { return globals_js_1._CONTEXT_VARIABLES_KEY; } });

package/dist/singletons/index.d.ts

@@ -1,2 +1,4 @@
-import { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage } from "./async_local_storage/index.js";
-export { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage, };
+import { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage } from "./async_local_storage/index.js";
+import { _CONTEXT_VARIABLES_KEY } from "./async_local_storage/globals.js";
+export { type AsyncLocalStorageInterface, AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage, };
+export { _CONTEXT_VARIABLES_KEY };

package/dist/singletons/index.js

@@ -1,3 +1,4 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage, } from "./async_local_storage/index.js";
-export { AsyncLocalStorageProviderSingleton, _CONTEXT_VARIABLES_KEY, MockAsyncLocalStorage, };
+import { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage, } from "./async_local_storage/index.js";
+import { _CONTEXT_VARIABLES_KEY } from "./async_local_storage/globals.js";
+export { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage, };
+export { _CONTEXT_VARIABLES_KEY };

package/dist/tools/index.cjs

@@ -60,21 +60,23 @@ class StructuredTool extends base_js_1.BaseLangChain {
     async invoke(input, config) {
         let tool_call_id;
         let toolInput;
+        let enrichedConfig = (0, config_js_1.ensureConfig)(config);
         if ((0, utils_js_1._isToolCall)(input)) {
             tool_call_id = input.id;
             toolInput = input.args;
+            enrichedConfig = {
+                ...enrichedConfig,
+                toolCall: input,
+                configurable: {
+                    ...enrichedConfig.configurable,
+                    tool_call_id,
+                },
+            };
         }
         else {
             toolInput = input;
         }
-        const ensuredConfig = (0, config_js_1.ensureConfig)(config);
-        return this.call(toolInput, {
-            ...ensuredConfig,
-            configurable: {
-                ...ensuredConfig.configurable,
-                tool_call_id,
-            },
-        });
+        return this.call(toolInput, enrichedConfig);
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -103,7 +105,7 @@ class StructuredTool extends base_js_1.BaseLangChain {
             throw new utils_js_1.ToolInputParsingException(message, JSON.stringify(arg));
         }
         const config = (0, manager_js_1.parseCallbackConfigArg)(configArg);
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = manager_js_1.CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
         const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
         delete config.runId;
         let result;
@@ -310,7 +312,7 @@ function tool(func, fields) {
                     const childConfig = (0, config_js_1.patchConfig)(config, {
                         callbacks: runManager?.getChild(),
                     });
-                    void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+                    void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(childConfig), async () => {
                         try {
                             // TS doesn't restrict the type here based on the guard above
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -336,7 +338,7 @@ function tool(func, fields) {
                 const childConfig = (0, config_js_1.patchConfig)(config, {
                     callbacks: runManager?.getChild(),
                 });
-                void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+                void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(childConfig), async () => {
                     try {
                         // TS doesn't restrict the type here based on the guard above
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -353,7 +355,7 @@ function tool(func, fields) {
 exports.tool = tool;
 function _formatToolOutput(params) {
     const { content, artifact, toolCallId } = params;
-    if (toolCallId) {
+    if (toolCallId && !(0, tool_js_1.isDirectToolOutput)(content)) {
         if (typeof content === "string" ||
             (Array.isArray(content) &&
                 content.every((item) => typeof item === "object"))) {

package/dist/tools/index.d.ts

@@ -32,6 +32,9 @@ export interface ToolParams extends BaseLangChainParams {
      */
     verboseParsingErrors?: boolean;
 }
+export type ToolRunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>> = RunnableConfig<ConfigurableFieldType> & {
+    toolCall?: ToolCall;
+};
 /**
  * Schema for defining tools.
  *
@@ -94,7 +97,7 @@ export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectA
      */
     responseFormat?: ResponseFormat;
     constructor(fields?: ToolParams);
-    protected abstract _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
+    protected abstract _call(arg: z.output<T>, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
     /**
      * Invokes the tool with the provided input and configuration.
      * @param input The input for the tool.
@@ -113,7 +116,7 @@ export declare abstract class StructuredTool<T extends ZodObjectAny = ZodObjectA
      * @param tags Optional tags for the tool.
      * @returns A Promise that resolves with a string.
      */
-    call(arg: (z.output<T> extends string ? string : never) | z.input<T> | ToolCall, configArg?: Callbacks | RunnableConfig, 
+    call(arg: (z.output<T> extends string ? string : never) | z.input<T>, configArg?: Callbacks | ToolRunnableConfig, 
     /** @deprecated */
     tags?: string[]): Promise<ToolReturnType>;
 }
@@ -163,7 +166,7 @@ export interface BaseDynamicToolInput extends ToolParams {
  * Interface for the input parameters of the DynamicTool class.
  */
 export interface DynamicToolInput extends BaseDynamicToolInput {
-    func: (input: string, runManager?: CallbackManagerForToolRun, config?: RunnableConfig) => Promise<ToolReturnType>;
+    func: (input: string, runManager?: CallbackManagerForToolRun, config?: ToolRunnableConfig) => Promise<ToolReturnType>;
 }
 /**
  * Interface for the input parameters of the DynamicStructuredTool class.
@@ -184,9 +187,9 @@ export declare class DynamicTool extends Tool {
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
      */
-    call(arg: string | undefined | z.input<this["schema"]> | ToolCall, configArg?: RunnableConfig | Callbacks): Promise<ToolReturnType>;
+    call(arg: string | undefined | z.input<this["schema"]> | ToolCall, configArg?: ToolRunnableConfig | Callbacks): Promise<ToolReturnType>;
     /** @ignore */
-    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: RunnableConfig): Promise<ToolReturnType>;
+    _call(input: string, runManager?: CallbackManagerForToolRun, parentConfig?: ToolRunnableConfig): Promise<ToolReturnType>;
 }
 /**
  * A tool that can be created dynamically from a function, name, and
@@ -272,6 +275,6 @@ interface ToolWrapperParams<RunInput extends ZodObjectAny | z.ZodString | Record
  *
  * @returns {DynamicStructuredTool<T>} A new StructuredTool instance.
  */
-export declare function tool<T extends z.ZodString>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicTool;
-export declare function tool<T extends ZodObjectAny>(func: RunnableFunc<z.output<T>, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
-export declare function tool<T extends Record<string, any>>(func: RunnableFunc<T, ToolReturnType>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
+export declare function tool<T extends z.ZodString>(func: RunnableFunc<z.output<T>, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<T>): DynamicTool;
+export declare function tool<T extends ZodObjectAny>(func: RunnableFunc<z.output<T>, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;
+export declare function tool<T extends Record<string, any>>(func: RunnableFunc<T, ToolReturnType, ToolRunnableConfig>, fields: ToolWrapperParams<T>): DynamicStructuredTool<T>;

package/dist/tools/index.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallbackManager, parseCallbackConfigArg, } from "../callbacks/manager.js";
 import { BaseLangChain, } from "../language_models/base.js";
-import { ensureConfig, patchConfig, } from "../runnables/config.js";
-import { ToolMessage } from "../messages/tool.js";
+import { ensureConfig, patchConfig, pickRunnableConfigKeys, } from "../runnables/config.js";
+import { isDirectToolOutput, ToolMessage } from "../messages/tool.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { _isToolCall, ToolInputParsingException } from "./utils.js";
 import { isZodSchema } from "../utils/types/is_zod_schema.js";
@@ -57,21 +57,23 @@ export class StructuredTool extends BaseLangChain {
     async invoke(input, config) {
         let tool_call_id;
         let toolInput;
+        let enrichedConfig = ensureConfig(config);
         if (_isToolCall(input)) {
             tool_call_id = input.id;
             toolInput = input.args;
+            enrichedConfig = {
+                ...enrichedConfig,
+                toolCall: input,
+                configurable: {
+                    ...enrichedConfig.configurable,
+                    tool_call_id,
+                },
+            };
         }
         else {
             toolInput = input;
         }
-        const ensuredConfig = ensureConfig(config);
-        return this.call(toolInput, {
-            ...ensuredConfig,
-            configurable: {
-                ...ensuredConfig.configurable,
-                tool_call_id,
-            },
-        });
+        return this.call(toolInput, enrichedConfig);
     }
     /**
      * @deprecated Use .invoke() instead. Will be removed in 0.3.0.
@@ -100,7 +102,7 @@ export class StructuredTool extends BaseLangChain {
             throw new ToolInputParsingException(message, JSON.stringify(arg));
         }
         const config = parseCallbackConfigArg(configArg);
-        const callbackManager_ = await CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = CallbackManager.configure(config.callbacks, this.callbacks, config.tags || tags, this.tags, config.metadata, this.metadata, { verbose: this.verbose });
         const runManager = await callbackManager_?.handleToolStart(this.toJSON(), typeof parsed === "string" ? parsed : JSON.stringify(parsed), config.runId, undefined, undefined, undefined, config.runName);
         delete config.runId;
         let result;
@@ -302,7 +304,7 @@ export function tool(func, fields) {
                     const childConfig = patchConfig(config, {
                         callbacks: runManager?.getChild(),
                     });
-                    void AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+                    void AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
                         try {
                             // TS doesn't restrict the type here based on the guard above
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -328,7 +330,7 @@ export function tool(func, fields) {
                 const childConfig = patchConfig(config, {
                     callbacks: runManager?.getChild(),
                 });
-                void AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
+                void AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(childConfig), async () => {
                     try {
                         // TS doesn't restrict the type here based on the guard above
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -344,7 +346,7 @@ export function tool(func, fields) {
 }
 function _formatToolOutput(params) {
     const { content, artifact, toolCallId } = params;
-    if (toolCallId) {
+    if (toolCallId && !isDirectToolOutput(content)) {
         if (typeof content === "string" ||
             (Array.isArray(content) &&
                 content.every((item) => typeof item === "object"))) {

package/dist/types/stream.d.ts

@@ -0,0 +1 @@
+export type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;

package/dist/utils/json_schema.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Validator = exports.deepCompareStrict = void 0;
-var index_js_1 = require("./@cfworker/json-schema/index.cjs");
-Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return index_js_1.deepCompareStrict; } });
-Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return index_js_1.Validator; } });
+var json_schema_1 = require("@cfworker/json-schema");
+Object.defineProperty(exports, "deepCompareStrict", { enumerable: true, get: function () { return json_schema_1.deepCompareStrict; } });
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return json_schema_1.Validator; } });

package/dist/utils/json_schema.d.ts

@@ -1 +1 @@
-export { deepCompareStrict, Validator } from "./@cfworker/json-schema/index.js";
+export { deepCompareStrict, Validator } from "@cfworker/json-schema";

package/dist/utils/json_schema.js

@@ -1 +1 @@
-export { deepCompareStrict, Validator } from "./@cfworker/json-schema/index.js";
+export { deepCompareStrict, Validator } from "@cfworker/json-schema";

package/dist/utils/stream.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pipeGeneratorWithSetup = exports.AsyncGeneratorWithSetup = exports.concat = exports.atee = exports.IterableReadableStream = void 0;
+const config_js_1 = require("../runnables/config.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 const signal_js_1 = require("./signal.cjs");
 /*
@@ -220,7 +221,7 @@ class AsyncGeneratorWithSetup {
         // needs to happen in logical order, ie. in the order in which input to
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
-            void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(params.config, async () => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(params.config), async () => {
                 this.firstResult = params.generator.next();
                 if (params.startSetup) {
                     this.firstResult.then(params.startSetup).then(resolve, reject);
@@ -237,7 +238,7 @@ class AsyncGeneratorWithSetup {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(this.config, this.signal
+        return index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(this.config), this.signal
             ? async () => {
                 return (0, signal_js_1.raceWithSignal)(this.generator.next(...args), this.signal);
             }

package/dist/utils/stream.d.ts

@@ -1,4 +1,5 @@
-export type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;
+import type { IterableReadableStreamInterface } from "../types/stream.js";
+export type { IterableReadableStreamInterface };
 export declare class IterableReadableStream<T> extends ReadableStream<T> implements IterableReadableStreamInterface<T> {
     reader: ReadableStreamDefaultReader<T>;
     ensureReader(): void;

package/dist/utils/stream.js

@@ -1,3 +1,4 @@
+import { pickRunnableConfigKeys } from "../runnables/config.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 import { raceWithSignal } from "./signal.js";
 /*
@@ -214,7 +215,7 @@ export class AsyncGeneratorWithSetup {
         // needs to happen in logical order, ie. in the order in which input to
         // to each generator is available.
         this.setup = new Promise((resolve, reject) => {
-            void AsyncLocalStorageProviderSingleton.runWithConfig(params.config, async () => {
+            void AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(params.config), async () => {
                 this.firstResult = params.generator.next();
                 if (params.startSetup) {
                     this.firstResult.then(params.startSetup).then(resolve, reject);
@@ -231,7 +232,7 @@ export class AsyncGeneratorWithSetup {
             this.firstResultUsed = true;
             return this.firstResult;
         }
-        return AsyncLocalStorageProviderSingleton.runWithConfig(this.config, this.signal
+        return AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(this.config), this.signal
             ? async () => {
                 return raceWithSignal(this.generator.next(...args), this.signal);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -33,6 +33,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
+    "@cfworker/json-schema": "^4.0.2",
     "ansi-styles": "^5.0.0",
     "camelcase": "6",
     "decamelize": "1.2.0",