langsmith 0.3.80 → 0.3.82

package/README.md

@@ -31,7 +31,8 @@ Sign up for [LangSmith](https://smith.langchain.com/) using your GitHub, Discord
 
 Then, create a unique API key on the [Settings Page](https://smith.langchain.com/settings).
 
-Note: Save the API Key in a secure location. It will not be shown again.
+> [!NOTE]
+> Save the API Key in a secure location. It will not be shown again.
 
 ## 2. Log Traces
 

package/dist/evaluation/evaluate_comparative.cjs

@@ -8,7 +8,7 @@ const uuid_1 = require("uuid");
 const index_js_1 = require("../index.cjs");
 const shuffle_js_1 = require("../utils/shuffle.cjs");
 const async_caller_js_1 = require("../utils/async_caller.cjs");
-const p_retry_1 = __importDefault(require("p-retry"));
+const index_js_2 = __importDefault(require("../utils/p-retry/index.cjs"));
 const traceable_js_1 = require("../traceable.cjs");
 function isExperimentResultsList(value) {
     return value.some((x) => typeof x !== "string");
@@ -64,7 +64,7 @@ async function evaluateComparative(experiments, options) {
         }
         // if we know the number of runs beforehand, check if the
         // number of runs in the project matches the expected number of runs
-        return Promise.all(resolvedExperiments.map((experiment) => (0, p_retry_1.default)(async () => {
+        return Promise.all(resolvedExperiments.map((experiment) => (0, index_js_2.default)(async () => {
             const project = await loadExperiment(client, experiment);
             if (project.run_count !== experiment?.results.length) {
                 throw new Error("Experiment is missing runs. Retrying.");

package/dist/evaluation/evaluate_comparative.js

@@ -2,7 +2,7 @@ import { v4 as uuid4, validate } from "uuid";
 import { Client } from "../index.js";
 import { shuffle } from "../utils/shuffle.js";
 import { AsyncCaller } from "../utils/async_caller.js";
-import pRetry from "p-retry";
+import pRetry from "../utils/p-retry/index.js";
 import { getCurrentRunTree, traceable } from "../traceable.js";
 function isExperimentResultsList(value) {
     return value.some((x) => typeof x !== "string");

package/dist/index.cjs

@@ -13,4 +13,4 @@ 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.80";
+exports.__version__ = "0.3.82";

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export { RunTree, type RunTreeConfig } from "./run_trees.js";
 export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
-export declare const __version__ = "0.3.80";
+export declare const __version__ = "0.3.82";

package/dist/index.js

@@ -4,4 +4,4 @@ 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.80";
+export const __version__ = "0.3.82";

package/dist/run_trees.cjs

@@ -8,11 +8,26 @@ 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, "");
 }
@@ -260,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,
@@ -293,9 +314,6 @@ class RunTree {
         if (!this.id) {
             this.id = (0, _uuid_js_1.uuid7FromTime)(this._serialized_start_time ?? this.start_time);
         }
-        if (config.id) {
-            (0, _uuid_js_1.warnIfNotUuidV7)(config.id, "run_id");
-        }
         if (!this.trace_id) {
             if (this.parent_run) {
                 this.trace_id = this.parent_run.trace_id ?? this.id;
@@ -304,12 +322,6 @@ class RunTree {
                 this.trace_id = this.id;
             }
         }
-        else if (config.trace_id) {
-            (0, _uuid_js_1.warnIfNotUuidV7)(config.trace_id, "trace_id");
-        }
-        if (config.parent_run_id) {
-            (0, _uuid_js_1.warnIfNotUuidV7)(config.parent_run_id, "parent_run_id");
-        }
         this.replicas = _ensureWriteReplicas(this.replicas);
         // Now set the dotted order with the actual ID
         if (!this.dotted_order) {
@@ -357,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,
@@ -461,10 +480,166 @@ 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,
+                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(".");
+                    }
+                }
+            }
+        }
+        // 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 {
+            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(".");
+        }
         return {
             ...baseRun,
+            id: newId,
+            trace_id: newTraceId,
+            parent_run_id: newParentId,
+            dotted_order: newDottedOrder,
             session_name: projectName,
         };
     }
@@ -472,9 +647,18 @@ class RunTree {
         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,
@@ -499,9 +683,17 @@ 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,
@@ -669,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 = {

package/dist/run_trees.d.ts

@@ -31,6 +31,7 @@ export interface RunTreeConfig {
     dotted_order?: string;
     attachments?: Attachments;
     replicas?: Replica[];
+    distributedParentId?: string;
 }
 export interface RunnableConfigLike {
     /**
@@ -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?: {