@ai-sdk/harness-codex 1.0.165 → 1.0.167

package/src/codex-harness.ts

@@ -14,7 +14,6 @@ import {
   type HarnessV1PromptControl,
   type HarnessV1PortEndpoint,
   type HarnessV1ResumeSessionState,
-  type HarnessV1NetworkSandboxSession,
   type HarnessV1PermissionMode,
   type HarnessV1Session,
   type HarnessV1Skill,
@@ -26,6 +25,7 @@ import {
   applyCredentialForwarding,
   classifyDiskLog,
   createBridgeToken,
+  createBridgeWebSocketConnect,
   resolveSandboxCredentialEnvironment,
   createBridgeErrorHandler,
   createBridgeStartupError,
@@ -35,12 +35,14 @@ import {
   forwardBridgeProcessStream,
   getRestrictedSandboxSession,
   markBridgeStarting,
+  resolveBridgeEndpoint,
+  resolveBridgePort,
   resolveSandboxHomeDir,
   SandboxChannel,
   shellQuote,
+  validateBridgeSandboxSettings,
   warnCredentialBrokeringUnavailable,
   waitForBridgeReady,
-  withBridgeToken,
   writeSkills,
   type SandboxChannelReconnectOptions,
 } from '@ai-sdk/harness/utils';
@@ -246,18 +248,13 @@ export function createCodex(
       const toolSafeSandboxSession =
         getRestrictedSandboxSession(sandboxSession);
       const sandboxId = 'id' in sandboxSession ? sandboxSession.id : undefined;
-      validateBasicSandboxSettings({
+      validateBridgeSandboxSettings({
         sandboxSession,
-        port: settings.port,
-        portEndpoint: settings.portEndpoint,
+        sandboxId,
+        portOverride: settings.port,
+        portEndpointOverride: settings.portEndpoint,
+        mintBridgeToken: settings.mintBridgeToken,
       });
-      if (settings.mintBridgeToken != null && sandboxId == null) {
-        throw new HarnessCapabilityUnsupportedError({
-          harnessId: 'codex',
-          message:
-            'The codex harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id.',
-        });
-      }
       const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
       const isResume = lifecycleState != null;
       const isContinue = startOpts.continueFrom != null;
@@ -380,18 +377,17 @@ export function createCodex(
        */
       if (coords) {
         try {
-          const endpoint = await resolveBridgeEndpoint({
+          const attachEndpoint = await resolveBridgeEndpoint({
             sandboxSession,
-            override: settings.portEndpoint,
             port: coords.port,
-          });
-          const attachEndpoint = withBridgeToken({
-            endpoint,
+            portEndpointOverride: settings.portEndpoint,
             token: coords.token,
           });
           const attachChannel: CodexChannel = new SandboxChannel({
-            connect: ({ abortSignal }) =>
-              openWebSocket({ ...attachEndpoint, abortSignal }),
+            connect: createBridgeWebSocketConnect({
+              endpoint: attachEndpoint,
+              webSocketConstructor: WebSocket,
+            }),
             outboundSchema: outboundMessageSchema,
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
@@ -455,7 +451,7 @@ export function createCodex(
 
       const port = resolveBridgePort({
         sandboxSession,
-        override: settings.port,
+        portOverride: settings.port,
       });
       const token =
         settings.mintBridgeToken == null
@@ -540,16 +536,20 @@ export function createCodex(
       });
       void drainBridgeProcessStream(proc.stdout);
 
-      const endpoint = await resolveBridgeEndpoint({
+      const bridgeEndpoint = await resolveBridgeEndpoint({
         sandboxSession,
-        override: settings.portEndpoint,
         port: boundPort,
+        portEndpointOverride: settings.portEndpoint,
+        token,
       });
-      const bridgeEndpoint = withBridgeToken({ endpoint, token });
 
       const channel: CodexChannel = new SandboxChannel({
-        connect: ({ abortSignal }) =>
-          openWebSocket({ ...bridgeEndpoint, abortSignal }),
+        connect: createBridgeWebSocketConnect({
+          endpoint: bridgeEndpoint,
+          webSocketConstructor: WebSocket,
+          openRetryTimeoutMs: timeoutMs,
+          startAbortSignal: startOpts.abortSignal,
+        }),
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
         onBridgeError,
@@ -594,128 +594,6 @@ export function createCodex(
   };
 }
 
-function resolveBridgePort({
-  sandboxSession,
-  override,
-}: {
-  sandboxSession: HarnessV1NetworkSandboxSession | SandboxSession;
-  override: number | undefined;
-}): number {
-  if (override !== undefined) return override;
-  if ('ports' in sandboxSession && sandboxSession.ports.length > 0) {
-    return sandboxSession.ports[0];
-  }
-  throw new HarnessCapabilityUnsupportedError({
-    harnessId: 'codex',
-    message:
-      'The codex harness needs a TCP port exposed by the sandbox. ' +
-      'Create the sandbox with `ports: [<port>]` or pass `createCodex({ port })`.',
-  });
-}
-
-function validateBasicSandboxSettings({
-  sandboxSession,
-  port,
-  portEndpoint,
-}: {
-  sandboxSession: HarnessV1NetworkSandboxSession | SandboxSession;
-  port: number | undefined;
-  portEndpoint: HarnessV1PortEndpoint | undefined;
-}): void {
-  if ('getPortEndpoint' in sandboxSession) return;
-  if (port == null) {
-    throw new HarnessCapabilityUnsupportedError({
-      harnessId: 'codex',
-      message:
-        'The codex harness requires an explicit `port` when using a basic sandbox session.',
-    });
-  }
-  if (portEndpoint == null) {
-    throw new HarnessCapabilityUnsupportedError({
-      harnessId: 'codex',
-      message:
-        'The codex harness requires an explicit `portEndpoint` when using a basic sandbox session.',
-    });
-  }
-}
-
-async function resolveBridgeEndpoint({
-  sandboxSession,
-  override,
-  port,
-}: {
-  sandboxSession: HarnessV1NetworkSandboxSession | SandboxSession;
-  override: HarnessV1PortEndpoint | undefined;
-  port: number;
-}): Promise<HarnessV1PortEndpoint> {
-  if (override != null) return override;
-  if ('getPortEndpoint' in sandboxSession) {
-    return sandboxSession.getPortEndpoint({ port, protocol: 'ws' });
-  }
-  throw new HarnessCapabilityUnsupportedError({
-    harnessId: 'codex',
-    message:
-      'The codex harness requires an explicit `portEndpoint` when using a basic sandbox session.',
-  });
-}
-
-function openWebSocket({
-  url,
-  headers,
-  abortSignal,
-}: HarnessV1PortEndpoint & { abortSignal: AbortSignal }): Promise<WebSocket> {
-  return new Promise((resolve, reject) => {
-    if (abortSignal.aborted) {
-      reject(abortSignal.reason ?? new Error('WebSocket connection aborted'));
-      return;
-    }
-
-    const ws = new WebSocket(url, {
-      headers: headers == null ? undefined : { ...headers },
-    });
-
-    let settled = false;
-    const cleanup = () => {
-      abortSignal.removeEventListener('abort', onAbort);
-      ws.off('open', onOpen);
-      ws.off('error', onError);
-    };
-    const rejectWithCleanup = (error: unknown) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      ws.once('error', () => {});
-      try {
-        ws.terminate();
-      } catch {
-        try {
-          ws.close();
-        } catch {
-          // best-effort
-        }
-      }
-      reject(error);
-    };
-    const onOpen = () => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(ws);
-    };
-    const onError = (err: Error) => {
-      rejectWithCleanup(err);
-    };
-    const onAbort = () =>
-      rejectWithCleanup(
-        abortSignal.reason ?? new Error('WebSocket connection aborted'),
-      );
-
-    ws.once('open', onOpen);
-    ws.once('error', onError);
-    abortSignal.addEventListener('abort', onAbort, { once: true });
-  });
-}
-
 function createSession({
   sessionId,
   channel,