@langchain/core 0.3.58 → 0.3.59-rc.1

package/dist/language_models/base.d.ts

@@ -63,7 +63,25 @@ export interface BaseLanguageModelParams extends AsyncCallerParams, BaseLangChai
     callbackManager?: CallbackManager;
     cache?: BaseCache | boolean;
 }
-export interface BaseLanguageModelCallOptions extends RunnableConfig {
+export interface BaseLanguageModelTracingCallOptions {
+    /**
+     * Describes the format of structured outputs.
+     * This should be provided if an output is considered to be structured
+     */
+    ls_structured_output_format?: {
+        /**
+         * An object containing the method used for structured output (e.g., "jsonMode").
+         */
+        kwargs: {
+            method: string;
+        };
+        /**
+         * The JSON schema describing the expected output structure.
+         */
+        schema?: JSONSchema;
+    };
+}
+export interface BaseLanguageModelCallOptions extends RunnableConfig, BaseLanguageModelTracingCallOptions {
     /**
      * Stop tokens to use for this call.
      * If not provided, the default stop tokens for the model will be used.

package/dist/singletons/async_local_storage/index.cjs

@@ -38,7 +38,7 @@ class AsyncLocalStorageProvider {
         const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
         let runTree;
         if (langChainTracer && parentRunId) {
-            runTree = langChainTracer.convertToRunTree(parentRunId);
+            runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);
         }
         else if (!avoidCreatingRootRunTree) {
             runTree = new langsmith_1.RunTree({

package/dist/singletons/async_local_storage/index.js

@@ -34,7 +34,7 @@ class AsyncLocalStorageProvider {
         const langChainTracer = callbackManager?.handlers?.find((handler) => handler?.name === "langchain_tracer");
         let runTree;
         if (langChainTracer && parentRunId) {
-            runTree = langChainTracer.convertToRunTree(parentRunId);
+            runTree = langChainTracer.getRunTreeWithTracingConfig(parentRunId);
         }
         else if (!avoidCreatingRootRunTree) {
             runTree = new RunTree({

package/dist/singletons/callbacks.cjs

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.awaitAllCallbacks = exports.consumeCallback = exports.getQueue = void 0;
 const p_queue_1 = __importDefault(require("p-queue"));
 const globals_js_1 = require("./async_local_storage/globals.cjs");
+const tracer_js_1 = require("./tracer.cjs");
 let queue;
 /**
  * Creates a queue using the p-queue library. The queue is configured to
@@ -62,7 +63,11 @@ exports.consumeCallback = consumeCallback;
  * Waits for all promises in the queue to resolve. If the queue is
  * undefined, it immediately resolves a promise.
  */
-function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
+async function awaitAllCallbacks() {
+    const defaultClient = (0, tracer_js_1.getDefaultLangChainClientSingleton)();
+    await Promise.all([
+        typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(),
+        defaultClient.awaitPendingTraceBatches(),
+    ]);
 }
 exports.awaitAllCallbacks = awaitAllCallbacks;

package/dist/singletons/callbacks.js

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import PQueueMod from "p-queue";
 import { getGlobalAsyncLocalStorageInstance } from "./async_local_storage/globals.js";
+import { getDefaultLangChainClientSingleton } from "./tracer.js";
 let queue;
 /**
  * Creates a queue using the p-queue library. The queue is configured to
@@ -54,6 +55,10 @@ export async function consumeCallback(promiseFn, wait) {
  * Waits for all promises in the queue to resolve. If the queue is
  * undefined, it immediately resolves a promise.
  */
-export function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
+export async function awaitAllCallbacks() {
+    const defaultClient = getDefaultLangChainClientSingleton();
+    await Promise.all([
+        typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve(),
+        defaultClient.awaitPendingTraceBatches(),
+    ]);
 }

package/dist/tracers/base.cjs

@@ -1,7 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseTracer = exports.isBaseTracer = void 0;
+const run_trees_1 = require("langsmith/run_trees");
 const base_js_1 = require("../callbacks/base.cjs");
+const env_js_1 = require("../utils/env.cjs");
+// TODO: Remove and just use base LangSmith Run type
+const convertRunTreeToRun = (runTree) => {
+    if (!runTree) {
+        return undefined;
+    }
+    // Important that we return the raw run tree object since the reference
+    // is mutated in other places.
+    // TODO: Remove places where this is being done.
+    // eslint-disable-next-line no-param-reassign
+    runTree.events = runTree.events ?? [];
+    // eslint-disable-next-line no-param-reassign
+    runTree.child_runs = runTree.child_runs ?? [];
+    // TODO: Remove this cast and just use the LangSmith RunTree type.
+    return runTree;
+};
+function convertRunToRunTree(run, parentRun) {
+    if (!run) {
+        return undefined;
+    }
+    return new run_trees_1.RunTree({
+        ...run,
+        parent_run: convertRunToRunTree(parentRun),
+        child_runs: run.child_runs
+            .map((r) => convertRunToRunTree(r))
+            .filter((r) => r !== undefined),
+        extra: {
+            ...run.extra,
+            runtime: (0, env_js_1.getRuntimeEnvironmentSync)(),
+        },
+        tracingEnabled: false,
+    });
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value && !Array.isArray(value) && typeof value === "object"
@@ -22,16 +56,37 @@ exports.isBaseTracer = isBaseTracer;
 class BaseTracer extends base_js_1.BaseCallbackHandler {
     constructor(_fields) {
         super(...arguments);
+        /** @deprecated Use `runTreeMap` instead. */
         Object.defineProperty(this, "runMap", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "runTreeMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "usesRunTreeMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
     }
     copy() {
         return this;
     }
+    getRunById(runId) {
+        if (runId === undefined) {
+            return undefined;
+        }
+        return this.usesRunTreeMap
+            ? convertRunTreeToRun(this.runTreeMap.get(runId))
+            : this.runMap.get(runId);
+    }
     stringifyError(error) {
         // eslint-disable-next-line no-instanceof/no-instanceof
         if (error instanceof Error) {
@@ -48,8 +103,8 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     _addRunToRunMap(run) {
         const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order);
         const storedRun = { ...run };
+        const parentRun = this.getRunById(storedRun.parent_run_id);
         if (storedRun.parent_run_id !== undefined) {
-            const parentRun = this.runMap.get(storedRun.parent_run_id);
             if (parentRun) {
                 this._addChildRun(parentRun, storedRun);
                 parentRun.child_execution_order = Math.max(parentRun.child_execution_order, storedRun.child_execution_order);
@@ -76,22 +131,35 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
             storedRun.trace_id = storedRun.id;
             storedRun.dotted_order = currentDottedOrder;
         }
-        this.runMap.set(storedRun.id, storedRun);
+        if (this.usesRunTreeMap) {
+            const runTree = convertRunToRunTree(storedRun, parentRun);
+            if (runTree !== undefined) {
+                this.runTreeMap.set(storedRun.id, runTree);
+            }
+        }
+        else {
+            this.runMap.set(storedRun.id, storedRun);
+        }
         return storedRun;
     }
     async _endTrace(run) {
-        const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
+        const parentRun = run.parent_run_id !== undefined && this.getRunById(run.parent_run_id);
         if (parentRun) {
             parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
         }
         else {
             await this.persistRun(run);
         }
-        this.runMap.delete(run.id);
         await this.onRunUpdate?.(run);
+        if (this.usesRunTreeMap) {
+            this.runTreeMap.delete(run.id);
+        }
+        else {
+            this.runMap.delete(run.id);
+        }
     }
     _getExecutionOrder(parentRunId) {
-        const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
+        const parentRun = parentRunId !== undefined && this.getRunById(parentRunId);
         // If a run has no parent then execution order is 1
         if (!parentRun) {
             return 1;
@@ -132,7 +200,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
@@ -172,14 +240,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
         return run;
     }
     async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
         }
@@ -195,7 +263,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return run;
     }
     async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
         }
@@ -241,14 +309,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
         await this.onRunCreate?.(run);
         await this.onChainStart?.(run);
         return run;
     }
     async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
@@ -266,7 +334,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return run;
     }
     async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
@@ -314,7 +382,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onToolStart?.(run);
@@ -322,7 +390,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleToolEnd(output, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "tool") {
             throw new Error("No tool run to end");
         }
@@ -337,7 +405,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return run;
     }
     async handleToolError(error, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "tool") {
             throw new Error("No tool run to end");
         }
@@ -352,7 +420,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return run;
     }
     async handleAgentAction(action, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -367,7 +435,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this.onAgentAction?.(run);
     }
     async handleAgentEnd(action, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -409,14 +477,14 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onRetrieverStart?.(run);
         return run;
     }
     async handleRetrieverEnd(documents, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "retriever") {
             throw new Error("No retriever run to end");
         }
@@ -431,7 +499,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return run;
     }
     async handleRetrieverError(error, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "retriever") {
             throw new Error("No retriever run to end");
         }
@@ -446,7 +514,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         return run;
     }
     async handleText(text, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -458,7 +526,7 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
         await this.onText?.(run);
     }
     async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
         }

package/dist/tracers/base.d.ts

@@ -1,4 +1,5 @@
 import { KVMap, BaseRun } from "langsmith/schemas";
+import { RunTree } from "langsmith/run_trees";
 import type { ChainValues } from "../utils/types/index.js";
 import type { AgentAction, AgentFinish } from "../agents.js";
 import type { LLMResult } from "../outputs.js";
@@ -26,9 +27,13 @@ export interface AgentRun extends Run {
 }
 export declare function isBaseTracer(x: BaseCallbackHandler): x is BaseTracer;
 export declare abstract class BaseTracer extends BaseCallbackHandler {
+    /** @deprecated Use `runTreeMap` instead. */
     protected runMap: Map<string, Run>;
+    protected runTreeMap: Map<string, RunTree>;
+    protected usesRunTreeMap: boolean;
     constructor(_fields?: BaseCallbackHandlerInput);
     copy(): this;
+    protected getRunById(runId?: string): Run | undefined;
     protected stringifyError(error: unknown): string;
     protected abstract persistRun(run: Run): Promise<void>;
     protected _addChildRun(parentRun: Run, childRun: Run): void;

package/dist/tracers/base.js

@@ -1,4 +1,38 @@
+import { RunTree } from "langsmith/run_trees";
 import { BaseCallbackHandler, } from "../callbacks/base.js";
+import { getRuntimeEnvironmentSync } from "../utils/env.js";
+// TODO: Remove and just use base LangSmith Run type
+const convertRunTreeToRun = (runTree) => {
+    if (!runTree) {
+        return undefined;
+    }
+    // Important that we return the raw run tree object since the reference
+    // is mutated in other places.
+    // TODO: Remove places where this is being done.
+    // eslint-disable-next-line no-param-reassign
+    runTree.events = runTree.events ?? [];
+    // eslint-disable-next-line no-param-reassign
+    runTree.child_runs = runTree.child_runs ?? [];
+    // TODO: Remove this cast and just use the LangSmith RunTree type.
+    return runTree;
+};
+function convertRunToRunTree(run, parentRun) {
+    if (!run) {
+        return undefined;
+    }
+    return new RunTree({
+        ...run,
+        parent_run: convertRunToRunTree(parentRun),
+        child_runs: run.child_runs
+            .map((r) => convertRunToRunTree(r))
+            .filter((r) => r !== undefined),
+        extra: {
+            ...run.extra,
+            runtime: getRuntimeEnvironmentSync(),
+        },
+        tracingEnabled: false,
+    });
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value && !Array.isArray(value) && typeof value === "object"
@@ -18,16 +52,37 @@ export function isBaseTracer(x) {
 export class BaseTracer extends BaseCallbackHandler {
     constructor(_fields) {
         super(...arguments);
+        /** @deprecated Use `runTreeMap` instead. */
         Object.defineProperty(this, "runMap", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Map()
         });
+        Object.defineProperty(this, "runTreeMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "usesRunTreeMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
     }
     copy() {
         return this;
     }
+    getRunById(runId) {
+        if (runId === undefined) {
+            return undefined;
+        }
+        return this.usesRunTreeMap
+            ? convertRunTreeToRun(this.runTreeMap.get(runId))
+            : this.runMap.get(runId);
+    }
     stringifyError(error) {
         // eslint-disable-next-line no-instanceof/no-instanceof
         if (error instanceof Error) {
@@ -44,8 +99,8 @@ export class BaseTracer extends BaseCallbackHandler {
     _addRunToRunMap(run) {
         const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order);
         const storedRun = { ...run };
+        const parentRun = this.getRunById(storedRun.parent_run_id);
         if (storedRun.parent_run_id !== undefined) {
-            const parentRun = this.runMap.get(storedRun.parent_run_id);
             if (parentRun) {
                 this._addChildRun(parentRun, storedRun);
                 parentRun.child_execution_order = Math.max(parentRun.child_execution_order, storedRun.child_execution_order);
@@ -72,22 +127,35 @@ export class BaseTracer extends BaseCallbackHandler {
             storedRun.trace_id = storedRun.id;
             storedRun.dotted_order = currentDottedOrder;
         }
-        this.runMap.set(storedRun.id, storedRun);
+        if (this.usesRunTreeMap) {
+            const runTree = convertRunToRunTree(storedRun, parentRun);
+            if (runTree !== undefined) {
+                this.runTreeMap.set(storedRun.id, runTree);
+            }
+        }
+        else {
+            this.runMap.set(storedRun.id, storedRun);
+        }
         return storedRun;
     }
     async _endTrace(run) {
-        const parentRun = run.parent_run_id !== undefined && this.runMap.get(run.parent_run_id);
+        const parentRun = run.parent_run_id !== undefined && this.getRunById(run.parent_run_id);
         if (parentRun) {
             parentRun.child_execution_order = Math.max(parentRun.child_execution_order, run.child_execution_order);
         }
         else {
             await this.persistRun(run);
         }
-        this.runMap.delete(run.id);
         await this.onRunUpdate?.(run);
+        if (this.usesRunTreeMap) {
+            this.runTreeMap.delete(run.id);
+        }
+        else {
+            this.runMap.delete(run.id);
+        }
     }
     _getExecutionOrder(parentRunId) {
-        const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
+        const parentRun = parentRunId !== undefined && this.getRunById(parentRunId);
         // If a run has no parent then execution order is 1
         if (!parentRun) {
             return 1;
@@ -128,7 +196,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
@@ -168,14 +236,14 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
         return run;
     }
     async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
         }
@@ -191,7 +259,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
         }
@@ -237,14 +305,14 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name);
         await this.onRunCreate?.(run);
         await this.onChainStart?.(run);
         return run;
     }
     async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
@@ -262,7 +330,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
@@ -310,7 +378,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onToolStart?.(run);
@@ -318,7 +386,7 @@ export class BaseTracer extends BaseCallbackHandler {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleToolEnd(output, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "tool") {
             throw new Error("No tool run to end");
         }
@@ -333,7 +401,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleToolError(error, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "tool") {
             throw new Error("No tool run to end");
         }
@@ -348,7 +416,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleAgentAction(action, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -363,7 +431,7 @@ export class BaseTracer extends BaseCallbackHandler {
         await this.onAgentAction?.(run);
     }
     async handleAgentEnd(action, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -405,14 +473,14 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
-        const run = this.runMap.get(runId) ??
+        const run = this.getRunById(runId) ??
             this._createRunForRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onRetrieverStart?.(run);
         return run;
     }
     async handleRetrieverEnd(documents, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "retriever") {
             throw new Error("No retriever run to end");
         }
@@ -427,7 +495,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleRetrieverError(error, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "retriever") {
             throw new Error("No retriever run to end");
         }
@@ -442,7 +510,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleText(text, runId) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -454,7 +522,7 @@ export class BaseTracer extends BaseCallbackHandler {
         await this.onText?.(run);
     }
     async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
-        const run = this.runMap.get(runId);
+        const run = this.getRunById(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error(`Invalid "runId" provided to "handleLLMNewToken" callback.`);
         }

package/dist/tracers/tracer_langchain.cjs

@@ -33,11 +33,24 @@ class LangChainTracer extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
-        const { exampleId, projectName, client } = fields;
+        Object.defineProperty(this, "replicas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "usesRunTreeMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        const { exampleId, projectName, client, replicas } = fields;
         this.projectName =
             projectName ??
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_PROJECT") ??
                 (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
+        this.replicas = replicas;
         this.exampleId = exampleId;
         this.client = client ?? (0, tracer_js_1.getDefaultLangChainClientSingleton)();
         const traceableTree = LangChainTracer.getTraceableRunTree();
@@ -45,40 +58,17 @@ class LangChainTracer extends base_js_1.BaseTracer {
             this.updateFromRunTree(traceableTree);
         }
     }
-    async _convertToCreate(run, example_id = undefined) {
-        return {
-            ...run,
-            extra: {
-                ...run.extra,
-                runtime: await (0, env_js_1.getRuntimeEnvironment)(),
-            },
-            child_runs: undefined,
-            session_name: this.projectName,
-            reference_example_id: run.parent_run_id ? undefined : example_id,
-        };
-    }
     async persistRun(_run) { }
     async onRunCreate(run) {
-        const persistedRun = await this._convertToCreate(run, this.exampleId);
-        await this.client.createRun(persistedRun);
+        const runTree = this.getRunTreeWithTracingConfig(run.id);
+        await runTree?.postRun();
     }
     async onRunUpdate(run) {
-        const runUpdate = {
-            end_time: run.end_time,
-            error: run.error,
-            outputs: run.outputs,
-            events: run.events,
-            inputs: run.inputs,
-            trace_id: run.trace_id,
-            dotted_order: run.dotted_order,
-            parent_run_id: run.parent_run_id,
-            extra: run.extra,
-            session_name: this.projectName,
-        };
-        await this.client.updateRun(run.id, runUpdate);
+        const runTree = this.getRunTreeWithTracingConfig(run.id);
+        await runTree?.patchRun();
     }
     getRun(id) {
-        return this.runMap.get(id);
+        return this.runTreeMap.get(id);
     }
     updateFromRunTree(runTree) {
         let rootRun = runTree;
@@ -98,56 +88,28 @@ class LangChainTracer extends base_js_1.BaseTracer {
             if (!current || visited.has(current.id))
                 continue;
             visited.add(current.id);
-            // @ts-expect-error Types of property 'events' are incompatible.
-            this.runMap.set(current.id, current);
+            this.runTreeMap.set(current.id, current);
             if (current.child_runs) {
                 queue.push(...current.child_runs);
             }
         }
         this.client = runTree.client ?? this.client;
+        this.replicas = runTree.replicas ?? this.replicas;
         this.projectName = runTree.project_name ?? this.projectName;
         this.exampleId = runTree.reference_example_id ?? this.exampleId;
     }
-    convertToRunTree(id) {
-        const runTreeMap = {};
-        const runTreeList = [];
-        for (const [id, run] of this.runMap) {
-            // by converting the run map to a run tree, we are doing a copy
-            // thus, any mutation performed on the run tree will not be reflected
-            // back in the run map
-            // TODO: Stop using `this.runMap` in favour of LangSmith's `RunTree`
-            const runTree = new run_trees_1.RunTree({
-                ...run,
-                child_runs: [],
-                parent_run: undefined,
-                // inherited properties
-                client: this.client,
-                project_name: this.projectName,
-                reference_example_id: this.exampleId,
-                tracingEnabled: true,
-            });
-            runTreeMap[id] = runTree;
-            runTreeList.push([id, run.dotted_order]);
-        }
-        runTreeList.sort((a, b) => {
-            if (!a[1] || !b[1])
-                return 0;
-            return a[1].localeCompare(b[1]);
+    getRunTreeWithTracingConfig(id) {
+        const runTree = this.runTreeMap.get(id);
+        if (!runTree)
+            return undefined;
+        return new run_trees_1.RunTree({
+            ...runTree,
+            client: this.client,
+            project_name: this.projectName,
+            replicas: this.replicas,
+            reference_example_id: this.exampleId,
+            tracingEnabled: true,
         });
-        for (const [id] of runTreeList) {
-            const run = this.runMap.get(id);
-            const runTree = runTreeMap[id];
-            if (!run || !runTree)
-                continue;
-            if (run.parent_run_id) {
-                const parentRunTree = runTreeMap[run.parent_run_id];
-                if (parentRunTree) {
-                    parentRunTree.child_runs.push(runTree);
-                    runTree.parent_run = parentRunTree;
-                }
-            }
-        }
-        return runTreeMap[id];
     }
     static getTraceableRunTree() {
         try {

package/dist/tracers/tracer_langchain.d.ts

@@ -24,19 +24,21 @@ export interface LangChainTracerFields extends BaseCallbackHandlerInput {
     exampleId?: string;
     projectName?: string;
     client?: LangSmithTracingClientInterface;
+    replicas?: RunTree["replicas"];
 }
 export declare class LangChainTracer extends BaseTracer implements LangChainTracerFields {
     name: string;
     projectName?: string;
     exampleId?: string;
     client: LangSmithTracingClientInterface;
+    replicas?: RunTree["replicas"];
+    usesRunTreeMap: boolean;
     constructor(fields?: LangChainTracerFields);
-    private _convertToCreate;
     protected persistRun(_run: Run): Promise<void>;
     onRunCreate(run: Run): Promise<void>;
     onRunUpdate(run: Run): Promise<void>;
     getRun(id: string): Run | undefined;
     updateFromRunTree(runTree: RunTree): void;
-    convertToRunTree(id: string): RunTree | undefined;
+    getRunTreeWithTracingConfig(id: string): RunTree | undefined;
     static getTraceableRunTree(): RunTree | undefined;
 }

package/dist/tracers/tracer_langchain.js

@@ -1,6 +1,6 @@
 import { RunTree } from "langsmith/run_trees";
 import { getCurrentRunTree } from "langsmith/singletons/traceable";
-import { getEnvironmentVariable, getRuntimeEnvironment } from "../utils/env.js";
+import { getEnvironmentVariable } from "../utils/env.js";
 import { BaseTracer } from "./base.js";
 import { getDefaultLangChainClientSingleton } from "../singletons/tracer.js";
 export class LangChainTracer extends BaseTracer {
@@ -30,11 +30,24 @@ export class LangChainTracer extends BaseTracer {
             writable: true,
             value: void 0
         });
-        const { exampleId, projectName, client } = fields;
+        Object.defineProperty(this, "replicas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "usesRunTreeMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        const { exampleId, projectName, client, replicas } = fields;
         this.projectName =
             projectName ??
                 getEnvironmentVariable("LANGCHAIN_PROJECT") ??
                 getEnvironmentVariable("LANGCHAIN_SESSION");
+        this.replicas = replicas;
         this.exampleId = exampleId;
         this.client = client ?? getDefaultLangChainClientSingleton();
         const traceableTree = LangChainTracer.getTraceableRunTree();
@@ -42,40 +55,17 @@ export class LangChainTracer extends BaseTracer {
             this.updateFromRunTree(traceableTree);
         }
     }
-    async _convertToCreate(run, example_id = undefined) {
-        return {
-            ...run,
-            extra: {
-                ...run.extra,
-                runtime: await getRuntimeEnvironment(),
-            },
-            child_runs: undefined,
-            session_name: this.projectName,
-            reference_example_id: run.parent_run_id ? undefined : example_id,
-        };
-    }
     async persistRun(_run) { }
     async onRunCreate(run) {
-        const persistedRun = await this._convertToCreate(run, this.exampleId);
-        await this.client.createRun(persistedRun);
+        const runTree = this.getRunTreeWithTracingConfig(run.id);
+        await runTree?.postRun();
     }
     async onRunUpdate(run) {
-        const runUpdate = {
-            end_time: run.end_time,
-            error: run.error,
-            outputs: run.outputs,
-            events: run.events,
-            inputs: run.inputs,
-            trace_id: run.trace_id,
-            dotted_order: run.dotted_order,
-            parent_run_id: run.parent_run_id,
-            extra: run.extra,
-            session_name: this.projectName,
-        };
-        await this.client.updateRun(run.id, runUpdate);
+        const runTree = this.getRunTreeWithTracingConfig(run.id);
+        await runTree?.patchRun();
     }
     getRun(id) {
-        return this.runMap.get(id);
+        return this.runTreeMap.get(id);
     }
     updateFromRunTree(runTree) {
         let rootRun = runTree;
@@ -95,56 +85,28 @@ export class LangChainTracer extends BaseTracer {
             if (!current || visited.has(current.id))
                 continue;
             visited.add(current.id);
-            // @ts-expect-error Types of property 'events' are incompatible.
-            this.runMap.set(current.id, current);
+            this.runTreeMap.set(current.id, current);
             if (current.child_runs) {
                 queue.push(...current.child_runs);
             }
         }
         this.client = runTree.client ?? this.client;
+        this.replicas = runTree.replicas ?? this.replicas;
         this.projectName = runTree.project_name ?? this.projectName;
         this.exampleId = runTree.reference_example_id ?? this.exampleId;
     }
-    convertToRunTree(id) {
-        const runTreeMap = {};
-        const runTreeList = [];
-        for (const [id, run] of this.runMap) {
-            // by converting the run map to a run tree, we are doing a copy
-            // thus, any mutation performed on the run tree will not be reflected
-            // back in the run map
-            // TODO: Stop using `this.runMap` in favour of LangSmith's `RunTree`
-            const runTree = new RunTree({
-                ...run,
-                child_runs: [],
-                parent_run: undefined,
-                // inherited properties
-                client: this.client,
-                project_name: this.projectName,
-                reference_example_id: this.exampleId,
-                tracingEnabled: true,
-            });
-            runTreeMap[id] = runTree;
-            runTreeList.push([id, run.dotted_order]);
-        }
-        runTreeList.sort((a, b) => {
-            if (!a[1] || !b[1])
-                return 0;
-            return a[1].localeCompare(b[1]);
+    getRunTreeWithTracingConfig(id) {
+        const runTree = this.runTreeMap.get(id);
+        if (!runTree)
+            return undefined;
+        return new RunTree({
+            ...runTree,
+            client: this.client,
+            project_name: this.projectName,
+            replicas: this.replicas,
+            reference_example_id: this.exampleId,
+            tracingEnabled: true,
         });
-        for (const [id] of runTreeList) {
-            const run = this.runMap.get(id);
-            const runTree = runTreeMap[id];
-            if (!run || !runTree)
-                continue;
-            if (run.parent_run_id) {
-                const parentRunTree = runTreeMap[run.parent_run_id];
-                if (parentRunTree) {
-                    parentRunTree.child_runs.push(runTree);
-                    runTree.parent_run = parentRunTree;
-                }
-            }
-        }
-        return runTreeMap[id];
     }
     static getTraceableRunTree() {
         try {

package/dist/utils/env.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvironmentVariable = exports.getRuntimeEnvironment = exports.getEnv = exports.isNode = exports.isDeno = exports.isJsDom = exports.isWebWorker = exports.isBrowser = void 0;
+exports.getEnvironmentVariable = exports.getRuntimeEnvironmentSync = exports.getRuntimeEnvironment = exports.getEnv = exports.isNode = exports.isDeno = exports.isJsDom = exports.isWebWorker = exports.isBrowser = void 0;
 const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
 exports.isBrowser = isBrowser;
 const isWebWorker = () => typeof globalThis === "object" &&
@@ -44,7 +44,14 @@ const getEnv = () => {
 };
 exports.getEnv = getEnv;
 let runtimeEnvironment;
+/**
+ * @deprecated Use getRuntimeEnvironmentSync instead
+ */
 async function getRuntimeEnvironment() {
+    return getRuntimeEnvironmentSync();
+}
+exports.getRuntimeEnvironment = getRuntimeEnvironment;
+function getRuntimeEnvironmentSync() {
     if (runtimeEnvironment === undefined) {
         const env = (0, exports.getEnv)();
         runtimeEnvironment = {
@@ -54,7 +61,7 @@ async function getRuntimeEnvironment() {
     }
     return runtimeEnvironment;
 }
-exports.getRuntimeEnvironment = getRuntimeEnvironment;
+exports.getRuntimeEnvironmentSync = getRuntimeEnvironmentSync;
 function getEnvironmentVariable(name) {
     // Certain Deno setups will throw an error if you try to access environment variables
     // https://github.com/langchain-ai/langchainjs/issues/1412

package/dist/utils/env.d.ts

@@ -20,5 +20,9 @@ export type RuntimeEnvironment = {
     runtime: string;
     runtimeVersion?: string;
 };
+/**
+ * @deprecated Use getRuntimeEnvironmentSync instead
+ */
 export declare function getRuntimeEnvironment(): Promise<RuntimeEnvironment>;
+export declare function getRuntimeEnvironmentSync(): RuntimeEnvironment;
 export declare function getEnvironmentVariable(name: string): string | undefined;

package/dist/utils/env.js

@@ -35,7 +35,13 @@ export const getEnv = () => {
     return env;
 };
 let runtimeEnvironment;
+/**
+ * @deprecated Use getRuntimeEnvironmentSync instead
+ */
 export async function getRuntimeEnvironment() {
+    return getRuntimeEnvironmentSync();
+}
+export function getRuntimeEnvironmentSync() {
     if (runtimeEnvironment === undefined) {
         const env = getEnv();
         runtimeEnvironment = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.3.58",
+  "version": "0.3.59-rc.1",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -38,7 +38,7 @@
     "camelcase": "6",
     "decamelize": "1.2.0",
     "js-tiktoken": "^1.0.12",
-    "langsmith": "^0.3.29",
+    "langsmith": "^0.3.32",
     "mustache": "^4.2.0",
     "p-queue": "^6.6.2",
     "p-retry": "4",