@langchain/core 0.2.14 → 0.2.15

package/README.md

@@ -1,6 +1,6 @@
 # 🦜🍎️ @langchain/core
 
-[![CI](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml) ![npm](https://img.shields.io/npm/dm/@langchain/core) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai) [![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![CI](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml) ![npm](https://img.shields.io/npm/dm/@langchain/core) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai) 
 
 `@langchain/core` contains the core abstractions and schemas of LangChain.js, including base classes for language models,
 chat models, vectorstores, retrievers, and runnables.

package/dist/callbacks/manager.cjs

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traceAsGroup = exports.TraceGroup = exports.ensureHandler = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0;
+exports.traceAsGroup = exports.TraceGroup = exports.ensureHandler = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseRunManager = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0;
 const uuid_1 = require("uuid");
 const base_js_1 = require("./base.cjs");
 const console_js_1 = require("../tracers/console.cjs");
-const initialize_js_1 = require("../tracers/initialize.cjs");
 const utils_js_1 = require("../messages/utils.cjs");
 const env_js_1 = require("../utils/env.cjs");
 const tracer_langchain_js_1 = require("../tracers/tracer_langchain.cjs");
 const promises_js_1 = require("./promises.cjs");
+const callbacks_js_1 = require("../utils/callbacks.cjs");
 if (
 /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" &&
     /* #__PURE__ */ (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_CALLBACKS_BACKGROUND") !==
@@ -94,6 +94,9 @@ class BaseRunManager {
             value: _parentRunId
         });
     }
+    get parentRunId() {
+        return this._parentRunId;
+    }
     async handleText(text) {
         await Promise.all(this.handlers.map((handler) => (0, promises_js_1.consumeCallback)(async () => {
             try {
@@ -108,6 +111,7 @@ class BaseRunManager {
         }, handler.awaitHandlers)));
     }
 }
+exports.BaseRunManager = BaseRunManager;
 /**
  * Manages callbacks for retriever runs.
  */
@@ -586,6 +590,10 @@ class CallbackManager extends BaseCallbackManager {
         return manager;
     }
     static async configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
+        return this._configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options);
+    }
+    // TODO: Deprecate async method in favor of this one.
+    static _configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
         let callbackManager;
         if (inheritableHandlers || localHandlers) {
             if (Array.isArray(inheritableHandlers) || !inheritableHandlers) {
@@ -601,8 +609,7 @@ class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING_V2") === "true" ||
-            (0, env_js_1.getEnvironmentVariable)("LANGSMITH_TRACING") === "true";
+        const tracingV2Enabled = (0, callbacks_js_1.isTracingEnabled)();
         const tracingEnabled = tracingV2Enabled ||
             ((0, env_js_1.getEnvironmentVariable)("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -617,7 +624,7 @@ class CallbackManager extends BaseCallbackManager {
             if (tracingEnabled &&
                 !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) {
                 if (tracingV2Enabled) {
-                    const tracerV2 = await (0, initialize_js_1.getTracingV2CallbackHandler)();
+                    const tracerV2 = new tracer_langchain_js_1.LangChainTracer();
                     callbackManager.addHandler(tracerV2, true);
                     // handoff between langchain and langsmith/traceable
                     // override the parent run ID

package/dist/callbacks/manager.d.ts

@@ -53,7 +53,7 @@ export declare abstract class BaseCallbackManager {
 /**
  * Base class for run manager in LangChain.
  */
-declare class BaseRunManager {
+export declare class BaseRunManager {
     readonly runId: string;
     readonly handlers: BaseCallbackHandler[];
     protected readonly inheritableHandlers: BaseCallbackHandler[];
@@ -63,6 +63,7 @@ declare class BaseRunManager {
     protected readonly inheritableMetadata: Record<string, unknown>;
     protected readonly _parentRunId?: string | undefined;
     constructor(runId: string, handlers: BaseCallbackHandler[], inheritableHandlers: BaseCallbackHandler[], tags: string[], inheritableTags: string[], metadata: Record<string, unknown>, inheritableMetadata: Record<string, unknown>, _parentRunId?: string | undefined);
+    get parentRunId(): string | undefined;
     handleText(text: string): Promise<void>;
 }
 /**
@@ -150,6 +151,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     copy(additionalHandlers?: BaseCallbackHandler[], inherit?: boolean): CallbackManager;
     static fromHandlers(handlers: CallbackHandlerMethods): CallbackManager;
     static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): Promise<CallbackManager | undefined>;
+    static _configureSync(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): CallbackManager | undefined;
 }
 export declare function ensureHandler(handler: BaseCallbackHandler | CallbackHandlerMethods): BaseCallbackHandler;
 /**

package/dist/callbacks/manager.js

@@ -1,11 +1,11 @@
 import { v4 as uuidv4 } from "uuid";
 import { BaseCallbackHandler, } from "./base.js";
 import { ConsoleCallbackHandler } from "../tracers/console.js";
-import { getTracingV2CallbackHandler } from "../tracers/initialize.js";
 import { getBufferString } from "../messages/utils.js";
 import { getEnvironmentVariable } from "../utils/env.js";
 import { LangChainTracer, } from "../tracers/tracer_langchain.js";
 import { consumeCallback } from "./promises.js";
+import { isTracingEnabled } from "../utils/callbacks.js";
 if (
 /* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" &&
     /* #__PURE__ */ getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") !==
@@ -38,7 +38,7 @@ export class BaseCallbackManager {
 /**
  * Base class for run manager in LangChain.
  */
-class BaseRunManager {
+export class BaseRunManager {
     constructor(runId, handlers, inheritableHandlers, tags, inheritableTags, metadata, inheritableMetadata, _parentRunId) {
         Object.defineProperty(this, "runId", {
             enumerable: true,
@@ -89,6 +89,9 @@ class BaseRunManager {
             value: _parentRunId
         });
     }
+    get parentRunId() {
+        return this._parentRunId;
+    }
     async handleText(text) {
         await Promise.all(this.handlers.map((handler) => consumeCallback(async () => {
             try {
@@ -577,6 +580,10 @@ export class CallbackManager extends BaseCallbackManager {
         return manager;
     }
     static async configure(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
+        return this._configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options);
+    }
+    // TODO: Deprecate async method in favor of this one.
+    static _configureSync(inheritableHandlers, localHandlers, inheritableTags, localTags, inheritableMetadata, localMetadata, options) {
         let callbackManager;
         if (inheritableHandlers || localHandlers) {
             if (Array.isArray(inheritableHandlers) || !inheritableHandlers) {
@@ -592,8 +599,7 @@ export class CallbackManager extends BaseCallbackManager {
         }
         const verboseEnabled = getEnvironmentVariable("LANGCHAIN_VERBOSE") === "true" ||
             options?.verbose;
-        const tracingV2Enabled = getEnvironmentVariable("LANGCHAIN_TRACING_V2") === "true" ||
-            getEnvironmentVariable("LANGSMITH_TRACING") === "true";
+        const tracingV2Enabled = isTracingEnabled();
         const tracingEnabled = tracingV2Enabled ||
             (getEnvironmentVariable("LANGCHAIN_TRACING") ?? false);
         if (verboseEnabled || tracingEnabled) {
@@ -608,7 +614,7 @@ export class CallbackManager extends BaseCallbackManager {
             if (tracingEnabled &&
                 !callbackManager.handlers.some((handler) => handler.name === "langchain_tracer")) {
                 if (tracingV2Enabled) {
-                    const tracerV2 = await getTracingV2CallbackHandler();
+                    const tracerV2 = new LangChainTracer();
                     callbackManager.addHandler(tracerV2, true);
                     // handoff between langchain and langsmith/traceable
                     // override the parent run ID

package/dist/runnables/base.cjs

@@ -8,7 +8,6 @@ const zod_1 = require("zod");
 const p_retry_1 = __importDefault(require("p-retry"));
 const uuid_1 = require("uuid");
 const traceable_1 = require("langsmith/singletons/traceable");
-const manager_js_1 = require("../callbacks/manager.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
 const event_stream_js_1 = require("../tracers/event_stream.cjs");
 const serializable_js_1 = require("../load/serializable.cjs");
@@ -1574,12 +1573,16 @@ class RunnableLambda extends Runnable {
                 }
             }
         }
+        const childConfig = (0, config_js_1.patchConfig)(config, {
+            callbacks: runManager?.getChild(),
+            recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+        });
         const output = await new Promise((resolve, reject) => {
-            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+            void index_js_1.AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                 try {
                     const res = await this.func(finalChunk, {
-                        ...config,
-                        config,
+                        ...childConfig,
+                        config: childConfig,
                     });
                     resolve(res);
                 }
@@ -1592,21 +1595,18 @@ class RunnableLambda extends Runnable {
             if (config?.recursionLimit === 0) {
                 throw new Error("Recursion limit reached.");
             }
-            const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
-            }));
+            const stream = await output.stream(finalChunk, childConfig);
             for await (const chunk of stream) {
                 yield chunk;
             }
         }
         else if ((0, iter_js_1.isAsyncIterable)(output)) {
-            for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(config, output)) {
+            for await (const chunk of (0, iter_js_1.consumeAsyncIterableInContext)(childConfig, output)) {
                 yield chunk;
             }
         }
         else if ((0, iter_js_1.isIterableIterator)(output)) {
-            for (const chunk of (0, iter_js_1.consumeIteratorInContext)(config, output)) {
+            for (const chunk of (0, iter_js_1.consumeIteratorInContext)(childConfig, output)) {
                 yield chunk;
             }
         }
@@ -1677,13 +1677,14 @@ class RunnableWithFallbacks extends Runnable {
         }
     }
     async invoke(input, options) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const { runId, ...otherOptions } = options ?? {};
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const { runId, ...otherConfigFields } = config;
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherOptions, { callbacks: runManager?.getChild() }));
+                const output = await runnable.invoke(input, (0, config_js_1.patchConfig)(otherConfigFields, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1704,7 +1705,7 @@ class RunnableWithFallbacks extends Runnable {
             throw new Error("Not implemented.");
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map((config) => manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
+        const callbackManagers = await Promise.all(configList.map((config) => (0, config_js_1.getCallbackManagerForConfig)(config)));
         const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
             const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
             delete configList[i].runId;

package/dist/runnables/base.d.ts

@@ -10,8 +10,10 @@ import { Run } from "../tracers/base.js";
 import { Graph } from "./graph.js";
 export { type RunnableInterface, RunnableBatchOptions };
 export type RunnableFunc<RunInput, RunOutput> = (input: RunInput, options?: ({
+    /** @deprecated Use top-level config fields instead. */
     config?: RunnableConfig;
 } & RunnableConfig) | Record<string, any> | (Record<string, any> & {
+    /** @deprecated Use top-level config fields instead. */
     config: RunnableConfig;
 } & RunnableConfig)) => RunOutput | Promise<RunOutput>;
 export type RunnableMapLike<RunInput, RunOutput> = {

package/dist/runnables/base.js

@@ -2,7 +2,6 @@ import { z } from "zod";
 import pRetry from "p-retry";
 import { v4 as uuidv4 } from "uuid";
 import { isTraceableFunction, } from "langsmith/singletons/traceable";
-import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, isLogStreamHandler, } from "../tracers/log_stream.js";
 import { EventStreamCallbackHandler, isStreamEventsHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
@@ -1560,12 +1559,16 @@ export class RunnableLambda extends Runnable {
                 }
             }
         }
+        const childConfig = patchConfig(config, {
+            callbacks: runManager?.getChild(),
+            recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+        });
         const output = await new Promise((resolve, reject) => {
-            void AsyncLocalStorageProviderSingleton.getInstance().run(config, async () => {
+            void AsyncLocalStorageProviderSingleton.getInstance().run(childConfig, async () => {
                 try {
                     const res = await this.func(finalChunk, {
-                        ...config,
-                        config,
+                        ...childConfig,
+                        config: childConfig,
                     });
                     resolve(res);
                 }
@@ -1578,21 +1581,18 @@ export class RunnableLambda extends Runnable {
             if (config?.recursionLimit === 0) {
                 throw new Error("Recursion limit reached.");
             }
-            const stream = await output.stream(finalChunk, patchConfig(config, {
-                callbacks: runManager?.getChild(),
-                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
-            }));
+            const stream = await output.stream(finalChunk, childConfig);
             for await (const chunk of stream) {
                 yield chunk;
             }
         }
         else if (isAsyncIterable(output)) {
-            for await (const chunk of consumeAsyncIterableInContext(config, output)) {
+            for await (const chunk of consumeAsyncIterableInContext(childConfig, output)) {
                 yield chunk;
             }
         }
         else if (isIterableIterator(output)) {
-            for (const chunk of consumeIteratorInContext(config, output)) {
+            for (const chunk of consumeIteratorInContext(childConfig, output)) {
                 yield chunk;
             }
         }
@@ -1661,13 +1661,14 @@ export class RunnableWithFallbacks extends Runnable {
         }
     }
     async invoke(input, options) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const { runId, ...otherOptions } = options ?? {};
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherOptions?.runName);
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const { runId, ...otherConfigFields } = config;
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), runId, undefined, undefined, undefined, otherConfigFields?.runName);
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const output = await runnable.invoke(input, patchConfig(otherOptions, { callbacks: runManager?.getChild() }));
+                const output = await runnable.invoke(input, patchConfig(otherConfigFields, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1688,7 +1689,7 @@ export class RunnableWithFallbacks extends Runnable {
             throw new Error("Not implemented.");
         }
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
+        const callbackManagers = await Promise.all(configList.map((config) => getCallbackManagerForConfig(config)));
         const runManagers = await Promise.all(callbackManagers.map(async (callbackManager, i) => {
             const handleStartRes = await callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), configList[i].runId, undefined, undefined, undefined, configList[i].runName);
             delete configList[i].runId;

package/dist/runnables/config.cjs

@@ -89,25 +89,47 @@ const PRIMITIVES = new Set(["string", "number", "boolean"]);
  * should not be called with a default or prepopulated config argument.
  */
 function ensureConfig(config) {
-    const loadedConfig = config ?? index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const implicitConfig = index_js_1.AsyncLocalStorageProviderSingleton.getInstance().getStore();
     let empty = {
         tags: [],
         metadata: {},
-        callbacks: undefined,
         recursionLimit: 25,
         runId: undefined,
     };
-    if (loadedConfig) {
-        empty = { ...empty, ...loadedConfig };
+    if (implicitConfig) {
+        // Don't allow runId to be loaded implicitly, as this can cause
+        // child runs to improperly inherit their parents' run ids.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { runId, ...rest } = implicitConfig;
+        empty = Object.entries(rest).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
+    }
+    if (config) {
+        empty = Object.entries(config).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
     }
-    if (loadedConfig?.configurable) {
-        for (const key of Object.keys(loadedConfig.configurable)) {
-            if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) &&
+    if (empty?.configurable) {
+        for (const key of Object.keys(empty.configurable)) {
+            if (PRIMITIVES.has(typeof empty.configurable[key]) &&
                 !empty.metadata?.[key]) {
                 if (!empty.metadata) {
                     empty.metadata = {};
                 }
-                empty.metadata[key] = loadedConfig.configurable[key];
+                empty.metadata[key] = empty.configurable[key];
             }
         }
     }

package/dist/runnables/config.js

@@ -84,25 +84,47 @@ const PRIMITIVES = new Set(["string", "number", "boolean"]);
  * should not be called with a default or prepopulated config argument.
  */
 export function ensureConfig(config) {
-    const loadedConfig = config ?? AsyncLocalStorageProviderSingleton.getInstance().getStore();
+    const implicitConfig = AsyncLocalStorageProviderSingleton.getInstance().getStore();
     let empty = {
         tags: [],
         metadata: {},
-        callbacks: undefined,
         recursionLimit: 25,
         runId: undefined,
     };
-    if (loadedConfig) {
-        empty = { ...empty, ...loadedConfig };
+    if (implicitConfig) {
+        // Don't allow runId to be loaded implicitly, as this can cause
+        // child runs to improperly inherit their parents' run ids.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { runId, ...rest } = implicitConfig;
+        empty = Object.entries(rest).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
+    }
+    if (config) {
+        empty = Object.entries(config).reduce(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (currentConfig, [key, value]) => {
+            if (value !== undefined) {
+                // eslint-disable-next-line no-param-reassign
+                currentConfig[key] = value;
+            }
+            return currentConfig;
+        }, empty);
     }
-    if (loadedConfig?.configurable) {
-        for (const key of Object.keys(loadedConfig.configurable)) {
-            if (PRIMITIVES.has(typeof loadedConfig.configurable[key]) &&
+    if (empty?.configurable) {
+        for (const key of Object.keys(empty.configurable)) {
+            if (PRIMITIVES.has(typeof empty.configurable[key]) &&
                 !empty.metadata?.[key]) {
                 if (!empty.metadata) {
                     empty.metadata = {};
                 }
-                empty.metadata[key] = loadedConfig.configurable[key];
+                empty.metadata[key] = empty.configurable[key];
             }
         }
     }

package/dist/runnables/history.cjs

@@ -211,7 +211,7 @@ class RunnableWithMessageHistory extends base_js_1.RunnableBinding {
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
-        const history = kwargs?.config?.configurable?.messageHistory;
+        const history = kwargs?.configurable?.messageHistory;
         const messages = await history.getMessages();
         if (this.historyMessagesKey === undefined) {
             return messages.concat(this._getInputMessages(input));

package/dist/runnables/history.d.ts

@@ -85,9 +85,7 @@ export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends Run
     constructor(fields: RunnableWithMessageHistoryInputs<RunInput, RunOutput>);
     _getInputMessages(inputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
     _getOutputMessages(outputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
-    _enterHistory(input: any, kwargs?: {
-        config?: RunnableConfig;
-    }): Promise<BaseMessage[]>;
+    _enterHistory(input: any, kwargs?: RunnableConfig): Promise<BaseMessage[]>;
     _exitHistory(run: Run, config: RunnableConfig): Promise<void>;
     _mergeConfig(...configs: Array<RunnableConfig | undefined>): Promise<Partial<RunnableConfig>>;
 }

package/dist/runnables/history.js

@@ -208,7 +208,7 @@ export class RunnableWithMessageHistory extends RunnableBinding {
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
-        const history = kwargs?.config?.configurable?.messageHistory;
+        const history = kwargs?.configurable?.messageHistory;
         const messages = await history.getMessages();
         if (this.historyMessagesKey === undefined) {
             return messages.concat(this._getInputMessages(input));

package/dist/runnables/tests/runnable.test.js

@@ -373,19 +373,19 @@ test("Create a runnable sequence with a static method with invalid output and ca
 test("RunnableSequence can pass config to every step in batched request", async () => {
     let numSeen = 0;
     const addOne = (x, options) => {
-        if (options?.config?.configurable?.isPresent === true) {
+        if (options?.configurable?.isPresent === true) {
             numSeen += 1;
         }
         return x + 1;
     };
     const addTwo = (x, options) => {
-        if (options?.config?.configurable?.isPresent === true) {
+        if (options?.configurable?.isPresent === true) {
             numSeen += 1;
         }
         return x + 2;
     };
     const addThree = (x, options) => {
-        if (options?.config?.configurable?.isPresent === true) {
+        if (options?.configurable?.isPresent === true) {
             numSeen += 1;
         }
         return x + 3;

package/dist/runnables/tests/runnable_stream_events_v2.test.js

@@ -958,7 +958,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
             event: "on_chat_model_start",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -976,7 +976,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -989,7 +989,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1002,7 +1002,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1015,7 +1015,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1029,7 +1029,7 @@ test("Chat model that supports streaming, but is invoked, should still emit on_s
             event: "on_chat_model_end",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1172,7 +1172,7 @@ test("Chat model that doesn't support streaming, but is invoked, should emit one
             event: "on_chat_model_start",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1190,7 +1190,7 @@ test("Chat model that doesn't support streaming, but is invoked, should emit one
         {
             event: "on_chat_model_stream",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["my_chain", "my_model", "seq:step:2"]),
+            tags: expect.arrayContaining(["my_chain", "my_model"]),
             metadata: {
                 a: "b",
                 foo: "bar",
@@ -1204,7 +1204,7 @@ test("Chat model that doesn't support streaming, but is invoked, should emit one
             event: "on_chat_model_end",
             name: "my_model",
             run_id: expect.any(String),
-            tags: expect.arrayContaining(["seq:step:2", "my_model", "my_chain"]),
+            tags: expect.arrayContaining(["my_model", "my_chain"]),
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1356,7 +1356,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
                 },
             },
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             run_id: expect.any(String),
             metadata: {
                 foo: "bar",
@@ -1372,7 +1372,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1387,7 +1387,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1402,7 +1402,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1417,7 +1417,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1443,7 +1443,7 @@ test("LLM that supports streaming, but is invoked, should still emit on_stream e
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1587,7 +1587,7 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
                 },
             },
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             run_id: expect.any(String),
             metadata: {
                 foo: "bar",
@@ -1603,7 +1603,7 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",
@@ -1629,7 +1629,7 @@ test("LLM that doesn't support streaming, but is invoked, should emit one on_str
             },
             run_id: expect.any(String),
             name: "my_model",
-            tags: ["seq:step:2", "my_model", "my_chain"],
+            tags: ["my_model", "my_chain"],
             metadata: {
                 foo: "bar",
                 a: "b",

package/dist/singletons/tests/async_local_storage.test.js

@@ -1,8 +1,22 @@
 import { test, expect } from "@jest/globals";
+import { v4 } from "uuid";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { AsyncLocalStorageProviderSingleton } from "../index.js";
 import { RunnableLambda } from "../../runnables/base.js";
 import { FakeListChatModel } from "../../utils/testing/index.js";
+import { getCallbackManagerForConfig } from "../../runnables/config.js";
+import { BaseCallbackHandler } from "../../callbacks/base.js";
+class FakeCallbackHandler extends BaseCallbackHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: `fake-${v4()}`
+        });
+    }
+}
 test("Config should be automatically populated after setting global async local storage", async () => {
     const inner = RunnableLambda.from((_, config) => config);
     const outer = RunnableLambda.from(async (input) => {
@@ -32,7 +46,6 @@ test("Config should be automatically populated after setting global async local
     });
     const chunks = [];
     for await (const chunk of stream) {
-        console.log(chunk);
         chunks.push(chunk);
     }
     expect(chunks.length).toEqual(1);
@@ -58,7 +71,6 @@ test("Config should be automatically populated after setting global async local
     });
     const chunks2 = [];
     for await (const chunk of stream2) {
-        console.log(chunk);
         chunks2.push(chunk);
     }
     expect(chunks2.length).toEqual(1);
@@ -90,17 +102,38 @@ test("Config should be automatically populated after setting global async local
     const eventStream = await outer4.streamEvents({ hi: true }, { version: "v1" });
     const events = [];
     for await (const event of eventStream) {
-        console.log(event);
         events.push(event);
     }
     expect(events.filter((event) => event.event === "on_llm_start").length).toEqual(1);
 });
 test("Runnable streamEvents method with streaming nested in a RunnableLambda", async () => {
     AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new AsyncLocalStorage());
+    const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
     const chat = new FakeListChatModel({
         responses: ["Hello"],
     });
+    const outerRunId = v4();
+    const innerRunId = v4();
+    const innerRunId2 = v4();
+    const dummyHandler = new FakeCallbackHandler();
     const myFunc = async (input) => {
+        const outerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+        expect(outerCallbackManager?.getParentRunId()).toEqual(outerRunId);
+        const nestedLambdaWithOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
+            expect(config?.callbacks?.handlers).toEqual([]);
+        });
+        await nestedLambdaWithOverriddenCallbacks.invoke(input, {
+            runId: innerRunId,
+            callbacks: [],
+        });
+        const nestedLambdaWithoutOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
+            const innerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+            expect(innerCallbackManager?.getParentRunId()).toEqual(innerRunId2);
+            expect(config?.callbacks?.handlers).toContain(dummyHandler);
+        });
+        await nestedLambdaWithoutOverriddenCallbacks.invoke(input, {
+            runId: innerRunId2,
+        });
         for await (const _ of await chat.stream(input)) {
             // no-op
         }
@@ -109,8 +142,9 @@ test("Runnable streamEvents method with streaming nested in a RunnableLambda", a
     const events = [];
     for await (const event of myNestedLambda.streamEvents("hello", {
         version: "v1",
+        runId: outerRunId,
+        callbacks: [dummyHandler],
     })) {
-        console.log(event);
         events.push(event);
     }
     const chatModelStreamEvent = events.find((event) => {

package/dist/tracers/initialize.cjs

@@ -24,6 +24,8 @@ async function getTracingCallbackHandler(session) {
 }
 exports.getTracingCallbackHandler = getTracingCallbackHandler;
 /**
+ * @deprecated Instantiate directly using the LangChainTracer constructor.
+ *
  * Function that returns an instance of `LangChainTracer`. It does not
  * load any session data.
  * @returns An instance of `LangChainTracer`.

package/dist/tracers/initialize.d.ts

@@ -11,6 +11,8 @@ import { LangChainTracerV1 } from "./tracer_langchain_v1.js";
  */
 export declare function getTracingCallbackHandler(session?: string): Promise<LangChainTracerV1>;
 /**
+ * @deprecated Instantiate directly using the LangChainTracer constructor.
+ *
  * Function that returns an instance of `LangChainTracer`. It does not
  * load any session data.
  * @returns An instance of `LangChainTracer`.

package/dist/tracers/initialize.js

@@ -20,6 +20,8 @@ export async function getTracingCallbackHandler(session) {
     return tracer;
 }
 /**
+ * @deprecated Instantiate directly using the LangChainTracer constructor.
+ *
  * Function that returns an instance of `LangChainTracer`. It does not
  * load any session data.
  * @returns An instance of `LangChainTracer`.

package/dist/utils/callbacks.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTracingEnabled = void 0;
+const env_js_1 = require("./env.cjs");
+const isTracingEnabled = (tracingEnabled) => {
+    if (tracingEnabled !== undefined) {
+        return tracingEnabled;
+    }
+    const envVars = [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ];
+    return !!envVars.find((envVar) => (0, env_js_1.getEnvironmentVariable)(envVar) === "true");
+};
+exports.isTracingEnabled = isTracingEnabled;

package/dist/utils/callbacks.d.ts

@@ -0,0 +1 @@
+export declare const isTracingEnabled: (tracingEnabled?: boolean) => boolean;

package/dist/utils/callbacks.js

@@ -0,0 +1,13 @@
+import { getEnvironmentVariable } from "./env.js";
+export const isTracingEnabled = (tracingEnabled) => {
+    if (tracingEnabled !== undefined) {
+        return tracingEnabled;
+    }
+    const envVars = [
+        "LANGSMITH_TRACING_V2",
+        "LANGCHAIN_TRACING_V2",
+        "LANGSMITH_TRACING",
+        "LANGCHAIN_TRACING",
+    ];
+    return !!envVars.find((envVar) => getEnvironmentVariable(envVar) === "true");
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -473,15 +473,6 @@
       "import": "./utils/async_caller.js",
       "require": "./utils/async_caller.cjs"
     },
-    "./utils/beta_warning": {
-      "types": {
-        "import": "./utils/beta_warning.d.ts",
-        "require": "./utils/beta_warning.d.cts",
-        "default": "./utils/beta_warning.d.ts"
-      },
-      "import": "./utils/beta_warning.js",
-      "require": "./utils/beta_warning.cjs"
-    },
     "./utils/chunk_array": {
       "types": {
         "import": "./utils/chunk_array.d.ts",
@@ -771,10 +762,6 @@
     "utils/async_caller.js",
     "utils/async_caller.d.ts",
     "utils/async_caller.d.cts",
-    "utils/beta_warning.cjs",
-    "utils/beta_warning.js",
-    "utils/beta_warning.d.ts",
-    "utils/beta_warning.d.cts",
     "utils/chunk_array.cjs",
     "utils/chunk_array.js",
     "utils/chunk_array.d.ts",

package/dist/utils/beta_warning.cjs

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.betaWarning = void 0;
-/**
- * Util function for logging a warning when a method is called.
- * @param {string} func The name of the function that is in beta.
- */
-function betaWarning(func) {
-    console.warn(`The function '${func}' is in beta. It is actively being worked on, so the API may change.`);
-}
-exports.betaWarning = betaWarning;

package/dist/utils/beta_warning.d.ts

@@ -1,5 +0,0 @@
-/**
- * Util function for logging a warning when a method is called.
- * @param {string} func The name of the function that is in beta.
- */
-export declare function betaWarning(func: string): void;

package/dist/utils/beta_warning.js

@@ -1,7 +0,0 @@
-/**
- * Util function for logging a warning when a method is called.
- * @param {string} func The name of the function that is in beta.
- */
-export function betaWarning(func) {
-    console.warn(`The function '${func}' is in beta. It is actively being worked on, so the API may change.`);
-}

package/utils/beta_warning.cjs

@@ -1 +0,0 @@
-module.exports = require('../dist/utils/beta_warning.cjs');

package/utils/beta_warning.d.cts

@@ -1 +0,0 @@
-export * from '../dist/utils/beta_warning.js'

package/utils/beta_warning.d.ts

@@ -1 +0,0 @@
-export * from '../dist/utils/beta_warning.js'

package/utils/beta_warning.js

@@ -1 +0,0 @@
-export * from '../dist/utils/beta_warning.js'