@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/singletons/async_local_storage/context.js

@@ -1,182 +1,175 @@
-import { isRunTree, RunTree } from "langsmith/run_trees";
-import { _CONTEXT_VARIABLES_KEY, getGlobalAsyncLocalStorageInstance, } from "./globals.js";
+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
- * child runnables called by the current runnable, or globally if set outside
- * of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
- *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- * @param value The value to set.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function setContextVariable(name, value) {
-    // Avoid using global singleton due to circuluar dependency issues
-    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
-    if (asyncLocalStorageInstance === undefined) {
-        throw new Error(`Internal error: Global shared async local storage instance has not been initialized.`);
-    }
-    const runTree = asyncLocalStorageInstance.getStore();
-    const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };
-    contextVars[name] = value;
-    let newValue = {};
-    if (isRunTree(runTree)) {
-        newValue = new RunTree(runTree);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    newValue[_CONTEXT_VARIABLES_KEY] = contextVars;
-    asyncLocalStorageInstance.enterWith(newValue);
+* Set a context variable. Context variables are scoped to any
+* child runnables called by the current runnable, or globally if set outside
+* of any runnable.
+*
+* @remarks
+* This function is only supported in environments that support AsyncLocalStorage,
+* including Node.js, Deno, and Cloudflare Workers.
+*
+* @example
+* ```ts
+* import { RunnableLambda } from "@langchain/core/runnables";
+* import {
+*   getContextVariable,
+*   setContextVariable
+* } from "@langchain/core/context";
+*
+* const nested = RunnableLambda.from(() => {
+*   // "bar" because it was set by a parent
+*   console.log(getContextVariable("foo"));
+*
+*   // Override to "baz", but only for child runnables
+*   setContextVariable("foo", "baz");
+*
+*   // Now "baz", but only for child runnables
+*   return getContextVariable("foo");
+* });
+*
+* const runnable = RunnableLambda.from(async () => {
+*   // Set a context variable named "foo"
+*   setContextVariable("foo", "bar");
+*
+*   const res = await nested.invoke({});
+*
+*   // Still "bar" since child changes do not affect parents
+*   console.log(getContextVariable("foo"));
+*
+*   return res;
+* });
+*
+* // undefined, because context variable has not been set yet
+* console.log(getContextVariable("foo"));
+*
+* // Final return value is "baz"
+* const result = await runnable.invoke({});
+* ```
+*
+* @param name The name of the context variable.
+* @param value The value to set.
+*/
+function setContextVariable(name, value) {
+	const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
+	if (asyncLocalStorageInstance === void 0) throw new Error(`Internal error: Global shared async local storage instance has not been initialized.`);
+	const runTree = asyncLocalStorageInstance.getStore();
+	const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };
+	contextVars[name] = value;
+	let newValue = {};
+	if (isRunTree(runTree)) newValue = new RunTree(runTree);
+	newValue[_CONTEXT_VARIABLES_KEY] = contextVars;
+	asyncLocalStorageInstance.enterWith(newValue);
 }
 /**
- * Get the value of a previously set context variable. Context variables
- * are scoped to any child runnables called by the current runnable,
- * or globally if set outside of any runnable.
- *
- * @remarks
- * This function is only supported in environments that support AsyncLocalStorage,
- * including Node.js, Deno, and Cloudflare Workers.
- *
- * @example
- * ```ts
- * import { RunnableLambda } from "@langchain/core/runnables";
- * import {
- *   getContextVariable,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const nested = RunnableLambda.from(() => {
- *   // "bar" because it was set by a parent
- *   console.log(getContextVariable("foo"));
- *
- *   // Override to "baz", but only for child runnables
- *   setContextVariable("foo", "baz");
- *
- *   // Now "baz", but only for child runnables
- *   return getContextVariable("foo");
- * });
- *
- * const runnable = RunnableLambda.from(async () => {
- *   // Set a context variable named "foo"
- *   setContextVariable("foo", "bar");
- *
- *   const res = await nested.invoke({});
- *
- *   // Still "bar" since child changes do not affect parents
- *   console.log(getContextVariable("foo"));
- *
- *   return res;
- * });
- *
- * // undefined, because context variable has not been set yet
- * console.log(getContextVariable("foo"));
- *
- * // Final return value is "baz"
- * const result = await runnable.invoke({});
- * ```
- *
- * @param name The name of the context variable.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function getContextVariable(name) {
-    // Avoid using global singleton due to circuluar dependency issues
-    const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
-    if (asyncLocalStorageInstance === undefined) {
-        return undefined;
-    }
-    const runTree = asyncLocalStorageInstance.getStore();
-    return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
+* Get the value of a previously set context variable. Context variables
+* are scoped to any child runnables called by the current runnable,
+* or globally if set outside of any runnable.
+*
+* @remarks
+* This function is only supported in environments that support AsyncLocalStorage,
+* including Node.js, Deno, and Cloudflare Workers.
+*
+* @example
+* ```ts
+* import { RunnableLambda } from "@langchain/core/runnables";
+* import {
+*   getContextVariable,
+*   setContextVariable
+* } from "@langchain/core/context";
+*
+* const nested = RunnableLambda.from(() => {
+*   // "bar" because it was set by a parent
+*   console.log(getContextVariable("foo"));
+*
+*   // Override to "baz", but only for child runnables
+*   setContextVariable("foo", "baz");
+*
+*   // Now "baz", but only for child runnables
+*   return getContextVariable("foo");
+* });
+*
+* const runnable = RunnableLambda.from(async () => {
+*   // Set a context variable named "foo"
+*   setContextVariable("foo", "bar");
+*
+*   const res = await nested.invoke({});
+*
+*   // Still "bar" since child changes do not affect parents
+*   console.log(getContextVariable("foo"));
+*
+*   return res;
+* });
+*
+* // undefined, because context variable has not been set yet
+* console.log(getContextVariable("foo"));
+*
+* // Final return value is "baz"
+* const result = await runnable.invoke({});
+* ```
+*
+* @param name The name of the context variable.
+*/
+function getContextVariable(name) {
+	const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();
+	if (asyncLocalStorageInstance === void 0) return void 0;
+	const runTree = asyncLocalStorageInstance.getStore();
+	return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];
 }
 const LC_CONFIGURE_HOOKS_KEY = Symbol("lc:configure_hooks");
-export const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
+const _getConfigureHooks = () => getContextVariable(LC_CONFIGURE_HOOKS_KEY) || [];
 /**
- * Register a callback configure hook to automatically add callback handlers to all runs.
- *
- * There are two ways to use this:
- *
- * 1. Using a context variable:
- *    - Set `contextVar` to specify the variable name
- *    - Use `setContextVariable()` to store your handler instance
- *
- * 2. Using an environment variable:
- *    - Set both `envVar` and `handlerClass`
- *    - The handler will be instantiated when the env var is set to "true".
- *
- * @example
- * ```typescript
- * // Method 1: Using context variable
- * import {
- *   registerConfigureHook,
- *   setContextVariable
- * } from "@langchain/core/context";
- *
- * const tracer = new MyCallbackHandler();
- * registerConfigureHook({
- *   contextVar: "my_tracer",
- * });
- * setContextVariable("my_tracer", tracer);
- *
- * // ...run code here
- *
- * // Method 2: Using environment variable
- * registerConfigureHook({
- *   handlerClass: MyCallbackHandler,
- *   envVar: "MY_TRACER_ENABLED",
- * });
- * process.env.MY_TRACER_ENABLED = "true";
- *
- * // ...run code here
- * ```
- *
- * @param config Configuration object for the hook
- * @param config.contextVar Name of the context variable containing the handler instance
- * @param config.inheritable Whether child runs should inherit this handler
- * @param config.handlerClass Optional callback handler class (required if using envVar)
- * @param config.envVar Optional environment variable name to control handler activation
- */
-export const registerConfigureHook = (config) => {
-    if (config.envVar && !config.handlerClass) {
-        throw new Error("If envVar is set, handlerClass must also be set to a non-None value.");
-    }
-    setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);
+* Register a callback configure hook to automatically add callback handlers to all runs.
+*
+* There are two ways to use this:
+*
+* 1. Using a context variable:
+*    - Set `contextVar` to specify the variable name
+*    - Use `setContextVariable()` to store your handler instance
+*
+* 2. Using an environment variable:
+*    - Set both `envVar` and `handlerClass`
+*    - The handler will be instantiated when the env var is set to "true".
+*
+* @example
+* ```typescript
+* // Method 1: Using context variable
+* import {
+*   registerConfigureHook,
+*   setContextVariable
+* } from "@langchain/core/context";
+*
+* const tracer = new MyCallbackHandler();
+* registerConfigureHook({
+*   contextVar: "my_tracer",
+* });
+* setContextVariable("my_tracer", tracer);
+*
+* // ...run code here
+*
+* // Method 2: Using environment variable
+* registerConfigureHook({
+*   handlerClass: MyCallbackHandler,
+*   envVar: "MY_TRACER_ENABLED",
+* });
+* process.env.MY_TRACER_ENABLED = "true";
+*
+* // ...run code here
+* ```
+*
+* @param config Configuration object for the hook
+* @param config.contextVar Name of the context variable containing the handler instance
+* @param config.inheritable Whether child runs should inherit this handler
+* @param config.handlerClass Optional callback handler class (required if using envVar)
+* @param config.envVar Optional environment variable name to control handler activation
+*/
+const registerConfigureHook = (config) => {
+	if (config.envVar && !config.handlerClass) throw new Error("If envVar is set, handlerClass must also be set to a non-None value.");
+	setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);
 };
+
+//#endregion
+export { _getConfigureHooks, getContextVariable, registerConfigureHook, setContextVariable };
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +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 */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function setContextVariable<T>(name: PropertyKey, value: T): void {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    throw new Error(\n      `Internal error: Global shared async local storage instance has not been initialized.`\n    );\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  const contextVars = { ...runTree?.[_CONTEXT_VARIABLES_KEY] };\n  contextVars[name] = value;\n  let newValue = {};\n  if (isRunTree(runTree)) {\n    newValue = new RunTree(runTree);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (newValue as any)[_CONTEXT_VARIABLES_KEY] = contextVars;\n  asyncLocalStorageInstance.enterWith(newValue);\n}\n\n/**\n * Get the value of a previously set context variable. Context variables\n * are scoped to any child runnables called by the current runnable,\n * or globally if set outside of any runnable.\n *\n * @remarks\n * This function is only supported in environments that support AsyncLocalStorage,\n * including Node.js, Deno, and Cloudflare Workers.\n *\n * @example\n * ```ts\n * import { RunnableLambda } from \"@langchain/core/runnables\";\n * import {\n *   getContextVariable,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const nested = RunnableLambda.from(() => {\n *   // \"bar\" because it was set by a parent\n *   console.log(getContextVariable(\"foo\"));\n *\n *   // Override to \"baz\", but only for child runnables\n *   setContextVariable(\"foo\", \"baz\");\n *\n *   // Now \"baz\", but only for child runnables\n *   return getContextVariable(\"foo\");\n * });\n *\n * const runnable = RunnableLambda.from(async () => {\n *   // Set a context variable named \"foo\"\n *   setContextVariable(\"foo\", \"bar\");\n *\n *   const res = await nested.invoke({});\n *\n *   // Still \"bar\" since child changes do not affect parents\n *   console.log(getContextVariable(\"foo\"));\n *\n *   return res;\n * });\n *\n * // undefined, because context variable has not been set yet\n * console.log(getContextVariable(\"foo\"));\n *\n * // Final return value is \"baz\"\n * const result = await runnable.invoke({});\n * ```\n *\n * @param name The name of the context variable.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getContextVariable<T = any>(name: PropertyKey): T | undefined {\n  // Avoid using global singleton due to circuluar dependency issues\n  const asyncLocalStorageInstance = getGlobalAsyncLocalStorageInstance();\n  if (asyncLocalStorageInstance === undefined) {\n    return undefined;\n  }\n  const runTree = asyncLocalStorageInstance.getStore();\n  return runTree?.[_CONTEXT_VARIABLES_KEY]?.[name];\n}\n\nconst LC_CONFIGURE_HOOKS_KEY = Symbol(\"lc:configure_hooks\");\n\nexport const _getConfigureHooks = () =>\n  getContextVariable<ConfigureHook[]>(LC_CONFIGURE_HOOKS_KEY) || [];\n\n/**\n * Register a callback configure hook to automatically add callback handlers to all runs.\n *\n * There are two ways to use this:\n *\n * 1. Using a context variable:\n *    - Set `contextVar` to specify the variable name\n *    - Use `setContextVariable()` to store your handler instance\n *\n * 2. Using an environment variable:\n *    - Set both `envVar` and `handlerClass`\n *    - The handler will be instantiated when the env var is set to \"true\".\n *\n * @example\n * ```typescript\n * // Method 1: Using context variable\n * import {\n *   registerConfigureHook,\n *   setContextVariable\n * } from \"@langchain/core/context\";\n *\n * const tracer = new MyCallbackHandler();\n * registerConfigureHook({\n *   contextVar: \"my_tracer\",\n * });\n * setContextVariable(\"my_tracer\", tracer);\n *\n * // ...run code here\n *\n * // Method 2: Using environment variable\n * registerConfigureHook({\n *   handlerClass: MyCallbackHandler,\n *   envVar: \"MY_TRACER_ENABLED\",\n * });\n * process.env.MY_TRACER_ENABLED = \"true\";\n *\n * // ...run code here\n * ```\n *\n * @param config Configuration object for the hook\n * @param config.contextVar Name of the context variable containing the handler instance\n * @param config.inheritable Whether child runs should inherit this handler\n * @param config.handlerClass Optional callback handler class (required if using envVar)\n * @param config.envVar Optional environment variable name to control handler activation\n */\nexport const registerConfigureHook = (config: ConfigureHook) => {\n  if (config.envVar && !config.handlerClass) {\n    throw new Error(\n      \"If envVar is set, handlerClass must also be set to a non-None value.\"\n    );\n  }\n  setContextVariable(LC_CONFIGURE_HOOKS_KEY, [..._getConfigureHooks(), config]);\n};\n\nexport type ConfigureHook = {\n  contextVar?: string;\n  inheritable?: boolean;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  handlerClass?: new (...args: any[]) => BaseCallbackHandler;\n  envVar?: string;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAgB,mBAAsBA,MAAmBC,OAAgB;CAEvE,MAAM,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"}

package/dist/singletons/async_local_storage/globals.cjs

@@ -1,13 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobalAsyncLocalStorageInstance = exports.setGlobalAsyncLocalStorageInstance = exports._CONTEXT_VARIABLES_KEY = exports.TRACING_ALS_KEY = void 0;
-exports.TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
-exports._CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
+
+//#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");
 const setGlobalAsyncLocalStorageInstance = (instance) => {
-    globalThis[exports.TRACING_ALS_KEY] = instance;
+	globalThis[TRACING_ALS_KEY] = instance;
 };
-exports.setGlobalAsyncLocalStorageInstance = setGlobalAsyncLocalStorageInstance;
 const getGlobalAsyncLocalStorageInstance = () => {
-    return globalThis[exports.TRACING_ALS_KEY];
+	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

@@ -0,0 +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"}

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

@@ -0,0 +1,11 @@
+//#region src/singletons/async_local_storage/globals.d.ts
+/* eslint-disable @typescript-eslint/no-explicit-any */
+interface AsyncLocalStorageInterface {
+  getStore: () => any | undefined;
+  run: <T>(store: any, callback: () => T) => T;
+  enterWith: (store: any) => void;
+}
+declare const _CONTEXT_VARIABLES_KEY: unique symbol;
+//#endregion
+export { AsyncLocalStorageInterface, _CONTEXT_VARIABLES_KEY };
+//# sourceMappingURL=globals.d.cts.map

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

@@ -0,0 +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":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport 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"],"mappings":";;AACiBA,UAAAA,0BAAAA,CAA0B;EAAA,QAAA,EAAA,GAAA,GAAA,GAAA,GAAA,SAAA;EAAA,GAEFC,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,CAAAA,EAAAA,GAAMA,CAANA;EAAC,SAAKA,EAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,GAAAA,IAAAA;AAAC;cAI3BE"}

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

@@ -1,9 +1,11 @@
-export interface AsyncLocalStorageInterface {
-    getStore: () => any | undefined;
-    run: <T>(store: any, callback: () => T) => T;
-    enterWith: (store: any) => void;
+//#region src/singletons/async_local_storage/globals.d.ts
+/* eslint-disable @typescript-eslint/no-explicit-any */
+interface AsyncLocalStorageInterface {
+  getStore: () => any | undefined;
+  run: <T>(store: any, callback: () => T) => T;
+  enterWith: (store: any) => void;
 }
-export declare const TRACING_ALS_KEY: unique symbol;
-export declare const _CONTEXT_VARIABLES_KEY: unique symbol;
-export declare const setGlobalAsyncLocalStorageInstance: (instance: AsyncLocalStorageInterface) => void;
-export declare const getGlobalAsyncLocalStorageInstance: () => AsyncLocalStorageInterface | undefined;
+declare const _CONTEXT_VARIABLES_KEY: unique symbol;
+//#endregion
+export { AsyncLocalStorageInterface, _CONTEXT_VARIABLES_KEY };
+//# sourceMappingURL=globals.d.ts.map

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

@@ -0,0 +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":["/* eslint-disable @typescript-eslint/no-explicit-any */\nexport 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"],"mappings":";;AACiBA,UAAAA,0BAAAA,CAA0B;EAAA,QAAA,EAAA,GAAA,GAAA,GAAA,GAAA,SAAA;EAAA,GAEFC,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,QAAAA,EAAAA,GAAAA,GAAAA,CAAAA,EAAAA,GAAMA,CAANA;EAAC,SAAKA,EAAAA,CAAAA,KAAAA,EAAAA,GAAAA,EAAAA,GAAAA,IAAAA;AAAC;cAI3BE"}

package/dist/singletons/async_local_storage/globals.js

@@ -1,8 +1,13 @@
-export const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
-export const _CONTEXT_VARIABLES_KEY = Symbol.for("lc:context_variables");
-export const setGlobalAsyncLocalStorageInstance = (instance) => {
-    globalThis[TRACING_ALS_KEY] = instance;
+//#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");
+const setGlobalAsyncLocalStorageInstance = (instance) => {
+	globalThis[TRACING_ALS_KEY] = instance;
 };
-export const getGlobalAsyncLocalStorageInstance = () => {
-    return globalThis[TRACING_ALS_KEY];
+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

@@ -0,0 +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"}

package/dist/singletons/async_local_storage/index.cjs

@@ -1,69 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncLocalStorageProviderSingleton = exports.MockAsyncLocalStorage = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const langsmith_1 = require("langsmith");
-const globals_js_1 = require("./globals.cjs");
-const manager_js_1 = require("../../callbacks/manager.cjs");
-class MockAsyncLocalStorage {
-    getStore() {
-        return undefined;
-    }
-    run(_store, callback) {
-        return callback();
-    }
-    enterWith(_store) {
-        return undefined;
-    }
-}
-exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
+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"));
+
+//#region src/singletons/async_local_storage/index.ts
+var MockAsyncLocalStorage = class {
+	getStore() {
+		return void 0;
+	}
+	run(_store, callback) {
+		return callback();
+	}
+	enterWith(_store) {
+		return void 0;
+	}
+};
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
 const LC_CHILD_KEY = Symbol.for("lc:child_config");
-class AsyncLocalStorageProvider {
-    getInstance() {
-        return (0, globals_js_1.getGlobalAsyncLocalStorageInstance)() ?? mockAsyncLocalStorage;
-    }
-    getRunnableConfig() {
-        const storage = this.getInstance();
-        // this has the runnable config
-        // which means that we should also have an instance of a LangChainTracer
-        // with the run map prepopulated
-        return storage.getStore()?.extra?.[LC_CHILD_KEY];
-    }
-    runWithConfig(config, callback, avoidCreatingRootRunTree) {
-        const callbackManager = manager_js_1.CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
-        const storage = this.getInstance();
-        const previousValue = storage.getStore();
-        const parentRunId = callbackManager?.getParentRunId();
-        const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
-        let runTree;
-        if (langChainTracer && parentRunId) {
-            runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);
-        }
-        else if (!avoidCreatingRootRunTree) {
-            runTree = new langsmith_1.RunTree({
-                name: "<runnable_lambda>",
-                tracingEnabled: false,
-            });
-        }
-        if (runTree) {
-            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
-        }
-        if (previousValue !== undefined &&
-            previousValue[globals_js_1._CONTEXT_VARIABLES_KEY] !== undefined) {
-            if (runTree === undefined) {
-                runTree = {};
-            }
-            runTree[globals_js_1._CONTEXT_VARIABLES_KEY] =
-                previousValue[globals_js_1._CONTEXT_VARIABLES_KEY];
-        }
-        return storage.run(runTree, callback);
-    }
-    initializeGlobalInstance(instance) {
-        if ((0, globals_js_1.getGlobalAsyncLocalStorageInstance)() === undefined) {
-            (0, globals_js_1.setGlobalAsyncLocalStorageInstance)(instance);
-        }
-    }
-}
+var AsyncLocalStorageProvider = class {
+	getInstance() {
+		return require_globals.getGlobalAsyncLocalStorageInstance() ?? mockAsyncLocalStorage;
+	}
+	getRunnableConfig() {
+		const storage = this.getInstance();
+		return storage.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);
+		const storage = this.getInstance();
+		const previousValue = storage.getStore();
+		const parentRunId = callbackManager?.getParentRunId();
+		const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
+		let runTree;
+		if (langChainTracer && parentRunId) runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);
+		else if (!avoidCreatingRootRunTree) runTree = new langsmith.RunTree({
+			name: "<runnable_lambda>",
+			tracingEnabled: false
+		});
+		if (runTree) runTree.extra = {
+			...runTree.extra,
+			[LC_CHILD_KEY]: config
+		};
+		if (previousValue !== void 0 && previousValue[require_globals._CONTEXT_VARIABLES_KEY] !== void 0) {
+			if (runTree === void 0) runTree = {};
+			runTree[require_globals._CONTEXT_VARIABLES_KEY] = previousValue[require_globals._CONTEXT_VARIABLES_KEY];
+		}
+		return storage.run(runTree, callback);
+	}
+	initializeGlobalInstance(instance) {
+		if (require_globals.getGlobalAsyncLocalStorageInstance() === void 0) require_globals.setGlobalAsyncLocalStorageInstance(instance);
+	}
+};
 const AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
+
+//#endregion
 exports.AsyncLocalStorageProviderSingleton = AsyncLocalStorageProviderSingleton;
+exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,18 @@
+import { AsyncLocalStorageInterface } from "./globals.cjs";
+
+//#region src/singletons/async_local_storage/index.d.ts
+declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface {
+  getStore(): any;
+  run<T>(_store: any, callback: () => T): T;
+  enterWith(_store: any): undefined;
+}
+declare class AsyncLocalStorageProvider {
+  getInstance(): AsyncLocalStorageInterface;
+  getRunnableConfig(): any;
+  runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;
+  initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
+}
+declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;
+//#endregion
+export { AsyncLocalStorageProviderSingleton, MockAsyncLocalStorage };
+//# sourceMappingURL=index.d.cts.map