@langchain/core 0.3.21 → 0.3.23

package/dist/runnables/config.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.patchConfig = exports.ensureConfig = exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
+exports.pickRunnableConfigKeys = exports.patchConfig = exports.ensureConfig = exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
 const manager_js_1 = require("../callbacks/manager.cjs");
 const index_js_1 = require("../singletons/index.cjs");
 exports.DEFAULT_RECURSION_LIMIT = 25;
@@ -205,3 +205,19 @@ function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, r
     return newConfig;
 }
 exports.patchConfig = patchConfig;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function pickRunnableConfigKeys(config) {
+    return config
+        ? {
+            configurable: config.configurable,
+            recursionLimit: config.recursionLimit,
+            callbacks: config.callbacks,
+            tags: config.tags,
+            metadata: config.metadata,
+            maxConcurrency: config.maxConcurrency,
+            timeout: config.timeout,
+            signal: config.signal,
+        }
+        : undefined;
+}
+exports.pickRunnableConfigKeys = pickRunnableConfigKeys;

package/dist/runnables/config.d.ts

@@ -12,3 +12,4 @@ export declare function ensureConfig<CallOptions extends RunnableConfig>(config?
  * Helper function that patches runnable configs with updated properties.
  */
 export declare function patchConfig<CallOptions extends RunnableConfig>(config?: Partial<CallOptions>, { callbacks, maxConcurrency, recursionLimit, runName, configurable, runId, }?: RunnableConfig): Partial<CallOptions>;
+export declare function pickRunnableConfigKeys<CallOptions extends Record<string, any>>(config?: CallOptions): Partial<RunnableConfig> | undefined;

package/dist/runnables/config.js

@@ -198,3 +198,18 @@ export function patchConfig(config = {}, { callbacks, maxConcurrency, recursionL
     }
     return newConfig;
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function pickRunnableConfigKeys(config) {
+    return config
+        ? {
+            configurable: config.configurable,
+            recursionLimit: config.recursionLimit,
+            callbacks: config.callbacks,
+            tags: config.tags,
+            metadata: config.metadata,
+            maxConcurrency: config.maxConcurrency,
+            timeout: config.timeout,
+            signal: config.signal,
+        }
+        : undefined;
+}

package/dist/runnables/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports.RunnableToolLike = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.pickRunnableConfigKeys = exports.mergeConfigs = exports.ensureConfig = exports.patchConfig = exports.getCallbackManagerForConfig = exports.RunnableToolLike = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
 Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
@@ -20,6 +20,7 @@ Object.defineProperty(exports, "getCallbackManagerForConfig", { enumerable: true
 Object.defineProperty(exports, "patchConfig", { enumerable: true, get: function () { return config_js_1.patchConfig; } });
 Object.defineProperty(exports, "ensureConfig", { enumerable: true, get: function () { return config_js_1.ensureConfig; } });
 Object.defineProperty(exports, "mergeConfigs", { enumerable: true, get: function () { return config_js_1.mergeConfigs; } });
+Object.defineProperty(exports, "pickRunnableConfigKeys", { enumerable: true, get: function () { return config_js_1.pickRunnableConfigKeys; } });
 var passthrough_js_1 = require("./passthrough.cjs");
 Object.defineProperty(exports, "RunnablePassthrough", { enumerable: true, get: function () { return passthrough_js_1.RunnablePassthrough; } });
 var router_js_1 = require("./router.cjs");

package/dist/runnables/index.d.ts

@@ -1,6 +1,6 @@
 export { type RunnableFunc, type RunnableLike, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, RunnableToolLike, type RunnableToolLikeArgs, } from "./base.js";
 export { type RunnableBatchOptions, type RunnableInterface, type RunnableIOSchema, } from "./types.js";
-export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, } from "./config.js";
+export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, pickRunnableConfigKeys, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { type RouterInput, RouterRunnable } from "./router.js";
 export { RunnableBranch, type Branch, type BranchLike } from "./branch.js";

package/dist/runnables/index.js

@@ -1,5 +1,5 @@
 export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, RunnableToolLike, } from "./base.js";
-export { getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, } from "./config.js";
+export { getCallbackManagerForConfig, patchConfig, ensureConfig, mergeConfigs, pickRunnableConfigKeys, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";
 export { RunnableBranch } from "./branch.js";

package/dist/runnables/iter.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.consumeAsyncIterableInContext = exports.consumeIteratorInContext = exports.isAsyncIterable = exports.isIterator = exports.isIterableIterator = void 0;
 const index_js_1 = require("../singletons/index.cjs");
+const config_js_1 = require("./config.cjs");
 function isIterableIterator(thing) {
     return (typeof thing === "object" &&
         thing !== null &&
@@ -24,7 +25,7 @@ function isAsyncIterable(thing) {
 exports.isAsyncIterable = isAsyncIterable;
 function* consumeIteratorInContext(context, iter) {
     while (true) {
-        const { value, done } = index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(context, iter.next.bind(iter), true);
+        const { value, done } = index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(context), iter.next.bind(iter), true);
         if (done) {
             break;
         }
@@ -37,7 +38,7 @@ exports.consumeIteratorInContext = consumeIteratorInContext;
 async function* consumeAsyncIterableInContext(context, iter) {
     const iterator = iter[Symbol.asyncIterator]();
     while (true) {
-        const { value, done } = await index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig(context, iterator.next.bind(iter), true);
+        const { value, done } = await index_js_1.AsyncLocalStorageProviderSingleton.runWithConfig((0, config_js_1.pickRunnableConfigKeys)(context), iterator.next.bind(iter), true);
         if (done) {
             break;
         }

package/dist/runnables/iter.d.ts

@@ -1,4 +1,4 @@
-import { RunnableConfig } from "./config.js";
+import type { RunnableConfig } from "../runnables/types.js";
 export declare function isIterableIterator(thing: unknown): thing is IterableIterator<unknown>;
 export declare const isIterator: (x: unknown) => x is Iterator<unknown, any, undefined>;
 export declare function isAsyncIterable(thing: unknown): thing is AsyncIterable<unknown>;

package/dist/runnables/iter.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorageProviderSingleton } from "../singletons/index.js";
+import { pickRunnableConfigKeys } from "./config.js";
 export function isIterableIterator(thing) {
     return (typeof thing === "object" &&
         thing !== null &&
@@ -18,7 +19,7 @@ export function isAsyncIterable(thing) {
 }
 export function* consumeIteratorInContext(context, iter) {
     while (true) {
-        const { value, done } = AsyncLocalStorageProviderSingleton.runWithConfig(context, iter.next.bind(iter), true);
+        const { value, done } = AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(context), iter.next.bind(iter), true);
         if (done) {
             break;
         }
@@ -30,7 +31,7 @@ export function* consumeIteratorInContext(context, iter) {
 export async function* consumeAsyncIterableInContext(context, iter) {
     const iterator = iter[Symbol.asyncIterator]();
     while (true) {
-        const { value, done } = await AsyncLocalStorageProviderSingleton.runWithConfig(context, iterator.next.bind(iter), true);
+        const { value, done } = await AsyncLocalStorageProviderSingleton.runWithConfig(pickRunnableConfigKeys(context), iterator.next.bind(iter), true);
         if (done) {
             break;
         }

package/dist/runnables/types.d.ts

@@ -1,7 +1,7 @@
 import type { z } from "zod";
-import type { IterableReadableStreamInterface } from "../utils/stream.js";
 import type { SerializableInterface } from "../load/serializable.js";
 import type { BaseCallbackConfig } from "../callbacks/manager.js";
+import type { IterableReadableStreamInterface } from "../types/stream.js";
 export type RunnableBatchOptions = {
     /** @deprecated Pass in via the standard runnable config object instead */
     maxConcurrency?: number;

package/dist/singletons/async_local_storage/context.cjs

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

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

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