langsmith 0.4.10 → 0.4.12

package/dist/client.cjs

@@ -2949,7 +2949,7 @@ class Client {
             return res;
         });
     }
-    async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, }) {
+    async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, sessionId, startTime, }) {
         if (!runId && !projectId) {
             throw new Error("One of runId or projectId must be provided");
         }
@@ -2980,7 +2980,8 @@ class Client {
             feedback_source: feedback_source,
             comparative_experiment_id: comparativeExperimentId,
             feedbackConfig,
-            session_id: projectId,
+            session_id: sessionId ?? projectId,
+            start_time: startTime,
         };
         const body = JSON.stringify(feedback);
         const url = `${this.apiUrl}/feedback`;
@@ -3201,6 +3202,8 @@ class Client {
                 sourceRunId: res.sourceRunId,
                 feedbackConfig: res.feedbackConfig,
                 feedbackSourceType: "model",
+                sessionId: run?.session_id,
+                startTime: run?.start_time,
             }));
         }
         return [evalResults, feedbacks];

package/dist/client.d.ts

@@ -822,7 +822,7 @@ export declare class Client implements LangSmithTracingClientInterface {
         exampleIds: string[];
         remove?: boolean;
     }): Promise<void>;
-    createFeedback(runId: string | null, key: string, { score, value, correction, comment, sourceInfo, feedbackSourceType, sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, }: {
+    createFeedback(runId: string | null, key: string, { score, value, correction, comment, sourceInfo, feedbackSourceType, sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, sessionId, startTime, }: {
         score?: ScoreType;
         value?: ValueType;
         correction?: object;
@@ -835,6 +835,10 @@ export declare class Client implements LangSmithTracingClientInterface {
         eager?: boolean;
         projectId?: string;
         comparativeExperimentId?: string;
+        /** The session (project) ID of the run this feedback is for. */
+        sessionId?: string;
+        /** The start time of the run this feedback is for. Accepts ISO string or epoch ms. */
+        startTime?: number | string;
     }): Promise<Feedback>;
     updateFeedback(feedbackId: string, { score, value, correction, comment, }: {
         score?: number | boolean | null;

package/dist/client.js

@@ -2911,7 +2911,7 @@ export class Client {
             return res;
         });
     }
-    async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, }) {
+    async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId, sessionId, startTime, }) {
         if (!runId && !projectId) {
             throw new Error("One of runId or projectId must be provided");
         }
@@ -2942,7 +2942,8 @@ export class Client {
             feedback_source: feedback_source,
             comparative_experiment_id: comparativeExperimentId,
             feedbackConfig,
-            session_id: projectId,
+            session_id: sessionId ?? projectId,
+            start_time: startTime,
         };
         const body = JSON.stringify(feedback);
         const url = `${this.apiUrl}/feedback`;
@@ -3163,6 +3164,8 @@ export class Client {
                 sourceRunId: res.sourceRunId,
                 feedbackConfig: res.feedbackConfig,
                 feedbackSourceType: "model",
+                sessionId: run?.session_id,
+                startTime: run?.start_time,
             }));
         }
         return [evalResults, feedbacks];

package/dist/evaluation/evaluate_comparative.cjs

@@ -176,15 +176,20 @@ async function evaluateComparative(experiments, options) {
                 referenceOutputs: example.outputs || {},
             })
             : await evaluator(runs, example);
+        // Build a lookup for run metadata
+        const runsById = new Map(runs.map((r) => [r.id, r]));
         for (const [runId, score] of Object.entries(result.scores)) {
             // validate if the run id
             if (!expectedRunIds.has(runId)) {
                 throw new Error(`Returning an invalid run id ${runId} from evaluator.`);
             }
+            const run = runsById.get(runId);
             await client.createFeedback(runId, result.key, {
                 score,
                 sourceRunId: result.source_run_id,
                 comparativeExperimentId: comparativeExperiment.id,
+                sessionId: run?.session_id,
+                startTime: run?.start_time,
             });
         }
         return result;

package/dist/evaluation/evaluate_comparative.js

@@ -170,15 +170,20 @@ export async function evaluateComparative(experiments, options) {
                 referenceOutputs: example.outputs || {},
             })
             : await evaluator(runs, example);
+        // Build a lookup for run metadata
+        const runsById = new Map(runs.map((r) => [r.id, r]));
         for (const [runId, score] of Object.entries(result.scores)) {
             // validate if the run id
             if (!expectedRunIds.has(runId)) {
                 throw new Error(`Returning an invalid run id ${runId} from evaluator.`);
             }
+            const run = runsById.get(runId);
             await client.createFeedback(runId, result.key, {
                 score,
                 sourceRunId: result.source_run_id,
                 comparativeExperimentId: comparativeExperiment.id,
+                sessionId: run?.session_id,
+                startTime: run?.start_time,
             });
         }
         return result;

package/dist/index.cjs

@@ -15,4 +15,4 @@ Object.defineProperty(exports, "uuid7FromTime", { enumerable: true, get: functio
 var prompts_cache_js_1 = require("./utils/prompts_cache.cjs");
 Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return prompts_cache_js_1.Cache; } });
 // Update using yarn bump-version
-exports.__version__ = "0.4.10";
+exports.__version__ = "0.4.12";

package/dist/index.d.ts

@@ -5,4 +5,4 @@ export { overrideFetchImplementation } from "./singletons/fetch.js";
 export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, type CacheConfig, type CacheMetrics, } from "./utils/prompts_cache.js";
-export declare const __version__ = "0.4.10";
+export declare const __version__ = "0.4.12";

package/dist/index.js

@@ -5,4 +5,4 @@ export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, } from "./utils/prompts_cache.js";
 // Update using yarn bump-version
-export const __version__ = "0.4.10";
+export const __version__ = "0.4.12";

package/dist/run_trees.cjs

@@ -636,14 +636,15 @@ class RunTree {
                 }
             }
         }
-        // Remap IDs for the replica using uuid5 (deterministic)
-        // This ensures consistency across runs in the same replica
+        // Remap IDs for the replica using nonCryptographicUuid7Deterministic
+        // This ensures consistency across runs in the same replica while
+        // preserving UUID7 properties (time-ordering, monotonicity)
         const oldId = baseRun.id;
-        const newId = (0, uuid_1.v5)(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
+        const newId = (0, _uuid_js_1.nonCryptographicUuid7Deterministic)(oldId, projectName);
         // Remap trace_id
         let newTraceId;
         if (baseRun.trace_id) {
-            newTraceId = (0, uuid_1.v5)(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
+            newTraceId = (0, _uuid_js_1.nonCryptographicUuid7Deterministic)(baseRun.trace_id, projectName);
         }
         else {
             newTraceId = newId;
@@ -651,7 +652,7 @@ class RunTree {
         // Remap parent_run_id
         let newParentId;
         if (baseRun.parent_run_id) {
-            newParentId = (0, uuid_1.v5)(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
+            newParentId = (0, _uuid_js_1.nonCryptographicUuid7Deterministic)(baseRun.parent_run_id, projectName);
         }
         // Remap dotted_order segments
         let newDottedOrder;
@@ -660,7 +661,7 @@ class RunTree {
             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);
+                const remappedId = (0, _uuid_js_1.nonCryptographicUuid7Deterministic)(segId, projectName);
                 // Replace the UUID part while keeping the timestamp prefix
                 return seg.slice(0, -TIMESTAMP_LENGTH) + remappedId;
             });

package/dist/run_trees.js

@@ -7,7 +7,7 @@ import { getEnvironmentVariable, getRuntimeEnvironment, } from "./utils/env.js";
 import { getDefaultProjectName } from "./utils/project.js";
 import { getLangSmithEnvironmentVariable } from "./utils/env.js";
 import { warnOnce } from "./utils/warn.js";
-import { uuid7FromTime } from "./utils/_uuid.js";
+import { uuid7FromTime, nonCryptographicUuid7Deterministic, } from "./utils/_uuid.js";
 import { v5 as uuidv5 } from "uuid";
 const TIMESTAMP_LENGTH = 36;
 // DNS namespace for UUID v5 (same as Python's uuid.NAMESPACE_DNS)
@@ -630,14 +630,15 @@ export class RunTree {
                 }
             }
         }
-        // Remap IDs for the replica using uuid5 (deterministic)
-        // This ensures consistency across runs in the same replica
+        // Remap IDs for the replica using nonCryptographicUuid7Deterministic
+        // This ensures consistency across runs in the same replica while
+        // preserving UUID7 properties (time-ordering, monotonicity)
         const oldId = baseRun.id;
-        const newId = uuidv5(`${oldId}:${projectName}`, UUID_NAMESPACE_DNS);
+        const newId = nonCryptographicUuid7Deterministic(oldId, projectName);
         // Remap trace_id
         let newTraceId;
         if (baseRun.trace_id) {
-            newTraceId = uuidv5(`${baseRun.trace_id}:${projectName}`, UUID_NAMESPACE_DNS);
+            newTraceId = nonCryptographicUuid7Deterministic(baseRun.trace_id, projectName);
         }
         else {
             newTraceId = newId;
@@ -645,7 +646,7 @@ export class RunTree {
         // Remap parent_run_id
         let newParentId;
         if (baseRun.parent_run_id) {
-            newParentId = uuidv5(`${baseRun.parent_run_id}:${projectName}`, UUID_NAMESPACE_DNS);
+            newParentId = nonCryptographicUuid7Deterministic(baseRun.parent_run_id, projectName);
         }
         // Remap dotted_order segments
         let newDottedOrder;
@@ -654,7 +655,7 @@ export class RunTree {
             const remappedSegs = segs.map((seg) => {
                 // Extract the UUID from the segment (last TIMESTAMP_LENGTH characters)
                 const segId = seg.slice(-TIMESTAMP_LENGTH);
-                const remappedId = uuidv5(`${segId}:${projectName}`, UUID_NAMESPACE_DNS);
+                const remappedId = nonCryptographicUuid7Deterministic(segId, projectName);
                 // Replace the UUID part while keeping the timestamp prefix
                 return seg.slice(0, -TIMESTAMP_LENGTH) + remappedId;
             });

package/dist/schemas.d.ts

@@ -392,6 +392,7 @@ export interface InvocationParamsSchema {
     ls_temperature?: number;
     ls_max_tokens?: number;
     ls_stop?: string[];
+    ls_invocation_params?: Record<string, unknown>;
 }
 export interface PromptCommit {
     owner: string;

package/dist/utils/_uuid.cjs

@@ -4,10 +4,12 @@ exports.assertUuid = assertUuid;
 exports.uuid7FromTime = uuid7FromTime;
 exports.getUuidVersion = getUuidVersion;
 exports.warnIfNotUuidV7 = warnIfNotUuidV7;
+exports.nonCryptographicUuid7Deterministic = nonCryptographicUuid7Deterministic;
 // Relaxed UUID validation regex (allows any valid UUID format including nil UUIDs)
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const uuid_1 = require("uuid");
 const warn_js_1 = require("./warn.cjs");
+const xxhash_js_1 = require("./xxhash/xxhash.cjs");
 let UUID7_WARNING_EMITTED = false;
 function assertUuid(str, which) {
     // Use relaxed regex validation instead of strict uuid.validate()
@@ -64,3 +66,114 @@ function warnIfNotUuidV7(uuidStr, _idType) {
             `Future versions will require UUID v7.`);
     }
 }
+/**
+ * Convert a UUID string to its 16-byte representation.
+ * @param uuidStr - The UUID string (with or without dashes)
+ * @returns A Uint8Array containing the 16 bytes of the UUID
+ */
+function uuidToBytes(uuidStr) {
+    const hex = uuidStr.replace(/-/g, "");
+    const bytes = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+/**
+ * Convert 16 bytes to a UUID string.
+ * @param bytes - A Uint8Array containing 16 bytes
+ * @returns A UUID string in standard format
+ */
+function bytesToUuid(bytes) {
+    const hex = Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+// Reuse TextEncoder instance for performance
+const _textEncoder = new TextEncoder();
+/**
+ * Generates a 16-byte fingerprint for deterministic UUID generation using XXH3-128.
+ *
+ * XXH3 is an extremely fast, non-cryptographic hash function that provides excellent
+ * collision resistance. It's widely used in production systems and compatible with
+ * xxHash implementations in other languages.
+ *
+ * See: https://github.com/Cyan4973/xxHash
+ *
+ * @param str - The input string to hash
+ * @returns A Uint8Array containing 16 bytes of hash output
+ */
+function _fastHash128(str) {
+    const data = _textEncoder.encode(str);
+    // Compute XXH3-128 hash and convert to bytes
+    const hash128 = (0, xxhash_js_1.XXH3_128)(data);
+    return (0, xxhash_js_1.xxh128ToBytes)(hash128);
+}
+/**
+ * Generate a deterministic UUID v7 derived from an original UUID and a key.
+ *
+ * This function creates a new UUID that:
+ * - Preserves the timestamp from the original UUID if it's UUID v7
+ * - Uses current time if the original is not UUID v7
+ * - Uses deterministic "random" bits derived from hashing the original + key
+ * - Is valid UUID v7 format
+ *
+ * This is used for creating replica IDs that maintain time-ordering properties
+ * while being deterministic across distributed systems.
+ *
+ * @param originalId - The source UUID string (ideally UUID v7 to preserve timestamp)
+ * @param key - A string key used for deterministic derivation (e.g., project name)
+ * @returns A new UUID v7 string with preserved timestamp (if original is v7) and
+ *          deterministic random bits
+ *
+ * @example
+ * ```typescript
+ * const original = uuidv7();
+ * const replicaId = nonCryptographicUuid7Deterministic(original, "replica-project");
+ * // Same inputs always produce same output
+ * assert(nonCryptographicUuid7Deterministic(original, "replica-project") === replicaId);
+ * ```
+ */
+function nonCryptographicUuid7Deterministic(originalId, key) {
+    // Generate deterministic bytes from hash of original + key
+    const hashInput = `${originalId}:${key}`;
+    const h = _fastHash128(hashInput);
+    // Build new UUID7:
+    // UUID7 structure (RFC 9562):
+    // [0-5]  48 bits: unix_ts_ms (timestamp in milliseconds)
+    // [6]    4 bits: version (0111 = 7) + 4 bits rand_a
+    // [7]    8 bits: rand_a (continued)
+    // [8]    2 bits: variant (10) + 6 bits rand_b
+    // [9-15] 56 bits: rand_b (continued)
+    const b = new Uint8Array(16);
+    // Check if original is UUID v7 - if so, preserve its timestamp
+    // If not, use current time to ensure the derived UUID has a valid timestamp
+    const version = getUuidVersion(originalId);
+    if (version === 7) {
+        // Preserve timestamp from original UUID7 (bytes 0-5)
+        const originalBytes = uuidToBytes(originalId);
+        b.set(originalBytes.slice(0, 6), 0);
+    }
+    else {
+        // Generate fresh timestamp for non-UUID7 inputs
+        // This matches the uuid npm package's v7 implementation:
+        // https://github.com/uuidjs/uuid/blob/main/src/v7.ts
+        const msecs = Date.now();
+        b[0] = (msecs / 0x10000000000) & 0xff;
+        b[1] = (msecs / 0x100000000) & 0xff;
+        b[2] = (msecs / 0x1000000) & 0xff;
+        b[3] = (msecs / 0x10000) & 0xff;
+        b[4] = (msecs / 0x100) & 0xff;
+        b[5] = msecs & 0xff;
+    }
+    // Set version 7 (0111) in high nibble + 4 bits from hash
+    b[6] = 0x70 | (h[0] & 0x0f);
+    // rand_a continued (8 bits from hash)
+    b[7] = h[1];
+    // Set variant (10) in high 2 bits + 6 bits from hash
+    b[8] = 0x80 | (h[2] & 0x3f);
+    // rand_b (56 bits = 7 bytes from hash)
+    b.set(h.slice(3, 10), 9);
+    return bytesToUuid(b);
+}

package/dist/utils/_uuid.d.ts

@@ -19,3 +19,29 @@ export declare function getUuidVersion(uuidStr: string): number | null;
  * @param idType - The type of ID (e.g., "run_id", "trace_id") for the warning message
  */
 export declare function warnIfNotUuidV7(uuidStr: string, _idType: string): void;
+/**
+ * Generate a deterministic UUID v7 derived from an original UUID and a key.
+ *
+ * This function creates a new UUID that:
+ * - Preserves the timestamp from the original UUID if it's UUID v7
+ * - Uses current time if the original is not UUID v7
+ * - Uses deterministic "random" bits derived from hashing the original + key
+ * - Is valid UUID v7 format
+ *
+ * This is used for creating replica IDs that maintain time-ordering properties
+ * while being deterministic across distributed systems.
+ *
+ * @param originalId - The source UUID string (ideally UUID v7 to preserve timestamp)
+ * @param key - A string key used for deterministic derivation (e.g., project name)
+ * @returns A new UUID v7 string with preserved timestamp (if original is v7) and
+ *          deterministic random bits
+ *
+ * @example
+ * ```typescript
+ * const original = uuidv7();
+ * const replicaId = nonCryptographicUuid7Deterministic(original, "replica-project");
+ * // Same inputs always produce same output
+ * assert(nonCryptographicUuid7Deterministic(original, "replica-project") === replicaId);
+ * ```
+ */
+export declare function nonCryptographicUuid7Deterministic(originalId: string, key: string): string;

package/dist/utils/_uuid.js

@@ -2,6 +2,7 @@
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 import { v7 as uuidv7 } from "uuid";
 import { warnOnce } from "./warn.js";
+import { XXH3_128, xxh128ToBytes } from "./xxhash/xxhash.js";
 let UUID7_WARNING_EMITTED = false;
 export function assertUuid(str, which) {
     // Use relaxed regex validation instead of strict uuid.validate()
@@ -58,3 +59,114 @@ export function warnIfNotUuidV7(uuidStr, _idType) {
             `Future versions will require UUID v7.`);
     }
 }
+/**
+ * Convert a UUID string to its 16-byte representation.
+ * @param uuidStr - The UUID string (with or without dashes)
+ * @returns A Uint8Array containing the 16 bytes of the UUID
+ */
+function uuidToBytes(uuidStr) {
+    const hex = uuidStr.replace(/-/g, "");
+    const bytes = new Uint8Array(16);
+    for (let i = 0; i < 16; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+/**
+ * Convert 16 bytes to a UUID string.
+ * @param bytes - A Uint8Array containing 16 bytes
+ * @returns A UUID string in standard format
+ */
+function bytesToUuid(bytes) {
+    const hex = Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+// Reuse TextEncoder instance for performance
+const _textEncoder = new TextEncoder();
+/**
+ * Generates a 16-byte fingerprint for deterministic UUID generation using XXH3-128.
+ *
+ * XXH3 is an extremely fast, non-cryptographic hash function that provides excellent
+ * collision resistance. It's widely used in production systems and compatible with
+ * xxHash implementations in other languages.
+ *
+ * See: https://github.com/Cyan4973/xxHash
+ *
+ * @param str - The input string to hash
+ * @returns A Uint8Array containing 16 bytes of hash output
+ */
+function _fastHash128(str) {
+    const data = _textEncoder.encode(str);
+    // Compute XXH3-128 hash and convert to bytes
+    const hash128 = XXH3_128(data);
+    return xxh128ToBytes(hash128);
+}
+/**
+ * Generate a deterministic UUID v7 derived from an original UUID and a key.
+ *
+ * This function creates a new UUID that:
+ * - Preserves the timestamp from the original UUID if it's UUID v7
+ * - Uses current time if the original is not UUID v7
+ * - Uses deterministic "random" bits derived from hashing the original + key
+ * - Is valid UUID v7 format
+ *
+ * This is used for creating replica IDs that maintain time-ordering properties
+ * while being deterministic across distributed systems.
+ *
+ * @param originalId - The source UUID string (ideally UUID v7 to preserve timestamp)
+ * @param key - A string key used for deterministic derivation (e.g., project name)
+ * @returns A new UUID v7 string with preserved timestamp (if original is v7) and
+ *          deterministic random bits
+ *
+ * @example
+ * ```typescript
+ * const original = uuidv7();
+ * const replicaId = nonCryptographicUuid7Deterministic(original, "replica-project");
+ * // Same inputs always produce same output
+ * assert(nonCryptographicUuid7Deterministic(original, "replica-project") === replicaId);
+ * ```
+ */
+export function nonCryptographicUuid7Deterministic(originalId, key) {
+    // Generate deterministic bytes from hash of original + key
+    const hashInput = `${originalId}:${key}`;
+    const h = _fastHash128(hashInput);
+    // Build new UUID7:
+    // UUID7 structure (RFC 9562):
+    // [0-5]  48 bits: unix_ts_ms (timestamp in milliseconds)
+    // [6]    4 bits: version (0111 = 7) + 4 bits rand_a
+    // [7]    8 bits: rand_a (continued)
+    // [8]    2 bits: variant (10) + 6 bits rand_b
+    // [9-15] 56 bits: rand_b (continued)
+    const b = new Uint8Array(16);
+    // Check if original is UUID v7 - if so, preserve its timestamp
+    // If not, use current time to ensure the derived UUID has a valid timestamp
+    const version = getUuidVersion(originalId);
+    if (version === 7) {
+        // Preserve timestamp from original UUID7 (bytes 0-5)
+        const originalBytes = uuidToBytes(originalId);
+        b.set(originalBytes.slice(0, 6), 0);
+    }
+    else {
+        // Generate fresh timestamp for non-UUID7 inputs
+        // This matches the uuid npm package's v7 implementation:
+        // https://github.com/uuidjs/uuid/blob/main/src/v7.ts
+        const msecs = Date.now();
+        b[0] = (msecs / 0x10000000000) & 0xff;
+        b[1] = (msecs / 0x100000000) & 0xff;
+        b[2] = (msecs / 0x1000000) & 0xff;
+        b[3] = (msecs / 0x10000) & 0xff;
+        b[4] = (msecs / 0x100) & 0xff;
+        b[5] = msecs & 0xff;
+    }
+    // Set version 7 (0111) in high nibble + 4 bits from hash
+    b[6] = 0x70 | (h[0] & 0x0f);
+    // rand_a continued (8 bits from hash)
+    b[7] = h[1];
+    // Set variant (10) in high 2 bits + 6 bits from hash
+    b[8] = 0x80 | (h[2] & 0x3f);
+    // rand_b (56 bits = 7 bytes from hash)
+    b.set(h.slice(3, 10), 9);
+    return bytesToUuid(b);
+}