@nocobase/plugin-ai 1.9.33 → 1.9.34

package/dist/node_modules/@langchain/core/dist/tracers/base.js

@@ -1,33 +1,82 @@
+import { RunTree, convertToDottedOrderFormat } 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,
+        start_time: run._serialized_start_time ?? run.start_time,
+        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"
         ? value
         : { [defaultKey]: value };
 }
-function stripNonAlphanumeric(input) {
-    return input.replace(/[-:.]/g, "");
-}
-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);
-}
 export function isBaseTracer(x) {
     return typeof x._addRunToRunMap === "function";
 }
 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) {
@@ -42,10 +91,10 @@ export class BaseTracer extends BaseCallbackHandler {
         parentRun.child_runs.push(childRun);
     }
     _addRunToRunMap(run) {
-        const currentDottedOrder = convertToDottedOrderFormat(run.start_time, run.id, run.execution_order);
+        const { dottedOrder: currentDottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(new Date(run.start_time).getTime(), 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);
@@ -55,6 +104,7 @@ export class BaseTracer extends BaseCallbackHandler {
                         parentRun.dotted_order,
                         currentDottedOrder,
                     ].join(".");
+                    storedRun._serialized_start_time = microsecondPrecisionDatestring;
                 }
                 else {
                     // This can happen naturally for callbacks added within a run
@@ -71,23 +121,37 @@ export class BaseTracer extends BaseCallbackHandler {
         else {
             storedRun.trace_id = storedRun.id;
             storedRun.dotted_order = currentDottedOrder;
+            storedRun._serialized_start_time = microsecondPrecisionDatestring;
+        }
+        if (this.usesRunTreeMap) {
+            const runTree = convertRunToRunTree(storedRun, parentRun);
+            if (runTree !== undefined) {
+                this.runTreeMap.set(storedRun.id, runTree);
+            }
+        }
+        else {
+            this.runMap.set(storedRun.id, storedRun);
         }
-        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 +192,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 +232,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 +255,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 +301,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 +326,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 +374,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 +382,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 +397,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 +412,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 +427,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 +469,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 +491,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 +506,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 +518,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/node_modules/@langchain/core/dist/tracers/initialize.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracingV2CallbackHandler = exports.getTracingCallbackHandler = void 0;
+exports.getTracingCallbackHandler = getTracingCallbackHandler;
+exports.getTracingV2CallbackHandler = getTracingV2CallbackHandler;
 const tracer_langchain_js_1 = require("./tracer_langchain.cjs");
 const tracer_langchain_v1_js_1 = require("./tracer_langchain_v1.cjs");
 /**
@@ -22,7 +23,6 @@ async function getTracingCallbackHandler(session) {
     }
     return tracer;
 }
-exports.getTracingCallbackHandler = getTracingCallbackHandler;
 /**
  * @deprecated Instantiate directly using the LangChainTracer constructor.
  *
@@ -33,4 +33,3 @@ exports.getTracingCallbackHandler = getTracingCallbackHandler;
 async function getTracingV2CallbackHandler() {
     return new tracer_langchain_js_1.LangChainTracer();
 }
-exports.getTracingV2CallbackHandler = getTracingV2CallbackHandler;

package/dist/node_modules/@langchain/core/dist/tracers/tracer_langchain.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LangChainTracer = void 0;
+const langsmith_1 = require("langsmith");
 const run_trees_1 = require("langsmith/run_trees");
 const traceable_1 = require("langsmith/singletons/traceable");
-const env_js_1 = require("../utils/env.cjs");
 const base_js_1 = require("./base.cjs");
 const tracer_js_1 = require("../singletons/tracer.cjs");
 class LangChainTracer extends base_js_1.BaseTracer {
@@ -33,11 +33,21 @@ class LangChainTracer extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
-        const { exampleId, projectName, client } = fields;
-        this.projectName =
-            projectName ??
-                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_PROJECT") ??
-                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
+        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, langsmith_1.getDefaultProjectName)();
+        this.replicas = replicas;
         this.exampleId = exampleId;
         this.client = client ?? (0, tracer_js_1.getDefaultLangChainClientSingleton)();
         const traceableTree = LangChainTracer.getTraceableRunTree();
@@ -45,41 +55,20 @@ 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,
-        };
-        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) {
+        this.runTreeMap.set(runTree.id, runTree);
         let rootRun = runTree;
         const visited = new Set();
         while (rootRun.parent_run) {
@@ -97,60 +86,35 @@ 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 {
-            return (0, traceable_1.getCurrentRunTree)();
+            return (
+            // The type cast here provides forward compatibility. Old versions of LangSmith will just
+            // ignore the permitAbsentRunTree arg.
+            traceable_1.getCurrentRunTree(true));
         }
         catch {
             return undefined;

package/dist/node_modules/@langchain/core/dist/tracers/tracer_langchain.d.ts

@@ -1,5 +1,5 @@
-import type { LangSmithTracingClientInterface } from "langsmith";
-import { RunTree } from "langsmith/run_trees";
+import { type LangSmithTracingClientInterface } from "langsmith";
+import { RunTree, type RunTreeConfig } from "langsmith/run_trees";
 import { BaseRun, RunCreate, RunUpdate as BaseRunUpdate, KVMap } from "langsmith/schemas";
 import { BaseTracer } from "./base.js";
 import { BaseCallbackHandlerInput } from "../callbacks/base.js";
@@ -24,19 +24,21 @@ export interface LangChainTracerFields extends BaseCallbackHandlerInput {
     exampleId?: string;
     projectName?: string;
     client?: LangSmithTracingClientInterface;
+    replicas?: RunTreeConfig["replicas"];
 }
 export declare class LangChainTracer extends BaseTracer implements LangChainTracerFields {
     name: string;
     projectName?: string;
     exampleId?: string;
     client: LangSmithTracingClientInterface;
+    replicas?: RunTreeConfig["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/node_modules/@langchain/core/dist/tracers/tracer_langchain.js

@@ -1,6 +1,6 @@
+import { getDefaultProjectName, } from "langsmith";
 import { RunTree } from "langsmith/run_trees";
 import { getCurrentRunTree } from "langsmith/singletons/traceable";
-import { getEnvironmentVariable, getRuntimeEnvironment } from "../utils/env.js";
 import { BaseTracer } from "./base.js";
 import { getDefaultLangChainClientSingleton } from "../singletons/tracer.js";
 export class LangChainTracer extends BaseTracer {
@@ -30,11 +30,21 @@ export class LangChainTracer extends BaseTracer {
             writable: true,
             value: void 0
         });
-        const { exampleId, projectName, client } = fields;
-        this.projectName =
-            projectName ??
-                getEnvironmentVariable("LANGCHAIN_PROJECT") ??
-                getEnvironmentVariable("LANGCHAIN_SESSION");
+        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 ?? getDefaultProjectName();
+        this.replicas = replicas;
         this.exampleId = exampleId;
         this.client = client ?? getDefaultLangChainClientSingleton();
         const traceableTree = LangChainTracer.getTraceableRunTree();
@@ -42,41 +52,20 @@ 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,
-        };
-        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) {
+        this.runTreeMap.set(runTree.id, runTree);
         let rootRun = runTree;
         const visited = new Set();
         while (rootRun.parent_run) {
@@ -94,60 +83,35 @@ 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 {
-            return getCurrentRunTree();
+            return (
+            // The type cast here provides forward compatibility. Old versions of LangSmith will just
+            // ignore the permitAbsentRunTree arg.
+            getCurrentRunTree(true));
         }
         catch {
             return undefined;