@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/singletons/async_local_storage/context.cjs

@@ -1,7 +1,6 @@
-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"));
-
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_globals = require("./globals.cjs");
+let langsmith_run_trees = require("langsmith/run_trees");
 //#region src/singletons/async_local_storage/context.ts
 /**
 * Set a context variable. Context variables are scoped to any
@@ -115,9 +114,8 @@ function setContextVariable(name, value) {
 */
 function getContextVariable(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];
+	if (asyncLocalStorageInstance === void 0) return;
+	return asyncLocalStorageInstance.getStore()?.[require_globals._CONTEXT_VARIABLES_KEY]?.[name];
 }
 const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
 const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
@@ -170,10 +168,10 @@ 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]);
 };
-
 //#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

@@ -1 +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 */\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,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"}
+{"version":3,"file":"context.cjs","names":["getGlobalAsyncLocalStorageInstance","_CONTEXT_VARIABLES_KEY","RunTree"],"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 */\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  // oxlint-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// oxlint-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  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsB,MAAmB,OAAgB;CAEvE,MAAM,4BAA4BA,gBAAAA,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAUC,gBAAAA,yBAAyB;AAC5D,aAAY,QAAQ;CACpB,IAAI,WAAW,EAAE;AACjB,MAAA,GAAA,oBAAA,WAAc,QAAQ,CACpB,YAAW,IAAIC,oBAAAA,QAAQ,QAAQ;AAGhC,UAAiBD,gBAAAA,0BAA0B;AAC5C,2BAA0B,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqD/C,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4BD,gBAAAA,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC;AAGF,QADgB,0BAA0B,UAC5B,GAAGC,gBAAAA,0BAA0B;;AAG7C,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,2BACX,mBAAoC,uBAAuB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,yBAAyB,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR,uEACD;AAEH,oBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,OAAO,CAAC"}

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

@@ -1,7 +1,6 @@
 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

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.cts","names":["BaseCallbackHandler","setContextVariable","T","PropertyKey","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 */\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 */\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    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n//# sourceMappingURL=context.d.ts.map"],"mappings":";;;;;;AAmDA;AAkDA;AA+CA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlGwBC,4BAA4BE,oBAAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDhDE,kCAAkCD,cAAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDK,gCAAgCD;KACzCA,aAAAA;;;yCAG+BN"}
+{"version":3,"file":"context.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"mappings":";;;;;AAyDA;;;;;;;;;;;AAsEA;;;;;;;;;;AA4DA;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;iBA3IgB,kBAAA,GAAA,CAAsB,IAAA,EAAM,WAAA,EAAa,KAAA,EAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsEhD,kBAAA,SAAA,CAA4B,IAAA,EAAM,WAAA,GAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DnD,qBAAA,GAAqB,MAAA,EAAY,aAAA;AAAA,KASlC,aAAA;EACV,UAAA;EACA,WAAA;EAEA,YAAA,WAAuB,IAAA,YAAgB,mBAAA;EACvC,MAAA;AAAA"}

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

@@ -1,7 +1,6 @@
 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

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

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":["BaseCallbackHandler","setContextVariable","T","PropertyKey","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 */\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 */\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    handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n    envVar?: string;\n};\n//# sourceMappingURL=context.d.ts.map"],"mappings":";;;;;;AAmDA;AAkDA;AA+CA;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlGwBC,4BAA4BE,oBAAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDhDE,kCAAkCD,cAAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CnDK,gCAAgCD;KACzCA,aAAAA;;;yCAG+BN"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/context.ts"],"mappings":";;;;;AAyDA;;;;;;;;;;;AAsEA;;;;;;;;;;AA4DA;;;;;AASA;;;;;;;;;;;;;;;;;;;;;;iBA3IgB,kBAAA,GAAA,CAAsB,IAAA,EAAM,WAAA,EAAa,KAAA,EAAO,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsEhD,kBAAA,SAAA,CAA4B,IAAA,EAAM,WAAA,GAAc,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DnD,qBAAA,GAAqB,MAAA,EAAY,aAAA;AAAA,KASlC,aAAA;EACV,UAAA;EACA,WAAA;EAEA,YAAA,WAAuB,IAAA,YAAgB,mBAAA;EACvC,MAAA;AAAA"}

package/dist/singletons/async_local_storage/context.js

@@ -1,6 +1,5 @@
 import { _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance } from "./globals.js";
 import { RunTree, isRunTree } from "langsmith/run_trees";
-
 //#region src/singletons/async_local_storage/context.ts
 /**
 * Set a context variable. Context variables are scoped to any
@@ -114,9 +113,8 @@ function setContextVariable(name, value) {
 */
 function getContextVariable(name) {
 	const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
-	if (asyncLocalStorageInstance === void 0) return void 0;
-	const runTree = asyncLocalStorageInstance.getStore();
-	return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
+	if (asyncLocalStorageInstance === void 0) return;
+	return asyncLocalStorageInstance.getStore()?.[_CONTEXT_VARIABLES_KEY]?.[name];
 }
 const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
 const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
@@ -169,7 +167,7 @@ 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]);
 };
-
 //#endregion
 export { _getConfigureHooks, getContextVariable, registerConfigureHook, setContextVariable };
+
 //# sourceMappingURL=context.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"context.js","names":["name: PropertyKey","value: T","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 */\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsBA,MAAmBC,OAAgB;CAEvE,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,OAChC,OAAM,IAAI,MACR,CAAC,oFAAoF,CAAC;CAG1F,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAU,wBAAyB;CAC5D,YAAY,QAAQ;CACpB,IAAI,WAAW,CAAE;AACjB,KAAI,UAAU,QAAQ,EACpB,WAAW,IAAI,QAAQ;CAGxB,SAAiB,0BAA0B;CAC5C,0BAA0B,UAAU,SAAS;AAC9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,mBAA4BD,MAAkC;CAE5E,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,OAChC,QAAO;CAET,MAAM,UAAU,0BAA0B,UAAU;AACpD,QAAO,UAAU,0BAA0B;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"}
+{"version":3,"file":"context.js","names":[],"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 */\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  // oxlint-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// oxlint-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  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,mBAAsB,MAAmB,OAAgB;CAEvE,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC,OAAM,IAAI,MACR,uFACD;CAEH,MAAM,UAAU,0BAA0B,UAAU;CACpD,MAAM,cAAc,EAAE,GAAG,UAAU,yBAAyB;AAC5D,aAAY,QAAQ;CACpB,IAAI,WAAW,EAAE;AACjB,KAAI,UAAU,QAAQ,CACpB,YAAW,IAAI,QAAQ,QAAQ;AAGhC,UAAiB,0BAA0B;AAC5C,2BAA0B,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqD/C,SAAgB,mBAA4B,MAAkC;CAE5E,MAAM,4BAA4B,oCAAoC;AACtE,KAAI,8BAA8B,KAAA,EAChC;AAGF,QADgB,0BAA0B,UAC5B,GAAG,0BAA0B;;AAG7C,MAAM,yBAAyB,OAAO,qBAAqB;AAE3D,MAAa,2BACX,mBAAoC,uBAAuB,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CnE,MAAa,yBAAyB,WAA0B;AAC9D,KAAI,OAAO,UAAU,CAAC,OAAO,aAC3B,OAAM,IAAI,MACR,uEACD;AAEH,oBAAmB,wBAAwB,CAAC,GAAG,oBAAoB,EAAE,OAAO,CAAC"}

package/dist/singletons/async_local_storage/globals.cjs

@@ -1,4 +1,3 @@
-
 //#region src/singletons/async_local_storage/globals.ts
 const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
 const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
@@ -8,9 +7,9 @@ const setGlobalAsyncLocalStorageInstance = (instance) => {
 const getGlobalAsyncLocalStorageInstance = () => {
 	return globalThis[TRACING_ALS_KEY];
 };
-
 //#endregion
 exports._CONTEXT_VARIABLES_KEY = _CONTEXT_VARIABLES_KEY;
 exports.getGlobalAsyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance;
 exports.setGlobalAsyncLocalStorageInstance = setGlobalAsyncLocalStorageInstance;
+
 //# sourceMappingURL=globals.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"globals.cjs","names":["instance: AsyncLocalStorageInterface"],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";;AASA,MAAa,kBAAkB,OAAO,IAAI,iCAAiC;AAE3E,MAAa,yBAAyB,OAAO,IAAI,uBAAuB;AAExE,MAAa,qCAAqC,CAChDA,aACG;CACF,WAAmB,mBAAmB;AACxC;AAED,MAAa,qCAAqC,MAEjC;AACf,QAAQ,WAAmB;AAC5B"}
+{"version":3,"file":"globals.cjs","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,iCAAiC;AAE3E,MAAa,yBAAyB,OAAO,IAAI,uBAAuB;AAExE,MAAa,sCACX,aACG;AACF,YAAmB,mBAAmB;;AAGzC,MAAa,2CAEI;AACf,QAAQ,WAAmB"}

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

@@ -1 +1 @@
-{"version":3,"file":"globals.d.cts","names":["AsyncLocalStorageInterface","T","TRACING_ALS_KEY","_CONTEXT_VARIABLES_KEY","setGlobalAsyncLocalStorageInstance","getGlobalAsyncLocalStorageInstance"],"sources":["../../../src/singletons/async_local_storage/globals.d.ts"],"sourcesContent":["export interface AsyncLocalStorageInterface {\n    getStore: () => any | undefined;\n    run: <T>(store: any, callback: () => T) => T;\n    enterWith: (store: any) => void;\n}\nexport declare const TRACING_ALS_KEY: unique symbol;\nexport declare const _CONTEXT_VARIABLES_KEY: unique symbol;\nexport declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;\nexport declare const getGlobalAsyncLocalStorageInstance: () => AsyncLocalStorageInterface | undefined;\n//# sourceMappingURL=globals.d.ts.map"],"mappings":";UAAiBA,0BAAAA;EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,GAAAA,GAAAA,SAA0B;EAMtBG,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAqC,EAAA,GAAA,GAJjBF,CAIiB,EAAA,GAJXA,CAIW;;;cAArCE"}
+{"version":3,"file":"globals.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"mappings":";UACiB,0BAAA;EACf,QAAA;EAEA,GAAA,MAAS,KAAA,OAAY,QAAA,QAAgB,CAAA,KAAM,CAAA;EAE3C,SAAA,GAAY,KAAA;AAAA;AAAA,cAKD,sBAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"globals.d.ts","names":["AsyncLocalStorageInterface","T","TRACING_ALS_KEY","_CONTEXT_VARIABLES_KEY","setGlobalAsyncLocalStorageInstance","getGlobalAsyncLocalStorageInstance"],"sources":["../../../src/singletons/async_local_storage/globals.d.ts"],"sourcesContent":["export interface AsyncLocalStorageInterface {\n    getStore: () => any | undefined;\n    run: <T>(store: any, callback: () => T) => T;\n    enterWith: (store: any) => void;\n}\nexport declare const TRACING_ALS_KEY: unique symbol;\nexport declare const _CONTEXT_VARIABLES_KEY: unique symbol;\nexport declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;\nexport declare const getGlobalAsyncLocalStorageInstance: () => AsyncLocalStorageInterface | undefined;\n//# sourceMappingURL=globals.d.ts.map"],"mappings":";UAAiBA,0BAAAA;EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,GAAAA,GAAAA,SAA0B;EAMtBG,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAqC,EAAA,GAAA,GAJjBF,CAIiB,EAAA,GAJXA,CAIW;;;cAArCE"}
+{"version":3,"file":"globals.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"mappings":";UACiB,0BAAA;EACf,QAAA;EAEA,GAAA,MAAS,KAAA,OAAY,QAAA,QAAgB,CAAA,KAAM,CAAA;EAE3C,SAAA,GAAY,KAAA;AAAA;AAAA,cAKD,sBAAA"}

package/dist/singletons/async_local_storage/globals.js

@@ -7,7 +7,7 @@ const setGlobalAsyncLocalStorageInstance = (instance) => {
 const getGlobalAsyncLocalStorageInstance = () => {
 	return globalThis[TRACING_ALS_KEY];
 };
-
 //#endregion
 export { _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance };
+
 //# sourceMappingURL=globals.js.map

package/dist/singletons/async_local_storage/globals.js.map

@@ -1 +1 @@
-{"version":3,"file":"globals.js","names":["instance: AsyncLocalStorageInterface"],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,iCAAiC;AAE3E,MAAa,yBAAyB,OAAO,IAAI,uBAAuB;AAExE,MAAa,qCAAqC,CAChDA,aACG;CACF,WAAmB,mBAAmB;AACxC;AAED,MAAa,qCAAqC,MAEjC;AACf,QAAQ,WAAmB;AAC5B"}
+{"version":3,"file":"globals.js","names":[],"sources":["../../../src/singletons/async_local_storage/globals.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nexport interface AsyncLocalStorageInterface {\n  getStore: () => any | undefined;\n\n  run: <T>(store: any, callback: () => T) => T;\n\n  enterWith: (store: any) => void;\n}\n\nexport const TRACING_ALS_KEY = Symbol.for(\"ls:tracing_async_local_storage\");\n\nexport const _CONTEXT_VARIABLES_KEY = Symbol.for(\"lc:context_variables\");\n\nexport const setGlobalAsyncLocalStorageInstance = (\n  instance: AsyncLocalStorageInterface\n) => {\n  (globalThis as any)[TRACING_ALS_KEY] = instance;\n};\n\nexport const getGlobalAsyncLocalStorageInstance = ():\n  | AsyncLocalStorageInterface\n  | undefined => {\n  return (globalThis as any)[TRACING_ALS_KEY];\n};\n"],"mappings":";AASA,MAAa,kBAAkB,OAAO,IAAI,iCAAiC;AAE3E,MAAa,yBAAyB,OAAO,IAAI,uBAAuB;AAExE,MAAa,sCACX,aACG;AACF,YAAmB,mBAAmB;;AAGzC,MAAa,2CAEI;AACf,QAAQ,WAAmB"}

package/dist/singletons/async_local_storage/index.cjs

@@ -1,19 +1,14 @@
-const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
-const require_globals = require('./globals.cjs');
-const require_callbacks_manager = require('../../callbacks/manager.cjs');
-const langsmith = require_rolldown_runtime.__toESM(require("langsmith"));
-
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_globals = require("./globals.cjs");
+const require_callbacks_manager = require("../../callbacks/manager.cjs");
+let langsmith = require("langsmith");
 //#region src/singletons/async_local_storage/index.ts
 var MockAsyncLocalStorage = class {
-	getStore() {
-		return void 0;
-	}
+	getStore() {}
 	run(_store, callback) {
 		return callback();
 	}
-	enterWith(_store) {
-		return void 0;
-	}
+	enterWith(_store) {}
 };
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 const LC_CHILD_KEY = Symbol.for("lc:child_config");
@@ -22,8 +17,7 @@ var AsyncLocalStorageProvider = class {
 		return require_globals.getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;
 	}
 	getRunnableConfig() {
-		const storage = this.getInstance();
-		return storage.getStore()?.extra?.[LC_CHILD_KEY];
+		return this.getInstance().getStore()?.extra?.[LC_CHILD_KEY];
 	}
 	runWithConfig(config, callback, avoidCreatingRootRunTree) {
 		const callbackManager = require_callbacks_manager.CallbackManager._configureSync(config?.callbacks, void 0, config?.tags, void 0, config?.metadata);
@@ -52,8 +46,8 @@ var AsyncLocalStorageProvider = class {
 	}
 };
 const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
-
 //#endregion
 exports.AsyncLocalStorageProviderSingleton = AsyncLocalStorageProviderSingleton;
 exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
+
 //# sourceMappingURL=index.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["_store: any","callback: () => T","getGlobalAsyncLocalStorageInstance","config: any","avoidCreatingRootRunTree?: boolean","CallbackManager","RunTree","_CONTEXT_VARIABLES_KEY","instance: AsyncLocalStorageInterface","setGlobalAsyncLocalStorageInstance"],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;AACd,SAAO;CACR;CAED,IAAOA,QAAaC,UAAsB;AACxC,SAAO,UAAU;CAClB;CAED,UAAUD,QAAa;AACrB,SAAO;CACR;AACF;AAED,MAAM,wBAAwB,IAAI;AAElC,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAOE,oDAAoC,IAAI;CAChD;CAED,oBAAoB;EAClB,MAAM,UAAU,KAAK,aAAa;AAIlC,SAAO,QAAQ,UAAU,EAAE,QAAQ;CACpC;CAED,cACEC,QACAF,UACAG,0BACG;EACH,MAAM,kBAAkBC,0CAAgB,eACtC,QAAQ,WACR,QACA,QAAQ,MACR,QACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,KACjD,CAAC,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,aACrB,UAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,0BACV,UAAU,IAAIC,kBAAQ;GACpB,MAAM;GACN,gBAAgB;EACjB;AAGH,MAAI,SACF,QAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;EAAQ;AAG9D,MACE,kBAAkB,UAClB,cAAcC,4CAA4B,QAC1C;AACA,OAAI,YAAY,QACd,UAAU,CAAE;GAEb,QAAgBA,0CACf,cAAcA;EACjB;AAED,SAAO,QAAQ,IAAI,SAAS,SAAS;CACtC;CAED,yBAAyBC,UAAsC;AAC7D,MAAIN,oDAAoC,KAAK,QAC3CO,mDAAmC,SAAS;CAE/C;AACF;AAED,MAAM,qCAAqC,IAAI"}
+{"version":3,"file":"index.cjs","names":["getGlobalAsyncLocalStorageInstance","CallbackManager","RunTree","_CONTEXT_VARIABLES_KEY"],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;CAIhB,IAAO,QAAa,UAAsB;AACxC,SAAO,UAAU;;CAGnB,UAAU,QAAa;;AAKzB,MAAM,wBAAwB,IAAI,uBAAuB;AAEzD,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAOA,gBAAAA,oCAAoC,IAAI;;CAGjD,oBAAoB;AAKlB,SAJgB,KAAK,aAIP,CAAC,UAAU,EAAE,QAAQ;;CAGrC,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkBC,0BAAAA,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,YACrB,WAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,yBACV,WAAU,IAAIC,UAAAA,QAAQ;GACpB,MAAM;GACN,gBAAgB;GACjB,CAAC;AAGJ,MAAI,QACF,SAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;GAAQ;AAG9D,MACE,kBAAkB,KAAA,KAClB,cAAcC,gBAAAA,4BAA4B,KAAA,GAC1C;AACA,OAAI,YAAY,KAAA,EACd,WAAU,EAAE;AAEb,WAAgBA,gBAAAA,0BACf,cAAcA,gBAAAA;;AAGlB,SAAO,QAAQ,IAAI,SAAS,SAAS;;CAGvC,yBAAyB,UAAsC;AAC7D,MAAIH,gBAAAA,oCAAoC,KAAK,KAAA,EAC3C,iBAAA,mCAAmC,SAAS;;;AAKlD,MAAM,qCAAqC,IAAI,2BAA2B"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["AsyncLocalStorageInterface","MockAsyncLocalStorage","T","AsyncLocalStorageProvider","AsyncLocalStorageProviderSingleton"],"sources":["../../../src/singletons/async_local_storage/index.d.ts"],"sourcesContent":["import { AsyncLocalStorageInterface } from \"./globals.js\";\nexport declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n    getStore(): any;\n    run<T>(_store: any, callback: () => T): T;\n    enterWith(_store: any): undefined;\n}\ndeclare class AsyncLocalStorageProvider {\n    getInstance(): AsyncLocalStorageInterface;\n    getRunnableConfig(): any;\n    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;\n    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;\n}\ndeclare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;cACqBC,qBAAAA,YAAiCD;;EAAjCC,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAqB,EAAAC,GAAAA,GAEFA,CAFE,CAAA,EAEEA,CAFF;EAEFA,SAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,SAAAA;;cAG1BC,yBAAAA,CALwCH;EAA0B,WAAA,CAAA,CAAA,EAM7DA,0BAN6D;EAKlEG,iBAAAA,CAAAA,CAAAA,EAAAA,GAAAA;EACKH,aAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAE+BE,CAF/BF,EAAAA,wBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAEuEE,CAFvEF;EAE+BE,wBAAAA,CAAAA,QAAAA,EACXF,0BADWE,CAAAA,EAAAA,IAAAA;;cAGpCE,kCAFyBJ,EAEWG,yBAFXH"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"mappings":";;;cAWa,qBAAA,YAAiC,0BAAA;EAC5C,QAAA,CAAA;EAIA,GAAA,GAAA,CAAO,MAAA,OAAa,QAAA,QAAgB,CAAA,GAAI,CAAA;EAIxC,SAAA,CAAU,MAAA;AAAA;AAAA,cASN,yBAAA;EACJ,WAAA,CAAA,GAAe,0BAAA;EAIf,iBAAA,CAAA;EAQA,aAAA,GAAA,CACE,MAAA,OACA,QAAA,QAAgB,CAAA,EAChB,wBAAA,aACC,CAAA;EA4CH,wBAAA,CAAyB,QAAA,EAAU,0BAAA;AAAA;AAAA,cAO/B,kCAAA,EAAkC,yBAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["AsyncLocalStorageInterface","MockAsyncLocalStorage","T","AsyncLocalStorageProvider","AsyncLocalStorageProviderSingleton"],"sources":["../../../src/singletons/async_local_storage/index.d.ts"],"sourcesContent":["import { AsyncLocalStorageInterface } from \"./globals.js\";\nexport declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n    getStore(): any;\n    run<T>(_store: any, callback: () => T): T;\n    enterWith(_store: any): undefined;\n}\ndeclare class AsyncLocalStorageProvider {\n    getInstance(): AsyncLocalStorageInterface;\n    getRunnableConfig(): any;\n    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;\n    initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;\n}\ndeclare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;cACqBC,qBAAAA,YAAiCD;;EAAjCC,GAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAqB,EAAAC,GAAAA,GAEFA,CAFE,CAAA,EAEEA,CAFF;EAEFA,SAAAA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA,EAAAA,SAAAA;;cAG1BC,yBAAAA,CALwCH;EAA0B,WAAA,CAAA,CAAA,EAM7DA,0BAN6D;EAKlEG,iBAAAA,CAAAA,CAAAA,EAAAA,GAAAA;EACKH,aAAAA,CAAAA,CAAAA,CAAAA,CAAAA,MAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAE+BE,CAF/BF,EAAAA,wBAAAA,CAAAA,EAAAA,OAAAA,CAAAA,EAEuEE,CAFvEF;EAE+BE,wBAAAA,CAAAA,QAAAA,EACXF,0BADWE,CAAAA,EAAAA,IAAAA;;cAGpCE,kCAFyBJ,EAEWG,yBAFXH"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"mappings":";;;cAWa,qBAAA,YAAiC,0BAAA;EAC5C,QAAA,CAAA;EAIA,GAAA,GAAA,CAAO,MAAA,OAAa,QAAA,QAAgB,CAAA,GAAI,CAAA;EAIxC,SAAA,CAAU,MAAA;AAAA;AAAA,cASN,yBAAA;EACJ,WAAA,CAAA,GAAe,0BAAA;EAIf,iBAAA,CAAA;EAQA,aAAA,GAAA,CACE,MAAA,OACA,QAAA,QAAgB,CAAA,EAChB,wBAAA,aACC,CAAA;EA4CH,wBAAA,CAAyB,QAAA,EAAU,0BAAA;AAAA;AAAA,cAO/B,kCAAA,EAAkC,yBAAA"}

package/dist/singletons/async_local_storage/index.js

@@ -1,18 +1,13 @@
 import { _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance, setGlobalAsyncLocalStorageInstance } from "./globals.js";
 import { CallbackManager } from "../../callbacks/manager.js";
 import { RunTree } from "langsmith";
-
 //#region src/singletons/async_local_storage/index.ts
 var MockAsyncLocalStorage = class {
-	getStore() {
-		return void 0;
-	}
+	getStore() {}
 	run(_store, callback) {
 		return callback();
 	}
-	enterWith(_store) {
-		return void 0;
-	}
+	enterWith(_store) {}
 };
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 const LC_CHILD_KEY = Symbol.for("lc:child_config");
@@ -21,8 +16,7 @@ var AsyncLocalStorageProvider = class {
 		return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;
 	}
 	getRunnableConfig() {
-		const storage = this.getInstance();
-		return storage.getStore()?.extra?.[LC_CHILD_KEY];
+		return this.getInstance().getStore()?.extra?.[LC_CHILD_KEY];
 	}
 	runWithConfig(config, callback, avoidCreatingRootRunTree) {
 		const callbackManager = CallbackManager._configureSync(config?.callbacks, void 0, config?.tags, void 0, config?.metadata);
@@ -51,7 +45,7 @@ var AsyncLocalStorageProvider = class {
 	}
 };
 const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
-
 //#endregion
 export { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage };
+
 //# sourceMappingURL=index.js.map

package/dist/singletons/async_local_storage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_store: any","callback: () => T","config: any","avoidCreatingRootRunTree?: boolean","instance: AsyncLocalStorageInterface"],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;AACd,SAAO;CACR;CAED,IAAOA,QAAaC,UAAsB;AACxC,SAAO,UAAU;CAClB;CAED,UAAUD,QAAa;AACrB,SAAO;CACR;AACF;AAED,MAAM,wBAAwB,IAAI;AAElC,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAO,oCAAoC,IAAI;CAChD;CAED,oBAAoB;EAClB,MAAM,UAAU,KAAK,aAAa;AAIlC,SAAO,QAAQ,UAAU,EAAE,QAAQ;CACpC;CAED,cACEE,QACAD,UACAE,0BACG;EACH,MAAM,kBAAkB,gBAAgB,eACtC,QAAQ,WACR,QACA,QAAQ,MACR,QACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,KACjD,CAAC,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,aACrB,UAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,0BACV,UAAU,IAAI,QAAQ;GACpB,MAAM;GACN,gBAAgB;EACjB;AAGH,MAAI,SACF,QAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;EAAQ;AAG9D,MACE,kBAAkB,UAClB,cAAc,4BAA4B,QAC1C;AACA,OAAI,YAAY,QACd,UAAU,CAAE;GAEb,QAAgB,0BACf,cAAc;EACjB;AAED,SAAO,QAAQ,IAAI,SAAS,SAAS;CACtC;CAED,yBAAyBC,UAAsC;AAC7D,MAAI,oCAAoC,KAAK,QAC3C,mCAAmC,SAAS;CAE/C;AACF;AAED,MAAM,qCAAqC,IAAI"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/singletons/async_local_storage/index.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\nimport { RunTree } from \"langsmith\";\nimport {\n  AsyncLocalStorageInterface,\n  getGlobalAsyncLocalStorageInstance,\n  setGlobalAsyncLocalStorageInstance,\n  _CONTEXT_VARIABLES_KEY,\n} from \"./globals.js\";\nimport { CallbackManager } from \"../../callbacks/manager.js\";\nimport { LangChainTracer } from \"../../tracers/tracer_langchain.js\";\n\nexport class MockAsyncLocalStorage implements AsyncLocalStorageInterface {\n  getStore(): any {\n    return undefined;\n  }\n\n  run<T>(_store: any, callback: () => T): T {\n    return callback();\n  }\n\n  enterWith(_store: any) {\n    return undefined;\n  }\n}\n\nconst mockAsyncLocalStorage = new MockAsyncLocalStorage();\n\nconst LC_CHILD_KEY = Symbol.for(\"lc:child_config\");\n\nclass AsyncLocalStorageProvider {\n  getInstance(): AsyncLocalStorageInterface {\n    return getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;\n  }\n\n  getRunnableConfig() {\n    const storage = this.getInstance();\n    // this has the runnable config\n    // which means that we should also have an instance of a LangChainTracer\n    // with the run map prepopulated\n    return storage.getStore()?.extra?.[LC_CHILD_KEY];\n  }\n\n  runWithConfig<T>(\n    config: any,\n    callback: () => T,\n    avoidCreatingRootRunTree?: boolean\n  ): T {\n    const callbackManager = CallbackManager._configureSync(\n      config?.callbacks,\n      undefined,\n      config?.tags,\n      undefined,\n      config?.metadata\n    );\n    const storage = this.getInstance();\n    const previousValue = storage.getStore();\n    const parentRunId = callbackManager?.getParentRunId();\n\n    const langChainTracer = callbackManager?.handlers?.find(\n      (handler) => handler?.name === \"langchain_tracer\"\n    ) as LangChainTracer | undefined;\n\n    let runTree;\n    if (langChainTracer && parentRunId) {\n      runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);\n    } else if (!avoidCreatingRootRunTree) {\n      runTree = new RunTree({\n        name: \"<runnable_lambda>\",\n        tracingEnabled: false,\n      });\n    }\n\n    if (runTree) {\n      runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };\n    }\n\n    if (\n      previousValue !== undefined &&\n      previousValue[_CONTEXT_VARIABLES_KEY] !== undefined\n    ) {\n      if (runTree === undefined) {\n        runTree = {};\n      }\n      (runTree as any)[_CONTEXT_VARIABLES_KEY] =\n        previousValue[_CONTEXT_VARIABLES_KEY];\n    }\n\n    return storage.run(runTree, callback);\n  }\n\n  initializeGlobalInstance(instance: AsyncLocalStorageInterface) {\n    if (getGlobalAsyncLocalStorageInstance() === undefined) {\n      setGlobalAsyncLocalStorageInstance(instance);\n    }\n  }\n}\n\nconst AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();\n\nexport { AsyncLocalStorageProviderSingleton, type AsyncLocalStorageInterface };\n"],"mappings":";;;;AAWA,IAAa,wBAAb,MAAyE;CACvE,WAAgB;CAIhB,IAAO,QAAa,UAAsB;AACxC,SAAO,UAAU;;CAGnB,UAAU,QAAa;;AAKzB,MAAM,wBAAwB,IAAI,uBAAuB;AAEzD,MAAM,eAAe,OAAO,IAAI,kBAAkB;AAElD,IAAM,4BAAN,MAAgC;CAC9B,cAA0C;AACxC,SAAO,oCAAoC,IAAI;;CAGjD,oBAAoB;AAKlB,SAJgB,KAAK,aAIP,CAAC,UAAU,EAAE,QAAQ;;CAGrC,cACE,QACA,UACA,0BACG;EACH,MAAM,kBAAkB,gBAAgB,eACtC,QAAQ,WACR,KAAA,GACA,QAAQ,MACR,KAAA,GACA,QAAQ,SACT;EACD,MAAM,UAAU,KAAK,aAAa;EAClC,MAAM,gBAAgB,QAAQ,UAAU;EACxC,MAAM,cAAc,iBAAiB,gBAAgB;EAErD,MAAM,kBAAkB,iBAAiB,UAAU,MAChD,YAAY,SAAS,SAAS,mBAChC;EAED,IAAI;AACJ,MAAI,mBAAmB,YACrB,WAAU,gBAAgB,4BAA4B,YAAY;WACzD,CAAC,yBACV,WAAU,IAAI,QAAQ;GACpB,MAAM;GACN,gBAAgB;GACjB,CAAC;AAGJ,MAAI,QACF,SAAQ,QAAQ;GAAE,GAAG,QAAQ;IAAQ,eAAe;GAAQ;AAG9D,MACE,kBAAkB,KAAA,KAClB,cAAc,4BAA4B,KAAA,GAC1C;AACA,OAAI,YAAY,KAAA,EACd,WAAU,EAAE;AAEb,WAAgB,0BACf,cAAc;;AAGlB,SAAO,QAAQ,IAAI,SAAS,SAAS;;CAGvC,yBAAyB,UAAsC;AAC7D,MAAI,oCAAoC,KAAK,KAAA,EAC3C,oCAAmC,SAAS;;;AAKlD,MAAM,qCAAqC,IAAI,2BAA2B"}

package/dist/singletons/callbacks.cjs

@@ -1,8 +1,8 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_tracer = require('./tracer.cjs');
-const require_globals = require('./async_local_storage/globals.cjs');
-const p_queue = require_rolldown_runtime.__toESM(require("p-queue"));
-
+const require_runtime = require("../_virtual/_rolldown/runtime.cjs");
+const require_tracer = require("./tracer.cjs");
+const require_globals = require("./async_local_storage/globals.cjs");
+let p_queue = require("p-queue");
+p_queue = require_runtime.__toESM(p_queue, 1);
 //#region src/singletons/callbacks.ts
 let queue;
 /**
@@ -11,8 +11,7 @@ let queue;
 * one at a time.
 */
 function createQueue() {
-	const PQueue = "default" in p_queue.default ? p_queue.default.default : p_queue.default;
-	return new PQueue({
+	return new ("default" in p_queue.default ? p_queue.default.default : p_queue.default)({
 		autoStart: true,
 		concurrency: 1
 	});
@@ -48,8 +47,8 @@ async function awaitAllCallbacks() {
 	const defaultClient = require_tracer.getDefaultLangChainClientSingleton();
 	await Promise.allSettled([typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(), defaultClient.awaitPendingTraceBatches()]);
 }
-
 //#endregion
 exports.awaitAllCallbacks = awaitAllCallbacks;
 exports.consumeCallback = consumeCallback;
+
 //# sourceMappingURL=callbacks.cjs.map

package/dist/singletons/callbacks.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.cjs","names":["queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"]","PQueue: any","PQueueMod","promiseFn: () => Promise<T> | T | void","wait: boolean","getGlobalAsyncLocalStorageInstance","getDefaultLangChainClientSingleton"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // eslint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;;;AAMA,IAAIA;;;;;;AAOJ,SAAS,cAAc;CACrB,MAAMC,SAAc,aAAaC,kBAAYA,gBAAU,UAAUA;AACjE,QAAO,IAAI,OAAO;EAChB,WAAW;EACX,aAAa;CACd;AACF;AAED,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,aACnB,QAAQ,aAAa;AAEvB,QAAO;AACR;;;;;;AAOD,eAAsB,gBACpBC,WACAC,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4BC,oDAAoC;AACtE,MAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;OAEvE,MAAM,WAAW;CAEpB,OAAM;EACL,QAAQ,UAAU;EAEb,MAAM,IAAI,YAAY;GACzB,MAAM,4BAA4BA,oDAAoC;AACtE,OAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;QAEvE,MAAM,WAAW;EAEpB,EAAC;CACH;AACF;;;;;AAMD,eAAsB,oBAAmC;CACvD,MAAM,gBAAgBC,mDAAoC;CAC1D,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,AACzC,EAAC;AACH"}
+{"version":3,"file":"callbacks.cjs","names":["PQueueMod","getGlobalAsyncLocalStorageInstance","getDefaultLangChainClientSingleton"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: (typeof import(\"p-queue\"))[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // oxlint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;;;AAMA,IAAI;;;;;;AAOJ,SAAS,cAAc;AAErB,QAAO,KADa,aAAaA,QAAAA,UAAYA,QAAAA,QAAU,UAAUA,QAAAA,SAC/C;EAChB,WAAW;EACX,aAAa;EACd,CAAC;;AAGJ,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,YACnB,SAAQ,aAAa;AAEvB,QAAO;;;;;;;AAQT,eAAsB,gBACpB,WACA,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4BC,gBAAAA,oCAAoC;AACtE,MAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;MAEvE,OAAM,WAAW;QAEd;AACL,UAAQ,UAAU;AAEb,QAAM,IAAI,YAAY;GACzB,MAAM,4BAA4BA,gBAAAA,oCAAoC;AACtE,OAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;OAEvE,OAAM,WAAW;IAEnB;;;;;;;AAQN,eAAsB,oBAAmC;CACvD,MAAM,gBAAgBC,eAAAA,oCAAoC;AAC1D,OAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,CACzC,CAAC"}

package/dist/singletons/callbacks.d.cts

@@ -1,5 +1,4 @@
 //#region src/singletons/callbacks.d.ts
-
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
  * @param promiseFn Promise to consume

package/dist/singletons/callbacks.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.d.cts","names":["PQueueMod","getQueue","consumeCallback","T","Promise","awaitAllCallbacks"],"sources":["../../src/singletons/callbacks.d.ts"],"sourcesContent":["import PQueueMod from \"p-queue\";\nexport declare function getQueue(): PQueueMod<any, any>;\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport declare function awaitAllCallbacks(): Promise<void>;\n//# sourceMappingURL=callbacks.d.ts.map"],"mappings":";;;;;;AAO0G;AAKlFK,iBALAH,eAKqBE,CAAAA,CAAAA,CAAAA,CAAAA,SAAO,EAAA,GAAA,GALQA,OAKR,CALgBD,CAKhB,CAAA,GALqBA,CAKrB,GAAA,IAAA,EAAA,IAAA,EAAA,OAAA,CAAA,EAL+CC,OAK/C,CAAA,IAAA,CAAA;;;;;iBAA5BC,iBAAAA,CAAAA,GAAqBD"}
+{"version":3,"file":"callbacks.d.cts","names":[],"sources":["../../src/singletons/callbacks.ts"],"mappings":";;AAiCA;;;;iBAAsB,eAAA,GAAA,CACpB,SAAA,QAAiB,OAAA,CAAQ,CAAA,IAAK,CAAA,SAC9B,IAAA,YACC,OAAA;;;;;iBA4BmB,iBAAA,CAAA,GAAqB,OAAA"}

package/dist/singletons/callbacks.d.ts

@@ -1,7 +1,6 @@
 import PQueueMod from "p-queue";
 
 //#region src/singletons/callbacks.d.ts
-
 /**
  * Consume a promise, either adding it to the queue or waiting for it to resolve
  * @param promiseFn Promise to consume

package/dist/singletons/callbacks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.d.ts","names":["PQueueMod","getQueue","consumeCallback","T","Promise","awaitAllCallbacks"],"sources":["../../src/singletons/callbacks.d.ts"],"sourcesContent":["import PQueueMod from \"p-queue\";\nexport declare function getQueue(): PQueueMod<any, any>;\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport declare function awaitAllCallbacks(): Promise<void>;\n//# sourceMappingURL=callbacks.d.ts.map"],"mappings":";;;;;AAOA;;;;AAAmGI,iBAA3EF,eAA2EE,CAAAA,CAAAA,CAAAA,CAAAA,SAAAA,EAAAA,GAAAA,GAAvCA,OAAuCA,CAA/BD,CAA+BC,CAAAA,GAA1BD,CAA0BC,GAAAA,IAAAA,EAAAA,IAAAA,EAAAA,OAAAA,CAAAA,EAAAA,OAAAA,CAAAA,IAAAA,CAAAA;AAAO;AAK1G;;;iBAAwBC,iBAAAA,CAAAA,GAAqBD"}
+{"version":3,"file":"callbacks.d.ts","names":[],"sources":["../../src/singletons/callbacks.ts"],"mappings":";;;;AAiCA;;;;iBAAsB,eAAA,GAAA,CACpB,SAAA,QAAiB,OAAA,CAAQ,CAAA,IAAK,CAAA,SAC9B,IAAA,YACC,OAAA;;;;;iBA4BmB,iBAAA,CAAA,GAAqB,OAAA"}

package/dist/singletons/callbacks.js

@@ -1,7 +1,6 @@
 import { getDefaultLangChainClientSingleton } from "./tracer.js";
 import { getGlobalAsyncLocalStorageInstance } from "./async_local_storage/globals.js";
 import PQueueMod from "p-queue";
-
 //#region src/singletons/callbacks.ts
 let queue;
 /**
@@ -10,8 +9,7 @@ let queue;
 * one at a time.
 */
 function createQueue() {
-	const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
-	return new PQueue({
+	return new ("default" in PQueueMod ? PQueueMod.default : PQueueMod)({
 		autoStart: true,
 		concurrency: 1
 	});
@@ -47,7 +45,7 @@ async function awaitAllCallbacks() {
 	const defaultClient = getDefaultLangChainClientSingleton();
 	await Promise.allSettled([typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(), defaultClient.awaitPendingTraceBatches()]);
 }
-
 //#endregion
 export { awaitAllCallbacks, consumeCallback };
+
 //# sourceMappingURL=callbacks.js.map

package/dist/singletons/callbacks.js.map

@@ -1 +1 @@
-{"version":3,"file":"callbacks.js","names":["queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"]","PQueue: any","promiseFn: () => Promise<T> | T | void","wait: boolean"],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: typeof import(\"p-queue\")[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // eslint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;;AAMA,IAAIA;;;;;;AAOJ,SAAS,cAAc;CACrB,MAAMC,SAAc,aAAa,YAAY,UAAU,UAAU;AACjE,QAAO,IAAI,OAAO;EAChB,WAAW;EACX,aAAa;CACd;AACF;AAED,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,aACnB,QAAQ,aAAa;AAEvB,QAAO;AACR;;;;;;AAOD,eAAsB,gBACpBC,WACAC,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4B,oCAAoC;AACtE,MAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;OAEvE,MAAM,WAAW;CAEpB,OAAM;EACL,QAAQ,UAAU;EAEb,MAAM,IAAI,YAAY;GACzB,MAAM,4BAA4B,oCAAoC;AACtE,OAAI,8BAA8B,QAChC,MAAM,0BAA0B,IAAI,QAAW,YAAY,WAAW,CAAC;QAEvE,MAAM,WAAW;EAEpB,EAAC;CACH;AACF;;;;;AAMD,eAAsB,oBAAmC;CACvD,MAAM,gBAAgB,oCAAoC;CAC1D,MAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,AACzC,EAAC;AACH"}
+{"version":3,"file":"callbacks.js","names":[],"sources":["../../src/singletons/callbacks.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nimport PQueueMod from \"p-queue\";\nimport { getGlobalAsyncLocalStorageInstance } from \"./async_local_storage/globals.js\";\nimport { getDefaultLangChainClientSingleton } from \"./tracer.js\";\n\nlet queue: (typeof import(\"p-queue\"))[\"default\"][\"prototype\"];\n\n/**\n * Creates a queue using the p-queue library. The queue is configured to\n * auto-start and has a concurrency of 1, meaning it will process tasks\n * one at a time.\n */\nfunction createQueue() {\n  const PQueue: any = \"default\" in PQueueMod ? PQueueMod.default : PQueueMod;\n  return new PQueue({\n    autoStart: true,\n    concurrency: 1,\n  });\n}\n\nexport function getQueue() {\n  if (typeof queue === \"undefined\") {\n    queue = createQueue();\n  }\n  return queue;\n}\n\n/**\n * Consume a promise, either adding it to the queue or waiting for it to resolve\n * @param promiseFn Promise to consume\n * @param wait Whether to wait for the promise to resolve or resolve immediately\n */\nexport async function consumeCallback<T>(\n  promiseFn: () => Promise<T> | T | void,\n  wait: boolean\n): Promise<void> {\n  if (wait === true) {\n    // Clear config since callbacks are not part of the root run\n    // Avoid using global singleton due to circuluar dependency issues\n    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n    if (asyncLocalStorageInstance !== undefined) {\n      await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n    } else {\n      await promiseFn();\n    }\n  } else {\n    queue = getQueue();\n    // oxlint-disable-next-line no-void\n    void queue.add(async () => {\n      const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n      if (asyncLocalStorageInstance !== undefined) {\n        await asyncLocalStorageInstance.run(undefined, async () => promiseFn());\n      } else {\n        await promiseFn();\n      }\n    });\n  }\n}\n\n/**\n * Waits for all promises in the queue to resolve. If the queue is\n * undefined, it immediately resolves a promise.\n */\nexport async function awaitAllCallbacks(): Promise<void> {\n  const defaultClient = getDefaultLangChainClientSingleton();\n  await Promise.allSettled([\n    typeof queue !== \"undefined\" ? queue.onIdle() : Promise.resolve(),\n    defaultClient.awaitPendingTraceBatches(),\n  ]);\n}\n"],"mappings":";;;;AAMA,IAAI;;;;;;AAOJ,SAAS,cAAc;AAErB,QAAO,KADa,aAAa,YAAY,UAAU,UAAU,WAC/C;EAChB,WAAW;EACX,aAAa;EACd,CAAC;;AAGJ,SAAgB,WAAW;AACzB,KAAI,OAAO,UAAU,YACnB,SAAQ,aAAa;AAEvB,QAAO;;;;;;;AAQT,eAAsB,gBACpB,WACA,MACe;AACf,KAAI,SAAS,MAAM;EAGjB,MAAM,4BAA4B,oCAAoC;AACtE,MAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;MAEvE,OAAM,WAAW;QAEd;AACL,UAAQ,UAAU;AAEb,QAAM,IAAI,YAAY;GACzB,MAAM,4BAA4B,oCAAoC;AACtE,OAAI,8BAA8B,KAAA,EAChC,OAAM,0BAA0B,IAAI,KAAA,GAAW,YAAY,WAAW,CAAC;OAEvE,OAAM,WAAW;IAEnB;;;;;;;AAQN,eAAsB,oBAAmC;CACvD,MAAM,gBAAgB,oCAAoC;AAC1D,OAAM,QAAQ,WAAW,CACvB,OAAO,UAAU,cAAc,MAAM,QAAQ,GAAG,QAAQ,SAAS,EACjE,cAAc,0BAA0B,CACzC,CAAC"}