@langchain/core 0.3.22 → 0.3.24-rc.0

package/dist/messages/tool.d.ts

@@ -15,12 +15,24 @@ export interface ToolMessageFieldsWithToolCallId extends BaseMessageFields {
      */
     status?: "success" | "error";
 }
+/**
+ * Marker parameter for objects that tools can return directly.
+ *
+ * If a custom BaseTool is invoked with a ToolCall and the output of custom code is
+ * not an instance of DirectToolOutput, the output will automatically be coerced to
+ * a string and wrapped in a ToolMessage.
+ */
+export interface DirectToolOutput {
+    readonly lc_direct_tool_output: boolean;
+}
+export declare function isDirectToolOutput(x: unknown): x is DirectToolOutput;
 /**
  * Represents a tool message in a conversation.
  */
-export declare class ToolMessage extends BaseMessage {
+export declare class ToolMessage extends BaseMessage implements DirectToolOutput {
     static lc_name(): string;
     get lc_aliases(): Record<string, string>;
+    lc_direct_tool_output: boolean;
     /**
      * Status of the tool invocation.
      * @version 0.2.19

package/dist/messages/tool.js

@@ -1,4 +1,10 @@
 import { BaseMessage, BaseMessageChunk, mergeContent, _mergeDicts, _mergeObj, _mergeStatus, } from "./base.js";
+export function isDirectToolOutput(x) {
+    return (x != null &&
+        typeof x === "object" &&
+        "lc_direct_tool_output" in x &&
+        x.lc_direct_tool_output === true);
+}
 /**
  * Represents a tool message in a conversation.
  */
@@ -16,6 +22,12 @@ export class ToolMessage extends BaseMessage {
             fields = { content: fields, name, tool_call_id: tool_call_id };
         }
         super(fields);
+        Object.defineProperty(this, "lc_direct_tool_output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         /**
          * Status of the tool invocation.
          * @version 0.2.19

package/dist/output_parsers/transform.cjs

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCumulativeTransformOutputParser = exports.BaseTransformOutputParser = void 0;
+const json_schema_1 = require("@cfworker/json-schema");
 const base_js_1 = require("./base.cjs");
 const base_js_2 = require("../messages/base.cjs");
 const utils_js_1 = require("../messages/utils.cjs");
 const outputs_js_1 = require("../outputs.cjs");
-const index_js_1 = require("../utils/@cfworker/json-schema/index.cjs");
 /**
  * Class to parse the output of an LLM call that also allows streaming inputs.
  */
@@ -94,7 +94,7 @@ class BaseCumulativeTransformOutputParser extends BaseTransformOutputParser {
             const parsed = await this.parsePartialResult([accGen]);
             if (parsed !== undefined &&
                 parsed !== null &&
-                !(0, index_js_1.deepCompareStrict)(parsed, prevParsed)) {
+                !(0, json_schema_1.deepCompareStrict)(parsed, prevParsed)) {
                 if (this.diff) {
                     yield this._diff(prevParsed, parsed);
                 }

package/dist/output_parsers/transform.js

@@ -1,8 +1,8 @@
+import { deepCompareStrict } from "@cfworker/json-schema";
 import { BaseOutputParser } from "./base.js";
 import { isBaseMessage, isBaseMessageChunk, } from "../messages/base.js";
 import { convertToChunk } from "../messages/utils.js";
 import { GenerationChunk, ChatGenerationChunk, } from "../outputs.js";
-import { deepCompareStrict } from "../utils/@cfworker/json-schema/index.js";
 /**
  * Class to parse the output of an LLM call that also allows streaming inputs.
  */

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;