@ai-sdk/harness-codex 1.0.165 → 1.0.167

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["SandboxSession"],"sources":["../src/codex-auth.ts","../src/codex-harness.ts","../src/version.ts","../src/index.ts"],"mappings":";;;;;KA8CY,0BAA0B;;;KCgD1B;WACD,OAAO;;;;;;WAMP,uBAAuB;;;;;;WAMvB,cAAc;;;;;WAKd,aAAa;;;;;WAKb;;;;WAIA;;;;;;;WAOA;;;;;WAKA,eAAe;;WAEf;;;;;;;WAOA,YAAY;;;;;WAKZ,kBAAkB;;cAYvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8DU,YACd,WAAU,uBACT,iBAAiB;;;qBC7NP;;;;;;;;qBCKA,iCAAK"}
+{"version":3,"file":"index.d.ts","names":["SandboxSession"],"sources":["../src/codex-auth.ts","../src/codex-harness.ts","../src/version.ts","../src/index.ts"],"mappings":";;;;;KA8CY,0BAA0B;;;KCkD1B;WACD,OAAO;;;;;;WAMP,uBAAuB;;;;;;WAMvB,cAAc;;;;;WAKd,aAAa;;;;;WAKb;;;;WAIA;;;;;;;WAOA;;;;;WAKA,eAAe;;WAEf;;;;;;;WAOA,YAAY;;;;;WAKZ,kBAAkB;;cAYvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8DU,YACd,WAAU,uBACT,iBAAiB;;;qBC/NP;;;;;;;;qBCKA,iCAAK"}

package/dist/index.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import path, { dirname, join, resolve } from "node:path";
 import { HarnessCapabilityUnsupportedError, commonTool, harnessSessionDataDirectoryPath, harnessStateDirectoryPath, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgeStartBaseSchema, harnessV1DiagnosticFromBridgeFrame } from "@ai-sdk/harness";
-import { SandboxChannel, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, extractHarnessPromptContent, forwardBridgeProcessStream, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, harnessPromptContentSchema, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isWindows, markBridgeStarting, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveSandboxCredentialEnvironment, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeSkills } from "@ai-sdk/harness/utils";
+import { SandboxChannel, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createBridgeWebSocketConnect, createCredentialRequestTransformation, createReadBridgeAsset, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, extractHarnessPromptContent, forwardBridgeProcessStream, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, harnessPromptContentSchema, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isWindows, markBridgeStarting, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveBridgeEndpoint, resolveBridgePort, resolveSandboxCredentialEnvironment, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, validateBridgeSandboxSettings, waitForBridgeReady, warnCredentialBrokeringUnavailable, writeSkills } from "@ai-sdk/harness/utils";
 import { isRecord, safeParseJSON, tool } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
 import { z } from "zod/v4";
@@ -399,7 +399,7 @@ const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
 z.discriminatedUnion("type", [startMessageSchema, ...harnessV1BridgeInboundCommandSchemas]);
 //#endregion
 //#region src/version.ts
-const VERSION = "1.0.165";
+const VERSION = "1.0.167";
 //#endregion
 //#region src/codex-harness.ts
 const DEFAULT_CODEX_MODEL = "gpt-5.5";
@@ -482,14 +482,12 @@ function createCodex(settings = {}) {
 			const sandboxSession = startOpts.sandboxSession;
 			const toolSafeSandboxSession = getRestrictedSandboxSession(sandboxSession);
 			const sandboxId = "id" in sandboxSession ? sandboxSession.id : void 0;
-			validateBasicSandboxSettings({
+			validateBridgeSandboxSettings({
 				sandboxSession,
-				port: settings.port,
-				portEndpoint: settings.portEndpoint
-			});
-			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."
+				sandboxId,
+				portOverride: settings.port,
+				portEndpointOverride: settings.portEndpoint,
+				mintBridgeToken: settings.mintBridgeToken
 			});
 			const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
 			const isResume = lifecycleState != null;
@@ -551,19 +549,16 @@ function createCodex(settings = {}) {
 				sessionId: startOpts.sessionId
 			});
 			if (coords) try {
-				const endpoint = await resolveBridgeEndpoint({
+				const attachEndpoint = await resolveBridgeEndpoint({
 					sandboxSession,
-					override: settings.portEndpoint,
-					port: coords.port
-				});
-				const attachEndpoint = withBridgeToken({
-					endpoint,
+					port: coords.port,
+					portEndpointOverride: settings.portEndpoint,
 					token: coords.token
 				});
 				const attachChannel = new SandboxChannel({
-					connect: ({ abortSignal }) => openWebSocket({
-						...attachEndpoint,
-						abortSignal
+					connect: createBridgeWebSocketConnect({
+						endpoint: attachEndpoint,
+						webSocketConstructor: WebSocket
 					}),
 					outboundSchema: outboundMessageSchema,
 					initialLastSeenEventId: coords.lastSeenEventId,
@@ -608,7 +603,7 @@ function createCodex(settings = {}) {
 			}
 			const port = resolveBridgePort({
 				sandboxSession,
-				override: settings.port
+				portOverride: settings.port
 			});
 			const token = settings.mintBridgeToken == null ? createBridgeToken() : settings.mintBridgeToken(sandboxId);
 			const forwardedAuthEnvironment = credentialsBrokered ? sandboxAuthEnvironment : await applyCredentialForwarding({
@@ -673,19 +668,18 @@ function createCodex(settings = {}) {
 				})
 			});
 			drainBridgeProcessStream(proc.stdout);
-			const endpoint = await resolveBridgeEndpoint({
+			const bridgeEndpoint = await resolveBridgeEndpoint({
 				sandboxSession,
-				override: settings.portEndpoint,
-				port: boundPort
-			});
-			const bridgeEndpoint = withBridgeToken({
-				endpoint,
+				port: boundPort,
+				portEndpointOverride: settings.portEndpoint,
 				token
 			});
 			const channel = new SandboxChannel({
-				connect: ({ abortSignal }) => openWebSocket({
-					...bridgeEndpoint,
-					abortSignal
+				connect: createBridgeWebSocketConnect({
+					endpoint: bridgeEndpoint,
+					webSocketConstructor: WebSocket,
+					openRetryTimeoutMs: timeoutMs,
+					startAbortSignal: startOpts.abortSignal
 				}),
 				outboundSchema: outboundMessageSchema,
 				onDiagnostic,
@@ -722,78 +716,6 @@ function createCodex(settings = {}) {
 		}
 	};
 }
-function resolveBridgePort({ sandboxSession, override }) {
-	if (override !== void 0) 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 }) {
-	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 }) {
-	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 }) {
-	return new Promise((resolve, reject) => {
-		if (abortSignal.aborted) {
-			reject(abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted"));
-			return;
-		}
-		const ws = new WebSocket(url, { headers: headers == null ? void 0 : { ...headers } });
-		let settled = false;
-		const cleanup = () => {
-			abortSignal.removeEventListener("abort", onAbort);
-			ws.off("open", onOpen);
-			ws.off("error", onError);
-		};
-		const rejectWithCleanup = (error) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			ws.once("error", () => {});
-			try {
-				ws.terminate();
-			} catch {
-				try {
-					ws.close();
-				} catch {}
-			}
-			reject(error);
-		};
-		const onOpen = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve(ws);
-		};
-		const onError = (err) => {
-			rejectWithCleanup(err);
-		};
-		const onAbort = () => rejectWithCleanup(abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted"));
-		ws.once("open", onOpen);
-		ws.once("error", onError);
-		abortSignal.addEventListener("abort", onAbort, { once: true });
-	});
-}
 function createSession({ sessionId, channel, proc, model, reasoningEffort, webSearch, builtinToolFiltering, codexConfig, mcpServers, headers, resumeThreadId, isResume, seedResumeThreadOnFirstPrompt, rerunContinue, bridgePort, bridgeToken, sandboxId, sandboxCredentialEnvironment, debug, permissionMode, sandbox, sandboxHomeDir, turnConfigurationFingerprint }) {
 	let stopped = false;
 	let stopPromise;