@nocobase/plugin-ai 1.9.36 → 1.9.37

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

@@ -1,82 +1,33 @@
-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) {
@@ -91,10 +42,10 @@ export class BaseTracer extends BaseCallbackHandler {
         parentRun.child_runs.push(childRun);
     }
     _addRunToRunMap(run) {
-        const { dottedOrder: currentDottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(new Date(run.start_time).getTime(), run.id, run.execution_order);
+        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);
@@ -104,7 +55,6 @@ 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
@@ -121,37 +71,23 @@ 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.getRunById(run.parent_run_id);
+        const parentRun = run.parent_run_id !== undefined && this.runMap.get(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.getRunById(parentRunId);
+        const parentRun = parentRunId !== undefined && this.runMap.get(parentRunId);
         // If a run has no parent then execution order is 1
         if (!parentRun) {
             return 1;
@@ -192,7 +128,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name) {
-        const run = this.getRunById(runId) ??
+        const run = this.runMap.get(runId) ??
             this._createRunForLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onLLMStart?.(run);
@@ -232,14 +168,14 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, name) {
-        const run = this.getRunById(runId) ??
+        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;
     }
     async handleLLMEnd(output, runId, _parentRunId, _tags, extraParams) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
         }
@@ -255,7 +191,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleLLMError(error, runId, _parentRunId, _tags, extraParams) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "llm") {
             throw new Error("No LLM run to end.");
         }
@@ -301,14 +237,14 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, runType, name) {
-        const run = this.getRunById(runId) ??
+        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;
     }
     async handleChainEnd(outputs, runId, _parentRunId, _tags, kwargs) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
@@ -326,7 +262,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleChainError(error, runId, _parentRunId, _tags, kwargs) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run) {
             throw new Error("No chain run to end.");
         }
@@ -374,7 +310,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleToolStart(tool, input, runId, parentRunId, tags, metadata, name) {
-        const run = this.getRunById(runId) ??
+        const run = this.runMap.get(runId) ??
             this._createRunForToolStart(tool, input, runId, parentRunId, tags, metadata, name);
         await this.onRunCreate?.(run);
         await this.onToolStart?.(run);
@@ -382,7 +318,7 @@ export class BaseTracer extends BaseCallbackHandler {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async handleToolEnd(output, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "tool") {
             throw new Error("No tool run to end");
         }
@@ -397,7 +333,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleToolError(error, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "tool") {
             throw new Error("No tool run to end");
         }
@@ -412,7 +348,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleAgentAction(action, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -427,7 +363,7 @@ export class BaseTracer extends BaseCallbackHandler {
         await this.onAgentAction?.(run);
     }
     async handleAgentEnd(action, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -469,14 +405,14 @@ export class BaseTracer extends BaseCallbackHandler {
         return this._addRunToRunMap(run);
     }
     async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
-        const run = this.getRunById(runId) ??
+        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;
     }
     async handleRetrieverEnd(documents, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "retriever") {
             throw new Error("No retriever run to end");
         }
@@ -491,7 +427,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleRetrieverError(error, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "retriever") {
             throw new Error("No retriever run to end");
         }
@@ -506,7 +442,7 @@ export class BaseTracer extends BaseCallbackHandler {
         return run;
     }
     async handleText(text, runId) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(runId);
         if (!run || run?.run_type !== "chain") {
             return;
         }
@@ -518,7 +454,7 @@ export class BaseTracer extends BaseCallbackHandler {
         await this.onText?.(run);
     }
     async handleLLMNewToken(token, idx, runId, _parentRunId, _tags, fields) {
-        const run = this.getRunById(runId);
+        const run = this.runMap.get(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,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracingCallbackHandler = getTracingCallbackHandler;
-exports.getTracingV2CallbackHandler = getTracingV2CallbackHandler;
+exports.getTracingV2CallbackHandler = exports.getTracingCallbackHandler = void 0;
 const tracer_langchain_js_1 = require("./tracer_langchain.cjs");
 const tracer_langchain_v1_js_1 = require("./tracer_langchain_v1.cjs");
 /**
@@ -23,6 +22,7 @@ async function getTracingCallbackHandler(session) {
     }
     return tracer;
 }
+exports.getTracingCallbackHandler = getTracingCallbackHandler;
 /**
  * @deprecated Instantiate directly using the LangChainTracer constructor.
  *
@@ -33,3 +33,4 @@ async function getTracingCallbackHandler(session) {
 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,21 +33,11 @@ class LangChainTracer extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
-        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;
+        const { exampleId, projectName, client } = fields;
+        this.projectName =
+            projectName ??
+                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_PROJECT") ??
+                (0, env_js_1.getEnvironmentVariable)("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
         this.client = client ?? (0, tracer_js_1.getDefaultLangChainClientSingleton)();
         const traceableTree = LangChainTracer.getTraceableRunTree();
@@ -55,20 +45,41 @@ 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 runTree = this.getRunTreeWithTracingConfig(run.id);
-        await runTree?.postRun();
+        const persistedRun = await this._convertToCreate(run, this.exampleId);
+        await this.client.createRun(persistedRun);
     }
     async onRunUpdate(run) {
-        const runTree = this.getRunTreeWithTracingConfig(run.id);
-        await runTree?.patchRun();
+        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);
     }
     getRun(id) {
-        return this.runTreeMap.get(id);
+        return this.runMap.get(id);
     }
     updateFromRunTree(runTree) {
-        this.runTreeMap.set(runTree.id, runTree);
         let rootRun = runTree;
         const visited = new Set();
         while (rootRun.parent_run) {
@@ -86,35 +97,60 @@ class LangChainTracer extends base_js_1.BaseTracer {
             if (!current || visited.has(current.id))
                 continue;
             visited.add(current.id);
-            this.runTreeMap.set(current.id, current);
+            // @ts-expect-error Types of property 'events' are incompatible.
+            this.runMap.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;
     }
-    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,
+    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]);
         });
+        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 (
-            // The type cast here provides forward compatibility. Old versions of LangSmith will just
-            // ignore the permitAbsentRunTree arg.
-            traceable_1.getCurrentRunTree(true));
+            return (0, traceable_1.getCurrentRunTree)();
         }
         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, type RunTreeConfig } from "langsmith/run_trees";
+import type { LangSmithTracingClientInterface } from "langsmith";
+import { RunTree } 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,21 +24,19 @@ 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;
-    getRunTreeWithTracingConfig(id: string): RunTree | undefined;
+    convertToRunTree(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,21 +30,11 @@ export class LangChainTracer extends BaseTracer {
             writable: true,
             value: void 0
         });
-        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;
+        const { exampleId, projectName, client } = fields;
+        this.projectName =
+            projectName ??
+                getEnvironmentVariable("LANGCHAIN_PROJECT") ??
+                getEnvironmentVariable("LANGCHAIN_SESSION");
         this.exampleId = exampleId;
         this.client = client ?? getDefaultLangChainClientSingleton();
         const traceableTree = LangChainTracer.getTraceableRunTree();
@@ -52,20 +42,41 @@ 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 runTree = this.getRunTreeWithTracingConfig(run.id);
-        await runTree?.postRun();
+        const persistedRun = await this._convertToCreate(run, this.exampleId);
+        await this.client.createRun(persistedRun);
     }
     async onRunUpdate(run) {
-        const runTree = this.getRunTreeWithTracingConfig(run.id);
-        await runTree?.patchRun();
+        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);
     }
     getRun(id) {
-        return this.runTreeMap.get(id);
+        return this.runMap.get(id);
     }
     updateFromRunTree(runTree) {
-        this.runTreeMap.set(runTree.id, runTree);
         let rootRun = runTree;
         const visited = new Set();
         while (rootRun.parent_run) {
@@ -83,35 +94,60 @@ export class LangChainTracer extends BaseTracer {
             if (!current || visited.has(current.id))
                 continue;
             visited.add(current.id);
-            this.runTreeMap.set(current.id, current);
+            // @ts-expect-error Types of property 'events' are incompatible.
+            this.runMap.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;
     }
-    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,
+    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]);
         });
+        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 (
-            // The type cast here provides forward compatibility. Old versions of LangSmith will just
-            // ignore the permitAbsentRunTree arg.
-            getCurrentRunTree(true));
+            return getCurrentRunTree();
         }
         catch {
             return undefined;

package/dist/node_modules/@langchain/core/dist/types/stream.d.ts

@@ -1,2 +1 @@
-export { type IterableReadableStreamInterface } from "./_internal.js";
-export { type StreamEvent, type StreamEventData, } from "../tracers/event_stream.js";
+export type IterableReadableStreamInterface<T> = ReadableStream<T> & AsyncIterable<T>;