@langchain/core 0.2.17 → 0.2.18-rc.0

package/dist/callbacks/manager.cjs

@@ -9,8 +9,9 @@ const env_js_1 = require("../utils/env.cjs");
 const tracer_langchain_js_1 = require("../tracers/tracer_langchain.cjs");
 const promises_js_1 = require("./promises.cjs");
 const callbacks_js_1 = require("../utils/callbacks.cjs");
+const base_js_2 = require("../tracers/base.cjs");
 if (
-/* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" &&
+/* #__PURE__ */ (0, callbacks_js_1.isTracingEnabled)() &&
     /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !==
         "true") {
     /* #__PURE__ */ console.warn([
@@ -417,8 +418,17 @@ class CallbackManager extends BaseCallbackManager {
         return Promise.all(prompts.map(async (prompt, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : (0, uuid_1.v4)();
-            await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if ((0, base_js_2.isBaseTracer)(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForLLMStart(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return (0, promises_js_1.consumeCallback)(async () => {
                     try {
                         await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                     }
@@ -428,8 +438,8 @@ class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
@@ -437,8 +447,17 @@ class CallbackManager extends BaseCallbackManager {
         return Promise.all(messages.map(async (messageGroup, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : (0, uuid_1.v4)();
-            await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if ((0, base_js_2.isBaseTracer)(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForChatModelStart(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return (0, promises_js_1.consumeCallback)(async () => {
                     try {
                         if (handler.handleChatModelStart) {
                             await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
@@ -454,14 +473,23 @@ class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
     async handleChainStart(chain, inputs, runId = (0, uuid_1.v4)(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-            if (!handler.ignoreChain) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreChain) {
+                return;
+            }
+            if ((0, base_js_2.isBaseTracer)(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
+            }
+            return (0, promises_js_1.consumeCallback)(async () => {
                 try {
                     await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
                 }
@@ -471,13 +499,22 @@ class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleToolStart(tool, input, runId = (0, uuid_1.v4)(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-            if (!handler.ignoreAgent) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreAgent) {
+                return;
+            }
+            if ((0, base_js_2.isBaseTracer)(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForToolStart(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return (0, promises_js_1.consumeCallback)(async () => {
                 try {
                     await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -487,13 +524,22 @@ class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleRetrieverStart(retriever, query, runId = (0, uuid_1.v4)(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
-            if (!handler.ignoreRetriever) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreRetriever) {
+                return;
+            }
+            if ((0, base_js_2.isBaseTracer)(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForRetrieverStart(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return (0, promises_js_1.consumeCallback)(async () => {
                 try {
                     await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -503,8 +549,8 @@ class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleCustomEvent(eventName, 
@@ -629,7 +675,8 @@ class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = (0, callbacks_js_1.isTracingEnabled)();
+        const tracingV2Enabled = tracer_langchain_js_1.LangChainTracer.getTraceableRunTree()?.tracingEnabled ||
+            (0, callbacks_js_1.isTracingEnabled)();
         const tracingEnabled = tracingV2Enabled ||
             ((0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -649,7 +696,8 @@ class CallbackManager extends BaseCallbackManager {
                     // handoff between langchain and langsmith/traceable
                     // override the parent run ID
                     callbackManager._parentRunId =
-                        tracerV2.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
+                        tracer_langchain_js_1.LangChainTracer.getTraceableRunTree()?.id ??
+                            callbackManager._parentRunId;
                 }
             }
         }

package/dist/callbacks/manager.js

@@ -6,8 +6,9 @@ import { getEnvironmentVariable } from "../utils/env.js";
 import { LangChainTracer, } from "../tracers/tracer_langchain.js";
 import { consumeCallback } from "./promises.js";
 import { isTracingEnabled } from "../utils/callbacks.js";
+import { isBaseTracer } from "../tracers/base.js";
 if (
-/* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" &&
+/* #__PURE__ */ isTracingEnabled() &&
     /* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !==
         "true") {
     /* #__PURE__ */ console.warn([
@@ -407,8 +408,17 @@ export class CallbackManager extends BaseCallbackManager {
         return Promise.all(prompts.map(async (prompt, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : uuidv4();
-            await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if (isBaseTracer(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForLLMStart(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return consumeCallback(async () => {
                     try {
                         await handler.handleLLMStart?.(llm, [prompt], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
                     }
@@ -418,8 +428,8 @@ export class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
@@ -427,8 +437,17 @@ export class CallbackManager extends BaseCallbackManager {
         return Promise.all(messages.map(async (messageGroup, idx) => {
             // Can't have duplicate runs with the same run ID (if provided)
             const runId_ = idx === 0 && runId ? runId : uuidv4();
-            await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-                if (!handler.ignoreLLM) {
+            await Promise.all(this.handlers.map((handler) => {
+                if (handler.ignoreLLM) {
+                    return;
+                }
+                if (isBaseTracer(handler)) {
+                    // Create and add run to the run map.
+                    // We do this synchronously to avoid race conditions
+                    // when callbacks are backgrounded.
+                    handler._createRunForChatModelStart(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
+                }
+                return consumeCallback(async () => {
                     try {
                         if (handler.handleChatModelStart) {
                             await handler.handleChatModelStart?.(llm, [messageGroup], runId_, this._parentRunId, extraParams, this.tags, this.metadata, runName);
@@ -444,14 +463,23 @@ export class CallbackManager extends BaseCallbackManager {
                             throw err;
                         }
                     }
-                }
-            }, handler.awaitHandlers)));
+                }, handler.awaitHandlers);
+            }));
             return new CallbackManagerForLLMRun(runId_, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
         }));
     }
     async handleChainStart(chain, inputs, runId = uuidv4(), runType = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-            if (!handler.ignoreChain) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreChain) {
+                return;
+            }
+            if (isBaseTracer(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForChainStart(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
+            }
+            return consumeCallback(async () => {
                 try {
                     await handler.handleChainStart?.(chain, inputs, runId, this._parentRunId, this.tags, this.metadata, runType, runName);
                 }
@@ -461,13 +489,22 @@ export class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForChainRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleToolStart(tool, input, runId = uuidv4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-            if (!handler.ignoreAgent) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreAgent) {
+                return;
+            }
+            if (isBaseTracer(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForToolStart(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return consumeCallback(async () => {
                 try {
                     await handler.handleToolStart?.(tool, input, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -477,13 +514,22 @@ export class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForToolRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleRetrieverStart(retriever, query, runId = uuidv4(), _parentRunId = undefined, _tags = undefined, _metadata = undefined, runName = undefined) {
-        await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
-            if (!handler.ignoreRetriever) {
+        await Promise.all(this.handlers.map((handler) => {
+            if (handler.ignoreRetriever) {
+                return;
+            }
+            if (isBaseTracer(handler)) {
+                // Create and add run to the run map.
+                // We do this synchronously to avoid race conditions
+                // when callbacks are backgrounded.
+                handler._createRunForRetrieverStart(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
+            }
+            return consumeCallback(async () => {
                 try {
                     await handler.handleRetrieverStart?.(retriever, query, runId, this._parentRunId, this.tags, this.metadata, runName);
                 }
@@ -493,8 +539,8 @@ export class CallbackManager extends BaseCallbackManager {
                         throw err;
                     }
                 }
-            }
-        }, handler.awaitHandlers)));
+            }, handler.awaitHandlers);
+        }));
         return new CallbackManagerForRetrieverRun(runId, this.handlers, this.inheritableHandlers, this.tags, this.inheritableTags, this.metadata, this.inheritableMetadata, this._parentRunId);
     }
     async handleCustomEvent(eventName, 
@@ -619,7 +665,8 @@ export class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = isTracingEnabled();
+        const tracingV2Enabled = LangChainTracer.getTraceableRunTree()?.tracingEnabled ||
+            isTracingEnabled();
         const tracingEnabled = tracingV2Enabled ||
             (getEnvironmentVariable("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -639,7 +686,8 @@ export class CallbackManager extends BaseCallbackManager {
                     // handoff between langchain and langsmith/traceable
                     // override the parent run ID
                     callbackManager._parentRunId =
-                        tracerV2.getTraceableRunTree()?.id ?? callbackManager._parentRunId;
+                        LangChainTracer.getTraceableRunTree()?.id ??
+                            callbackManager._parentRunId;
                 }
             }
         }

package/dist/callbacks/tests/callbacks.test.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-promise-executor-return */
 import { test, expect } from "@jest/globals";
 import * as uuid from "uuid";
 import { CallbackManager } from "../manager.js";
@@ -227,6 +228,8 @@ test("CallbackManager", async () => {
         new Document({ pageContent: "test", metadata: { test: "test" } }),
     ]);
     await retrieverCb.handleRetrieverError(new Error("test"));
+    // In case background mode is on while running this test
+    await new Promise((resolve) => setTimeout(resolve, 100));
     for (const handler of [handler1, handler2]) {
         expect(handler.starts).toBe(5);
         expect(handler.ends).toBe(5);

package/dist/runnables/base.cjs

@@ -1508,7 +1508,7 @@ class RunnableLambda extends Runnable {
                 callbacks: runManager?.getChild(),
                 recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
             });
-            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
                 try {
                     let output = await this.func(input, {
                         ...childConfig,
@@ -1594,7 +1594,7 @@ class RunnableLambda extends Runnable {
             recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
         });
         const output = await new Promise((resolve, reject) => {
-            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
                 try {
                     const res = await this.func(finalChunk, {
                         ...childConfig,

package/dist/runnables/base.d.ts

@@ -202,11 +202,11 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
      * | on_llm_end           | [model name]     |                                 | 'Hello human!'                                |                                                 |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chain_start       | format_docs      |                                 |                                               |                                                 |
+     * | on_chain_start       | some_runnable    |                                 |                                               |                                                 |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chain_stream      | format_docs      | "hello world!, goodbye world!"  |                                               |                                                 |
+     * | on_chain_stream      | some_runnable    | "hello world!, goodbye world!"  |                                               |                                                 |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
-     * | on_chain_end         | format_docs      |                                 | [Document(...)]                               | "hello world!, goodbye world!"                  |
+     * | on_chain_end         | some_runnable    |                                 | [Document(...)]                               | "hello world!, goodbye world!"                  |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
      * | on_tool_start        | some_tool        |                                 | {"x": 1, "y": "2"}                            |                                                 |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
@@ -220,6 +220,52 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
      * | on_prompt_end        | [template_name]  |                                 | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
      * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     *
+     * The "on_chain_*" events are the default for Runnables that don't fit one of the above categories.
+     *
+     * In addition to the standard events above, users can also dispatch custom events.
+     *
+     * Custom events will be only be surfaced with in the `v2` version of the API!
+     *
+     * A custom event has following format:
+     *
+     * +-----------+------+-----------------------------------------------------------------------------------------------------------+
+     * | Attribute | Type | Description                                                                                               |
+     * +===========+======+===========================================================================================================+
+     * | name      | str  | A user defined name for the event.                                                                        |
+     * +-----------+------+-----------------------------------------------------------------------------------------------------------+
+     * | data      | Any  | The data associated with the event. This can be anything, though we suggest making it JSON serializable.  |
+     * +-----------+------+-----------------------------------------------------------------------------------------------------------+
+     *
+     * Here's an example:
+     * @example
+     * ```ts
+     * import { RunnableLambda } from "@langchain/core/runnables";
+     * import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
+     * // Use this import for web environments that don't support "async_hooks"
+     * // and manually pass config to child runs.
+     * // import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch/web";
+     *
+     * const slowThing = RunnableLambda.from(async (someInput: string) => {
+     *   // Placeholder for some slow operation
+     *   await new Promise((resolve) => setTimeout(resolve, 100));
+     *   await dispatchCustomEvent("progress_event", {
+     *    message: "Finished step 1 of 2",
+     *  });
+     *  await new Promise((resolve) => setTimeout(resolve, 100));
+     *  return "Done";
+     * });
+     *
+     * const eventStream = await slowThing.streamEvents("hello world", {
+     *   version: "v2",
+     * });
+     *
+     * for await (const event of eventStream) {
+     *  if (event.event === "on_custom_event") {
+     *    console.log(event);
+     *  }
+     * }
+     * ```
      */
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
         version: "v1" | "v2";

package/dist/runnables/base.js

@@ -1494,7 +1494,7 @@ export class RunnableLambda extends Runnable {
                 callbacks: runManager?.getChild(),
                 recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
             });
-            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+            void AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
                 try {
                     let output = await this.func(input, {
                         ...childConfig,
@@ -1580,7 +1580,7 @@ export class RunnableLambda extends Runnable {
             recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
         });
         const output = await new Promise((resolve, reject) => {
-            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
+            void AsyncLocalStorageProviderSingleton.runWithConfig(childConfig, async () => {
                 try {
                     const res = await this.func(finalChunk, {
                         ...childConfig,

package/dist/runnables/config.cjs

@@ -5,7 +5,7 @@ const manager_js_1 = require("../callbacks/manager.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 exports.DEFAULT_RECURSION_LIMIT = 25;
 async function getCallbackManagerForConfig(config) {
-    return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
+    return manager_js_1.CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
 exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
 function mergeConfigs(...configs) {
@@ -84,12 +84,9 @@ exports.mergeConfigs = mergeConfigs;
 const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
- *
- * Note: To make sure async local storage loading works correctly, this
- * should not be called with a default or prepopulated config argument.
  */
 function ensureConfig(config) {
-    const implicitConfig = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const implicitConfig = index_js_1.AsyncLocalStorageProviderSingleton.getRunnableConfig();
     let empty = {
         tags: [],
         metadata: {},
@@ -97,10 +94,10 @@ function ensureConfig(config) {
         runId: undefined,
     };
     if (implicitConfig) {
-        // Don't allow runId to be loaded implicitly, as this can cause
+        // Don't allow runId and runName to be loaded implicitly, as this can cause
         // child runs to improperly inherit their parents' run ids.
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { runId, ...rest } = implicitConfig;
+        const { runId, runName, ...rest } = implicitConfig;
         empty = Object.entries(rest).reduce(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         (currentConfig, [key, value]) => {

package/dist/runnables/config.d.ts

@@ -1,25 +1,11 @@
-import { type BaseCallbackConfig, CallbackManager } from "../callbacks/manager.js";
+import { CallbackManager } from "../callbacks/manager.js";
+import { RunnableConfig } from "./types.js";
 export declare const DEFAULT_RECURSION_LIMIT = 25;
-export interface RunnableConfig extends BaseCallbackConfig {
-    /**
-     * Runtime values for attributes previously made configurable on this Runnable,
-     * or sub-Runnables.
-     */
-    configurable?: Record<string, any>;
-    /**
-     * Maximum number of times a call can recurse. If not provided, defaults to 25.
-     */
-    recursionLimit?: number;
-    /** Maximum number of parallel calls to make. */
-    maxConcurrency?: number;
-}
+export { type RunnableConfig };
 export declare function getCallbackManagerForConfig(config?: RunnableConfig): Promise<CallbackManager | undefined>;
 export declare function mergeConfigs<CallOptions extends RunnableConfig>(...configs: (CallOptions | RunnableConfig | undefined | null)[]): Partial<CallOptions>;
 /**
  * Ensure that a passed config is an object with all required keys present.
- *
- * Note: To make sure async local storage loading works correctly, this
- * should not be called with a default or prepopulated config argument.
  */
 export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): CallOptions;
 /**

package/dist/runnables/config.js

@@ -1,8 +1,8 @@
-import { CallbackManager, ensureHandler, } from "../callbacks/manager.js";
+import { CallbackManager, ensureHandler } from "../callbacks/manager.js";
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
 export const DEFAULT_RECURSION_LIMIT = 25;
 export async function getCallbackManagerForConfig(config) {
-    return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
+    return CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
 export function mergeConfigs(...configs) {
     // We do not want to call ensureConfig on the empty state here as this may cause
@@ -79,12 +79,9 @@ export function mergeConfigs(...configs) {
 const PRIMITIVES = new Set(["string", "number", "boolean"]);
 /**
  * Ensure that a passed config is an object with all required keys present.
- *
- * Note: To make sure async local storage loading works correctly, this
- * should not be called with a default or prepopulated config argument.
  */
 export function ensureConfig(config) {
-    const implicitConfig = AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const implicitConfig = AsyncLocalStorageProviderSingleton.getRunnableConfig();
     let empty = {
         tags: [],
         metadata: {},
@@ -92,10 +89,10 @@ export function ensureConfig(config) {
         runId: undefined,
     };
     if (implicitConfig) {
-        // Don't allow runId to be loaded implicitly, as this can cause
+        // Don't allow runId and runName to be loaded implicitly, as this can cause
         // child runs to improperly inherit their parents' run ids.
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { runId, ...rest } = implicitConfig;
+        const { runId, runName, ...rest } = implicitConfig;
         empty = Object.entries(rest).reduce(
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         (currentConfig, [key, value]) => {

package/dist/runnables/graph.d.ts

@@ -15,7 +15,7 @@ export declare class Graph {
      */
     extend(graph: Graph, prefix?: string): ({
         id: string;
-        data: RunnableIOSchema | RunnableInterface<any, any, import("./config.js").RunnableConfig>;
+        data: RunnableIOSchema | RunnableInterface<any, any, import("./types.js").RunnableConfig>;
     } | undefined)[];
     trimFirstNode(): void;
     trimLastNode(): void;

package/dist/runnables/iter.cjs

@@ -23,9 +23,8 @@ function isAsyncIterable(thing) {
 }
 exports.isAsyncIterable = isAsyncIterable;
 function* consumeIteratorInContext(context, iter) {
-    const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
     while (true) {
-        const { value, done } = storage.run(context, iter.next.bind(iter));
+        const { value, done } = index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(context, iter.next.bind(iter), true);
         if (done) {
             break;
         }
@@ -36,10 +35,9 @@ function* consumeIteratorInContext(context, iter) {
 }
 exports.consumeIteratorInContext = consumeIteratorInContext;
 async function* consumeAsyncIterableInContext(context, iter) {
-    const storage = index_js_1.AsyncLocalStorageProviderSingleton.getInstance();
     const iterator = iter[Symbol.asyncIterator]();
     while (true) {
-        const { value, done } = await storage.run(context, iterator.next.bind(iter));
+        const { value, done } = await index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(context, iterator.next.bind(iter), true);
         if (done) {
             break;
         }

package/dist/runnables/iter.js

@@ -17,9 +17,8 @@ export function isAsyncIterable(thing) {
             "function");
 }
 export function* consumeIteratorInContext(context, iter) {
-    const storage = AsyncLocalStorageProviderSingleton.getInstance();
     while (true) {
-        const { value, done } = storage.run(context, iter.next.bind(iter));
+        const { value, done } = AsyncLocalStorageProviderSingleton.runWithConfig(context, iter.next.bind(iter), true);
         if (done) {
             break;
         }
@@ -29,10 +28,9 @@ export function* consumeIteratorInContext(context, iter) {
     }
 }
 export async function* consumeAsyncIterableInContext(context, iter) {
-    const storage = AsyncLocalStorageProviderSingleton.getInstance();
     const iterator = iter[Symbol.asyncIterator]();
     while (true) {
-        const { value, done } = await storage.run(context, iterator.next.bind(iter));
+        const { value, done } = await AsyncLocalStorageProviderSingleton.runWithConfig(context, iterator.next.bind(iter), true);
         if (done) {
             break;
         }