@langchain/core 0.3.22 → 0.3.23

package/dist/singletons/async_local_storage/context.cjs

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigureHook = exports._getConfigureHooks = exports.getContextVariable = exports.setContextVariable = void 0;
+const run_trees_1 = require("langsmith/run_trees");
+const globals_js_1 = require("./globals.cjs");
+/**
+ * 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
+function setContextVariable(name, value) {
+    // Avoid using global singleton due to circuluar dependency issues
+    const asyncLocalStorageInstance = (0, globals_js_1.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?.[globals_js_1._CONTEXT_VARIABLES_KEY] };
+    contextVars[name] = value;
+    let newValue = {};
+    if ((0, run_trees_1.isRunTree)(runTree)) {
+        newValue = new run_trees_1.RunTree(runTree);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    newValue[globals_js_1._CONTEXT_VARIABLES_KEY] = contextVars;
+    asyncLocalStorageInstance.enterWith(newValue);
+}
+exports.setContextVariable = setContextVariable;
+/**
+ * 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
+function getContextVariable(name) {
+    // Avoid using global singleton due to circuluar dependency issues
+    const asyncLocalStorageInstance = (0, globals_js_1.getGlobalAsyncLocalStorageInstance)();
+    if (asyncLocalStorageInstance === undefined) {
+        return undefined;
+    }
+    const runTree = asyncLocalStorageInstance.getStore();
+    return runTree?.[globals_js_1._CONTEXT_VARIABLES_KEY]?.[name];
+}
+exports.getContextVariable = getContextVariable;
+const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
+const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
+exports._getConfigureHooks = _getConfigureHooks;
+/**
+ * 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
+ */
+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, [...(0, exports._getConfigureHooks)(), config]);
+};
+exports.registerConfigureHook = registerConfigureHook;

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

@@ -0,0 +1,155 @@
+import { BaseCallbackHandler } from "../../callbacks/base.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.
+ */
+export declare function setContextVariable<T>(name: PropertyKey, value: T): void;
+/**
+ * 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.
+ */
+export declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;
+export declare const _getConfigureHooks: () => ConfigureHook[];
+/**
+ * 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 declare const registerConfigureHook: (config: ConfigureHook) => void;
+export type ConfigureHook = {
+    contextVar?: string;
+    inheritable?: boolean;
+    handlerClass?: new (...args: any[]) => BaseCallbackHandler;
+    envVar?: string;
+};

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 };