@nocobase/plugin-ai 1.9.36 → 1.9.38

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/middleware.cjs

@@ -11,7 +11,10 @@ const _formatTracedInputs = (params) => {
         return params;
     }
     if (Array.isArray(prompt)) {
-        return { ...rest, messages: prompt.map(utils_js_1.convertMessageToTracedFormat) };
+        return {
+            ...rest,
+            messages: prompt.map((message) => (0, utils_js_1.convertMessageToTracedFormat)(message)),
+        };
     }
     return rest;
 };

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/middleware.js

@@ -8,7 +8,10 @@ const _formatTracedInputs = (params) => {
         return params;
     }
     if (Array.isArray(prompt)) {
-        return { ...rest, messages: prompt.map(convertMessageToTracedFormat) };
+        return {
+            ...rest,
+            messages: prompt.map((message) => convertMessageToTracedFormat(message)),
+        };
     }
     return rest;
 };

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/utils.cjs

@@ -97,7 +97,7 @@ const normalizeFileDataAsDataURL = (fileData, mimeType) => {
     return normalizedFileData;
 };
 exports.normalizeFileDataAsDataURL = normalizeFileDataAsDataURL;
-const convertMessageToTracedFormat = (message) => {
+const convertMessageToTracedFormat = (message, responseMetadata) => {
     const formattedMessage = {
         ...message,
     };
@@ -165,6 +165,9 @@ const convertMessageToTracedFormat = (message) => {
             });
         }
     }
+    if (responseMetadata != null) {
+        formattedMessage.response_metadata = responseMetadata;
+    }
     return formattedMessage;
 };
 exports.convertMessageToTracedFormat = convertMessageToTracedFormat;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/utils.d.ts

@@ -1,4 +1,4 @@
 import type { LanguageModelV2DataContent, LanguageModelV2Message } from "@ai-sdk/provider";
 import type { ModelMessage } from "ai";
 export declare const normalizeFileDataAsDataURL: (fileData: LanguageModelV2DataContent | ArrayBuffer, mimeType?: string) => string;
-export declare const convertMessageToTracedFormat: (message: LanguageModelV2Message | ModelMessage) => Record<string, unknown>;
+export declare const convertMessageToTracedFormat: (message: LanguageModelV2Message | ModelMessage, responseMetadata?: Record<string, unknown>) => Record<string, unknown>;

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/experimental/vercel/utils.js

@@ -93,7 +93,7 @@ export const normalizeFileDataAsDataURL = (fileData, mimeType) => {
     }
     return normalizedFileData;
 };
-export const convertMessageToTracedFormat = (message) => {
+export const convertMessageToTracedFormat = (message, responseMetadata) => {
     const formattedMessage = {
         ...message,
     };
@@ -161,5 +161,8 @@ export const convertMessageToTracedFormat = (message) => {
             });
         }
     }
+    if (responseMetadata != null) {
+        formattedMessage.response_metadata = responseMetadata;
+    }
     return formattedMessage;
 };

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__version__ = exports.getDefaultProjectName = exports.overrideFetchImplementation = exports.RunTree = exports.Client = void 0;
+exports.__version__ = exports.uuid7FromTime = exports.uuid7 = exports.getDefaultProjectName = exports.overrideFetchImplementation = exports.RunTree = exports.Client = void 0;
 var client_js_1 = require("./client.cjs");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_js_1.Client; } });
 var run_trees_js_1 = require("./run_trees.cjs");
@@ -9,5 +9,8 @@ var fetch_js_1 = require("./singletons/fetch.cjs");
 Object.defineProperty(exports, "overrideFetchImplementation", { enumerable: true, get: function () { return fetch_js_1.overrideFetchImplementation; } });
 var project_js_1 = require("./utils/project.cjs");
 Object.defineProperty(exports, "getDefaultProjectName", { enumerable: true, get: function () { return project_js_1.getDefaultProjectName; } });
+var uuid_js_1 = require("./uuid.cjs");
+Object.defineProperty(exports, "uuid7", { enumerable: true, get: function () { return uuid_js_1.uuid7; } });
+Object.defineProperty(exports, "uuid7FromTime", { enumerable: true, get: function () { return uuid_js_1.uuid7FromTime; } });
 // Update using yarn bump-version
-exports.__version__ = "0.3.74";
+exports.__version__ = "0.3.87";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/index.d.ts

@@ -3,4 +3,5 @@ export type { Dataset, Example, TracerSession, Run, Feedback, RetrieverOutput, }
 export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
-export declare const __version__ = "0.3.74";
+export { uuid7, uuid7FromTime } from "./uuid.js";
+export declare const __version__ = "0.3.87";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/index.js

@@ -2,5 +2,6 @@ export { Client, } from "./client.js";
 export { RunTree } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
+export { uuid7, uuid7FromTime } from "./uuid.js";
 // Update using yarn bump-version
-export const __version__ = "0.3.74";
+export const __version__ = "0.3.87";

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/run_trees.cjs

@@ -1,61 +1,44 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunTree = void 0;
 exports.convertToDottedOrderFormat = convertToDottedOrderFormat;
 exports.isRunTree = isRunTree;
 exports.isRunnableConfigLike = isRunnableConfigLike;
-const uuid = __importStar(require("uuid"));
 const client_js_1 = require("./client.cjs");
 const env_js_1 = require("./env.cjs");
 const error_js_1 = require("./utils/error.cjs");
 const constants_js_1 = require("./singletons/constants.cjs");
+const context_vars_js_1 = require("./utils/context_vars.cjs");
 const env_js_2 = require("./utils/env.cjs");
 const project_js_1 = require("./utils/project.cjs");
 const env_js_3 = require("./utils/env.cjs");
 const warn_js_1 = require("./utils/warn.cjs");
+const _uuid_js_1 = require("./utils/_uuid.cjs");
+const uuid_1 = require("uuid");
+const TIMESTAMP_LENGTH = 36;
+// DNS namespace for UUID v5 (same as Python's uuid.NAMESPACE_DNS)
+const UUID_NAMESPACE_DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+function getReplicaKey(replica) {
+    // Generate a unique key by hashing the replica's identifying properties
+    // This ensures each unique replica (combination of projectName, apiUrl, workspaceId, apiKey) gets a unique key
+    // Sort keys to ensure consistent hashing
+    const sortedKeys = Object.keys(replica).sort();
+    const keyData = sortedKeys
+        .map((key) => `${key}:${replica[key] ?? ""}`)
+        .join("|");
+    return (0, uuid_1.v5)(keyData, UUID_NAMESPACE_DNS);
+}
 function stripNonAlphanumeric(input) {
     return input.replace(/[-:.]/g, "");
 }
-function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+function getMicrosecondPrecisionDatestring(epoch, executionOrder = 1) {
     // Date only has millisecond precision, so we use the microseconds to break
     // possible ties, avoiding incorrect run order
     const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
-    const microsecondPrecisionDatestring = `${new Date(epoch)
-        .toISOString()
-        .slice(0, -1)}${paddedOrder}Z`;
+    return `${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`;
+}
+function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+    const microsecondPrecisionDatestring = getMicrosecondPrecisionDatestring(epoch, executionOrder);
     return {
         dottedOrder: stripNonAlphanumeric(microsecondPrecisionDatestring) + runId,
         microsecondPrecisionDatestring,
@@ -292,6 +275,12 @@ class RunTree {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "distributedParentId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "_serialized_start_time", {
             enumerable: true,
             configurable: true,
@@ -311,7 +300,20 @@ class RunTree {
             ...config?.extra?.metadata,
         };
         config.extra = { ...config.extra, metadata: dedupedMetadata };
+        if ("id" in config && config.id == null) {
+            delete config.id;
+        }
         Object.assign(this, { ...defaultConfig, ...config, client });
+        this.execution_order ??= 1;
+        this.child_execution_order ??= 1;
+        // Generate serialized start time for ID generation
+        if (!this.dotted_order) {
+            this._serialized_start_time = getMicrosecondPrecisionDatestring(this.start_time, this.execution_order);
+        }
+        // Generate id from serialized start_time if not provided
+        if (!this.id) {
+            this.id = (0, _uuid_js_1.uuid7FromTime)(this._serialized_start_time ?? this.start_time);
+        }
         if (!this.trace_id) {
             if (this.parent_run) {
                 this.trace_id = this.parent_run.trace_id ?? this.id;
@@ -321,17 +323,15 @@ class RunTree {
             }
         }
         this.replicas = _ensureWriteReplicas(this.replicas);
-        this.execution_order ??= 1;
-        this.child_execution_order ??= 1;
+        // Now set the dotted order with the actual ID
         if (!this.dotted_order) {
-            const { dottedOrder, microsecondPrecisionDatestring } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
+            const { dottedOrder } = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
             if (this.parent_run) {
                 this.dotted_order = this.parent_run.dotted_order + "." + dottedOrder;
             }
             else {
                 this.dotted_order = dottedOrder;
             }
-            this._serialized_start_time = microsecondPrecisionDatestring;
         }
     }
     set metadata(metadata) {
@@ -347,15 +347,15 @@ class RunTree {
         return this.extra?.metadata;
     }
     static getDefaultConfig() {
+        const start_time = Date.now();
         return {
-            id: uuid.v4(),
             run_type: "chain",
             project_name: (0, project_js_1.getDefaultProjectName)(),
             child_runs: [],
             api_url: (0, env_js_2.getEnvironmentVariable)("LANGCHAIN_ENDPOINT") ?? "http://localhost:1984",
             api_key: (0, env_js_2.getEnvironmentVariable)("LANGCHAIN_API_KEY"),
             caller_options: {},
-            start_time: Date.now(),
+            start_time,
             serialized: {},
             inputs: {},
             extra: {},
@@ -369,11 +369,18 @@ class RunTree {
     }
     createChild(config) {
         const child_execution_order = this.child_execution_order + 1;
+        // Handle replicas: if child has its own replicas, use those; otherwise inherit parent's (with reroot stripped)
+        // Reroot should only apply to the run where it's explicitly configured, not propagate down
+        const inheritedReplicas = this.replicas?.map((replica) => {
+            const { reroot, ...rest } = replica;
+            return rest;
+        });
+        const childReplicas = config.replicas ?? inheritedReplicas;
         const child = new RunTree({
             ...config,
             parent_run: this,
             project_name: this.project_name,
-            replicas: this.replicas,
+            replicas: childReplicas,
             client: this.client,
             tracingEnabled: this.tracingEnabled,
             execution_order: child_execution_order,
@@ -473,60 +480,185 @@ class RunTree {
             events: run.events,
         };
     }
-    _remapForProject(projectName, runtimeEnv, excludeChildRuns = true) {
+    _sliceParentId(parentId, run) {
+        /**
+         * Slice the parent id from dotted order.
+         * Additionally check if the current run is a child of the parent. If so, update
+         * the parent_run_id to undefined, and set the trace id to the new root id after
+         * parent_id.
+         */
+        if (run.dotted_order) {
+            const segs = run.dotted_order.split(".");
+            let startIdx = null;
+            // Find the index of the parent ID in the dotted order
+            for (let idx = 0; idx < segs.length; idx++) {
+                const segId = segs[idx].slice(-TIMESTAMP_LENGTH);
+                if (segId === parentId) {
+                    startIdx = idx;
+                    break;
+                }
+            }
+            if (startIdx !== null) {
+                // Trim segments to start after parent_id (exclusive)
+                const trimmedSegs = segs.slice(startIdx + 1);
+                // Rebuild dotted_order
+                run.dotted_order = trimmedSegs.join(".");
+                if (trimmedSegs.length > 0) {
+                    run.trace_id = trimmedSegs[0].slice(-TIMESTAMP_LENGTH);
+                }
+                else {
+                    run.trace_id = run.id;
+                }
+            }
+        }
+        if (run.parent_run_id === parentId) {
+            // We've found the new root node.
+            run.parent_run_id = undefined;
+        }
+    }
+    _setReplicaTraceRoot(replicaKey, traceRootId) {
+        // Set the replica trace root in context vars on this run and all descendants
+        const replicaTraceRoots = (0, context_vars_js_1.getContextVar)(this, constants_js_1._REPLICA_TRACE_ROOTS_KEY) ?? {};
+        replicaTraceRoots[replicaKey] = traceRootId;
+        (0, context_vars_js_1.setContextVar)(this, constants_js_1._REPLICA_TRACE_ROOTS_KEY, replicaTraceRoots);
+        // Recursively update all descendants to avoid race conditions
+        // around run tree creation vs processing time
+        for (const child of this.child_runs) {
+            child._setReplicaTraceRoot(replicaKey, traceRootId);
+        }
+    }
+    _remapForProject(params) {
+        const { projectName, runtimeEnv, excludeChildRuns = true, reroot = false, distributedParentId, apiUrl, apiKey, workspaceId, } = params;
         const baseRun = this._convertToCreate(this, runtimeEnv, excludeChildRuns);
+        // Skip remapping if project name is the same
         if (projectName === this.project_name) {
-            return baseRun;
-        }
-        // Create a deterministic UUID mapping for this project
-        const createRemappedId = (originalId) => {
-            return uuid.v5(`${originalId}:${projectName}`, uuid.v5.DNS);
-        };
-        // Remap the current run's ID
-        const newId = createRemappedId(baseRun.id);
-        const newTraceId = baseRun.trace_id
-            ? createRemappedId(baseRun.trace_id)
-            : undefined;
-        const newParentRunId = baseRun.parent_run_id
-            ? createRemappedId(baseRun.parent_run_id)
-            : undefined;
-        let newDottedOrder;
-        if (baseRun.dotted_order) {
-            const segments = _parseDottedOrder(baseRun.dotted_order);
-            const rebuilt = [];
-            // Process all segments except the last one
-            for (let i = 0; i < segments.length - 1; i++) {
-                const [timestamp, segmentId] = segments[i];
-                const remappedId = createRemappedId(segmentId);
-                rebuilt.push(timestamp.toISOString().replace(/[-:]/g, "").replace(".", "") +
-                    remappedId);
+            return {
+                ...baseRun,
+                session_name: projectName,
+            };
+        }
+        // Apply reroot logic before ID remapping
+        if (reroot) {
+            if (distributedParentId) {
+                // If we have a distributed parent ID, slice at that point
+                this._sliceParentId(distributedParentId, baseRun);
+            }
+            else {
+                // If no distributed parent ID, simply make this run a root run
+                // by removing parent_run_id and resetting trace info
+                baseRun.parent_run_id = undefined;
+                // Keep the current run as the trace root
+                if (baseRun.dotted_order) {
+                    // Reset dotted order to just this run
+                    const segs = baseRun.dotted_order.split(".");
+                    if (segs.length > 0) {
+                        baseRun.dotted_order = segs[segs.length - 1];
+                        baseRun.trace_id = baseRun.id;
+                    }
+                }
+            }
+            // Store this run's original ID in context vars so descendants know the new trace root
+            // We store the original ID (before remapping) so it can be found in dotted_order
+            const replicaKey = getReplicaKey({
+                projectName,
+                apiUrl,
+                apiKey,
+                workspaceId,
+            });
+            this._setReplicaTraceRoot(replicaKey, baseRun.id);
+        }
+        // If an ancestor was rerooted for this replica, update trace_id and dotted_order
+        // to reflect the new trace hierarchy. This is tracked via context variables.
+        let ancestorRerootedTraceId;
+        if (!reroot) {
+            const replicaTraceRoots = (0, context_vars_js_1.getContextVar)(this, constants_js_1._REPLICA_TRACE_ROOTS_KEY) ?? {};
+            const replicaKey = getReplicaKey({
+                projectName,
+                apiUrl,
+                apiKey,
+                workspaceId,
+            });
+            ancestorRerootedTraceId = replicaTraceRoots[replicaKey];
+            if (ancestorRerootedTraceId) {
+                // An ancestor was rerooted for this replica, so set our trace_id
+                // to the ancestor's original (unmapped) ID. It will be remapped along with other IDs.
+                baseRun.trace_id = ancestorRerootedTraceId;
+                // Also slice the dotted_order to start from the new trace root
+                // This ensures descendants of a rerooted ancestor have correct hierarchy
+                if (baseRun.dotted_order) {
+                    const segs = baseRun.dotted_order.split(".");
+                    let rootIdx = null;
+                    // Find the new trace root's segment in dotted_order
+                    for (let idx = 0; idx < segs.length; idx++) {
+                        const segId = segs[idx].slice(-TIMESTAMP_LENGTH);
+                        if (segId === ancestorRerootedTraceId) {
+                            rootIdx = idx;
+                            break;
+                        }
+                    }
+                    if (rootIdx !== null) {
+                        // Keep segments from new trace root onwards
+                        const trimmedSegs = segs.slice(rootIdx);
+                        baseRun.dotted_order = trimmedSegs.join(".");
+                    }
+                }
             }
-            // Process the last segment with the new run ID
-            const [lastTimestamp] = segments[segments.length - 1];
-            rebuilt.push(lastTimestamp.toISOString().replace(/[-:]/g, "").replace(".", "") +
-                newId);
-            newDottedOrder = rebuilt.join(".");
+        }
+        // Remap IDs for the replica using uuid5 (deterministic)
+        // This ensures consistency across runs in the same replica
+        const oldId = baseRun.id;
+        const newId = (0, uuid_1.v5)(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
+        // Remap trace_id
+        let newTraceId;
+        if (baseRun.trace_id) {
+            newTraceId = (0, uuid_1.v5)(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
         }
         else {
-            newDottedOrder = undefined;
+            newTraceId = newId;
+        }
+        // Remap parent_run_id
+        let newParentId;
+        if (baseRun.parent_run_id) {
+            newParentId = (0, uuid_1.v5)(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
+        }
+        // Remap dotted_order segments
+        let newDottedOrder;
+        if (baseRun.dotted_order) {
+            const segs = baseRun.dotted_order.split(".");
+            const remappedSegs = segs.map((seg) => {
+                // Extract the UUID from the segment (last TIMESTAMP_LENGTH characters)
+                const segId = seg.slice(-TIMESTAMP_LENGTH);
+                const remappedId = (0, uuid_1.v5)(`${segId}:${projectName}`, UUID_NAMESPACE_DNS);
+                // Replace the UUID part while keeping the timestamp prefix
+                return seg.slice(0, -TIMESTAMP_LENGTH) + remappedId;
+            });
+            newDottedOrder = remappedSegs.join(".");
         }
-        const remappedRun = {
+        return {
             ...baseRun,
             id: newId,
             trace_id: newTraceId,
-            parent_run_id: newParentRunId,
+            parent_run_id: newParentId,
             dotted_order: newDottedOrder,
             session_name: projectName,
         };
-        return remappedRun;
     }
     async postRun(excludeChildRuns = true) {
         try {
             const runtimeEnv = (0, env_js_2.getRuntimeEnvironment)();
             if (this.replicas && this.replicas.length > 0) {
-                for (const { projectName, apiKey, apiUrl, workspaceId } of this
+                for (const { projectName, apiKey, apiUrl, workspaceId, reroot } of this
                     .replicas) {
-                    const runCreate = this._remapForProject(projectName ?? this.project_name, runtimeEnv, true);
+                    const runCreate = this._remapForProject({
+                        projectName: projectName ?? this.project_name,
+                        runtimeEnv,
+                        excludeChildRuns: true,
+                        reroot,
+                        distributedParentId: this.distributedParentId,
+                        apiUrl,
+                        apiKey,
+                        workspaceId,
+                    });
                     await this.client.createRun(runCreate, {
                         apiKey,
                         apiUrl,
@@ -551,11 +683,22 @@ class RunTree {
     }
     async patchRun(options) {
         if (this.replicas && this.replicas.length > 0) {
-            for (const { projectName, apiKey, apiUrl, workspaceId, updates } of this
-                .replicas) {
-                const runData = this._remapForProject(projectName ?? this.project_name);
+            for (const { projectName, apiKey, apiUrl, workspaceId, updates, reroot, } of this.replicas) {
+                const runData = this._remapForProject({
+                    projectName: projectName ?? this.project_name,
+                    runtimeEnv: undefined,
+                    excludeChildRuns: true,
+                    reroot,
+                    distributedParentId: this.distributedParentId,
+                    apiUrl,
+                    apiKey,
+                    workspaceId,
+                });
                 const updatePayload = {
                     id: runData.id,
+                    name: runData.name,
+                    run_type: runData.run_type,
+                    start_time: runData.start_time,
                     outputs: runData.outputs,
                     error: runData.error,
                     parent_run_id: runData.parent_run_id,
@@ -586,6 +729,9 @@ class RunTree {
         else {
             try {
                 const runUpdate = {
+                    name: this.name,
+                    run_type: this.run_type,
+                    start_time: this._serialized_start_time ?? this.start_time,
                     end_time: this.end_time,
                     error: this.error,
                     outputs: this.outputs,
@@ -715,7 +861,10 @@ class RunTree {
             config.project_name = baggage.project_name;
             config.replicas = baggage.replicas;
         }
-        return new RunTree(config);
+        const runTree = new RunTree(config);
+        // Set the distributed parent ID to this run's ID for rerooting
+        runTree.distributedParentId = runTree.id;
+        return runTree;
     }
     toHeaders(headers) {
         const result = {
@@ -760,30 +909,14 @@ function isRunnableConfigLike(x) {
     // Check that it's an object with a callbacks arg
     // that has either a CallbackManagerLike object with a langchain tracer within it
     // or an array with a LangChainTracerLike object within it
+    const callbacks = x?.callbacks;
     return (x != null &&
-        typeof x.callbacks === "object" &&
+        typeof callbacks === "object" &&
         // Callback manager with a langchain tracer
-        (containsLangChainTracerLike(x.callbacks?.handlers) ||
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (containsLangChainTracerLike(callbacks?.handlers) ||
             // Or it's an array with a LangChainTracerLike object within it
-            containsLangChainTracerLike(x.callbacks)));
-}
-function _parseDottedOrder(dottedOrder) {
-    const parts = dottedOrder.split(".");
-    return parts.map((part) => {
-        const timestampStr = part.slice(0, -36);
-        const uuidStr = part.slice(-36);
-        // Parse timestamp: "%Y%m%dT%H%M%S%fZ" format
-        // Example: "20231215T143045123456Z"
-        const year = parseInt(timestampStr.slice(0, 4));
-        const month = parseInt(timestampStr.slice(4, 6)) - 1; // JS months are 0-indexed
-        const day = parseInt(timestampStr.slice(6, 8));
-        const hour = parseInt(timestampStr.slice(9, 11));
-        const minute = parseInt(timestampStr.slice(11, 13));
-        const second = parseInt(timestampStr.slice(13, 15));
-        const microsecond = parseInt(timestampStr.slice(15, 21));
-        const timestamp = new Date(year, month, day, hour, minute, second, microsecond / 1000);
-        return [timestamp, uuidStr];
-    });
+            containsLangChainTracerLike(callbacks)));
 }
 function _getWriteReplicasFromEnv() {
     const envVar = (0, env_js_2.getEnvironmentVariable)("LANGSMITH_RUNS_ENDPOINTS");

package/dist/node_modules/@langchain/core/node_modules/langsmith/dist/run_trees.d.ts

@@ -31,6 +31,7 @@ export interface RunTreeConfig {
     dotted_order?: string;
     attachments?: Attachments;
     replicas?: Replica[];
+    distributedParentId?: string;
 }
 export interface RunnableConfigLike {
     /**
@@ -47,7 +48,7 @@ export interface RunnableConfigLike {
      * Callbacks for this call and any sub-calls (eg. a Chain calling an LLM).
      * Tags are passed to all callbacks, metadata is passed to handle*Start callbacks.
      */
-    callbacks?: any;
+    callbacks?: Record<string, any> | any[];
 }
 interface HeadersLike {
     get(name: string): string | null;
@@ -61,6 +62,7 @@ type WriteReplica = {
     projectName?: string;
     updates?: KVMap | undefined;
     fromEnv?: boolean;
+    reroot?: boolean;
 };
 type Replica = ProjectReplica | WriteReplica;
 export declare class RunTree implements BaseRun {
@@ -97,6 +99,7 @@ export declare class RunTree implements BaseRun {
      * Projects to replicate this run to with optional updates.
      */
     replicas?: WriteReplica[];
+    distributedParentId?: string;
     private _serialized_start_time;
     constructor(originalConfig: RunTreeConfig | RunTree);
     set metadata(metadata: KVMap);
@@ -106,6 +109,8 @@ export declare class RunTree implements BaseRun {
     createChild(config: RunTreeConfig): RunTree;
     end(outputs?: KVMap, error?: string, endTime?: number, metadata?: KVMap): Promise<void>;
     private _convertToCreate;
+    private _sliceParentId;
+    private _setReplicaTraceRoot;
     private _remapForProject;
     postRun(excludeChildRuns?: boolean): Promise<void>;
     patchRun(options?: {