langsmith 0.5.9 → 0.5.10

package/dist/client.cjs

@@ -50,6 +50,26 @@ 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");
+/**
+ * Catches timestamps without a timezone suffix.
+ */
+function _ensureUTCTimestamp(ts) {
+    if (typeof ts === "string" &&
+        ts.length > 0 &&
+        !ts.includes("Z") &&
+        !ts.includes("+") &&
+        !ts.includes("-", 10)) {
+        return ts + "Z";
+    }
+    return ts;
+}
+function _normalizeRunTimestamps(run) {
+    return {
+        ...run,
+        start_time: _ensureUTCTimestamp(run.start_time),
+        end_time: _ensureUTCTimestamp(run.end_time),
+    };
+}
 function mergeRuntimeEnvIntoRun(run, cachedEnvVars, omitTracedRuntimeInfo) {
     if (omitTracedRuntimeInfo) {
         return run;
@@ -1542,7 +1562,7 @@ class Client {
     }
     async readRun(runId, { loadChildRuns } = { loadChildRuns: false }) {
         (0, _uuid_js_1.assertUuid)(runId);
-        let run = await this._get(`/runs/${runId}`);
+        let run = _normalizeRunTimestamps(await this._get(`/runs/${runId}`));
         if (loadChildRuns) {
             run = await this._loadChildRuns(run);
         }
@@ -1761,20 +1781,21 @@ class Client {
         }
         let runsYielded = 0;
         for await (const runs of this._getCursorPaginatedList("/runs/query", body)) {
+            const normalized = runs.map(_normalizeRunTimestamps);
             if (limit) {
                 if (runsYielded >= limit) {
                     break;
                 }
-                if (runs.length + runsYielded > limit) {
-                    const newRuns = runs.slice(0, limit - runsYielded);
+                if (normalized.length + runsYielded > limit) {
+                    const newRuns = normalized.slice(0, limit - runsYielded);
                     yield* newRuns;
                     break;
                 }
-                runsYielded += runs.length;
-                yield* runs;
+                runsYielded += normalized.length;
+                yield* normalized;
             }
             else {
-                yield* runs;
+                yield* normalized;
             }
         }
     }
@@ -1891,7 +1912,8 @@ class Client {
         }
         const threadsMap = new Map();
         for await (const runs of this._getCursorPaginatedList("/runs/query", bodyQuery)) {
-            for (const run of runs) {
+            for (const raw of runs) {
+                const run = _normalizeRunTimestamps(raw);
                 const tid = run.thread_id;
                 if (tid) {
                     const list = threadsMap.get(tid) ?? [];
@@ -2064,8 +2086,8 @@ class Client {
             await (0, error_js_1.raiseForStatus)(res, "list shared runs");
             return res;
         });
-        const runs = await response.json();
-        return runs;
+        const runs = (await response.json());
+        return runs.map(_normalizeRunTimestamps);
     }
     async readDatasetSharedSchema(datasetId, datasetName) {
         if (!datasetId && !datasetName) {
@@ -3714,7 +3736,8 @@ class Client {
             await (0, error_js_1.raiseForStatus)(res, "get run from annotation queue");
             return res;
         });
-        return response.json();
+        const run = await response.json();
+        return _normalizeRunTimestamps(run);
     }
     /**
      * Delete a run from an an annotation queue.

package/dist/client.js

@@ -13,6 +13,26 @@ 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 } from "./utils/fast-safe-stringify/index.js";
+/**
+ * Catches timestamps without a timezone suffix.
+ */
+function _ensureUTCTimestamp(ts) {
+    if (typeof ts === "string" &&
+        ts.length > 0 &&
+        !ts.includes("Z") &&
+        !ts.includes("+") &&
+        !ts.includes("-", 10)) {
+        return ts + "Z";
+    }
+    return ts;
+}
+function _normalizeRunTimestamps(run) {
+    return {
+        ...run,
+        start_time: _ensureUTCTimestamp(run.start_time),
+        end_time: _ensureUTCTimestamp(run.end_time),
+    };
+}
 export function mergeRuntimeEnvIntoRun(run, cachedEnvVars, omitTracedRuntimeInfo) {
     if (omitTracedRuntimeInfo) {
         return run;
@@ -1504,7 +1524,7 @@ export class Client {
     }
     async readRun(runId, { loadChildRuns } = { loadChildRuns: false }) {
         assertUuid(runId);
-        let run = await this._get(`/runs/${runId}`);
+        let run = _normalizeRunTimestamps(await this._get(`/runs/${runId}`));
         if (loadChildRuns) {
             run = await this._loadChildRuns(run);
         }
@@ -1723,20 +1743,21 @@ export class Client {
         }
         let runsYielded = 0;
         for await (const runs of this._getCursorPaginatedList("/runs/query", body)) {
+            const normalized = runs.map(_normalizeRunTimestamps);
             if (limit) {
                 if (runsYielded >= limit) {
                     break;
                 }
-                if (runs.length + runsYielded > limit) {
-                    const newRuns = runs.slice(0, limit - runsYielded);
+                if (normalized.length + runsYielded > limit) {
+                    const newRuns = normalized.slice(0, limit - runsYielded);
                     yield* newRuns;
                     break;
                 }
-                runsYielded += runs.length;
-                yield* runs;
+                runsYielded += normalized.length;
+                yield* normalized;
             }
             else {
-                yield* runs;
+                yield* normalized;
             }
         }
     }
@@ -1853,7 +1874,8 @@ export class Client {
         }
         const threadsMap = new Map();
         for await (const runs of this._getCursorPaginatedList("/runs/query", bodyQuery)) {
-            for (const run of runs) {
+            for (const raw of runs) {
+                const run = _normalizeRunTimestamps(raw);
                 const tid = run.thread_id;
                 if (tid) {
                     const list = threadsMap.get(tid) ?? [];
@@ -2026,8 +2048,8 @@ export class Client {
             await raiseForStatus(res, "list shared runs");
             return res;
         });
-        const runs = await response.json();
-        return runs;
+        const runs = (await response.json());
+        return runs.map(_normalizeRunTimestamps);
     }
     async readDatasetSharedSchema(datasetId, datasetName) {
         if (!datasetId && !datasetName) {
@@ -3676,7 +3698,8 @@ export class Client {
             await raiseForStatus(res, "get run from annotation queue");
             return res;
         });
-        return response.json();
+        const run = await response.json();
+        return _normalizeRunTimestamps(run);
     }
     /**
      * Delete a run from an an annotation queue.

package/dist/experimental/sandbox/client.cjs

@@ -106,6 +106,13 @@ class SandboxClient {
             headers,
         }));
     }
+    /**
+     * Get the API key for WebSocket authentication.
+     * @internal
+     */
+    getApiKey() {
+        return this._apiKey;
+    }
     // =========================================================================
     // Volume Operations
     // =========================================================================

package/dist/experimental/sandbox/client.js

@@ -103,6 +103,13 @@ export class SandboxClient {
             headers,
         }));
     }
+    /**
+     * Get the API key for WebSocket authentication.
+     * @internal
+     */
+    getApiKey() {
+        return this._apiKey;
+    }
     // =========================================================================
     // Volume Operations
     // =========================================================================

package/dist/experimental/sandbox/command_handle.cjs

@@ -0,0 +1,325 @@
+"use strict";
+/**
+ * CommandHandle - async handle to a running command with streaming output
+ * and auto-reconnect.
+ *
+ * Port of Python's AsyncCommandHandle to TypeScript.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandHandle = void 0;
+const errors_js_1 = require("./errors.cjs");
+/**
+ * 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}`);
+ * ```
+ */
+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 errors_js_1.LangSmithSandboxOperationError("Command stream ended before 'started' message", "command");
+        }
+        const firstMsg = firstResult.value;
+        if (firstMsg.type !== "started") {
+            throw new errors_js_1.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 errors_js_1.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 errors_js_1.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 errors_js_1.LangSmithSandboxOperationError("Cannot reconnect: command ID not available", "reconnect");
+        }
+        return this._sandbox.reconnect(this._commandId, {
+            stdoutOffset: this._lastStdoutOffset,
+            stderrOffset: this._lastStderrOffset,
+        });
+    }
+}
+exports.CommandHandle = CommandHandle;
+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/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>;
+}