langsmith 0.5.9 → 0.5.11

package/dist/experimental/sandbox/command_handle.d.ts

@@ -0,0 +1,98 @@
+/**
+ * CommandHandle - async handle to a running command with streaming output
+ * and auto-reconnect.
+ *
+ * Port of Python's AsyncCommandHandle to TypeScript.
+ */
+import type { ExecutionResult, OutputChunk } from "./types.js";
+/**
+ * Async handle to a running command with streaming output and auto-reconnect.
+ *
+ * Async iterable, yielding OutputChunk objects (stdout and stderr interleaved
+ * in arrival order). Access .result after iteration to get the full
+ * ExecutionResult.
+ *
+ * Auto-reconnect behavior:
+ * - Server hot-reload (1001 Going Away): reconnect immediately
+ * - Network error / unexpected close:    reconnect with exponential backoff
+ * - User called kill():                  do NOT reconnect (propagate error)
+ *
+ * @example
+ * ```typescript
+ * const handle = await sandbox.run("make build", { timeout: 600, wait: false });
+ *
+ * for await (const chunk of handle) {  // auto-reconnects on transient errors
+ *   process.stdout.write(chunk.data);
+ * }
+ *
+ * const result = await handle.result;
+ * console.log(`Exit code: ${result.exit_code}`);
+ * ```
+ */
+export declare class CommandHandle {
+    static MAX_AUTO_RECONNECTS: number;
+    static BACKOFF_BASE: number;
+    static BACKOFF_MAX: number;
+    private _stream;
+    private _control;
+    private _sandbox;
+    private _commandId;
+    private _pid;
+    private _result;
+    private _stdoutParts;
+    private _stderrParts;
+    private _exhausted;
+    private _lastStdoutOffset;
+    private _lastStderrOffset;
+    private _started;
+    /**
+     * Read the 'started' message to populate commandId and pid.
+     *
+     * Must be called (and awaited) before iterating for new executions.
+     */
+    _ensureStarted(): Promise<void>;
+    /** The server-assigned command ID. Available after _ensureStarted(). */
+    get commandId(): string | null;
+    /** The process ID on the sandbox. Available after _ensureStarted(). */
+    get pid(): number | null;
+    /**
+     * The final execution result. Drains the stream if not already exhausted.
+     */
+    get result(): Promise<ExecutionResult>;
+    private _getResult;
+    /**
+     * Iterate over output chunks from the current stream (no reconnect).
+     */
+    private _iterStream;
+    /**
+     * Async iterate over output chunks with auto-reconnect on transient errors.
+     *
+     * Reconnect strategy:
+     * - 1001 Going Away (hot-reload): immediate reconnect, no delay
+     * - Other SandboxConnectionError:  exponential backoff (0.5s, 1s, 2s...)
+     * - After kill():                  no reconnect, error propagates
+     */
+    [Symbol.asyncIterator](): AsyncIterableIterator<OutputChunk>;
+    /**
+     * Send a kill signal to the running command (SIGKILL).
+     *
+     * The server kills the entire process group. The stream will
+     * subsequently yield an exit message with a non-zero exit code.
+     */
+    kill(): void;
+    /**
+     * Write data to the command's stdin.
+     */
+    sendInput(data: string): void;
+    /** Last known stdout byte offset (for manual reconnection). */
+    get lastStdoutOffset(): number;
+    /** Last known stderr byte offset (for manual reconnection). */
+    get lastStderrOffset(): number;
+    /**
+     * Reconnect to this command from the last known offsets.
+     *
+     * Returns a new CommandHandle that resumes output from where this one
+     * left off.
+     */
+    reconnect(): Promise<CommandHandle>;
+}

package/dist/experimental/sandbox/command_handle.js

@@ -0,0 +1,321 @@
+/**
+ * CommandHandle - async handle to a running command with streaming output
+ * and auto-reconnect.
+ *
+ * Port of Python's AsyncCommandHandle to TypeScript.
+ */
+import { LangSmithSandboxConnectionError, LangSmithSandboxOperationError, } from "./errors.js";
+/**
+ * Async handle to a running command with streaming output and auto-reconnect.
+ *
+ * Async iterable, yielding OutputChunk objects (stdout and stderr interleaved
+ * in arrival order). Access .result after iteration to get the full
+ * ExecutionResult.
+ *
+ * Auto-reconnect behavior:
+ * - Server hot-reload (1001 Going Away): reconnect immediately
+ * - Network error / unexpected close:    reconnect with exponential backoff
+ * - User called kill():                  do NOT reconnect (propagate error)
+ *
+ * @example
+ * ```typescript
+ * const handle = await sandbox.run("make build", { timeout: 600, wait: false });
+ *
+ * for await (const chunk of handle) {  // auto-reconnects on transient errors
+ *   process.stdout.write(chunk.data);
+ * }
+ *
+ * const result = await handle.result;
+ * console.log(`Exit code: ${result.exit_code}`);
+ * ```
+ */
+export class CommandHandle {
+    /** @internal */
+    constructor(messageStream, control, sandbox, options) {
+        Object.defineProperty(this, "_stream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_control", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_sandbox", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_commandId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_pid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_result", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_stdoutParts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_stderrParts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "_exhausted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_lastStdoutOffset", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_lastStderrOffset", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._stream = messageStream;
+        this._control = control;
+        this._sandbox = sandbox;
+        this._lastStdoutOffset = options?.stdoutOffset ?? 0;
+        this._lastStderrOffset = options?.stderrOffset ?? 0;
+        // New executions (no commandId): _ensureStarted reads "started".
+        // Reconnections (commandId set): skip since reconnect streams
+        // don't send a "started" message.
+        if (options?.commandId) {
+            this._commandId = options.commandId;
+            this._started = true;
+        }
+        else {
+            this._started = false;
+        }
+    }
+    /**
+     * Read the 'started' message to populate commandId and pid.
+     *
+     * Must be called (and awaited) before iterating for new executions.
+     */
+    async _ensureStarted() {
+        if (this._started)
+            return;
+        const firstResult = await this._stream.next();
+        if (firstResult.done) {
+            throw new LangSmithSandboxOperationError("Command stream ended before 'started' message", "command");
+        }
+        const firstMsg = firstResult.value;
+        if (firstMsg.type !== "started") {
+            throw new LangSmithSandboxOperationError(`Expected 'started' message, got '${firstMsg.type}'`, "command");
+        }
+        this._commandId = firstMsg.command_id ?? null;
+        this._pid = firstMsg.pid ?? null;
+        this._started = true;
+    }
+    /** The server-assigned command ID. Available after _ensureStarted(). */
+    get commandId() {
+        return this._commandId;
+    }
+    /** The process ID on the sandbox. Available after _ensureStarted(). */
+    get pid() {
+        return this._pid;
+    }
+    /**
+     * The final execution result. Drains the stream if not already exhausted.
+     */
+    get result() {
+        return this._getResult();
+    }
+    async _getResult() {
+        if (this._result === null) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            for await (const _ of this) {
+                // drain
+            }
+        }
+        if (this._result === null) {
+            throw new LangSmithSandboxOperationError("Command stream ended without exit message", "command");
+        }
+        return this._result;
+    }
+    /**
+     * Iterate over output chunks from the current stream (no reconnect).
+     */
+    async *_iterStream() {
+        await this._ensureStarted();
+        if (this._exhausted)
+            return;
+        for await (const msg of this._stream) {
+            const msgType = msg.type;
+            if (msgType === "stdout" || msgType === "stderr") {
+                const chunk = {
+                    stream: msgType,
+                    data: msg.data,
+                    offset: msg.offset ?? 0,
+                };
+                if (msgType === "stdout") {
+                    this._stdoutParts.push(msg.data);
+                }
+                else {
+                    this._stderrParts.push(msg.data);
+                }
+                yield chunk;
+            }
+            else if (msgType === "exit") {
+                this._result = {
+                    stdout: this._stdoutParts.join(""),
+                    stderr: this._stderrParts.join(""),
+                    exit_code: msg.exit_code ?? -1,
+                };
+                this._exhausted = true;
+                return;
+            }
+        }
+        this._exhausted = true;
+    }
+    /**
+     * Async iterate over output chunks with auto-reconnect on transient errors.
+     *
+     * Reconnect strategy:
+     * - 1001 Going Away (hot-reload): immediate reconnect, no delay
+     * - Other SandboxConnectionError:  exponential backoff (0.5s, 1s, 2s...)
+     * - After kill():                  no reconnect, error propagates
+     */
+    async *[Symbol.asyncIterator]() {
+        let reconnectAttempts = 0;
+        while (true) {
+            try {
+                for await (const chunk of this._iterStream()) {
+                    reconnectAttempts = 0; // Reset on successful data
+                    if (chunk.stream === "stdout") {
+                        this._lastStdoutOffset =
+                            chunk.offset + new TextEncoder().encode(chunk.data).length;
+                    }
+                    else {
+                        this._lastStderrOffset =
+                            chunk.offset + new TextEncoder().encode(chunk.data).length;
+                    }
+                    yield chunk;
+                }
+                return; // Stream ended normally (exit message received)
+            }
+            catch (e) {
+                const eName = e != null && typeof e === "object" ? e.name : "";
+                if (eName !== "LangSmithSandboxConnectionError" &&
+                    eName !== "LangSmithSandboxServerReloadError") {
+                    throw e;
+                }
+                if (this._control && this._control.killed) {
+                    throw e;
+                }
+                reconnectAttempts++;
+                if (reconnectAttempts > CommandHandle.MAX_AUTO_RECONNECTS) {
+                    throw new LangSmithSandboxConnectionError(`Lost connection ${reconnectAttempts} times in succession, giving up`);
+                }
+                const isHotReload = eName === "LangSmithSandboxServerReloadError";
+                if (!isHotReload) {
+                    const delay = Math.min(CommandHandle.BACKOFF_BASE * 2 ** (reconnectAttempts - 1), CommandHandle.BACKOFF_MAX);
+                    await new Promise((r) => setTimeout(r, delay * 1000));
+                }
+                if (this._commandId === null) {
+                    throw e;
+                }
+                const newHandle = await this._sandbox.reconnect(this._commandId, {
+                    stdoutOffset: this._lastStdoutOffset,
+                    stderrOffset: this._lastStderrOffset,
+                });
+                this._stream = newHandle._stream;
+                this._control = newHandle._control;
+                this._exhausted = false;
+            }
+        }
+    }
+    /**
+     * Send a kill signal to the running command (SIGKILL).
+     *
+     * The server kills the entire process group. The stream will
+     * subsequently yield an exit message with a non-zero exit code.
+     */
+    kill() {
+        if (this._control) {
+            this._control.sendKill();
+        }
+    }
+    /**
+     * Write data to the command's stdin.
+     */
+    sendInput(data) {
+        if (this._control) {
+            this._control.sendInput(data);
+        }
+    }
+    /** Last known stdout byte offset (for manual reconnection). */
+    get lastStdoutOffset() {
+        return this._lastStdoutOffset;
+    }
+    /** Last known stderr byte offset (for manual reconnection). */
+    get lastStderrOffset() {
+        return this._lastStderrOffset;
+    }
+    /**
+     * Reconnect to this command from the last known offsets.
+     *
+     * Returns a new CommandHandle that resumes output from where this one
+     * left off.
+     */
+    async reconnect() {
+        if (this._commandId === null) {
+            throw new LangSmithSandboxOperationError("Cannot reconnect: command ID not available", "reconnect");
+        }
+        return this._sandbox.reconnect(this._commandId, {
+            stdoutOffset: this._lastStdoutOffset,
+            stderrOffset: this._lastStderrOffset,
+        });
+    }
+}
+Object.defineProperty(CommandHandle, "MAX_AUTO_RECONNECTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 5
+});
+Object.defineProperty(CommandHandle, "BACKOFF_BASE", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 0.5
+}); // seconds
+Object.defineProperty(CommandHandle, "BACKOFF_MAX", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: 8.0
+}); // seconds

package/dist/experimental/sandbox/errors.cjs

@@ -7,7 +7,7 @@
  * properties for specific handling when needed.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-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.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.
  */
@@ -340,3 +340,32 @@ class LangSmithSandboxOperationError extends LangSmithSandboxError {
     }
 }
 exports.LangSmithSandboxOperationError = LangSmithSandboxOperationError;
+/**
+ * Raised when a command exceeds its timeout.
+ */
+class LangSmithCommandTimeoutError extends LangSmithSandboxOperationError {
+    constructor(message, timeout) {
+        super(message, "command", "CommandTimeout");
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "LangSmithCommandTimeoutError";
+        this.timeout = timeout;
+    }
+}
+exports.LangSmithCommandTimeoutError = LangSmithCommandTimeoutError;
+/**
+ * Raised when the sandbox server is reloading (close code 1001).
+ *
+ * Subclass of connection error that signals immediate reconnect (no backoff).
+ */
+class LangSmithSandboxServerReloadError extends LangSmithSandboxConnectionError {
+    constructor(message) {
+        super(message);
+        this.name = "LangSmithSandboxServerReloadError";
+    }
+}
+exports.LangSmithSandboxServerReloadError = LangSmithSandboxServerReloadError;

package/dist/experimental/sandbox/errors.d.ts

@@ -147,3 +147,18 @@ export declare class LangSmithSandboxOperationError extends LangSmithSandboxErro
     constructor(message: string, operation?: string, errorType?: string);
     toString(): string;
 }
+/**
+ * Raised when a command exceeds its timeout.
+ */
+export declare class LangSmithCommandTimeoutError extends LangSmithSandboxOperationError {
+    timeout?: number;
+    constructor(message: string, timeout?: number);
+}
+/**
+ * Raised when the sandbox server is reloading (close code 1001).
+ *
+ * Subclass of connection error that signals immediate reconnect (no backoff).
+ */
+export declare class LangSmithSandboxServerReloadError extends LangSmithSandboxConnectionError {
+    constructor(message: string);
+}

package/dist/experimental/sandbox/errors.js

@@ -321,3 +321,30 @@ export class LangSmithSandboxOperationError extends LangSmithSandboxError {
         return super.toString();
     }
 }
+/**
+ * Raised when a command exceeds its timeout.
+ */
+export class LangSmithCommandTimeoutError extends LangSmithSandboxOperationError {
+    constructor(message, timeout) {
+        super(message, "command", "CommandTimeout");
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "LangSmithCommandTimeoutError";
+        this.timeout = timeout;
+    }
+}
+/**
+ * Raised when the sandbox server is reloading (close code 1001).
+ *
+ * Subclass of connection error that signals immediate reconnect (no backoff).
+ */
+export class LangSmithSandboxServerReloadError extends LangSmithSandboxConnectionError {
+    constructor(message) {
+        super(message);
+        this.name = "LangSmithSandboxServerReloadError";
+    }
+}

package/dist/experimental/sandbox/index.cjs

@@ -24,7 +24,7 @@
  * @packageDocumentation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LangSmithDataplaneNotConfiguredError = exports.LangSmithSandboxOperationError = exports.LangSmithSandboxNotReadyError = 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 = exports.Sandbox = exports.SandboxClient = void 0;
+exports.LangSmithDataplaneNotConfiguredError = exports.LangSmithCommandTimeoutError = exports.LangSmithSandboxOperationError = exports.LangSmithSandboxNotReadyError = exports.LangSmithSandboxCreationError = exports.LangSmithResourceCreationError = exports.LangSmithQuotaExceededError = exports.LangSmithValidationError = exports.LangSmithResourceNameConflictError = exports.LangSmithResourceAlreadyExistsError = exports.LangSmithResourceInUseError = exports.LangSmithResourceTimeoutError = exports.LangSmithResourceNotFoundError = exports.LangSmithSandboxServerReloadError = exports.LangSmithSandboxConnectionError = exports.LangSmithSandboxAuthenticationError = exports.LangSmithSandboxAPIError = exports.LangSmithSandboxError = exports.CommandHandle = exports.Sandbox = exports.SandboxClient = void 0;
 // Emit warning on import (alpha feature)
 console.warn("langsmith/experimental/sandbox is in alpha. " +
     "This feature is experimental, and breaking changes are expected.");
@@ -33,6 +33,8 @@ var client_js_1 = require("./client.cjs");
 Object.defineProperty(exports, "SandboxClient", { enumerable: true, get: function () { return client_js_1.SandboxClient; } });
 var sandbox_js_1 = require("./sandbox.cjs");
 Object.defineProperty(exports, "Sandbox", { enumerable: true, get: function () { return sandbox_js_1.Sandbox; } });
+var command_handle_js_1 = require("./command_handle.cjs");
+Object.defineProperty(exports, "CommandHandle", { enumerable: true, get: function () { return command_handle_js_1.CommandHandle; } });
 // Errors
 var errors_js_1 = require("./errors.cjs");
 // Base and connection errors
@@ -40,6 +42,7 @@ Object.defineProperty(exports, "LangSmithSandboxError", { enumerable: true, get:
 Object.defineProperty(exports, "LangSmithSandboxAPIError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxAPIError; } });
 Object.defineProperty(exports, "LangSmithSandboxAuthenticationError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxAuthenticationError; } });
 Object.defineProperty(exports, "LangSmithSandboxConnectionError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxConnectionError; } });
+Object.defineProperty(exports, "LangSmithSandboxServerReloadError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxServerReloadError; } });
 // Resource errors (type-based with resourceType attribute)
 Object.defineProperty(exports, "LangSmithResourceNotFoundError", { enumerable: true, get: function () { return errors_js_1.LangSmithResourceNotFoundError; } });
 Object.defineProperty(exports, "LangSmithResourceTimeoutError", { enumerable: true, get: function () { return errors_js_1.LangSmithResourceTimeoutError; } });
@@ -55,4 +58,5 @@ Object.defineProperty(exports, "LangSmithResourceCreationError", { enumerable: t
 Object.defineProperty(exports, "LangSmithSandboxCreationError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxCreationError; } });
 Object.defineProperty(exports, "LangSmithSandboxNotReadyError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxNotReadyError; } });
 Object.defineProperty(exports, "LangSmithSandboxOperationError", { enumerable: true, get: function () { return errors_js_1.LangSmithSandboxOperationError; } });
+Object.defineProperty(exports, "LangSmithCommandTimeoutError", { enumerable: true, get: function () { return errors_js_1.LangSmithCommandTimeoutError; } });
 Object.defineProperty(exports, "LangSmithDataplaneNotConfiguredError", { enumerable: true, get: function () { return errors_js_1.LangSmithDataplaneNotConfiguredError; } });

package/dist/experimental/sandbox/index.d.ts

@@ -24,5 +24,6 @@
  */
 export { SandboxClient } from "./client.js";
 export { Sandbox } from "./sandbox.js";
-export type { ExecutionResult, ResourceSpec, ResourceStatus, VolumeMountSpec, Volume, SandboxTemplate, Pool, SandboxData, SandboxClientConfig, RunOptions, CreateSandboxOptions, WaitForSandboxOptions, CreateVolumeOptions, CreateTemplateOptions, UpdateTemplateOptions, CreatePoolOptions, UpdateVolumeOptions, UpdatePoolOptions, } from "./types.js";
-export { LangSmithSandboxError, LangSmithSandboxAPIError, LangSmithSandboxAuthenticationError, LangSmithSandboxConnectionError, LangSmithResourceNotFoundError, LangSmithResourceTimeoutError, LangSmithResourceInUseError, LangSmithResourceAlreadyExistsError, LangSmithResourceNameConflictError, LangSmithValidationError, LangSmithQuotaExceededError, LangSmithResourceCreationError, LangSmithSandboxCreationError, LangSmithSandboxNotReadyError, LangSmithSandboxOperationError, LangSmithDataplaneNotConfiguredError, } from "./errors.js";
+export { CommandHandle } from "./command_handle.js";
+export type { ExecutionResult, OutputChunk, WsMessage, WsRunOptions, ResourceSpec, ResourceStatus, VolumeMountSpec, Volume, SandboxTemplate, Pool, SandboxData, SandboxClientConfig, RunOptions, CreateSandboxOptions, WaitForSandboxOptions, CreateVolumeOptions, CreateTemplateOptions, UpdateTemplateOptions, CreatePoolOptions, UpdateVolumeOptions, UpdatePoolOptions, } from "./types.js";
+export { LangSmithSandboxError, LangSmithSandboxAPIError, LangSmithSandboxAuthenticationError, LangSmithSandboxConnectionError, LangSmithSandboxServerReloadError, LangSmithResourceNotFoundError, LangSmithResourceTimeoutError, LangSmithResourceInUseError, LangSmithResourceAlreadyExistsError, LangSmithResourceNameConflictError, LangSmithValidationError, LangSmithQuotaExceededError, LangSmithResourceCreationError, LangSmithSandboxCreationError, LangSmithSandboxNotReadyError, LangSmithSandboxOperationError, LangSmithCommandTimeoutError, LangSmithDataplaneNotConfiguredError, } from "./errors.js";

package/dist/experimental/sandbox/index.js

@@ -28,10 +28,11 @@ console.warn("langsmith/experimental/sandbox is in alpha. " +
 // Main classes
 export { SandboxClient } from "./client.js";
 export { Sandbox } from "./sandbox.js";
+export { CommandHandle } from "./command_handle.js";
 // Errors
 export { 
 // Base and connection errors
-LangSmithSandboxError, LangSmithSandboxAPIError, LangSmithSandboxAuthenticationError, LangSmithSandboxConnectionError, 
+LangSmithSandboxError, LangSmithSandboxAPIError, LangSmithSandboxAuthenticationError, LangSmithSandboxConnectionError, LangSmithSandboxServerReloadError, 
 // Resource errors (type-based with resourceType attribute)
 LangSmithResourceNotFoundError, LangSmithResourceTimeoutError, LangSmithResourceInUseError, LangSmithResourceAlreadyExistsError, LangSmithResourceNameConflictError, 
 // Validation and quota errors
@@ -39,4 +40,4 @@ LangSmithValidationError, LangSmithQuotaExceededError,
 // Resource creation errors
 LangSmithResourceCreationError, 
 // Sandbox-specific errors
-LangSmithSandboxCreationError, LangSmithSandboxNotReadyError, LangSmithSandboxOperationError, LangSmithDataplaneNotConfiguredError, } from "./errors.js";
+LangSmithSandboxCreationError, LangSmithSandboxNotReadyError, LangSmithSandboxOperationError, LangSmithCommandTimeoutError, LangSmithDataplaneNotConfiguredError, } from "./errors.js";