@langchain/core 0.2.17 → 0.2.18

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

@@ -57,6 +57,58 @@ test("Runnable streamEvents method", async () => {
         },
     ]);
 });
+test("Runnable streamEvents method on a chat model", async () => {
+    const model = new FakeListChatModel({
+        responses: ["abc"],
+    });
+    const events = [];
+    const eventStream = await model.streamEvents("hello", { version: "v2" });
+    for await (const event of eventStream) {
+        events.push(event);
+    }
+    expect(events).toMatchObject([
+        {
+            data: { input: "hello" },
+            event: "on_chat_model_start",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { chunk: new AIMessageChunk({ content: "a" }) },
+            event: "on_chat_model_stream",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { chunk: new AIMessageChunk({ content: "b" }) },
+            event: "on_chat_model_stream",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { chunk: new AIMessageChunk({ content: "c" }) },
+            event: "on_chat_model_stream",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+        {
+            data: { output: new AIMessageChunk({ content: "abc" }) },
+            event: "on_chat_model_end",
+            name: "FakeListChatModel",
+            metadata: expect.any(Object),
+            run_id: expect.any(String),
+            tags: [],
+        },
+    ]);
+});
 test("Runnable streamEvents method with three runnables", async () => {
     const r = RunnableLambda.from(reverse);
     const chain = r
@@ -556,18 +608,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "h",
-            },
-        },
         {
             event: "on_llm_stream",
             data: {
@@ -582,18 +622,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "e",
-            },
-        },
         {
             event: "on_llm_stream",
             data: {
@@ -608,18 +636,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "y",
-            },
-        },
         {
             event: "on_llm_stream",
             data: {
@@ -634,18 +650,6 @@ test("Runnable streamEvents method with llm", async () => {
                 a: "b",
             },
         },
-        {
-            event: "on_llm_stream",
-            run_id: expect.any(String),
-            name: "my_model",
-            tags: ["my_model"],
-            metadata: {
-                a: "b",
-            },
-            data: {
-                chunk: "!",
-            },
-        },
         {
             event: "on_llm_end",
             data: {

package/dist/runnables/types.d.ts

@@ -1,7 +1,7 @@
 import type { z } from "zod";
-import type { RunnableConfig } from "./config.js";
 import type { IterableReadableStreamInterface } from "../utils/stream.js";
 import type { SerializableInterface } from "../load/serializable.js";
+import type { BaseCallbackConfig } from "../callbacks/manager.js";
 export type RunnableBatchOptions = {
     /** @deprecated Pass in via the standard runnable config object instead */
     maxConcurrency?: number;
@@ -41,3 +41,16 @@ export interface Node {
     id: string;
     data: RunnableIOSchema | RunnableInterface;
 }
+export interface RunnableConfig extends BaseCallbackConfig {
+    /**
+     * Runtime values for attributes previously made configurable on this Runnable,
+     * or sub-Runnables.
+     */
+    configurable?: Record<string, any>;
+    /**
+     * Maximum number of times a call can recurse. If not provided, defaults to 25.
+     */
+    recursionLimit?: number;
+    /** Maximum number of parallel calls to make. */
+    maxConcurrency?: number;
+}

package/dist/singletons/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 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 manager_js_1 = require("../callbacks/manager.cjs");
 class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -12,14 +14,42 @@ class MockAsyncLocalStorage {
 }
 exports.MockAsyncLocalStorage = MockAsyncLocalStorage;
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
+const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const LC_CHILD_KEY = Symbol.for("lc:child_config");
 class AsyncLocalStorageProvider {
     getInstance() {
-        return (globalThis.__lc_tracing_async_local_storage ??
-            mockAsyncLocalStorage);
+        return globalThis[TRACING_ALS_KEY] ?? 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 parentRunId = callbackManager?.getParentRunId();
+        const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
+        let runTree;
+        if (langChainTracer && parentRunId) {
+            runTree = langChainTracer.convertToRunTree(parentRunId);
+        }
+        else if (!avoidCreatingRootRunTree) {
+            runTree = new langsmith_1.RunTree({
+                name: "<runnable_lambda>",
+                tracingEnabled: false,
+            });
+        }
+        if (runTree) {
+            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
+        }
+        return storage.run(runTree, callback);
     }
     initializeGlobalInstance(instance) {
-        if (globalThis.__lc_tracing_async_local_storage === undefined) {
-            globalThis.__lc_tracing_async_local_storage = instance;
+        if (globalThis[TRACING_ALS_KEY] === undefined) {
+            globalThis[TRACING_ALS_KEY] = instance;
         }
     }
 }

package/dist/singletons/index.d.ts

@@ -8,6 +8,8 @@ export declare class MockAsyncLocalStorage implements AsyncLocalStorageInterface
 }
 declare class AsyncLocalStorageProvider {
     getInstance(): AsyncLocalStorageInterface;
+    getRunnableConfig(): any;
+    runWithConfig<T>(config: any, callback: () => T, avoidCreatingRootRunTree?: boolean): T;
     initializeGlobalInstance(instance: AsyncLocalStorageInterface): void;
 }
 declare const AsyncLocalStorageProviderSingleton: AsyncLocalStorageProvider;

package/dist/singletons/index.js

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { RunTree } from "langsmith";
+import { CallbackManager } from "../callbacks/manager.js";
 export class MockAsyncLocalStorage {
     getStore() {
         return undefined;
@@ -8,14 +10,42 @@ export class MockAsyncLocalStorage {
     }
 }
 const mockAsyncLocalStorage = new MockAsyncLocalStorage();
+const TRACING_ALS_KEY = Symbol.for("ls:tracing_async_local_storage");
+const LC_CHILD_KEY = Symbol.for("lc:child_config");
 class AsyncLocalStorageProvider {
     getInstance() {
-        return (globalThis.__lc_tracing_async_local_storage ??
-            mockAsyncLocalStorage);
+        return globalThis[TRACING_ALS_KEY] ?? 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 = CallbackManager._configureSync(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
+        const storage = this.getInstance();
+        const parentRunId = callbackManager?.getParentRunId();
+        const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
+        let runTree;
+        if (langChainTracer && parentRunId) {
+            runTree = langChainTracer.convertToRunTree(parentRunId);
+        }
+        else if (!avoidCreatingRootRunTree) {
+            runTree = new RunTree({
+                name: "<runnable_lambda>",
+                tracingEnabled: false,
+            });
+        }
+        if (runTree) {
+            runTree.extra = { ...runTree.extra, [LC_CHILD_KEY]: config };
+        }
+        return storage.run(runTree, callback);
     }
     initializeGlobalInstance(instance) {
-        if (globalThis.__lc_tracing_async_local_storage === undefined) {
-            globalThis.__lc_tracing_async_local_storage = instance;
+        if (globalThis[TRACING_ALS_KEY] === undefined) {
+            globalThis[TRACING_ALS_KEY] = instance;
         }
     }
 }

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

@@ -108,7 +108,6 @@ test("Config should be automatically populated after setting global async local
 });
 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"],
     });
@@ -117,7 +116,7 @@ test("Runnable streamEvents method with streaming nested in a RunnableLambda", a
     const innerRunId2 = v4();
     const dummyHandler = new FakeCallbackHandler();
     const myFunc = async (input) => {
-        const outerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+        const outerCallbackManager = await getCallbackManagerForConfig(AsyncLocalStorageProviderSingleton.getRunnableConfig());
         expect(outerCallbackManager?.getParentRunId()).toEqual(outerRunId);
         const nestedLambdaWithOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
             expect(config?.callbacks?.handlers).toEqual([]);
@@ -127,7 +126,7 @@ test("Runnable streamEvents method with streaming nested in a RunnableLambda", a
             callbacks: [],
         });
         const nestedLambdaWithoutOverriddenCallbacks = RunnableLambda.from(async (_, config) => {
-            const innerCallbackManager = await getCallbackManagerForConfig(asyncLocalStorage.getStore());
+            const innerCallbackManager = await getCallbackManagerForConfig(AsyncLocalStorageProviderSingleton.getRunnableConfig());
             expect(innerCallbackManager?.getParentRunId()).toEqual(innerRunId2);
             expect(config?.callbacks?.handlers).toContain(dummyHandler);
         });

package/dist/tracers/base.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTracer = void 0;
+exports.BaseTracer = exports.isBaseTracer = void 0;
 const base_js_1 = require("../callbacks/base.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
@@ -15,6 +15,10 @@ function convertToDottedOrderFormat(epoch, runId, executionOrder) {
     const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
     return (stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId);
 }
+function isBaseTracer(x) {
+    return typeof x._addRunToRunMap === "function";
+}
+exports.isBaseTracer = isBaseTracer;
 class BaseTracer extends base_js_1.BaseCallbackHandler {
     constructor(_fields) {
         super(...arguments);
@@ -41,7 +45,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     _addChildRun(parentRun, childRun) {
         parentRun.child_runs.push(childRun);
     }
-    async _startTrace(run) {
+    _addRunToRunMap(run) {
         const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order);
         const storedRun = { ...run };
         if (storedRun.parent_run_id !== undefined) {
@@ -73,7 +77,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             storedRun.dotted_order = currentDottedOrder;
         }
         this.runMap.set(storedRun.id, storedRun);
-        await this.onRunCreate?.(storedRun);
+        return storedRun;
     }
     async _endTrace(run) {
         const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
@@ -94,7 +98,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         }
         return parentRun.child_execution_order + 1;
     }
-    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for LLM start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -120,11 +129,21 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
         return run;
     }
-    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for chat model start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const finalExtraParams = metadata
@@ -150,7 +169,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: finalExtraParams ?? {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
         return run;
     }
@@ -184,7 +208,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this._endTrace(run);
         return run;
     }
-    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+    /**
+     * Create and add a run to the run map for chain start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
@@ -207,7 +236,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
+        await this.onRunCreate?.(run);
         await this.onChainStart?.(run);
         return run;
     }
@@ -247,7 +281,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this._endTrace(run);
         return run;
     }
-    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for tool start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
@@ -270,7 +309,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onToolStart?.(run);
         return run;
     }
@@ -332,7 +376,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         });
         await this.onAgentEnd?.(run);
     }
-    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+    /**
+     * Create and add a run to the run map for retriever start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
         const execution_order = this._getExecutionOrder(parentRunId);
         const start_time = Date.now();
         const run = {
@@ -355,7 +404,12 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             extra: metadata ? { metadata } : {},
             tags: tags || [],
         };
-        await this._startTrace(run);
+        return this._addRunToRunMap(run);
+    }
+    async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
+        const run = this.runMap.get(runId) ??
+            this._createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name);
+        await this.onRunCreate?.(run);
         await this.onRetrieverStart?.(run);
         return run;
     }

package/dist/tracers/base.d.ts

@@ -24,6 +24,7 @@ export interface Run extends BaseRun {
 export interface AgentRun extends Run {
     actions: AgentAction[];
 }
+export declare function isBaseTracer(x: BaseCallbackHandler): x is BaseTracer;
 export declare abstract class BaseTracer extends BaseCallbackHandler {
     protected runMap: Map<string, Run>;
     constructor(_fields?: BaseCallbackHandlerInput);
@@ -31,13 +32,127 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     protected stringifyError(error: unknown): string;
     protected abstract persistRun(run: Run): Promise<void>;
     protected _addChildRun(parentRun: Run, childRun: Run): void;
-    protected _startTrace(run: Run): Promise<void>;
+    _addRunToRunMap(run: Run): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     protected _endTrace(run: Run): Promise<void>;
     protected _getExecutionOrder(parentRunId: string | undefined): number;
+    /**
+     * Create and add a run to the run map for LLM start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleLLMStart(llm: Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
+    /**
+     * Create and add a run to the run map for chat model start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleChatModelStart(llm: Serialized, messages: BaseMessage[][], runId: string, parentRunId?: string, extraParams?: KVMap, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleLLMEnd(output: LLMResult, runId: string): Promise<Run>;
     handleLLMError(error: unknown, runId: string): Promise<Run>;
+    /**
+     * Create and add a run to the run map for chain start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleChainStart(chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, runType?: string, name?: string): Promise<Run>;
     handleChainEnd(outputs: ChainValues, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
@@ -45,11 +160,71 @@ export declare abstract class BaseTracer extends BaseCallbackHandler {
     handleChainError(error: unknown, runId: string, _parentRunId?: string, _tags?: string[], kwargs?: {
         inputs?: Record<string, unknown>;
     }): Promise<Run>;
+    /**
+     * Create and add a run to the run map for tool start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleToolEnd(output: any, runId: string): Promise<Run>;
     handleToolError(error: unknown, runId: string): Promise<Run>;
     handleAgentAction(action: AgentAction, runId: string): Promise<void>;
     handleAgentEnd(action: AgentFinish, runId: string): Promise<void>;
+    /**
+     * Create and add a run to the run map for retriever start events.
+     * This must sometimes be done synchronously to avoid race conditions
+     * when callbacks are backgrounded, so we expose it as a separate method here.
+     */
+    _createRunForRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): {
+        id: string;
+        start_time: number;
+        execution_order: number;
+        child_runs: Run[];
+        child_execution_order: number;
+        events: {
+            name: string;
+            time: string;
+            kwargs?: Record<string, unknown> | undefined;
+        }[];
+        trace_id?: string | undefined;
+        dotted_order?: string | undefined;
+        name: string;
+        run_type: string;
+        end_time?: number | undefined;
+        extra?: KVMap | undefined;
+        error?: string | undefined;
+        serialized?: object | undefined;
+        inputs: KVMap;
+        outputs?: KVMap | undefined;
+        reference_example_id?: string | undefined;
+        parent_run_id?: string | undefined;
+        tags?: string[] | undefined;
+    };
     handleRetrieverStart(retriever: Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: KVMap, name?: string): Promise<Run>;
     handleRetrieverEnd(documents: Document<Record<string, unknown>>[], runId: string): Promise<Run>;
     handleRetrieverError(error: unknown, runId: string): Promise<Run>;