langsmith 0.5.23 → 0.5.25

package/dist/client.cjs

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = exports.AutoBatchQueue = exports.DEFAULT_MAX_SIZE_BYTES = exports.DEFAULT_UNCOMPRESSED_BATCH_SIZE_LIMIT_BYTES = void 0;
 exports.mergeRuntimeEnvIntoRun = mergeRuntimeEnvIntoRun;
-const uuid = __importStar(require("uuid"));
+const uuid = __importStar(require("./utils/uuid/src/index.cjs"));
 const translator_js_1 = require("./experimental/otel/translator.cjs");
 const otel_js_1 = require("./singletons/otel.cjs");
 const async_caller_js_1 = require("./utils/async_caller.cjs");
@@ -50,6 +50,7 @@ const index_js_2 = require("./utils/prompt_cache/index.cjs");
 const fsUtils = __importStar(require("./utils/fs.cjs"));
 const fetch_js_1 = require("./singletons/fetch.cjs");
 const index_js_3 = require("./utils/fast-safe-stringify/index.cjs");
+const serialize_worker_js_1 = require("./utils/serialize_worker.cjs");
 /**
  * Catches timestamps without a timezone suffix.
  */
@@ -200,7 +201,7 @@ class AutoBatchQueue {
         // real serialization still happens later, off the hot path, when the
         // batch is assembled for sending.
         const size = (0, env_js_1.getLangSmithEnvironmentVariable)("PERF_OPTIMIZATION") === "true"
-            ? (0, index_js_3.estimateSerializedSize)(item.item)
+            ? (0, index_js_3.estimateSerializedSize)(item.item).size
             : (0, index_js_3.serialize)(item.item, `Serializing run with id: ${item.item.id}`).length;
         // Check if adding this item would exceed the size limit
         // Allow the run if the queue is empty (to support large single traces)
@@ -265,9 +266,67 @@ class AutoBatchQueue {
 }
 exports.AutoBatchQueue = AutoBatchQueue;
 class Client {
+    get tracingMode() {
+        return this._tracingMode;
+    }
     get _fetch() {
         return this.fetchImplementation || (0, fetch_js_1._getFetchImplementation)(this.debug);
     }
+    /**
+     * Serialize a payload for tracing, optionally offloading the work to a
+     * Node worker thread when LANGSMITH_PERF_OPTIMIZATION=true and the runtime
+     * supports worker_threads.
+     *
+     * Falls back to synchronous serialization when:
+     *  - the perf flag is off
+     *  - manualFlushMode is enabled (serverless: worker boot cost > benefit)
+     *  - worker_threads is unavailable (non-Node runtimes)
+     *  - the payload contains values that can't be structured-cloned across
+     *    threads (functions, non-cloneable class instances, streams, etc.)
+     *  - the worker throws for any other reason
+     *
+     * In all fallback cases the returned bytes are identical to the sync path.
+     */
+    _trackDrain(promise) {
+        this._pendingDrains.add(promise);
+        promise.finally(() => {
+            this._pendingDrains.delete(promise);
+        });
+    }
+    async _serializeBody(payload, errorContext) {
+        const perfOptIn = (0, env_js_1.getLangSmithEnvironmentVariable)("PERF_OPTIMIZATION") === "true";
+        if (!perfOptIn || this.manualFlushMode) {
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+        // Shape-aware gate: worker offload pays for itself only when the
+        // payload is dominated by one or more large strings (V8 can refcount
+        // those across isolates instead of copying). For structure-heavy
+        // payloads -- many keys, deep nesting, lots of small strings -- the
+        // structuredClone walk plus thread-hop cost exceeds the JSON.stringify
+        // cost we would pay inline, so we fall through to sync serialize.
+        if (!(0, serialize_worker_js_1.hasLargeString)(payload)) {
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+        if (this._serializeWorker === undefined) {
+            this._serializeWorker = (0, serialize_worker_js_1.getSharedSerializeWorker)();
+        }
+        if (this._serializeWorker === null) {
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+        try {
+            const bytes = await this._serializeWorker.serialize(payload);
+            if (bytes === null) {
+                // Worker subsystem unavailable; cache the null to skip re-entry.
+                this._serializeWorker = null;
+                return (0, index_js_3.serialize)(payload, errorContext);
+            }
+            return bytes;
+        }
+        catch {
+            // DataCloneError, worker crash, etc. Fall back silently.
+            return (0, index_js_3.serialize)(payload, errorContext);
+        }
+    }
     constructor(config = {}) {
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
@@ -432,12 +491,35 @@ class Client {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_serializeWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Tracks in-flight drainAutoBatchQueue promises so awaitPendingTraceBatches
+         * can wait on them even if the flush involves async work (worker-thread
+         * serialize) that hasn't yet registered with batchIngestCaller.queue.
+         */
+        Object.defineProperty(this, "_pendingDrains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "langSmithToOTELTranslator", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_tracingMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "langsmith"
+        });
         Object.defineProperty(this, "fetchImplementation", {
             enumerable: true,
             configurable: true,
@@ -557,7 +639,8 @@ class Client {
         this.batchSizeLimit = config.batchSizeLimit;
         this.fetchOptions = config.fetchOptions || {};
         this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
-        if ((0, env_js_1.getOtelEnabled)()) {
+        this._tracingMode = (0, env_js_1.resolveTracingMode)(config.tracingMode);
+        if (this._tracingMode === "otel") {
             this.langSmithToOTELTranslator = new translator_js_1.LangSmithToOTELTranslator();
         }
         // Cache metadata env vars once during construction to avoid repeatedly scanning process.env
@@ -1096,18 +1179,18 @@ class Client {
         const sizeLimit = await this._getBatchSizeLimit();
         if (this.autoBatchQueue.sizeBytes > sizeLimitBytes ||
             this.autoBatchQueue.items.length > sizeLimit) {
-            void this.drainAutoBatchQueue({
+            this._trackDrain(this.drainAutoBatchQueue({
                 batchSizeLimitBytes: sizeLimitBytes,
                 batchSizeLimit: sizeLimit,
-            });
+            }));
         }
         if (this.autoBatchQueue.items.length > 0) {
             this.autoBatchTimeout = setTimeout(() => {
                 this.autoBatchTimeout = undefined;
-                void this.drainAutoBatchQueue({
+                this._trackDrain(this.drainAutoBatchQueue({
                     batchSizeLimitBytes: sizeLimitBytes,
                     batchSizeLimit: sizeLimit,
-                });
+                }));
             }, this.autoBatchAggregationDelayMs);
         }
         return itemPromise;
@@ -1116,7 +1199,7 @@ class Client {
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/info`, {
                 method: "GET",
-                headers: { Accept: "application/json" },
+                headers: { ...this._mergedHeaders, Accept: "application/json" },
                 signal: AbortSignal.timeout(SERVER_INFO_REQUEST_TIMEOUT_MS),
                 ...this.fetchOptions,
             });
@@ -1287,7 +1370,7 @@ class Client {
                 .map((item) => item.id)
                 .concat(batchChunks.patch.map((item) => item.id))
                 .join(",");
-            await this._postBatchIngestRuns((0, index_js_3.serialize)(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
+            await this._postBatchIngestRuns(await this._serializeBody(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
         }
     }
     async _postBatchIngestRuns(body, options) {
@@ -1388,7 +1471,7 @@ class Client {
                 const { inputs, outputs, events, extra, error, serialized, attachments, ...payload } = originalPayload;
                 const fields = { inputs, outputs, events, extra, error, serialized };
                 // encode the main run payload
-                const stringifiedPayload = (0, index_js_3.serialize)(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
+                const stringifiedPayload = await this._serializeBody(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
                 accumulatedParts.push({
                     name: `${method}.${payload.id}`,
                     payload: new Blob([stringifiedPayload], {
@@ -1400,7 +1483,7 @@ class Client {
                     if (value === undefined) {
                         continue;
                     }
-                    const stringifiedValue = (0, index_js_3.serialize)(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
+                    const stringifiedValue = await this._serializeBody(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
                     accumulatedParts.push({
                         name: `${method}.${payload.id}.${key}`,
                         payload: new Blob([stringifiedValue], {
@@ -4407,6 +4490,8 @@ class Client {
             commit_hash: result.commit_hash,
             manifest: result.manifest,
             examples: result.examples,
+            hub_model_config: result.model_config,
+            hub_model_provider: result.model_provider,
         };
     }
     async pullPromptCommit(promptIdentifier, options) {
@@ -4845,6 +4930,12 @@ class Client {
          * ```
          */
         await new Promise((resolve) => setTimeout(resolve, 1));
+        // Wait for any in-flight drains (whose serialize work may still be
+        // in-progress on a worker thread and not yet registered with the
+        // batchIngestCaller queue) before checking queue idleness.
+        while (this._pendingDrains.size > 0) {
+            await Promise.all([...this._pendingDrains]);
+        }
         await Promise.all([
             ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
             this.batchIngestCaller.queue.onIdle(),

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import type { OTELContext } from "./experimental/otel/types.js";
 import { AsyncCallerParams } from "./utils/async_caller.js";
 import { ComparativeExperiment, DataType, Dataset, DatasetDiffInfo, DatasetShareSchema, Example, ExampleCreate, ExampleUpdate, ExampleUpdateWithoutId, Feedback, FeedbackConfig, FeedbackIngestToken, KVMap, LangChainBaseMessage, LangSmithSettings, LikePromptResponse, Prompt, PromptCommit, PromptSortField, Run, RunCreate, RunUpdate, ScoreType, TimeDelta, TracerSession, TracerSessionResult, ValueType, AnnotationQueue, RunWithAnnotationQueueInfo, Attachments, UploadExamplesResponse, UpdateExamplesResponse, DatasetVersion, AnnotationQueueWithDetails, AnnotationQueueRubricItem, FeedbackConfigSchema, AgentContext, SkillContext, Entry } from "./schemas.js";
+import { type TracingMode } from "./utils/env.js";
 import { EvaluationResult, EvaluationResults } from "./evaluation/evaluator.js";
 import { PromptCache } from "./utils/prompt_cache/index.js";
 export interface ClientConfig {
@@ -56,6 +57,17 @@ export interface ClientConfig {
      * By default, prompt caching is enabled globally.
      */
     disablePromptCache?: boolean;
+    /**
+     * Where to send traces.  One of:
+     *
+     * - `"langsmith"` (default) — LangSmith REST API only.
+     * - `"otel"` — OpenTelemetry export only.
+     *
+     * Falls back to the `LANGSMITH_TRACING_MODE` env var, then to the
+     * legacy `OTEL_ENABLED` / `LANGSMITH_OTEL_ENABLED` env vars, then to
+     * `"langsmith"`.
+     */
+    tracingMode?: TracingMode;
     /**
      * Additional HTTP headers to include in all requests.
      * These headers will be merged with the default headers (User-Agent,
@@ -414,11 +426,37 @@ export declare class Client implements LangSmithTracingClientInterface {
     private _serverInfo;
     private _getServerInfoPromise?;
     private manualFlushMode;
+    private _serializeWorker?;
+    /**
+     * Tracks in-flight drainAutoBatchQueue promises so awaitPendingTraceBatches
+     * can wait on them even if the flush involves async work (worker-thread
+     * serialize) that hasn't yet registered with batchIngestCaller.queue.
+     */
+    private _pendingDrains;
     private langSmithToOTELTranslator?;
+    private _tracingMode;
+    get tracingMode(): TracingMode;
     private fetchImplementation?;
     private cachedLSEnvVarsForMetadata?;
     private _promptCache?;
     private get _fetch();
+    /**
+     * Serialize a payload for tracing, optionally offloading the work to a
+     * Node worker thread when LANGSMITH_PERF_OPTIMIZATION=true and the runtime
+     * supports worker_threads.
+     *
+     * Falls back to synchronous serialization when:
+     *  - the perf flag is off
+     *  - manualFlushMode is enabled (serverless: worker boot cost > benefit)
+     *  - worker_threads is unavailable (non-Node runtimes)
+     *  - the payload contains values that can't be structured-cloned across
+     *    threads (functions, non-cloneable class instances, streams, etc.)
+     *  - the worker throws for any other reason
+     *
+     * In all fallback cases the returned bytes are identical to the sync path.
+     */
+    private _trackDrain;
+    private _serializeBody;
     private multipartStreamingDisabled;
     private _multipartDisabled;
     private _runCompressionDisabled;

package/dist/client.js

@@ -1,9 +1,9 @@
-import * as uuid from "uuid";
+import * as uuid from "./utils/uuid/src/index.js";
 import { LangSmithToOTELTranslator, } from "./experimental/otel/translator.js";
 import { getDefaultOTLPTracerComponents, getOTELTrace, getOTELContext, } from "./singletons/otel.js";
 import { AsyncCaller } from "./utils/async_caller.js";
 import { convertLangChainMessageToExample, isLangChainMessage, } from "./utils/messages.js";
-import { getEnvironmentVariable, getLangSmithEnvVarsMetadata, getLangSmithEnvironmentVariable, getRuntimeEnvironment, getOtelEnabled, getEnv, } from "./utils/env.js";
+import { getEnvironmentVariable, getLangSmithEnvVarsMetadata, getLangSmithEnvironmentVariable, getRuntimeEnvironment, getEnv, resolveTracingMode, } from "./utils/env.js";
 import { __version__ } from "./index.js";
 import { assertUuid } from "./utils/_uuid.js";
 import { warnOnce } from "./utils/warn.js";
@@ -13,6 +13,7 @@ import { promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 import * as fsUtils from "./utils/fs.js";
 import { _shouldStreamForGlobalFetchImplementation, _getFetchImplementation, } from "./singletons/fetch.js";
 import { serialize as serializePayloadForTracing, estimateSerializedSize, } from "./utils/fast-safe-stringify/index.js";
+import { getSharedSerializeWorker, hasLargeString, } from "./utils/serialize_worker.js";
 /**
  * Catches timestamps without a timezone suffix.
  */
@@ -163,7 +164,7 @@ export class AutoBatchQueue {
         // real serialization still happens later, off the hot path, when the
         // batch is assembled for sending.
         const size = getLangSmithEnvironmentVariable("PERF_OPTIMIZATION") === "true"
-            ? estimateSerializedSize(item.item)
+            ? estimateSerializedSize(item.item).size
             : serializePayloadForTracing(item.item, `Serializing run with id: ${item.item.id}`).length;
         // Check if adding this item would exceed the size limit
         // Allow the run if the queue is empty (to support large single traces)
@@ -227,9 +228,67 @@ export class AutoBatchQueue {
     }
 }
 export class Client {
+    get tracingMode() {
+        return this._tracingMode;
+    }
     get _fetch() {
         return this.fetchImplementation || _getFetchImplementation(this.debug);
     }
+    /**
+     * Serialize a payload for tracing, optionally offloading the work to a
+     * Node worker thread when LANGSMITH_PERF_OPTIMIZATION=true and the runtime
+     * supports worker_threads.
+     *
+     * Falls back to synchronous serialization when:
+     *  - the perf flag is off
+     *  - manualFlushMode is enabled (serverless: worker boot cost > benefit)
+     *  - worker_threads is unavailable (non-Node runtimes)
+     *  - the payload contains values that can't be structured-cloned across
+     *    threads (functions, non-cloneable class instances, streams, etc.)
+     *  - the worker throws for any other reason
+     *
+     * In all fallback cases the returned bytes are identical to the sync path.
+     */
+    _trackDrain(promise) {
+        this._pendingDrains.add(promise);
+        promise.finally(() => {
+            this._pendingDrains.delete(promise);
+        });
+    }
+    async _serializeBody(payload, errorContext) {
+        const perfOptIn = getLangSmithEnvironmentVariable("PERF_OPTIMIZATION") === "true";
+        if (!perfOptIn || this.manualFlushMode) {
+            return serializePayloadForTracing(payload, errorContext);
+        }
+        // Shape-aware gate: worker offload pays for itself only when the
+        // payload is dominated by one or more large strings (V8 can refcount
+        // those across isolates instead of copying). For structure-heavy
+        // payloads -- many keys, deep nesting, lots of small strings -- the
+        // structuredClone walk plus thread-hop cost exceeds the JSON.stringify
+        // cost we would pay inline, so we fall through to sync serialize.
+        if (!hasLargeString(payload)) {
+            return serializePayloadForTracing(payload, errorContext);
+        }
+        if (this._serializeWorker === undefined) {
+            this._serializeWorker = getSharedSerializeWorker();
+        }
+        if (this._serializeWorker === null) {
+            return serializePayloadForTracing(payload, errorContext);
+        }
+        try {
+            const bytes = await this._serializeWorker.serialize(payload);
+            if (bytes === null) {
+                // Worker subsystem unavailable; cache the null to skip re-entry.
+                this._serializeWorker = null;
+                return serializePayloadForTracing(payload, errorContext);
+            }
+            return bytes;
+        }
+        catch {
+            // DataCloneError, worker crash, etc. Fall back silently.
+            return serializePayloadForTracing(payload, errorContext);
+        }
+    }
     constructor(config = {}) {
         Object.defineProperty(this, "apiKey", {
             enumerable: true,
@@ -394,12 +453,35 @@ export class Client {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "_serializeWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Tracks in-flight drainAutoBatchQueue promises so awaitPendingTraceBatches
+         * can wait on them even if the flush involves async work (worker-thread
+         * serialize) that hasn't yet registered with batchIngestCaller.queue.
+         */
+        Object.defineProperty(this, "_pendingDrains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
         Object.defineProperty(this, "langSmithToOTELTranslator", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_tracingMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "langsmith"
+        });
         Object.defineProperty(this, "fetchImplementation", {
             enumerable: true,
             configurable: true,
@@ -519,7 +601,8 @@ export class Client {
         this.batchSizeLimit = config.batchSizeLimit;
         this.fetchOptions = config.fetchOptions || {};
         this.manualFlushMode = config.manualFlushMode ?? this.manualFlushMode;
-        if (getOtelEnabled()) {
+        this._tracingMode = resolveTracingMode(config.tracingMode);
+        if (this._tracingMode === "otel") {
             this.langSmithToOTELTranslator = new LangSmithToOTELTranslator();
         }
         // Cache metadata env vars once during construction to avoid repeatedly scanning process.env
@@ -1058,18 +1141,18 @@ export class Client {
         const sizeLimit = await this._getBatchSizeLimit();
         if (this.autoBatchQueue.sizeBytes > sizeLimitBytes ||
             this.autoBatchQueue.items.length > sizeLimit) {
-            void this.drainAutoBatchQueue({
+            this._trackDrain(this.drainAutoBatchQueue({
                 batchSizeLimitBytes: sizeLimitBytes,
                 batchSizeLimit: sizeLimit,
-            });
+            }));
         }
         if (this.autoBatchQueue.items.length > 0) {
             this.autoBatchTimeout = setTimeout(() => {
                 this.autoBatchTimeout = undefined;
-                void this.drainAutoBatchQueue({
+                this._trackDrain(this.drainAutoBatchQueue({
                     batchSizeLimitBytes: sizeLimitBytes,
                     batchSizeLimit: sizeLimit,
-                });
+                }));
             }, this.autoBatchAggregationDelayMs);
         }
         return itemPromise;
@@ -1078,7 +1161,7 @@ export class Client {
         const response = await this.caller.call(async () => {
             const res = await this._fetch(`${this.apiUrl}/info`, {
                 method: "GET",
-                headers: { Accept: "application/json" },
+                headers: { ...this._mergedHeaders, Accept: "application/json" },
                 signal: AbortSignal.timeout(SERVER_INFO_REQUEST_TIMEOUT_MS),
                 ...this.fetchOptions,
             });
@@ -1249,7 +1332,7 @@ export class Client {
                 .map((item) => item.id)
                 .concat(batchChunks.patch.map((item) => item.id))
                 .join(",");
-            await this._postBatchIngestRuns(serializePayloadForTracing(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
+            await this._postBatchIngestRuns(await this._serializeBody(batchChunks, `Ingesting runs with ids: ${runIds}`), options);
         }
     }
     async _postBatchIngestRuns(body, options) {
@@ -1350,7 +1433,7 @@ export class Client {
                 const { inputs, outputs, events, extra, error, serialized, attachments, ...payload } = originalPayload;
                 const fields = { inputs, outputs, events, extra, error, serialized };
                 // encode the main run payload
-                const stringifiedPayload = serializePayloadForTracing(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
+                const stringifiedPayload = await this._serializeBody(payload, `Serializing for multipart ingestion of run with id: ${payload.id}`);
                 accumulatedParts.push({
                     name: `${method}.${payload.id}`,
                     payload: new Blob([stringifiedPayload], {
@@ -1362,7 +1445,7 @@ export class Client {
                     if (value === undefined) {
                         continue;
                     }
-                    const stringifiedValue = serializePayloadForTracing(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
+                    const stringifiedValue = await this._serializeBody(value, `Serializing ${key} for multipart ingestion of run with id: ${payload.id}`);
                     accumulatedParts.push({
                         name: `${method}.${payload.id}.${key}`,
                         payload: new Blob([stringifiedValue], {
@@ -4369,6 +4452,8 @@ export class Client {
             commit_hash: result.commit_hash,
             manifest: result.manifest,
             examples: result.examples,
+            hub_model_config: result.model_config,
+            hub_model_provider: result.model_provider,
         };
     }
     async pullPromptCommit(promptIdentifier, options) {
@@ -4807,6 +4892,12 @@ export class Client {
          * ```
          */
         await new Promise((resolve) => setTimeout(resolve, 1));
+        // Wait for any in-flight drains (whose serialize work may still be
+        // in-progress on a worker thread and not yet registered with the
+        // batchIngestCaller queue) before checking queue idleness.
+        while (this._pendingDrains.size > 0) {
+            await Promise.all([...this._pendingDrains]);
+        }
         await Promise.all([
             ...this.autoBatchQueue.items.map(({ itemPromise }) => itemPromise),
             this.batchIngestCaller.queue.onIdle(),

package/dist/evaluation/_runner.cjs

@@ -13,7 +13,7 @@ const env_js_1 = require("../utils/env.cjs");
 const error_js_1 = require("../utils/error.cjs");
 const _random_name_js_1 = require("./_random_name.cjs");
 const evaluator_js_1 = require("./evaluator.cjs");
-const uuid_1 = require("uuid");
+const index_js_2 = require("../utils/uuid/src/index.cjs");
 const evaluate_comparative_js_1 = require("./evaluate_comparative.cjs");
 const p_queue_js_1 = require("../utils/p-queue.cjs");
 // Implementation signature
@@ -202,7 +202,7 @@ class _ExperimentManager {
             this._experimentName = (0, _random_name_js_1.randomName)();
         }
         else if (typeof args.experiment === "string") {
-            this._experimentName = `${args.experiment}-${(0, uuid_1.v4)().slice(0, 8)}`;
+            this._experimentName = `${args.experiment}-${(0, index_js_2.v4)().slice(0, 8)}`;
         }
         else {
             if (!args.experiment.name) {
@@ -276,7 +276,7 @@ class _ExperimentManager {
             catch (e) {
                 // Naming collision
                 if (e?.name === "LangSmithConflictError") {
-                    const ent = (0, uuid_1.v4)().slice(0, 6);
+                    const ent = (0, index_js_2.v4)().slice(0, 6);
                     this._experimentName = `${originalExperimentName}-${ent}`;
                 }
                 else {

package/dist/evaluation/_runner.js

@@ -7,7 +7,7 @@ import { getLangSmithEnvVarsMetadata } from "../utils/env.js";
 import { printErrorStackTrace } from "../utils/error.js";
 import { randomName } from "./_random_name.js";
 import { runEvaluator, } from "./evaluator.js";
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from "../utils/uuid/src/index.js";
 import { evaluateComparative, } from "./evaluate_comparative.js";
 import { PQueue } from "../utils/p-queue.js";
 // Implementation signature

package/dist/evaluation/evaluate_comparative.cjs

@@ -4,22 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateComparative = evaluateComparative;
-const uuid_1 = require("uuid");
-const index_js_1 = require("../index.cjs");
+const index_js_1 = require("../utils/uuid/src/index.cjs");
+const index_js_2 = require("../index.cjs");
 const shuffle_js_1 = require("../utils/shuffle.cjs");
 const async_caller_js_1 = require("../utils/async_caller.cjs");
-const index_js_2 = __importDefault(require("../utils/p-retry/index.cjs"));
+const index_js_3 = __importDefault(require("../utils/p-retry/index.cjs"));
 const traceable_js_1 = require("../traceable.cjs");
 function isExperimentResultsList(value) {
     return value.some((x) => typeof x !== "string");
 }
 async function loadExperiment(client, experiment) {
     const value = typeof experiment === "string" ? experiment : experiment.experimentName;
-    return client.readProject((0, uuid_1.validate)(value) ? { projectId: value } : { projectName: value });
+    return client.readProject((0, index_js_1.validate)(value) ? { projectId: value } : { projectName: value });
 }
 async function loadTraces(client, experiment, options) {
     const executionOrder = options.loadNested ? undefined : 1;
-    const runs = await client.listRuns((0, uuid_1.validate)(experiment)
+    const runs = await client.listRuns((0, index_js_1.validate)(experiment)
         ? { projectId: experiment, executionOrder }
         : { projectName: experiment, executionOrder });
     const treeMap = {};
@@ -56,7 +56,7 @@ async function evaluateComparative(experiments, options) {
     if (options.maxConcurrency && options.maxConcurrency < 0) {
         throw new Error("maxConcurrency must be a positive number.");
     }
-    const client = options.client ?? new index_js_1.Client();
+    const client = options.client ?? new index_js_2.Client();
     const resolvedExperiments = await Promise.all(experiments);
     const projects = await (() => {
         if (!isExperimentResultsList(resolvedExperiments)) {
@@ -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, index_js_2.default)(async () => {
+        return Promise.all(resolvedExperiments.map((experiment) => (0, index_js_3.default)(async () => {
             const project = await loadExperiment(client, experiment);
             if (project.run_count !== experiment?.results.length) {
                 throw new Error("Experiment is missing runs. Retrying.");
@@ -83,16 +83,16 @@ async function evaluateComparative(experiments, options) {
         console.warn("Detected multiple dataset versions used by experiments, which may lead to inaccurate results.");
     }
     const datasetVersion = projects.at(0)?.extra?.metadata?.dataset_version;
-    const id = (0, uuid_1.v4)();
+    const id = (0, index_js_1.v4)();
     const experimentName = (() => {
         if (!options.experimentPrefix) {
             const names = projects
                 .map((p) => p.name)
                 .filter(Boolean)
                 .join(" vs. ");
-            return `${names}-${(0, uuid_1.v4)().slice(0, 4)}`;
+            return `${names}-${(0, index_js_1.v4)().slice(0, 4)}`;
         }
-        return `${options.experimentPrefix}-${(0, uuid_1.v4)().slice(0, 4)}`;
+        return `${options.experimentPrefix}-${(0, index_js_1.v4)().slice(0, 4)}`;
     })();
     // TODO: add URL to the comparative experiment
     console.log(`Starting pairwise evaluation of: ${experimentName}`);

package/dist/evaluation/evaluate_comparative.js

@@ -1,4 +1,4 @@
-import { v4 as uuid4, validate } from "uuid";
+import { v4 as uuid4, validate } from "../utils/uuid/src/index.js";
 import { Client } from "../index.js";
 import { shuffle } from "../utils/shuffle.js";
 import { AsyncCaller } from "../utils/async_caller.js";

package/dist/evaluation/evaluator.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynamicRunEvaluator = void 0;
 exports.runEvaluator = runEvaluator;
-const uuid_1 = require("uuid");
+const index_js_1 = require("../utils/uuid/src/index.cjs");
 const traceable_js_1 = require("../traceable.cjs");
 /**
  * Wraps an evaluator function + implements the RunEvaluator interface.
@@ -67,7 +67,7 @@ class DynamicRunEvaluator {
      * @returns A promise that extracts to the evaluation result.
      */
     async evaluateRun(run, example, options) {
-        let sourceRunId = (0, uuid_1.v7)();
+        let sourceRunId = (0, index_js_1.v7)();
         const metadata = {
             targetRunId: run.id,
         };

package/dist/evaluation/evaluator.js

@@ -1,4 +1,4 @@
-import { v7 as uuidv7 } from "uuid";
+import { v7 as uuidv7 } from "../utils/uuid/src/index.js";
 import { traceable } from "../traceable.js";
 /**
  * Wraps an evaluator function + implements the RunEvaluator interface.

package/dist/index.cjs

@@ -18,4 +18,4 @@ Object.defineProperty(exports, "PromptCache", { enumerable: true, get: function
 Object.defineProperty(exports, "configureGlobalPromptCache", { enumerable: true, get: function () { return index_js_1.configureGlobalPromptCache; } });
 Object.defineProperty(exports, "promptCacheSingleton", { enumerable: true, get: function () { return index_js_1.promptCacheSingleton; } });
 // Update using pnpm bump-version
-exports.__version__ = "0.5.23";
+exports.__version__ = "0.5.25";

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, PromptCache, type CacheConfig, type CacheMetrics, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
-export declare const __version__ = "0.5.23";
+export declare const __version__ = "0.5.25";

package/dist/index.js

@@ -5,4 +5,4 @@ export { getDefaultProjectName } from "./utils/project.js";
 export { uuid7, uuid7FromTime } from "./uuid.js";
 export { Cache, PromptCache, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 // Update using pnpm bump-version
-export const __version__ = "0.5.23";
+export const __version__ = "0.5.25";