langsmith 0.8.5 → 0.8.7

package/dist/index.cjs

@@ -35,6 +35,6 @@ Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, g
 Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return error_js_1.RateLimitError; } });
 Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return error_js_1.InternalServerError; } });
 // Update using pnpm bump-version
-exports.__version__ = "0.8.5";
+exports.__version__ = "0.8.7";
 // Metadata key to hide a traced run from LangSmith's Messages View.
 exports.LS_MESSAGE_VIEW_EXCLUDE = "ls_message_view_exclude";

package/dist/index.d.ts

@@ -7,5 +7,5 @@ export { computeRunIdForSecondaryReplica, uuid7, uuid7FromTime, } from "./uuid.j
 export { isTracingEnabled } from "./utils/guard.js";
 export { Cache, PromptCache, type CacheConfig, type CacheMetrics, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 export { LangsmithError, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, } from "./_openapi_client/core/error.js";
-export declare const __version__ = "0.8.5";
+export declare const __version__ = "0.8.7";
 export declare const LS_MESSAGE_VIEW_EXCLUDE: "ls_message_view_exclude";

package/dist/index.js

@@ -7,6 +7,6 @@ export { isTracingEnabled } from "./utils/guard.js";
 export { Cache, PromptCache, configureGlobalPromptCache, promptCacheSingleton, } from "./utils/prompt_cache/index.js";
 export { LangsmithError, APIError, APIUserAbortError, APIConnectionError, APIConnectionTimeoutError, BadRequestError, AuthenticationError, PermissionDeniedError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitError, InternalServerError, } from "./_openapi_client/core/error.js";
 // Update using pnpm bump-version
-export const __version__ = "0.8.5";
+export const __version__ = "0.8.7";
 // Metadata key to hide a traced run from LangSmith's Messages View.
 export const LS_MESSAGE_VIEW_EXCLUDE = "ls_message_view_exclude";

package/dist/sandbox/command_handle.cjs

@@ -147,7 +147,7 @@ class CommandHandle {
             return;
         const firstResult = await this._stream.next();
         if (firstResult.done) {
-            throw new errors_js_1.LangSmithSandboxOperationError("Command stream ended before 'started' message", "command");
+            throw new errors_js_1.LangSmithStreamEndedBeforeStartedError("Command stream ended before 'started' message");
         }
         const firstMsg = firstResult.value;
         if (firstMsg.type !== "started") {

package/dist/sandbox/command_handle.js

@@ -4,7 +4,7 @@
  *
  * Port of Python's AsyncCommandHandle to TypeScript.
  */
-import { LangSmithSandboxConnectionError, LangSmithSandboxOperationError, } from "./errors.js";
+import { LangSmithSandboxConnectionError, LangSmithSandboxOperationError, LangSmithStreamEndedBeforeStartedError, } from "./errors.js";
 /**
  * Async handle to a running command with streaming output and auto-reconnect.
  *
@@ -144,7 +144,7 @@ export class CommandHandle {
             return;
         const firstResult = await this._stream.next();
         if (firstResult.done) {
-            throw new LangSmithSandboxOperationError("Command stream ended before 'started' message", "command");
+            throw new LangSmithStreamEndedBeforeStartedError("Command stream ended before 'started' message");
         }
         const firstMsg = firstResult.value;
         if (firstMsg.type !== "started") {

package/dist/sandbox/errors.cjs

@@ -7,7 +7,7 @@
  * properties for specific handling when needed.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LangSmithSandboxServerReloadError = exports.LangSmithCommandTimeoutError = exports.LangSmithSandboxOperationError = exports.LangSmithSandboxNotReadyError = exports.LangSmithDataplaneNotConfiguredError = exports.LangSmithSandboxCreationError = exports.LangSmithResourceCreationError = exports.LangSmithQuotaExceededError = exports.LangSmithValidationError = exports.LangSmithResourceNameConflictError = exports.LangSmithResourceAlreadyExistsError = exports.LangSmithResourceInUseError = exports.LangSmithResourceTimeoutError = exports.LangSmithResourceNotFoundError = exports.LangSmithSandboxConnectionError = exports.LangSmithSandboxAuthenticationError = exports.LangSmithSandboxAPIError = exports.LangSmithSandboxError = void 0;
+exports.LangSmithSandboxServerReloadError = exports.LangSmithStreamEndedBeforeStartedError = exports.LangSmithCommandTimeoutError = exports.LangSmithSandboxOperationError = exports.LangSmithSandboxNotReadyError = exports.LangSmithDataplaneNotConfiguredError = exports.LangSmithSandboxCreationError = exports.LangSmithResourceCreationError = exports.LangSmithQuotaExceededError = exports.LangSmithValidationError = exports.LangSmithResourceNameConflictError = exports.LangSmithResourceAlreadyExistsError = exports.LangSmithResourceInUseError = exports.LangSmithResourceTimeoutError = exports.LangSmithResourceNotFoundError = exports.LangSmithSandboxConnectionError = exports.LangSmithSandboxAuthenticationError = exports.LangSmithSandboxAPIError = exports.LangSmithSandboxError = void 0;
 /**
  * Base exception for sandbox client errors.
  */
@@ -357,6 +357,21 @@ class LangSmithCommandTimeoutError extends LangSmithSandboxOperationError {
     }
 }
 exports.LangSmithCommandTimeoutError = LangSmithCommandTimeoutError;
+/**
+ * Internal: a command WebSocket closed before the guest sent its 'started'
+ * frame (the proxied tunnel was torn down gracefully mid-handshake).
+ *
+ * Marks the idempotently-retryable early close, as distinct from a
+ * command-level failure. Subclasses the operation error so callers that catch
+ * the public type are unaffected.
+ */
+class LangSmithStreamEndedBeforeStartedError extends LangSmithSandboxOperationError {
+    constructor(message) {
+        super(message, "command");
+        this.name = "LangSmithStreamEndedBeforeStartedError";
+    }
+}
+exports.LangSmithStreamEndedBeforeStartedError = LangSmithStreamEndedBeforeStartedError;
 /**
  * Raised when the sandbox server is reloading (close code 1001).
  *

package/dist/sandbox/errors.d.ts

@@ -154,6 +154,17 @@ export declare class LangSmithCommandTimeoutError extends LangSmithSandboxOperat
     timeout?: number;
     constructor(message: string, timeout?: number);
 }
+/**
+ * Internal: a command WebSocket closed before the guest sent its 'started'
+ * frame (the proxied tunnel was torn down gracefully mid-handshake).
+ *
+ * Marks the idempotently-retryable early close, as distinct from a
+ * command-level failure. Subclasses the operation error so callers that catch
+ * the public type are unaffected.
+ */
+export declare class LangSmithStreamEndedBeforeStartedError extends LangSmithSandboxOperationError {
+    constructor(message: string);
+}
 /**
  * Raised when the sandbox server is reloading (close code 1001).
  *

package/dist/sandbox/errors.js

@@ -337,6 +337,20 @@ export class LangSmithCommandTimeoutError extends LangSmithSandboxOperationError
         this.timeout = timeout;
     }
 }
+/**
+ * Internal: a command WebSocket closed before the guest sent its 'started'
+ * frame (the proxied tunnel was torn down gracefully mid-handshake).
+ *
+ * Marks the idempotently-retryable early close, as distinct from a
+ * command-level failure. Subclasses the operation error so callers that catch
+ * the public type are unaffected.
+ */
+export class LangSmithStreamEndedBeforeStartedError extends LangSmithSandboxOperationError {
+    constructor(message) {
+        super(message, "command");
+        this.name = "LangSmithStreamEndedBeforeStartedError";
+    }
+}
 /**
  * Raised when the sandbox server is reloading (close code 1001).
  *

package/dist/sandbox/sandbox.cjs

@@ -4,6 +4,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sandbox = void 0;
+const uuid_js_1 = require("../uuid.cjs");
 const errors_js_1 = require("./errors.cjs");
 const helpers_js_1 = require("./helpers.cjs");
 const command_handle_js_1 = require("./command_handle.cjs");
@@ -198,8 +199,9 @@ class Sandbox {
             // wait=true with callbacks: drain stream and return result
             return handle.result;
         }
-        // wait=true, no callbacks: try WS, fall back to HTTP
-        try {
+        // wait=true, no callbacks: use WebSocket when the 'ws' package is
+        // available, otherwise the blocking HTTP endpoint. WS errors propagate.
+        if (await this._wsAvailable()) {
             const handle = await this._runWs(command, {
                 ...restOptions,
                 idleTimeout,
@@ -209,17 +211,14 @@ class Sandbox {
             });
             return await handle.result;
         }
-        catch (e) {
-            // Fall back to HTTP on connection errors or missing ws package
-            const name = e != null && typeof e === "object" ? e.name : "";
-            const message = e != null && typeof e === "object" ? (e.message ?? "") : "";
-            if (name === "LangSmithSandboxConnectionError" ||
-                name === "LangSmithSandboxServerReloadError" ||
-                message.includes("'ws' package")) {
-                return this._runHttp(command, restOptions);
-            }
-            throw e;
-        }
+        return this._runHttp(command, restOptions);
+    }
+    /**
+     * Whether the optional `ws` package is importable (resolved once).
+     * @internal
+     */
+    _wsAvailable() {
+        return (0, ws_execute_js_1.isWsAvailable)();
     }
     /**
      * Execute a command via WebSocket streaming.
@@ -229,26 +228,49 @@ class Sandbox {
         const { timeout = 60, env, cwd, shell = "/bin/bash", onStdout, onStderr, commandId, idleTimeout, killOnDisconnect, ttlSeconds, pty, } = options;
         const dataplaneUrl = this.requireDataplaneUrl();
         const clientHeaders = this._client.getDefaultHeaders();
-        const [stream, control] = await (0, ws_execute_js_1.runWsStream)(dataplaneUrl, this._client.getApiKey(), command, {
-            timeout,
-            env,
-            cwd,
-            shell,
-            commandId,
-            idleTimeout,
-            killOnDisconnect,
-            ttlSeconds,
-            pty,
-            ...(Object.keys(clientHeaders).length > 0
-                ? { headers: clientHeaders }
-                : {}),
-        });
-        const handle = new command_handle_js_1.CommandHandle(stream, control, this, {
-            onStdout,
-            onStderr,
-        });
-        await handle._ensureStarted();
-        return handle;
+        // A client-supplied command_id makes execute idempotent: the daemon does
+        // get-or-create keyed on it, so if the tunnel closes before "started" we
+        // can re-issue the same id and reattach to the existing command instead of
+        // spawning a second one.
+        const execCommandId = commandId ?? (0, uuid_js_1.uuid7)();
+        let attempt = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const [stream, control] = await (0, ws_execute_js_1.runWsStream)(dataplaneUrl, this._client.getApiKey(), command, {
+                timeout,
+                env,
+                cwd,
+                shell,
+                commandId: execCommandId,
+                idleTimeout,
+                killOnDisconnect,
+                ttlSeconds,
+                pty,
+                ...(Object.keys(clientHeaders).length > 0
+                    ? { headers: clientHeaders }
+                    : {}),
+            });
+            const handle = new command_handle_js_1.CommandHandle(stream, control, this, {
+                onStdout,
+                onStderr,
+            });
+            try {
+                await handle._ensureStarted();
+                return handle;
+            }
+            catch (e) {
+                // Idempotent re-issue (same command_id) after an early close.
+                if (!(e instanceof errors_js_1.LangSmithStreamEndedBeforeStartedError)) {
+                    throw e;
+                }
+                attempt++;
+                if (attempt > command_handle_js_1.CommandHandle.MAX_AUTO_RECONNECTS) {
+                    throw e;
+                }
+                const delay = Math.min(command_handle_js_1.CommandHandle.BACKOFF_BASE * 2 ** (attempt - 1), command_handle_js_1.CommandHandle.BACKOFF_MAX);
+                await new Promise((r) => setTimeout(r, delay * 1000));
+            }
+        }
     }
     /**
      * Execute a command via HTTP POST (blocking).

package/dist/sandbox/sandbox.d.ts

@@ -78,7 +78,8 @@ export declare class Sandbox {
      * Execute a command in the sandbox.
      *
      * When `wait` is true (default) and no streaming callbacks are provided,
-     * tries WebSocket first and falls back to HTTP POST.
+     * uses WebSocket, falling back to HTTP POST only when the optional `ws`
+     * package isn't installed.
      *
      * When `wait` is false or streaming callbacks are provided, uses WebSocket
      * (required). Returns a CommandHandle for streaming output.

package/dist/sandbox/sandbox.js

@@ -1,10 +1,11 @@
 /**
  * Sandbox class for interacting with a specific sandbox instance.
  */
-import { LangSmithDataplaneNotConfiguredError } from "./errors.js";
+import { uuid7 } from "../uuid.js";
+import { LangSmithDataplaneNotConfiguredError, LangSmithStreamEndedBeforeStartedError, } from "./errors.js";
 import { handleSandboxHttpError } from "./helpers.js";
 import { CommandHandle } from "./command_handle.js";
-import { reconnectWsStream, runWsStream } from "./ws_execute.js";
+import { isWsAvailable, reconnectWsStream, runWsStream } from "./ws_execute.js";
 /**
  * Represents an active sandbox for running commands and file operations.
  *
@@ -195,8 +196,9 @@ export class Sandbox {
             // wait=true with callbacks: drain stream and return result
             return handle.result;
         }
-        // wait=true, no callbacks: try WS, fall back to HTTP
-        try {
+        // wait=true, no callbacks: use WebSocket when the 'ws' package is
+        // available, otherwise the blocking HTTP endpoint. WS errors propagate.
+        if (await this._wsAvailable()) {
             const handle = await this._runWs(command, {
                 ...restOptions,
                 idleTimeout,
@@ -206,17 +208,14 @@ export class Sandbox {
             });
             return await handle.result;
         }
-        catch (e) {
-            // Fall back to HTTP on connection errors or missing ws package
-            const name = e != null && typeof e === "object" ? e.name : "";
-            const message = e != null && typeof e === "object" ? (e.message ?? "") : "";
-            if (name === "LangSmithSandboxConnectionError" ||
-                name === "LangSmithSandboxServerReloadError" ||
-                message.includes("'ws' package")) {
-                return this._runHttp(command, restOptions);
-            }
-            throw e;
-        }
+        return this._runHttp(command, restOptions);
+    }
+    /**
+     * Whether the optional `ws` package is importable (resolved once).
+     * @internal
+     */
+    _wsAvailable() {
+        return isWsAvailable();
     }
     /**
      * Execute a command via WebSocket streaming.
@@ -226,26 +225,49 @@ export class Sandbox {
         const { timeout = 60, env, cwd, shell = "/bin/bash", onStdout, onStderr, commandId, idleTimeout, killOnDisconnect, ttlSeconds, pty, } = options;
         const dataplaneUrl = this.requireDataplaneUrl();
         const clientHeaders = this._client.getDefaultHeaders();
-        const [stream, control] = await runWsStream(dataplaneUrl, this._client.getApiKey(), command, {
-            timeout,
-            env,
-            cwd,
-            shell,
-            commandId,
-            idleTimeout,
-            killOnDisconnect,
-            ttlSeconds,
-            pty,
-            ...(Object.keys(clientHeaders).length > 0
-                ? { headers: clientHeaders }
-                : {}),
-        });
-        const handle = new CommandHandle(stream, control, this, {
-            onStdout,
-            onStderr,
-        });
-        await handle._ensureStarted();
-        return handle;
+        // A client-supplied command_id makes execute idempotent: the daemon does
+        // get-or-create keyed on it, so if the tunnel closes before "started" we
+        // can re-issue the same id and reattach to the existing command instead of
+        // spawning a second one.
+        const execCommandId = commandId ?? uuid7();
+        let attempt = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const [stream, control] = await runWsStream(dataplaneUrl, this._client.getApiKey(), command, {
+                timeout,
+                env,
+                cwd,
+                shell,
+                commandId: execCommandId,
+                idleTimeout,
+                killOnDisconnect,
+                ttlSeconds,
+                pty,
+                ...(Object.keys(clientHeaders).length > 0
+                    ? { headers: clientHeaders }
+                    : {}),
+            });
+            const handle = new CommandHandle(stream, control, this, {
+                onStdout,
+                onStderr,
+            });
+            try {
+                await handle._ensureStarted();
+                return handle;
+            }
+            catch (e) {
+                // Idempotent re-issue (same command_id) after an early close.
+                if (!(e instanceof LangSmithStreamEndedBeforeStartedError)) {
+                    throw e;
+                }
+                attempt++;
+                if (attempt > CommandHandle.MAX_AUTO_RECONNECTS) {
+                    throw e;
+                }
+                const delay = Math.min(CommandHandle.BACKOFF_BASE * 2 ** (attempt - 1), CommandHandle.BACKOFF_MAX);
+                await new Promise((r) => setTimeout(r, delay * 1000));
+            }
+        }
     }
     /**
      * Execute a command via HTTP POST (blocking).

package/dist/sandbox/ws_execute.cjs

@@ -7,21 +7,28 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WSStreamControl = void 0;
+exports.isWsAvailable = isWsAvailable;
 exports.buildWsUrl = buildWsUrl;
 exports.buildAuthHeaders = buildAuthHeaders;
 exports.raiseForWsError = raiseForWsError;
 exports.runWsStream = runWsStream;
 exports.reconnectWsStream = reconnectWsStream;
 const errors_js_1 = require("./errors.cjs");
+// Load the optional 'ws' package once, at module load, instead of importing on
+// every call. Resolves to the WebSocket constructor, or null if 'ws' isn't
+// installed. run() reads isWsAvailable() to choose WS vs the HTTP fallback.
+const wsWebSocketPromise = import("ws").then((ws) => ws.default || ws.WebSocket || ws, () => null);
+/** Whether the optional `ws` package could be loaded (resolved once). */
+async function isWsAvailable() {
+    return (await wsWebSocketPromise) !== null;
+}
 async function ensureWs() {
-    try {
-        const ws = await import("ws");
-        return { WebSocket: ws.default || ws.WebSocket || ws };
-    }
-    catch {
+    const WebSocket = await wsWebSocketPromise;
+    if (!WebSocket) {
         throw new Error("WebSocket-based execution requires the 'ws' package. " +
             "Install it with: npm install ws");
     }
+    return { WebSocket };
 }
 // =============================================================================
 // URL and Auth Helpers

package/dist/sandbox/ws_execute.d.ts

@@ -6,6 +6,8 @@
  */
 import type { WsMessage, WsRunOptions } from "./types.js";
 type WsWebSocket = any;
+/** Whether the optional `ws` package could be loaded (resolved once). */
+export declare function isWsAvailable(): Promise<boolean>;
 /**
  * Convert a dataplane HTTP URL to a WebSocket URL for /execute/ws.
  */

package/dist/sandbox/ws_execute.js

@@ -5,15 +5,21 @@
  * Install with: npm install ws
  */
 import { LangSmithCommandTimeoutError, LangSmithSandboxConnectionError, LangSmithSandboxOperationError, LangSmithSandboxServerReloadError, } from "./errors.js";
+// Load the optional 'ws' package once, at module load, instead of importing on
+// every call. Resolves to the WebSocket constructor, or null if 'ws' isn't
+// installed. run() reads isWsAvailable() to choose WS vs the HTTP fallback.
+const wsWebSocketPromise = import("ws").then((ws) => ws.default || ws.WebSocket || ws, () => null);
+/** Whether the optional `ws` package could be loaded (resolved once). */
+export async function isWsAvailable() {
+    return (await wsWebSocketPromise) !== null;
+}
 async function ensureWs() {
-    try {
-        const ws = await import("ws");
-        return { WebSocket: ws.default || ws.WebSocket || ws };
-    }
-    catch {
+    const WebSocket = await wsWebSocketPromise;
+    if (!WebSocket) {
         throw new Error("WebSocket-based execution requires the 'ws' package. " +
             "Install it with: npm install ws");
     }
+    return { WebSocket };
 }
 // =============================================================================
 // URL and Auth Helpers

package/dist/utils/jestlike/globals.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncExamplePromises = exports.evaluatorLogFeedbackPromises = exports.testWrapperAsyncLocalStorageInstance = exports.DEFAULT_TEST_CLIENT = void 0;
+exports.evaluatorLogFeedbackPromises = exports.testWrapperAsyncLocalStorageInstance = exports.DEFAULT_TEST_CLIENT = void 0;
 exports.trackingEnabled = trackingEnabled;
 exports._logTestFeedback = _logTestFeedback;
 const node_async_hooks_1 = require("node:async_hooks");
@@ -19,7 +19,6 @@ function trackingEnabled(context) {
     return (0, env_js_2.isEnvTracingEnabled)();
 }
 exports.evaluatorLogFeedbackPromises = new Set();
-exports.syncExamplePromises = new Map();
 function _logTestFeedback(params) {
     const { exampleId, feedback, context, runTree, client, sourceRunId } = params;
     if (trackingEnabled(context)) {
@@ -33,7 +32,7 @@ function _logTestFeedback(params) {
             if (context.project == null) {
                 throw new Error("Could not log feedback to LangSmith: missing project information. Please contact us for help.");
             }
-            await exports.syncExamplePromises.get(exampleId);
+            await context.syncExamplePromises?.get(exampleId);
             await client?.logEvaluationFeedback({
                 evaluatorResponse: feedback,
                 run: runTree,

package/dist/utils/jestlike/globals.d.ts

@@ -20,11 +20,11 @@ export type TestWrapperAsyncLocalStorageData = {
     suiteName: string;
     testRootRunTree?: RunTree;
     setupPromise?: Promise<void>;
+    syncExamplePromises?: Map<string, Promise<Example>>;
 };
 export declare const testWrapperAsyncLocalStorageInstance: AsyncLocalStorage<TestWrapperAsyncLocalStorageData>;
 export declare function trackingEnabled(context: TestWrapperAsyncLocalStorageData): boolean;
 export declare const evaluatorLogFeedbackPromises: Set<unknown>;
-export declare const syncExamplePromises: Map<any, any>;
 export declare function _logTestFeedback(params: {
     exampleId?: string;
     feedback: SimpleEvaluationResult;

package/dist/utils/jestlike/globals.js

@@ -14,7 +14,6 @@ export function trackingEnabled(context) {
     return isEnvTracingEnabled();
 }
 export const evaluatorLogFeedbackPromises = new Set();
-export const syncExamplePromises = new Map();
 export function _logTestFeedback(params) {
     const { exampleId, feedback, context, runTree, client, sourceRunId } = params;
     if (trackingEnabled(context)) {
@@ -28,7 +27,7 @@ export function _logTestFeedback(params) {
             if (context.project == null) {
                 throw new Error("Could not log feedback to LangSmith: missing project information. Please contact us for help.");
             }
-            await syncExamplePromises.get(exampleId);
+            await context.syncExamplePromises?.get(exampleId);
             await client?.logEvaluationFeedback({
                 evaluatorResponse: feedback,
                 run: runTree,

package/dist/utils/jestlike/index.cjs

@@ -300,6 +300,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     },
                     enableTestTracking: experimentConfig?.enableTestTracking,
                     setupPromise,
+                    syncExamplePromises: new Map(),
                 };
                 beforeAll(async () => {
                     const storageValue = await runDatasetSetup(context);
@@ -307,15 +308,14 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     setupPromiseResolver();
                 });
                 afterAll(async () => {
+                    const examples = await Promise.all(context.syncExamplePromises.values());
                     await Promise.all([
                         client.awaitPendingTraceBatches(),
-                        ...globals_js_1.syncExamplePromises.values(),
                         ...globals_js_1.evaluatorLogFeedbackPromises.values(),
                     ]);
                     if (!(0, globals_js_1.trackingEnabled)(context)) {
                         return;
                     }
-                    const examples = [...globals_js_1.syncExamplePromises.values()];
                     if (examples.length === 0) {
                         return;
                     }
@@ -364,6 +364,7 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                         await client.updateProject(datasetInfo.project.id, {
                             metadata: {
                                 ...suiteMetadata,
+                                dataset_version: finalModifiedAt,
                                 commit,
                                 branch,
                                 dirty,
@@ -546,8 +547,11 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                             // Currently run end time has to be after example modified time
                             // for examples to render properly, so we must modify the example
                             // first before running the test.
-                            if (globals_js_1.syncExamplePromises.get(exampleId) === undefined) {
-                                globals_js_1.syncExamplePromises.set(exampleId, await syncExample({
+                            if (context.syncExamplePromises === undefined) {
+                                throw new Error("Internal error: syncExamplePromises not initialized. This is a bug in the LangSmith SDK — please open an issue at https://github.com/langchain-ai/langsmith-sdk/issues.");
+                            }
+                            if (!context.syncExamplePromises.has(exampleId)) {
+                                const syncPromise = syncExample({
                                     client,
                                     exampleId,
                                     datasetId: dataset.id,
@@ -556,8 +560,10 @@ function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                                     metadata,
                                     split,
                                     createdAt,
-                                }));
+                                });
+                                context.syncExamplePromises.set(exampleId, syncPromise);
                             }
+                            await context.syncExamplePromises.get(exampleId);
                             const traceableOptions = {
                                 reference_example_id: exampleId,
                                 project_name: project.name,

package/dist/utils/jestlike/index.js

@@ -9,7 +9,7 @@ import { execSync } from "child_process";
 import { getCurrentRunTree, traceable } from "../../traceable.js";
 import { randomName } from "../../evaluation/_random_name.js";
 import { toBeRelativeCloseTo, toBeAbsoluteCloseTo, toBeSemanticCloseTo, } from "./matchers.js";
-import { evaluatorLogFeedbackPromises, testWrapperAsyncLocalStorageInstance, _logTestFeedback, syncExamplePromises, trackingEnabled, DEFAULT_TEST_CLIENT, } from "./globals.js";
+import { evaluatorLogFeedbackPromises, testWrapperAsyncLocalStorageInstance, _logTestFeedback, trackingEnabled, DEFAULT_TEST_CLIENT, } from "./globals.js";
 import { wrapExpect } from "./vendor/chain.js";
 import { getEnvironmentVariable, isJsDom } from "../env.js";
 import { STRIP_ANSI_REGEX, TEST_ID_DELIMITER, UUID5_NAMESPACE, } from "./constants.js";
@@ -253,6 +253,7 @@ export function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     },
                     enableTestTracking: experimentConfig?.enableTestTracking,
                     setupPromise,
+                    syncExamplePromises: new Map(),
                 };
                 beforeAll(async () => {
                     const storageValue = await runDatasetSetup(context);
@@ -260,15 +261,14 @@ export function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                     setupPromiseResolver();
                 });
                 afterAll(async () => {
+                    const examples = await Promise.all(context.syncExamplePromises.values());
                     await Promise.all([
                         client.awaitPendingTraceBatches(),
-                        ...syncExamplePromises.values(),
                         ...evaluatorLogFeedbackPromises.values(),
                     ]);
                     if (!trackingEnabled(context)) {
                         return;
                     }
-                    const examples = [...syncExamplePromises.values()];
                     if (examples.length === 0) {
                         return;
                     }
@@ -317,6 +317,7 @@ export function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                         await client.updateProject(datasetInfo.project.id, {
                             metadata: {
                                 ...suiteMetadata,
+                                dataset_version: finalModifiedAt,
                                 commit,
                                 branch,
                                 dirty,
@@ -499,8 +500,11 @@ export function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                             // Currently run end time has to be after example modified time
                             // for examples to render properly, so we must modify the example
                             // first before running the test.
-                            if (syncExamplePromises.get(exampleId) === undefined) {
-                                syncExamplePromises.set(exampleId, await syncExample({
+                            if (context.syncExamplePromises === undefined) {
+                                throw new Error("Internal error: syncExamplePromises not initialized. This is a bug in the LangSmith SDK — please open an issue at https://github.com/langchain-ai/langsmith-sdk/issues.");
+                            }
+                            if (!context.syncExamplePromises.has(exampleId)) {
+                                const syncPromise = syncExample({
                                     client,
                                     exampleId,
                                     datasetId: dataset.id,
@@ -509,8 +513,10 @@ export function generateWrapperFromJestlikeMethods(methods, testRunnerName) {
                                     metadata,
                                     split,
                                     createdAt,
-                                }));
+                                });
+                                context.syncExamplePromises.set(exampleId, syncPromise);
                             }
+                            await context.syncExamplePromises.get(exampleId);
                             const traceableOptions = {
                                 reference_example_id: exampleId,
                                 project_name: project.name,