@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/singletons/async_local_storage/context.cjs

@@ -1,189 +1,179 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerConfigureHook = exports._getConfigureHooks = void 0;
-exports.setContextVariable = setContextVariable;
-exports.getContextVariable = getContextVariable;
-const run_trees_1 = require("langsmith/run_trees");
-const globals_js_1 = require("./globals.cjs");
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_globals = require('./globals.cjs');
+const langsmith_run_trees = require_rolldown_runtime.__toESM(require("langsmith/run_trees"));
+
+//#region src/singletons/async_local_storage/context.ts
 /**
- * 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
+* 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.
+*/
 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);
+	const asyncLocalStorageInstance = require_globals.getGlobalAsyncLocalStorageInstance();
+	if (asyncLocalStorageInstance === void 0) throw new Error(`Internal error: Global shared async local storage instance has not been initialized.`);
+	const runTree = asyncLocalStorageInstance.getStore();
+	const contextVars = { ...runTree?.[require_globals._CONTEXT_VARIABLES_KEY] };
+	contextVars[name] = value;
+	let newValue = {};
+	if ((0, langsmith_run_trees.isRunTree)(runTree)) newValue = new langsmith_run_trees.RunTree(runTree);
+	newValue[require_globals._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
+* 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.
+*/
 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];
+	const asyncLocalStorageInstance = require_globals.getGlobalAsyncLocalStorageInstance();
+	if (asyncLocalStorageInstance === void 0) return void 0;
+	const runTree = asyncLocalStorageInstance.getStore();
+	return runTree?.[require_globals._CONTEXT_VARIABLES_KEY]?.[name];
 }
 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
- */
+* 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]);
+	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]);
 };
+
+//#endregion
+exports._getConfigureHooks = _getConfigureHooks;
+exports.getContextVariable = getContextVariable;
 exports.registerConfigureHook = registerConfigureHook;
+exports.setContextVariable = setContextVariable;
+//# sourceMappingURL=context.cjs.map

package/dist/singletons/async_local_storage/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","names":["name: PropertyKey","value: T","getGlobalAsyncLocalStorageInstance","_CONTEXT_VARIABLES_KEY","RunTree","config: ConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.ts"],"sourcesContent":["import { isRunTree, RunTree } from \"langsmith/run_trees\";\nimport { BaseCallbackHandler } from \"../../callbacks/base.js\";\nimport {\n  _CONTEXT_VARIABLES_KEY,\n  getGlobalAsyncLocalStorageInstance,\n} from \"./globals.js\";\n\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    throw new Error(\n      `Internal error: Global shared async local storage instance has not been initialized.`\n    );\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n  contextVars[name] = value;\n  let newValue = {};\n  if (isRunTree(runTree)) {\n    newValue = new RunTree(runTree);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n  asyncLocalStorageInstance.enterWith(newValue);\n}\n\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getContextVariable<T = any>(name: PropertyKey): T | undefined {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    return undefined;\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n  getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) || [];\n\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport const registerConfigureHook = (config: ConfigureHook) => {\n  if (config.envVar && !config.handlerClass) {\n    throw new Error(\n      \"If envVar is set, handlerClass must also be set to a non-None value.\"\n    );\n  }\n  setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\nexport type ConfigureHook = {\n  contextVar?: string;\n  inheritable?: boolean;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAgB,mBAAsBA,MAAmBC,OAAgB;CAEvE,MAAM,4BAA4BC,oDAAoC;AACtE,KAAI,8BAA8B,OAChC,OAAM,IAAI,MACR,CAAC,oFAAoF,CAAC;CAG1F,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAUC,wCAAyB;CAC5D,YAAY,QAAQ;CACpB,IAAI,WAAW,CAAE;AACjB,wCAAc,QAAQ,EACpB,WAAW,IAAIC,4BAAQ;CAGxB,SAAiBD,0CAA0B;CAC5C,0BAA0B,UAAU,SAAS;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,mBAA4BH,MAAkC;CAE5E,MAAM,4BAA4BE,oDAAoC;AACtE,KAAI,8BAA8B,OAChC,QAAO;CAET,MAAM,UAAU,0BAA0B,UAAU;AACpD,QAAO,UAAUC,0CAA0B;AAC5C;AAED,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,qBAAqB,MAChC,mBAAoC,uBAAuB,IAAI,CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,wBAAwB,CAACE,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR;CAGJ,mBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,MAAO,EAAC;AAC9E"}

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

@@ -0,0 +1,163 @@
+import { BaseCallbackHandler } from "../../callbacks/base.cjs";
+
+//#region src/singletons/async_local_storage/context.d.ts
+
+/**
+ * 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
+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.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;
+/**
+ * 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
+ */
+declare const registerConfigureHook: (config: ConfigureHook) => void;
+type ConfigureHook = {
+  contextVar?: string;
+  inheritable?: boolean;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlerClass?: new (...args: any[]) => BaseCallbackHandler;
+  envVar?: string;
+};
+//#endregion
+export { ConfigureHook, getContextVariable, registerConfigureHook, setContextVariable };
+//# sourceMappingURL=context.d.cts.map

package/dist/singletons/async_local_storage/context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","names":["BaseCallbackHandler","setContextVariable","PropertyKey","T","getContextVariable","_getConfigureHooks","ConfigureHook","registerConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.d.ts"],"sourcesContent":["import { BaseCallbackHandler } from \"../../callbacks/base.js\";\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function setContextVariable<T>(name: PropertyKey, value: T): void;\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;\nexport declare const _getConfigureHooks: () => ConfigureHook[];\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport declare const registerConfigureHook: (config: ConfigureHook) => void;\nexport type ConfigureHook = {\n    contextVar?: string;\n    inheritable?: boolean;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n"],"mappings":";;;;;;AAoDA;;;;AAAyE;AAmDzE;;;;AAAyE;AA+CzE;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAnGwBC,4BAA4BC,oBAAoBC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDhDC,kCAAkCF,cAAcC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDI,gCAAgCD;KACzCA,aAAAA;;;;yCAI+BN"}

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

@@ -1,4 +1,7 @@
 import { BaseCallbackHandler } from "../../callbacks/base.js";
+
+//#region src/singletons/async_local_storage/context.d.ts
+
 /**
  * Set a context variable. Context variables are scoped to any
  * child runnables called by the current runnable, or globally if set outside
@@ -49,7 +52,8 @@ import { BaseCallbackHandler } from "../../callbacks/base.js";
  * @param name The name of the context variable.
  * @param value The value to set.
  */
-export declare function setContextVariable<T>(name: PropertyKey, value: T): void;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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,
@@ -99,8 +103,8 @@ export declare function setContextVariable<T>(name: PropertyKey, value: T): void
  *
  * @param name The name of the context variable.
  */
-export declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;
-export declare const _getConfigureHooks: () => ConfigureHook[];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;
 /**
  * Register a callback configure hook to automatically add callback handlers to all runs.
  *
@@ -146,10 +150,14 @@ export declare const _getConfigureHooks: () => ConfigureHook[];
  * @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;
+declare const registerConfigureHook: (config: ConfigureHook) => void;
+type ConfigureHook = {
+  contextVar?: string;
+  inheritable?: boolean;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  handlerClass?: new (...args: any[]) => BaseCallbackHandler;
+  envVar?: string;
 };
+//#endregion
+export { ConfigureHook, getContextVariable, registerConfigureHook, setContextVariable };
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","names":["BaseCallbackHandler","setContextVariable","PropertyKey","T","getContextVariable","_getConfigureHooks","ConfigureHook","registerConfigureHook"],"sources":["../../../src/singletons/async_local_storage/context.d.ts"],"sourcesContent":["import { BaseCallbackHandler } from \"../../callbacks/base.js\";\n/**\n * Set a context variable. Context variables are scoped to any\n * child runnables called by the current runnable, or globally if set outside\n * of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n * @param value The value to set.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function setContextVariable<T>(name: PropertyKey, value: T): void;\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare function getContextVariable<T = any>(name: PropertyKey): T | undefined;\nexport declare const _getConfigureHooks: () => ConfigureHook[];\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport declare const registerConfigureHook: (config: ConfigureHook) => void;\nexport type ConfigureHook = {\n    contextVar?: string;\n    inheritable?: boolean;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n"],"mappings":";;;;;;AAoDA;;;;AAAyE;AAmDzE;;;;AAAyE;AA+CzE;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAnGwBC,4BAA4BC,oBAAoBC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDhDC,kCAAkCF,cAAcC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDI,gCAAgCD;KACzCA,aAAAA;;;;yCAI+BN"}