langsmith 0.8.8 → 0.8.9

package/dist/sandbox/command_handle.cjs

@@ -8,6 +8,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandle = void 0;
 const errors_js_1 = require("./errors.cjs");
+/**
+ * Whether a 'started' frame proves *this* command was reattached to.
+ *
+ * A command and its WebSocket are separate things: the command keeps running on
+ * the server and the socket is only this client's attachment to it. The server
+ * acknowledges every successful reattachment with 'started', which for a command
+ * that produces no output is the only evidence it landed. One naming a different
+ * command is not evidence, and must not clear the reconnect budget.
+ */
+function acknowledgesReconnect(msg, commandId) {
+    const acked = msg.command_id;
+    if (acked === commandId)
+        return true;
+    console.warn(`Ignoring reconnect acknowledgement for command ${String(acked)} while attached to ${String(commandId)}`);
+    return false;
+}
 /**
  * Async handle to a running command with streaming output and auto-reconnect.
  *
@@ -107,6 +123,12 @@ class CommandHandle {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "_onStdout", {
             enumerable: true,
             configurable: true,
@@ -192,7 +214,12 @@ class CommandHandle {
             return;
         for await (const msg of this._stream) {
             const msgType = msg.type;
-            if (msgType === "stdout" || msgType === "stderr") {
+            if (msgType === "started") {
+                if (acknowledgesReconnect(msg, this._commandId)) {
+                    this._reconnectAttempts = 0;
+                }
+            }
+            else if (msgType === "stdout" || msgType === "stderr") {
                 const chunk = {
                     stream: msgType,
                     data: msg.data,
@@ -227,11 +254,11 @@ class CommandHandle {
      * - After kill():                  no reconnect, error propagates
      */
     async *[Symbol.asyncIterator]() {
-        let reconnectAttempts = 0;
+        this._reconnectAttempts = 0;
         while (true) {
             try {
                 for await (const chunk of this._iterStream()) {
-                    reconnectAttempts = 0; // Reset on successful data
+                    this._reconnectAttempts = 0; // Reset on successful data
                     if (chunk.stream === "stdout") {
                         this._lastStdoutOffset =
                             chunk.offset + new TextEncoder().encode(chunk.data).length;
@@ -255,13 +282,13 @@ class CommandHandle {
                 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`);
+                this._reconnectAttempts++;
+                if (this._reconnectAttempts > CommandHandle.MAX_AUTO_RECONNECTS) {
+                    throw new errors_js_1.LangSmithSandboxConnectionError(`Failed to reattach to the command ${this._reconnectAttempts} times in succession, giving up`);
                 }
                 const isHotReload = e instanceof errors_js_1.LangSmithSandboxServerReloadError;
                 if (!isHotReload) {
-                    const delay = Math.min(CommandHandle.BACKOFF_BASE * 2 ** (reconnectAttempts - 1), CommandHandle.BACKOFF_MAX);
+                    const delay = Math.min(CommandHandle.BACKOFF_BASE * 2 ** (this._reconnectAttempts - 1), CommandHandle.BACKOFF_MAX);
                     await new Promise((r) => setTimeout(r, delay * 1000));
                 }
                 if (this._commandId === null) {

package/dist/sandbox/command_handle.d.ts

@@ -45,6 +45,7 @@ export declare class CommandHandle {
     private _lastStdoutOffset;
     private _lastStderrOffset;
     private _started;
+    private _reconnectAttempts;
     private _onStdout?;
     private _onStderr?;
     /**

package/dist/sandbox/command_handle.js

@@ -5,6 +5,22 @@
  * Port of Python's AsyncCommandHandle to TypeScript.
  */
 import { LangSmithSandboxConnectionError, LangSmithSandboxServerReloadError, LangSmithSandboxOperationError, LangSmithStreamEndedBeforeStartedError, } from "./errors.js";
+/**
+ * Whether a 'started' frame proves *this* command was reattached to.
+ *
+ * A command and its WebSocket are separate things: the command keeps running on
+ * the server and the socket is only this client's attachment to it. The server
+ * acknowledges every successful reattachment with 'started', which for a command
+ * that produces no output is the only evidence it landed. One naming a different
+ * command is not evidence, and must not clear the reconnect budget.
+ */
+function acknowledgesReconnect(msg, commandId) {
+    const acked = msg.command_id;
+    if (acked === commandId)
+        return true;
+    console.warn(`Ignoring reconnect acknowledgement for command ${String(acked)} while attached to ${String(commandId)}`);
+    return false;
+}
 /**
  * Async handle to a running command with streaming output and auto-reconnect.
  *
@@ -104,6 +120,12 @@ export class CommandHandle {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "_reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
         Object.defineProperty(this, "_onStdout", {
             enumerable: true,
             configurable: true,
@@ -189,7 +211,12 @@ export class CommandHandle {
             return;
         for await (const msg of this._stream) {
             const msgType = msg.type;
-            if (msgType === "stdout" || msgType === "stderr") {
+            if (msgType === "started") {
+                if (acknowledgesReconnect(msg, this._commandId)) {
+                    this._reconnectAttempts = 0;
+                }
+            }
+            else if (msgType === "stdout" || msgType === "stderr") {
                 const chunk = {
                     stream: msgType,
                     data: msg.data,
@@ -224,11 +251,11 @@ export class CommandHandle {
      * - After kill():                  no reconnect, error propagates
      */
     async *[Symbol.asyncIterator]() {
-        let reconnectAttempts = 0;
+        this._reconnectAttempts = 0;
         while (true) {
             try {
                 for await (const chunk of this._iterStream()) {
-                    reconnectAttempts = 0; // Reset on successful data
+                    this._reconnectAttempts = 0; // Reset on successful data
                     if (chunk.stream === "stdout") {
                         this._lastStdoutOffset =
                             chunk.offset + new TextEncoder().encode(chunk.data).length;
@@ -252,13 +279,13 @@ export class CommandHandle {
                 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`);
+                this._reconnectAttempts++;
+                if (this._reconnectAttempts > CommandHandle.MAX_AUTO_RECONNECTS) {
+                    throw new LangSmithSandboxConnectionError(`Failed to reattach to the command ${this._reconnectAttempts} times in succession, giving up`);
                 }
                 const isHotReload = e instanceof LangSmithSandboxServerReloadError;
                 if (!isHotReload) {
-                    const delay = Math.min(CommandHandle.BACKOFF_BASE * 2 ** (reconnectAttempts - 1), CommandHandle.BACKOFF_MAX);
+                    const delay = Math.min(CommandHandle.BACKOFF_BASE * 2 ** (this._reconnectAttempts - 1), CommandHandle.BACKOFF_MAX);
                     await new Promise((r) => setTimeout(r, delay * 1000));
                 }
                 if (this._commandId === null) {

package/dist/sandbox/ws_execute.cjs

@@ -382,8 +382,10 @@ async function runWsStream(dataplaneUrl, apiKey, command, options = {}) {
  * Reconnect to an existing command over WebSocket.
  *
  * Returns a tuple of [async_message_iterator, control], same as runWsStream.
- * The iterator yields stdout, stderr, exit, and error messages.
- * No 'started' message is sent on reconnection.
+ * The iterator yields the server's 'started' acknowledgement, then stdout,
+ * stderr, exit, and error messages. That acknowledgement is the only evidence a
+ * reattachment landed for a command producing no output, so it is forwarded
+ * rather than dropped.
  */
 async function reconnectWsStream(dataplaneUrl, apiKey, commandId, options = {}) {
     const { stdoutOffset = 0, stderrOffset = 0, headers: extraHeaders } = options;
@@ -405,7 +407,9 @@ async function reconnectWsStream(dataplaneUrl, apiKey, commandId, options = {})
             // Read messages until exit or error
             for await (const msg of readWsMessages(ws)) {
                 const msgType = msg.type;
-                if (msgType === "stdout" || msgType === "stderr") {
+                if (msgType === "started" ||
+                    msgType === "stdout" ||
+                    msgType === "stderr") {
                     yield msg;
                 }
                 else if (msgType === "exit") {

package/dist/sandbox/ws_execute.d.ts

@@ -70,8 +70,10 @@ export declare function runWsStream(dataplaneUrl: string, apiKey: string | undef
  * Reconnect to an existing command over WebSocket.
  *
  * Returns a tuple of [async_message_iterator, control], same as runWsStream.
- * The iterator yields stdout, stderr, exit, and error messages.
- * No 'started' message is sent on reconnection.
+ * The iterator yields the server's 'started' acknowledgement, then stdout,
+ * stderr, exit, and error messages. That acknowledgement is the only evidence a
+ * reattachment landed for a command producing no output, so it is forwarded
+ * rather than dropped.
  */
 export declare function reconnectWsStream(dataplaneUrl: string, apiKey: string | undefined, commandId: string, options?: {
     stdoutOffset?: number;

package/dist/sandbox/ws_execute.js

@@ -369,8 +369,10 @@ export async function runWsStream(dataplaneUrl, apiKey, command, options = {}) {
  * Reconnect to an existing command over WebSocket.
  *
  * Returns a tuple of [async_message_iterator, control], same as runWsStream.
- * The iterator yields stdout, stderr, exit, and error messages.
- * No 'started' message is sent on reconnection.
+ * The iterator yields the server's 'started' acknowledgement, then stdout,
+ * stderr, exit, and error messages. That acknowledgement is the only evidence a
+ * reattachment landed for a command producing no output, so it is forwarded
+ * rather than dropped.
  */
 export async function reconnectWsStream(dataplaneUrl, apiKey, commandId, options = {}) {
     const { stdoutOffset = 0, stderrOffset = 0, headers: extraHeaders } = options;
@@ -392,7 +394,9 @@ export async function reconnectWsStream(dataplaneUrl, apiKey, commandId, options
             // Read messages until exit or error
             for await (const msg of readWsMessages(ws)) {
                 const msgType = msg.type;
-                if (msgType === "stdout" || msgType === "stderr") {
+                if (msgType === "started" ||
+                    msgType === "stdout" ||
+                    msgType === "stderr") {
                     yield msg;
                 }
                 else if (msgType === "exit") {

package/dist/utils/v2_migration.cjs

@@ -1,7 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBackend = void 0;
+exports.getQueryBackend = getQueryBackend;
 exports.v2RunToRun = v2RunToRun;
 exports.loadTracesV2 = loadTracesV2;
+exports.QueryBackend = {
+    CLICKHOUSE_ONLY: "clickhouse_only",
+    SMITHDB_ONLY: "smithdb_only",
+    DUAL: "dual",
+};
+/** Which backend(s) `/info`'s `instance_flags` indicate for run/trace queries. */
+function getQueryBackend(instanceFlags) {
+    const flags = instanceFlags ?? {};
+    const chEnabled = Boolean(flags.ch_query_enabled ?? true);
+    const sdbEnabled = Boolean(flags.sdb_query_enabled ?? false);
+    if (!chEnabled && sdbEnabled)
+        return exports.QueryBackend.SMITHDB_ONLY;
+    if (chEnabled && sdbEnabled)
+        return exports.QueryBackend.DUAL;
+    return exports.QueryBackend.CLICKHOUSE_ONLY;
+}
 // Omitting selects from `/v2/runs/query` returns only the run ID.
 const V2_RUN_SELECTS = [
     "ID",

package/dist/utils/v2_migration.d.ts

@@ -1,6 +1,14 @@
 import type { Run as V2Run } from "../_openapi_client/resources/runs/runs.js";
 import type { Client } from "../client.js";
 import type { Run, TracerSession } from "../schemas.js";
+export declare const QueryBackend: {
+    readonly CLICKHOUSE_ONLY: "clickhouse_only";
+    readonly SMITHDB_ONLY: "smithdb_only";
+    readonly DUAL: "dual";
+};
+export type QueryBackend = (typeof QueryBackend)[keyof typeof QueryBackend];
+/** Which backend(s) `/info`'s `instance_flags` indicate for run/trace queries. */
+export declare function getQueryBackend(instanceFlags?: Record<string, unknown> | null): QueryBackend;
 export declare function v2RunToRun(run: V2Run): Run;
 export declare function loadTracesV2(client: Client, project: TracerSession, options: {
     isRoot?: boolean;

package/dist/utils/v2_migration.js

@@ -1,3 +1,19 @@
+export const QueryBackend = {
+    CLICKHOUSE_ONLY: "clickhouse_only",
+    SMITHDB_ONLY: "smithdb_only",
+    DUAL: "dual",
+};
+/** Which backend(s) `/info`'s `instance_flags` indicate for run/trace queries. */
+export function getQueryBackend(instanceFlags) {
+    const flags = instanceFlags ?? {};
+    const chEnabled = Boolean(flags.ch_query_enabled ?? true);
+    const sdbEnabled = Boolean(flags.sdb_query_enabled ?? false);
+    if (!chEnabled && sdbEnabled)
+        return QueryBackend.SMITHDB_ONLY;
+    if (chEnabled && sdbEnabled)
+        return QueryBackend.DUAL;
+    return QueryBackend.CLICKHOUSE_ONLY;
+}
 // Omitting selects from `/v2/runs/query` returns only the run ID.
 const V2_RUN_SELECTS = [
     "ID",

package/dist/utils/warn.cjs

@@ -1,10 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports._resetWarnedMessages = _resetWarnedMessages;
 exports.warnOnce = warnOnce;
 const warnedMessages = {};
-function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
+/**
+ * Clear the warn-once record so a later call warns again.
+ *
+ * Test-only. `warnedMessages` is module-global and never otherwise reset, so
+ * without this a test asserting "warning X was (not) emitted" depends on whether
+ * an earlier test in the same file already consumed X.
+ *
+ * @internal
+ */
+function _resetWarnedMessages() {
+    for (const key of Object.keys(warnedMessages)) {
+        delete warnedMessages[key];
+    }
+}
+function warnOnce(message, options) {
+    const key = options?.code ?? message;
+    if (!warnedMessages[key]) {
+        warnedMessages[key] = true;
+        if (options?.type &&
+            typeof process !== "undefined" &&
+            typeof process.emitWarning === "function") {
+            process.emitWarning(message, { type: options.type, code: options.code });
+        }
+        else if (options?.type && options?.code) {
+            console.warn(`${options.type} [${options.code}]: ${message}`);
+        }
+        else {
+            console.warn(message);
+        }
     }
 }

package/dist/utils/warn.d.ts

@@ -1 +1,4 @@
-export declare function warnOnce(message: string): void;
+export declare function warnOnce(message: string, options?: {
+    type?: string;
+    code?: string;
+}): void;

package/dist/utils/warn.js

@@ -1,7 +1,32 @@
 const warnedMessages = {};
-export function warnOnce(message) {
-    if (!warnedMessages[message]) {
-        console.warn(message);
-        warnedMessages[message] = true;
+/**
+ * Clear the warn-once record so a later call warns again.
+ *
+ * Test-only. `warnedMessages` is module-global and never otherwise reset, so
+ * without this a test asserting "warning X was (not) emitted" depends on whether
+ * an earlier test in the same file already consumed X.
+ *
+ * @internal
+ */
+export function _resetWarnedMessages() {
+    for (const key of Object.keys(warnedMessages)) {
+        delete warnedMessages[key];
+    }
+}
+export function warnOnce(message, options) {
+    const key = options?.code ?? message;
+    if (!warnedMessages[key]) {
+        warnedMessages[key] = true;
+        if (options?.type &&
+            typeof process !== "undefined" &&
+            typeof process.emitWarning === "function") {
+            process.emitWarning(message, { type: options.type, code: options.code });
+        }
+        else if (options?.type && options?.code) {
+            console.warn(`${options.type} [${options.code}]: ${message}`);
+        }
+        else {
+            console.warn(message);
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langsmith",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "Client library to connect to the LangSmith Observability and Evaluation Platform.",
   "packageManager": "pnpm@10.33.0",
   "files": [