@ai-sdk/harness 1.0.116 → 1.0.118

package/dist/utils/index.d.ts

@@ -22,13 +22,19 @@ type SandboxChannelDebugEvent = {
     cause: unknown;
 };
 interface SandboxChannelReconnectOptions {
-    /** Give up reconnecting after this many milliseconds. Default 30_000. */
+    /**
+     * Give up reconnecting after this many milliseconds, including connection
+     * establishment and backoff delays. Default 30_000.
+     */
     readonly maxElapsedMs?: number;
     /** First backoff delay. Default 50. */
     readonly initialDelayMs?: number;
     /** Backoff ceiling. Default 2_000. */
     readonly maxDelayMs?: number;
 }
+interface SandboxChannelConnectOptions {
+    readonly abortSignal: AbortSignal;
+}
 interface SandboxChannelOptions<TOut> {
     /**
      * Open a fresh WebSocket to the bridge and resolve once it is ready to carry
@@ -37,7 +43,7 @@ interface SandboxChannelOptions<TOut> {
      * every transient reconnect. Must reject if the connection cannot be
      * established.
      */
-    connect: () => Promise<WebSocket>;
+    connect: (options: SandboxChannelConnectOptions) => Promise<WebSocket>;
     /** Schema validating inbound (bridge → host) frames. */
     outboundSchema: FlexibleSchema<TOut>;
     reconnect?: SandboxChannelReconnectOptions;
@@ -123,6 +129,8 @@ declare class SandboxChannel<TOut extends {
     private _lastSeenEventId;
     private readonly pendingSends;
     private dispatchChain;
+    private activeConnectAbortController;
+    private reconnectAbortController;
     constructor(options: SandboxChannelOptions<TOut>);
     /**
      * Highest bridge event `seq` this channel has observed. Persist it (e.g. via
@@ -174,6 +182,9 @@ declare class SandboxChannel<TOut extends {
     isClosed(): boolean;
     private wire;
     private reconnectLoop;
+    private connect;
+    private abortActiveConnect;
+    private failReconnect;
     private rawSend;
     private flushPending;
     private enqueue;
@@ -700,4 +711,9 @@ declare function resolveSandboxDefaultWorkingDirectory({ sandboxSession, abortSi
 
 declare function getRestrictedSandboxSession(sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession): Experimental_SandboxSession;
 
-export { type BridgeReadyErrorContext, type BridgeReadySource, type DiskLogRecoveryMode, type Experimental_BridgeUserMessageRequest, type Experimental_BridgeUserMessageResponse, type Experimental_BridgeUserMessageSubmitter, type OAuthCredential, type RefreshOAuthAccessTokenResult, SandboxChannel, type SandboxChannelDebugEvent, type SandboxChannelOptions, type SandboxChannelReconnectOptions, type SkillFilePathMode, type WaitForBridgeReadyOptions, type WaitForBridgeReadyResult, type WriteInstructionsOptions, type WriteInstructionsResult, type WriteSkillsOptions, type WriteSkillsResult, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, createSandboxCredentialEnvironment, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, formatBridgeError, forwardBridgeProcessStream, generateSandboxCredentialPlaceholder, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isSandboxCredentialPlaceholder, isWindows, logBridgeError, markBridgeStarting, maskSandboxCredentials, parseJwtPayload, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveSandboxDefaultWorkingDirectory, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeInstructions, writeSkills };
+declare function sleep({ ms, abortSignal, }: {
+    ms: number;
+    abortSignal?: AbortSignal;
+}): Promise<void>;
+
+export { type BridgeReadyErrorContext, type BridgeReadySource, type DiskLogRecoveryMode, type Experimental_BridgeUserMessageRequest, type Experimental_BridgeUserMessageResponse, type Experimental_BridgeUserMessageSubmitter, type OAuthCredential, type RefreshOAuthAccessTokenResult, SandboxChannel, type SandboxChannelConnectOptions, type SandboxChannelDebugEvent, type SandboxChannelOptions, type SandboxChannelReconnectOptions, type SkillFilePathMode, type WaitForBridgeReadyOptions, type WaitForBridgeReadyResult, type WriteInstructionsOptions, type WriteInstructionsResult, type WriteSkillsOptions, type WriteSkillsResult, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, createSandboxCredentialEnvironment, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, formatBridgeError, forwardBridgeProcessStream, generateSandboxCredentialPlaceholder, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isSandboxCredentialPlaceholder, isWindows, logBridgeError, markBridgeStarting, maskSandboxCredentials, parseJwtPayload, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveSandboxDefaultWorkingDirectory, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeInstructions, writeSkills };

package/dist/utils/index.js

@@ -3,14 +3,95 @@ import {
   safeParseJSON,
   safeValidateTypes
 } from "@ai-sdk/provider-utils";
+
+// src/utils/sleep.ts
+function sleep({
+  ms,
+  abortSignal
+}) {
+  return new Promise((resolve) => {
+    var _a;
+    if (abortSignal == null ? void 0 : abortSignal.aborted) {
+      resolve();
+      return;
+    }
+    let settled = false;
+    let onAbort = () => {
+    };
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      abortSignal == null ? void 0 : abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    const timer = setTimeout(finish, ms);
+    (_a = timer.unref) == null ? void 0 : _a.call(timer);
+    onAbort = () => {
+      clearTimeout(timer);
+      finish();
+    };
+    abortSignal == null ? void 0 : abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/utils/sandbox-channel.ts
 var sandboxChannelEventCheckpointSymbol = /* @__PURE__ */ Symbol.for(
   "vercel.ai.harness.sandboxChannelEventCheckpoint"
 );
-var sleep = (ms) => new Promise((resolve) => {
+function getAbortReason({
+  abortSignal
+}) {
   var _a;
-  const t = setTimeout(resolve, ms);
-  (_a = t.unref) == null ? void 0 : _a.call(t);
-});
+  return (_a = abortSignal.reason) != null ? _a : new Error("SandboxChannel connection aborted");
+}
+function closeWebSocket({ ws }) {
+  try {
+    const terminable = ws;
+    if (terminable.terminate != null) {
+      terminable.terminate();
+    } else {
+      ws.close();
+    }
+  } catch (e) {
+    try {
+      ws.close();
+    } catch (e2) {
+    }
+  }
+}
+async function awaitWebSocketConnection({
+  connection,
+  abortSignal
+}) {
+  if (abortSignal.aborted) {
+    void connection.then((ws) => closeWebSocket({ ws })).catch(() => {
+    });
+    throw getAbortReason({ abortSignal });
+  }
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(getAbortReason({ abortSignal }));
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    const ws = await Promise.race([connection, aborted]);
+    if (abortSignal.aborted) {
+      closeWebSocket({ ws });
+      throw getAbortReason({ abortSignal });
+    }
+    return ws;
+  } catch (error) {
+    if (abortSignal.aborted) {
+      void connection.then((ws) => closeWebSocket({ ws })).catch(() => {
+      });
+    }
+    throw error;
+  } finally {
+    if (onAbort != null) {
+      abortSignal.removeEventListener("abort", onAbort);
+    }
+  }
+}
 var SandboxChannel = class {
   constructor(options) {
     this.listeners = /* @__PURE__ */ new Map();
@@ -66,17 +147,27 @@ var SandboxChannel = class {
     if (this.terminal) {
       throw new Error("SandboxChannel: cannot open a closed channel.");
     }
-    const ws = await this.connectThunk();
-    this.wire(ws);
-    this.ws = ws;
-    this.connected = true;
-    if (opts == null ? void 0 : opts.resume) {
-      this.rawSend(
-        JSON.stringify({
-          type: "resume",
-          lastSeenEventId: this._lastSeenEventId
-        })
-      );
+    const abortController = new AbortController();
+    this.activeConnectAbortController = abortController;
+    try {
+      const ws = await this.connect({
+        abortSignal: abortController.signal
+      });
+      this.wire(ws);
+      this.ws = ws;
+      this.connected = true;
+      if (opts == null ? void 0 : opts.resume) {
+        this.rawSend(
+          JSON.stringify({
+            type: "resume",
+            lastSeenEventId: this._lastSeenEventId
+          })
+        );
+      }
+    } finally {
+      if (this.activeConnectAbortController === abortController) {
+        this.activeConnectAbortController = void 0;
+      }
     }
   }
   on(type, listener) {
@@ -122,11 +213,13 @@ var SandboxChannel = class {
    */
   beginClose() {
     this.closing = true;
+    this.abortActiveConnect();
   }
   close() {
     var _a;
     if (this.terminal) return;
     this.closing = true;
+    this.abortActiveConnect();
     try {
       (_a = this.ws) == null ? void 0 : _a.close();
     } catch (e) {
@@ -157,6 +250,7 @@ var SandboxChannel = class {
       }
       this.suspended = true;
       this.closing = true;
+      this.abortActiveConnect();
       this.onClose(
         () => resolve(pinnedSuspensionCursor != null ? pinnedSuspensionCursor : this._lastSeenEventId)
       );
@@ -204,58 +298,129 @@ var SandboxChannel = class {
   async reconnectLoop() {
     var _a, _b, _c;
     if (this.terminal || this.closing) return;
-    const start = Date.now();
+    const deadline = Date.now() + this.maxElapsedMs;
     let attempt = 0;
     let delay = this.initialDelayMs;
-    while (!this.terminal && !this.closing) {
-      attempt++;
-      (_a = this.onDebug) == null ? void 0 : _a.call(this, {
-        event: "reconnect-attempt",
-        attempt,
-        lastSeenEventId: this._lastSeenEventId
-      });
-      try {
-        const ws = await this.connectThunk();
-        if (this.terminal || this.closing) {
-          try {
-            ws.close();
-          } catch (e) {
-          }
+    const reconnectAbortController = new AbortController();
+    this.reconnectAbortController = reconnectAbortController;
+    try {
+      while (!this.terminal && !this.closing) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+          this.failReconnect({
+            attempts: attempt,
+            cause: new Error("Reconnect deadline expired")
+          });
           return;
         }
-        this.wire(ws);
-        this.ws = ws;
-        this.connected = true;
-        this.rawSend(
-          JSON.stringify({
-            type: "resume",
-            lastSeenEventId: this._lastSeenEventId
-          })
-        );
-        this.flushPending();
-        for (const handler of this.onReconnectHandlers) handler();
-        (_b = this.onDebug) == null ? void 0 : _b.call(this, {
-          event: "reconnected",
+        attempt++;
+        (_a = this.onDebug) == null ? void 0 : _a.call(this, {
+          event: "reconnect-attempt",
           attempt,
           lastSeenEventId: this._lastSeenEventId
         });
-        return;
-      } catch (cause) {
-        if (Date.now() - start >= this.maxElapsedMs) {
-          this.finalizeClose(1006, "reconnect failed");
+        const abortController = new AbortController();
+        this.activeConnectAbortController = abortController;
+        const abortConnect = () => abortController.abort(reconnectAbortController.signal.reason);
+        reconnectAbortController.signal.addEventListener(
+          "abort",
+          abortConnect,
+          {
+            once: true
+          }
+        );
+        const timeout = setTimeout(() => {
+          abortController.abort(new Error("Reconnect deadline expired"));
+        }, remaining);
+        (_b = timeout.unref) == null ? void 0 : _b.call(timeout);
+        try {
+          const ws = await this.connect({
+            abortSignal: abortController.signal
+          });
+          if (this.terminal || this.closing) {
+            closeWebSocket({ ws });
+            return;
+          }
+          this.wire(ws);
+          this.ws = ws;
+          this.connected = true;
+          this.rawSend(
+            JSON.stringify({
+              type: "resume",
+              lastSeenEventId: this._lastSeenEventId
+            })
+          );
+          this.flushPending();
+          for (const handler of this.onReconnectHandlers) handler();
           (_c = this.onDebug) == null ? void 0 : _c.call(this, {
-            event: "reconnect-failed",
-            attempts: attempt,
-            lastSeenEventId: this._lastSeenEventId,
-            cause
+            event: "reconnected",
+            attempt,
+            lastSeenEventId: this._lastSeenEventId
           });
           return;
+        } catch (cause) {
+          if (this.terminal || this.closing || reconnectAbortController.signal.aborted) {
+            return;
+          }
+          const remainingAfterFailure = deadline - Date.now();
+          if (remainingAfterFailure <= 0) {
+            this.failReconnect({ attempts: attempt, cause });
+            return;
+          }
+          await sleep({
+            ms: Math.min(delay, remainingAfterFailure),
+            abortSignal: reconnectAbortController.signal
+          });
+          delay = Math.min(delay * 1.5, this.maxDelayMs);
+        } finally {
+          clearTimeout(timeout);
+          reconnectAbortController.signal.removeEventListener(
+            "abort",
+            abortConnect
+          );
+          if (this.activeConnectAbortController === abortController) {
+            this.activeConnectAbortController = void 0;
+          }
         }
-        await sleep(delay);
-        delay = Math.min(delay * 1.5, this.maxDelayMs);
+      }
+    } finally {
+      if (this.reconnectAbortController === reconnectAbortController) {
+        this.reconnectAbortController = void 0;
       }
     }
   }
+  connect({
+    abortSignal
+  }) {
+    return awaitWebSocketConnection({
+      connection: Promise.resolve().then(
+        () => this.connectThunk({ abortSignal })
+      ),
+      abortSignal
+    });
+  }
+  abortActiveConnect() {
+    var _a;
+    const controller = this.activeConnectAbortController;
+    this.activeConnectAbortController = void 0;
+    controller == null ? void 0 : controller.abort(new Error("SandboxChannel connection aborted"));
+    (_a = this.reconnectAbortController) == null ? void 0 : _a.abort(
+      new Error("SandboxChannel connection aborted")
+    );
+  }
+  failReconnect({
+    attempts,
+    cause
+  }) {
+    var _a;
+    this.finalizeClose(1006, "reconnect failed");
+    (_a = this.onDebug) == null ? void 0 : _a.call(this, {
+      event: "reconnect-failed",
+      attempts,
+      lastSeenEventId: this._lastSeenEventId,
+      cause
+    });
+  }
   rawSend(text) {
     if (this.connected && this.ws) {
       this.ws.send(text);
@@ -342,6 +507,7 @@ var SandboxChannel = class {
   }
   finalizeClose(code, reason) {
     if (this.terminal) return;
+    this.abortActiveConnect();
     this.terminal = true;
     this.connected = false;
     for (const h of this.onCloseHandlers) h(code, reason);
@@ -2315,6 +2481,7 @@ export {
   resolveSandboxHomeDir,
   shellQuote,
   shouldResolveNativeSubscription,
+  sleep,
   waitForBridgeReady,
   warnCredentialBrokeringUnavailable,
   withBridgeToken,