@ai-sdk/harness 1.0.163 → 1.0.165

package/dist/utils/index.d.ts

@@ -36,6 +36,12 @@ interface SandboxChannelReconnectOptions {
 }
 interface SandboxChannelConnectOptions {
   readonly abortSignal: AbortSignal;
+  /**
+   * Why the channel is connecting: `'open'` for the initial
+   * {@link SandboxChannel.open} call, `'reconnect'` for an attempt to recover
+   * from a transient disconnect.
+   */
+  readonly reason: 'open' | 'reconnect';
 }
 interface SandboxChannelOptions<TOut> {
   /**
@@ -625,6 +631,31 @@ type HarnessV1CredentialForwarding = (options: {
   readonly environmentVariableName: string;
 }) => string | PromiseLike<string>;
 //#endregion
+//#region src/v1/harness-v1-mint-bridge-token.d.ts
+/**
+ * Creates the authentication token a bridge-backed harness adapter uses to
+ * secure its sandbox bridge channel for one session. Defaults to a random
+ * 32-byte hexadecimal token when omitted.
+ */
+type HarnessV1MintBridgeTokenCallback = (sandboxId: string) => string;
+//#endregion
+//#region src/v1/harness-v1-bridge-protocol.d.ts
+/**
+ * Sent the instant the bridge accepts an authenticated WS connection. The host
+ * waits for it before sending `start`/`resume`, because some sandbox runtimes
+ * complete the upstream WS handshake before the connection is wired through to
+ * the bridge process — anything sent in that gap is dropped. Carries the
+ * bridge's lifecycle `state` and highest emitted `seq` for reconnect.
+ */
+declare const harnessV1BridgeHelloSchema: z.ZodObject<{
+  type: z.ZodLiteral<"bridge-hello">;
+  state: z.ZodOptional<z.ZodString>;
+  lastSeq: z.ZodOptional<z.ZodNumber>;
+  capabilities: z.ZodOptional<z.ZodObject<{
+    experimental_userMessageResponses: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+//#endregion
 //#region src/utils/credential-forwarding.d.ts
 export declare function applyCredentialForwarding({ environment, credentialEnvironmentVariables, credentialForwarding }: {
   environment: Readonly<Record<string, string>>;
@@ -742,10 +773,81 @@ export declare function waitForBridgeReady({ proc, sandbox, bridgeStateDir, brid
 //#endregion
 //#region src/utils/bridge-token.d.ts
 export declare function createBridgeToken(): string;
-export declare function withBridgeToken({ endpoint, token }: {
-  endpoint: HarnessV1PortEndpoint;
+//#endregion
+//#region src/utils/bridge-endpoint.d.ts
+/**
+ * Validates the bridge connection settings against the sandbox session before
+ * any bridge work starts.
+ *
+ * Basic sandbox sessions cannot expose ports, so they need both an explicit
+ * `port` and `portEndpoint` setting. A custom `mintBridgeToken` callback needs
+ * a sandbox id to mint the token for.
+ */
+export declare function validateBridgeSandboxSettings({ sandboxSession, sandboxId, portOverride, portEndpointOverride, mintBridgeToken }: {
+  sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+  sandboxId: string | undefined;
+  portOverride: number | undefined;
+  portEndpointOverride: HarnessV1PortEndpoint | undefined;
+  mintBridgeToken: HarnessV1MintBridgeTokenCallback | undefined;
+}): void;
+/**
+ * Resolves the port the bridge listens on inside the sandbox: the `port`
+ * setting if present, otherwise the first port the sandbox exposes.
+ */
+export declare function resolveBridgePort({ sandboxSession, portOverride }: {
+  sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+  portOverride: number | undefined;
+}): number;
+/**
+ * Resolves the host-reachable WebSocket endpoint for a bridge port and
+ * authenticates it with the bridge token.
+ *
+ * A `portEndpoint` setting takes precedence and is used as-is regardless of
+ * `port`, so it must point at the port the bridge actually listens on.
+ */
+export declare function resolveBridgeEndpoint({ sandboxSession, port, portEndpointOverride, token }: {
+  sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+  port: number;
+  portEndpointOverride: HarnessV1PortEndpoint | undefined;
   token: string;
-}): HarnessV1PortEndpoint;
+}): Promise<HarnessV1PortEndpoint>;
+//#endregion
+//#region src/utils/bridge-web-socket.d.ts
+type BridgeHello = z.infer<typeof harnessV1BridgeHelloSchema>;
+interface CreateBridgeWebSocketConnectOptions {
+  /** Bridge endpoint, already authenticated with the bridge token. */
+  endpoint: HarnessV1PortEndpoint;
+  /**
+   * `WebSocket` class from the `ws` package. Passed in by the adapter because
+   * `ws` is an optional peer dependency of `@ai-sdk/harness`.
+   */
+  webSocketConstructor: typeof WebSocket;
+  /**
+   * Retry budget in milliseconds for the channel's initial open (connect
+   * reason `'open'`). Omit for a single attempt. Reconnects always make a
+   * single attempt, because the channel retries them itself.
+   */
+  openRetryTimeoutMs?: number;
+  /**
+   * Abort signal that additionally cancels the channel's initial open, e.g.
+   * the abort signal of the harness start call. Not applied to reconnects.
+   */
+  startAbortSignal?: AbortSignal;
+  /** Called with the `bridge-hello` frame after every successful connect. */
+  onHello?: (hello: BridgeHello) => void;
+}
+/**
+ * Creates the `connect` function for a bridge `SandboxChannel`.
+ *
+ * A connection only counts as established once the socket is open and the
+ * bridge has sent `bridge-hello`. Some sandbox runtimes complete the host-side
+ * WebSocket upgrade before the connection reaches the bridge process, and
+ * frames sent in that gap are dropped. The bridge sends `bridge-hello` the
+ * instant it accepts a connection, and sends nothing else until the host sends
+ * `start` or `resume`, so no frame is lost between the handshake and the
+ * channel wiring the socket.
+ */
+export declare function createBridgeWebSocketConnect({ endpoint, webSocketConstructor, openRetryTimeoutMs, startAbortSignal, onHello }: CreateBridgeWebSocketConnectOptions): (options: SandboxChannelConnectOptions) => Promise<WebSocket>;
 //#endregion
 //#region src/utils/bridge-asset.d.ts
 export declare function createReadBridgeAsset<const ASSET_URLS extends Record<string, URL>>(assetUrls: ASSET_URLS): (name: Extract<keyof ASSET_URLS, string>) => Promise<string>;
@@ -842,5 +944,5 @@ export declare function convertHarnessToolModelOutput({ output }: {
   isError: boolean;
 };
 //#endregion
-export type { BridgeReadyErrorContext, BridgeReadySource, DiskLogRecoveryMode, Experimental_BridgeUserMessageRequest, Experimental_BridgeUserMessageResponse, Experimental_BridgeUserMessageSubmitter, HarnessPromptContent, HarnessPromptContentPart, HarnessToolModelOutputContent, OAuthCredential, RefreshOAuthAccessTokenResult, SandboxChannelConnectOptions, SandboxChannelDebugEvent, SandboxChannelOptions, SandboxChannelReconnectOptions, SkillFilePathMode, WaitForBridgeReadyOptions, WaitForBridgeReadyResult, WriteInstructionsOptions, WriteInstructionsResult, WriteSkillsOptions, WriteSkillsResult };
+export type { BridgeHello, BridgeReadyErrorContext, BridgeReadySource, CreateBridgeWebSocketConnectOptions, DiskLogRecoveryMode, Experimental_BridgeUserMessageRequest, Experimental_BridgeUserMessageResponse, Experimental_BridgeUserMessageSubmitter, HarnessPromptContent, HarnessPromptContentPart, HarnessToolModelOutputContent, OAuthCredential, RefreshOAuthAccessTokenResult, SandboxChannelConnectOptions, SandboxChannelDebugEvent, SandboxChannelOptions, SandboxChannelReconnectOptions, SkillFilePathMode, WaitForBridgeReadyOptions, WaitForBridgeReadyResult, WriteInstructionsOptions, WriteInstructionsResult, WriteSkillsOptions, WriteSkillsResult };
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["SandboxSession","SandboxSession","SandboxSession"],"sources":["../../src/utils/sandbox-channel.ts","../../src/utils/bridge-user-message-submitter.ts","../../src/utils/classify-disk-log.ts","../../src/utils/ai-gateway-auth.ts","../../src/v1/harness-authentication.ts","../../src/utils/authentication-environment.ts","../../src/utils/native-subscription/jwt.ts","../../src/utils/native-subscription/linux-secret-service.ts","../../src/utils/native-subscription/macos-keychain.ts","../../src/utils/native-subscription/should-resolve-native.ts","../../src/utils/native-subscription/windows-credential-manager.ts","../../src/utils/oauth-access-token.ts","../../src/utils/os.ts","../../src/v1/harness-v1-network-sandbox-session.ts","../../src/v1/harness-v1-prompt.ts","../../src/v1/harness-v1-skill.ts","../../src/v1/harness-v1-call-warning.ts","../../src/v1/harness-v1-credential-forwarding.ts","../../src/utils/credential-forwarding.ts","../../src/utils/sandbox-credential-brokering.ts","../../src/utils/sandbox-home-dir.ts","../../src/utils/shell-quote.ts","../../src/utils/write-instructions.ts","../../src/utils/write-skills.ts","../../src/utils/bridge-ready.ts","../../src/utils/bridge-token.ts","../../src/utils/bridge-asset.ts","../../src/utils/bridge-diagnostics.ts","../../src/utils/resolve-sandbox-default-working-directory.ts","../../src/utils/get-restricted-sandbox-session.ts","../../src/utils/sleep.ts","../../src/utils/normalize-harness-tool-model-output.ts","../../src/utils/extract-harness-prompt-content.ts","../../src/utils/convert-harness-tool-model-output.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["SandboxSession","SandboxSession","SandboxSession","SandboxSession"],"sources":["../../src/utils/sandbox-channel.ts","../../src/utils/bridge-user-message-submitter.ts","../../src/utils/classify-disk-log.ts","../../src/utils/ai-gateway-auth.ts","../../src/v1/harness-authentication.ts","../../src/utils/authentication-environment.ts","../../src/utils/native-subscription/jwt.ts","../../src/utils/native-subscription/linux-secret-service.ts","../../src/utils/native-subscription/macos-keychain.ts","../../src/utils/native-subscription/should-resolve-native.ts","../../src/utils/native-subscription/windows-credential-manager.ts","../../src/utils/oauth-access-token.ts","../../src/utils/os.ts","../../src/v1/harness-v1-network-sandbox-session.ts","../../src/v1/harness-v1-prompt.ts","../../src/v1/harness-v1-skill.ts","../../src/v1/harness-v1-call-warning.ts","../../src/v1/harness-v1-credential-forwarding.ts","../../src/v1/harness-v1-mint-bridge-token.ts","../../src/v1/harness-v1-bridge-protocol.ts","../../src/utils/credential-forwarding.ts","../../src/utils/sandbox-credential-brokering.ts","../../src/utils/sandbox-home-dir.ts","../../src/utils/shell-quote.ts","../../src/utils/write-instructions.ts","../../src/utils/write-skills.ts","../../src/utils/bridge-ready.ts","../../src/utils/bridge-token.ts","../../src/utils/bridge-endpoint.ts","../../src/utils/bridge-web-socket.ts","../../src/utils/bridge-asset.ts","../../src/utils/bridge-diagnostics.ts","../../src/utils/resolve-sandbox-default-working-directory.ts","../../src/utils/get-restricted-sandbox-session.ts","../../src/utils/sleep.ts","../../src/utils/normalize-harness-tool-model-output.ts","../../src/utils/extract-harness-prompt-content.ts","../../src/utils/convert-harness-tool-model-output.ts"],"mappings":";;;;;;;;;;;KAcY;EACN;EAA4B;EAAiB;;EAC7C;EAAsB;EAAiB;;EAEvC;EACA;EACA;EACA;;UAGW;;;;;WAKN;;WAEA;;WAEA;;UAGM;WACN,aAAa;;;;;;WAOb;;UAGM,sBAAsB;;;;;;;;EAQrC,UAAU,SAAS,iCAAiC,QAAQ;;EAG5D,gBAAgB,eAAe;EAE/B,YAAY;EAEZ,WAAW,OAAO;;;;;;;;EASlB,gBACE,OAAO,QAAQ;IAAQ;;EAGzB,iBAAiB,OAAO,QAAQ;IAAQ;;;;;;;;EAQxC;;KAGG,YAAY;EAAe;KAAkB;KAE7C,SAAS;EAAe;GAAgB,UAAU,YAAY,UACjE,OAAO,QAAQ;EAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;qBAqHlB,eACX;EAAe;GACf;EAAc;;EAAmB;;mBAEhB;mBAIA;mBACA;UACT;UACA;UACA;UACA;mBACS;mBAGA;mBAEA;mBAGA;mBACA;mBAGA;mBAGA;mBAGA;mBACA;mBACA;UAET;UACA;;UAEA;;;;;;;UAOA;UACA;;UAIA;UACA;mBACS;UACT;UACA;UACA;EAEI,YAAA,SAAS,sBAAsB;;;;;;MAiBvC;;;;;;;;;;;;EAeE,KAAK;IAAS;MAAqB;EA6BzC,GAAG,UAAU,YAAY,OACvB,MAAM,GACN,UAAU,SAAS,MAAM;;;;;;;;EAgC3B;EAiBA,QAAQ,UAAU,cAAc;EAIhC,YAAY;EAOZ,KAAK,SAAS;;;;;;;EAed;EAKA;;;;;;;;;;;;;;;EA0BA,WAAW;EA4BX;UAMQ;UA4BM;UAwGN;UAYA;UASA;UAgBA;UAQA;UAMA;UAIM;UAiCN;UAiCA;UAwCA;UAeA;UAwBA;UAkBA;UAOA;UAoBA;;;;KC50BE;EACV;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;IAAU;;;KAGA;EACV,OAAO,eAAe;EACtB,MAAM;;wBAGQ,8CAA8C;EAC5D,KAAK,SAAS;EACd,WACE,WAAW,UAAU;EAEvB,YAAY;IACV;;;;;;;;KCjBQ;;;;;;;;;;;;;wBAcU,gBACpB,sCACC,QAAQ;;;wBCrBK,0BACd;EAEA,KAAK;;EAEL;EACA;;;;;;;;;;KCFU,qCAAqC,SAC/C;;;;;KAOU,wBAAwB,8CACjC,0DAEkB,kDAKT,kBACA;;;wBCrBI,mCACd,iBACC,SAAS;;;wBCFU,kBACpB;EAEA;IACE,QAAQ,SAAS;wBAcC,kBACpB;EAEA;IACE;;;wBCnBkB,iCACpB;EAEA,YAAY,SAAS;IACnB;;;wBCJkB,4BACpB,SACA;EAEA;EACA;IACE;;;wBCRY,kCACd,MACA,KACA;EAEA,MAAM,QAAQ;EACd,KAAK,SAAS;EACd;;;;wBCuBoB,uCACpB;EAEA;IACE;;;KChCQ;WACD;WACA;WACA;;KAGC;WACD;WACA;WACA;;wBAGK,4BACd,WACA,KACA;WAES;WACA;WACA;;wBAKW,0BACpB,UACA,UACA,cACA,eACA,SACA,OAAO;WAEE;WACA;WACA;WACA;WACA,UAAU;WACV,eAAe,WAAW;IACjC,QAAQ;;;wBC3CI,QAAQ,UAAU,OAAO;wBAIzB,QAAQ,UAAU,OAAO;wBAIzB,UAAU,UAAU,OAAO;;;;;;;KCD/B;WACD;WACA,UAAU,SAAS;;;;;;;;;;;;;UAqCb,uCAAuCA;;;;;WAK7C;;;;;;;;;;WAWA;;WAGA,OAAO;;;;;WAMP,kBAAkB;IACzB;IACA;QACI,YAAY;;;;;;WAOT,aAAa;IACpB;IACA;QACI;;WAGG,YAAY;;;;;;;;WASZ,eAAe;;;;;;;WAQf,oBACP,QAAQ,2BACL;;;;;;;;;;WAWI,6BACP,iBAAiB,cAAc,oCAC5B;;;;;;;WAQI,6BACP,iBAAiB,cAAc,oCAC5B;;;;;;WAOI,YACP,OAAO,uBACP;IAAY,cAAc;QACvB;;;;;;;;;;;;WAaI,kBAAkBA;;;;;;;;;;;;;;;;;KAkBjB;EACN;;EACA;;EAEA;EACA,cAAc;EACd,eAAe;EACf,cAAc;;EAGd;EACA,eAAe;EACf,cAAc;EACd,cAAc;;KAGf;EACC;;EACA;;EACA;;KAED;EACC;;EACA;;EACA;;KAED;WACM,MAAM;WACN,QAAQ;;;;;;;;;;;;;KAcP;WACD;aACE;aACA,OAAO;aACP,SAAS;aACT,cAAc,cAAc;aAC5B,UAAU,cAAc;;WAE1B;aACE,SAAS,SAAS;;;;;;;;;;;;;KCnNnB,2BAA2B;;;;;;;KCN3B;;WAED;;;;;WAMA;;WAGA;;;;;;WAOA,QAAQ,cAAc;;KAGrB;;;;;;WAMD;;WAGA;;;;;;;;;;;KC3BC;EAEN;EACA;EACA;;EAGA;EACA;EACA;;EAGA;EACA;;;YAIM;IACR,WAAW;;;;;;;;;;;;;KCjBH,iCAAiC;;;;;;;WAOlC;;WAEA;eACI;;;;;;;;KCbH,oCAAoC;;;;;;;;;;cCiInC,4BAA0B,EAAA;;;;;;;GASrC,EAAA,KAAA;;;wBC5IoB,4BACpB,aACA,gCACA;EAEA,aAAa,SAAS;EACtB,gCAAgC;EAChC,sBAAsB;IACpB,QAAQ;wBAmBU,sCACpB,aACA,gCACA,sBACA;EAEA,aAAa,SAAS;EACtB,gCAAgC;EAChC,sBAAsB;EACtB,uCAAuC,SAAS;IAC9C,QAAQ;;;wBCnCI;wBAIA,+BAA+B;;;;;wBAQ/B,mCAAmC;EACjD,aAAa,SAAS;EACtB,sBAAsB,SAAS;EAC/B,gCAAgC;;wBA8BlB,yBACd,aACA;EAEA,aAAa,SAAS;EACtB,gCAAgC;IAC9B;wBAUY,wCACd,UACA,cACA;EAEA;EACA,cAAc,SAAS;EACvB,kBAAkB,SAAS;IACzB;;;wBCvEkB,wBACpB,SACA;EAEA,SAAS;EACT,cAAc;IACZ;;;wBCTY,WAAW;;;KCSf;EACV,SAAS;EACT;EACA;EACA;EACA,cAAc;;KAGJ;EACV;EACA;;wBAUoB,oBACpB,SACA,UACA,kBACA,cACA,eACC,2BAA2B,QAAQ;;;KCtB1B;KAEA;EACV,SAAS;EACT;EACA;EACA,QAAQ,cAAc;EACtB,cAAc;EACd,mBAAmB;EACnB,2BAA2B;IAAS;;EACpC,eAAe;EACf,+BAA+B;IAC7B;IACA;;EAEF;;KAGU;EACV;EACA;EACA;EACA;;wBAuBoB,cACpB,SACA,UACA,WACA,QACA,aACA,kBACA,yBACA,cACA,6BAEA,mBACC,qBAAqB,QAAQ;;;KCvDpB;KAEA;EACV,MAAM;EACN;;KAGU;EACV,MAAM;EACN,SAAS;EACT;EACA;EACA;EACA,cAAc;EACd;EACA,sBACE,SAAS,4BACN,QAAQ,QAAQ;EACrB,mBACE,SAAS,4BACN,QAAQ,QAAQ;;KAGX;EACV;EACA,QAAQ;EACR;;wBAGoB,qBACpB,SACA,gBACA,YACA;EAEA,SAAS;EACT;EACA;EACA,cAAc;IACZ;wBAgBkB,qBACpB,MACA,SACA,gBACA,YACA,WACA,aACA,gBACA,oBACA,mBACC,4BAA4B,QAAQ;;;wBC7EvB;;;;;;;;;;;wBCcA,gCACd,gBACA,WACA,cACA,sBACA;EAEA,gBAAgB,iCAAiCC;EACjD;EACA;EACA,sBAAsB;EACtB,iBAAiB;;;;;;wBAyBH,oBACd,gBACA;EAEA,gBAAgB,iCAAiCA;EACjD;;;;;;;;;wBAoBoB,wBACpB,gBACA,MACA,sBACA;EAEA,gBAAgB,iCAAiCA;EACjD;EACA,sBAAsB;EACtB;IACE,QAAQ;;;KC/EA,cAAc,EAAE,aAAa;UAExB;;EAEf,UAAU;;;;;EAMV,6BAA6B;;;;;;EAO7B;;;;;EAMA,mBAAmB;;EAGnB,WAAW,OAAO;;;;;;;;;;;;;wBAkBJ,+BACd,UACA,sBACA,oBACA,kBACA,WACC,uCACD,SAAS,iCACN,QAAQ;;;wBC3DG,4BACR,mBAAmB,eAAe,MAExC,WAAW,cACT,MAAM,cAAc,wBAAwB;;;KCF3C;wBAyBW,kBAAkB;wBAkBlB,iBACd,WACA,WACA,SACA,OACA;EAEA;EACA;EACA;EACA;EACA,SAAS;;wBAeK,2BACd,WACA;EAEA;EACA;KACG;EAAS;EAAe;;wBAWP,2BACpB,SACA,MACA,YACA,YACA;EAEA;EACA,MAAM;EACN;EACA;EACA,aAAa;IACX,QAAQ;wBA+BU,6BACpB,QACA,YACA,QACA,aACA;EAEA,QAAQ,eAAe;EACvB,YAAY;EACZ;EACA;EACA;IACE;wBAoBkB,yBACpB,QAAQ,eAAe,cACtB;;;wBCnKmB,wCACpB,gBACA;WAES,gBAAgB,iCAAiCC;WACjD,cAAc;IACrB;;;wBCPY,4BACd,gBAAgB,iCAAiCC,8BAChDA;;;wBCLa,QACd,IACA;EAEA;EACA,cAAc;IACZ;;;wBCIY,kCACd;EAEA,QAAQ;IACN;;;cCAE,gCAA8B,EAAA,uBAAA,EAAA;;;;;;;GAOlC,EAAA,KAAA;qBAEW,4BAA0B,EAAA,mBAAA,EAAA,WAAA,EAAA,SAAA,EAAA,uBAAA,EAAA;;;;;;;GAGrC,EAAA,KAAA;KAEU,2BAA2B,EAAE,aAChC;KAEG,uBAAuB,EAAE,aAAa;wBAElC,8BACd;EAEA,QAAQ;IACN;;;KClCQ;EACN;EAAc;;EACd;EAAe;EAAc;;wBAsBnB,gCACd;EAEA,QAAQ;;EACJ,SAAS;EAAiC"}

package/dist/utils/index.js

@@ -4,8 +4,8 @@ import { promisify } from "node:util";
 import { createHash, randomBytes } from "node:crypto";
 import path, { posix } from "node:path";
 import { z } from "zod/v4";
-import { readFile } from "node:fs/promises";
 import { AISDKError } from "@ai-sdk/provider";
+import { readFile } from "node:fs/promises";
 //#region src/utils/sleep.ts
 function sleep({ ms, abortSignal }) {
 	return new Promise((resolve) => {
@@ -33,7 +33,7 @@ function sleep({ ms, abortSignal }) {
 //#endregion
 //#region src/utils/sandbox-channel.ts
 const sandboxChannelEventCheckpointSymbol = Symbol.for("vercel.ai.harness.sandboxChannelEventCheckpoint");
-function getAbortReason({ abortSignal }) {
+function getAbortReason$1({ abortSignal }) {
 	return abortSignal.reason ?? /* @__PURE__ */ new Error("SandboxChannel connection aborted");
 }
 function closeWebSocket({ ws }) {
@@ -50,18 +50,18 @@ function closeWebSocket({ ws }) {
 async function awaitWebSocketConnection({ connection, abortSignal }) {
 	if (abortSignal.aborted) {
 		connection.then((ws) => closeWebSocket({ ws })).catch(() => {});
-		throw getAbortReason({ abortSignal });
+		throw getAbortReason$1({ abortSignal });
 	}
 	let onAbort;
 	const aborted = new Promise((_, reject) => {
-		onAbort = () => reject(getAbortReason({ abortSignal }));
+		onAbort = () => reject(getAbortReason$1({ abortSignal }));
 		abortSignal.addEventListener("abort", onAbort, { once: true });
 	});
 	try {
 		const ws = await Promise.race([connection, aborted]);
 		if (abortSignal.aborted) {
 			closeWebSocket({ ws });
-			throw getAbortReason({ abortSignal });
+			throw getAbortReason$1({ abortSignal });
 		}
 		return ws;
 	} catch (error) {
@@ -146,7 +146,10 @@ var SandboxChannel = class {
 		const abortController = new AbortController();
 		this.activeConnectAbortController = abortController;
 		try {
-			const ws = await this.connect({ abortSignal: abortController.signal });
+			const ws = await this.connect({
+				abortSignal: abortController.signal,
+				reason: "open"
+			});
 			this.wire(ws);
 			this.ws = ws;
 			this.connected = true;
@@ -314,7 +317,10 @@ var SandboxChannel = class {
 				}, remaining);
 				timeout.unref?.();
 				try {
-					const ws = await this.connect({ abortSignal: abortController.signal });
+					const ws = await this.connect({
+						abortSignal: abortController.signal,
+						reason: "reconnect"
+					});
 					if (this.terminal || this.closing) {
 						closeWebSocket({ ws });
 						return;
@@ -359,9 +365,12 @@ var SandboxChannel = class {
 			if (this.reconnectAbortController === reconnectAbortController) this.reconnectAbortController = void 0;
 		}
 	}
-	connect({ abortSignal }) {
+	connect({ abortSignal, reason }) {
 		return awaitWebSocketConnection({
-			connection: Promise.resolve().then(() => this.connectThunk({ abortSignal })),
+			connection: Promise.resolve().then(() => this.connectThunk({
+				abortSignal,
+				reason
+			})),
 			abortSignal
 		});
 	}
@@ -1886,6 +1895,267 @@ function withBridgeToken({ endpoint, token }) {
 	};
 }
 //#endregion
+//#region src/errors/harness-error.ts
+const name$2 = "AI_HarnessError";
+const marker$1 = `vercel.ai.error.${name$2}`;
+const symbol$1 = Symbol.for(marker$1);
+/**
+* Base error type for failures originating in or signalled by a harness
+* adapter. Specific failure modes (e.g. unsupported capability) extend this
+* class.
+*/
+var HarnessError = class extends AISDKError {
+	constructor({ message, cause }) {
+		super({
+			name: name$2,
+			message,
+			cause
+		});
+		this[symbol$1] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker$1);
+	}
+};
+//#endregion
+//#region src/errors/harness-capability-unsupported-error.ts
+const name$1 = "AI_HarnessCapabilityUnsupportedError";
+const marker = `vercel.ai.error.${name$1}`;
+const symbol = Symbol.for(marker);
+/**
+* Thrown when a caller asks the harness to do something the adapter (or the
+* supplied sandbox) does not support, e.g. requesting manual compaction from
+* an adapter that only auto-compacts, or invoking `getPortEndpoint` on a
+* sandbox that does not expose one.
+*
+* The caller supplies the full human-readable message. Optional `harnessId`
+* is recorded as structured context for tooling.
+*/
+var HarnessCapabilityUnsupportedError = class extends HarnessError {
+	constructor({ message, harnessId, cause }) {
+		super({
+			message,
+			cause
+		});
+		this[symbol] = true;
+		Object.defineProperty(this, "name", { value: name$1 });
+		this.harnessId = harnessId;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker);
+	}
+};
+//#endregion
+//#region src/utils/bridge-endpoint.ts
+/**
+* Validates the bridge connection settings against the sandbox session before
+* any bridge work starts.
+*
+* Basic sandbox sessions cannot expose ports, so they need both an explicit
+* `port` and `portEndpoint` setting. A custom `mintBridgeToken` callback needs
+* a sandbox id to mint the token for.
+*/
+function validateBridgeSandboxSettings({ sandboxSession, sandboxId, portOverride, portEndpointOverride, mintBridgeToken }) {
+	if (!("getPortEndpoint" in sandboxSession)) {
+		if (portOverride == null) throw new HarnessCapabilityUnsupportedError({ message: "The harness requires an explicit `port` setting when using a basic sandbox session." });
+		if (portEndpointOverride == null) throw createMissingPortEndpointError();
+	}
+	if (mintBridgeToken != null && sandboxId == null) throw new HarnessCapabilityUnsupportedError({ message: "The harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id." });
+}
+/**
+* Resolves the port the bridge listens on inside the sandbox: the `port`
+* setting if present, otherwise the first port the sandbox exposes.
+*/
+function resolveBridgePort({ sandboxSession, portOverride }) {
+	if (portOverride !== void 0) return portOverride;
+	if ("ports" in sandboxSession && sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+	throw new HarnessCapabilityUnsupportedError({ message: "The harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or configure the harness `port` setting." });
+}
+/**
+* Resolves the host-reachable WebSocket endpoint for a bridge port and
+* authenticates it with the bridge token.
+*
+* A `portEndpoint` setting takes precedence and is used as-is regardless of
+* `port`, so it must point at the port the bridge actually listens on.
+*/
+async function resolveBridgeEndpoint({ sandboxSession, port, portEndpointOverride, token }) {
+	let endpoint;
+	if (portEndpointOverride != null) endpoint = portEndpointOverride;
+	else if ("getPortEndpoint" in sandboxSession) endpoint = await sandboxSession.getPortEndpoint({
+		port,
+		protocol: "ws"
+	});
+	else throw createMissingPortEndpointError();
+	return withBridgeToken({
+		endpoint,
+		token
+	});
+}
+function createMissingPortEndpointError() {
+	return new HarnessCapabilityUnsupportedError({ message: "The harness requires an explicit `portEndpoint` setting when using a basic sandbox session." });
+}
+//#endregion
+//#region src/utils/bridge-web-socket.ts
+const OPEN_TIMEOUT_MS = 1e4;
+const HELLO_TIMEOUT_MS = 5e3;
+const UNAUTHORIZED_CLOSE_CODE = 1008;
+/**
+* Creates the `connect` function for a bridge `SandboxChannel`.
+*
+* A connection only counts as established once the socket is open and the
+* bridge has sent `bridge-hello`. Some sandbox runtimes complete the host-side
+* WebSocket upgrade before the connection reaches the bridge process, and
+* frames sent in that gap are dropped. The bridge sends `bridge-hello` the
+* instant it accepts a connection, and sends nothing else until the host sends
+* `start` or `resume`, so no frame is lost between the handshake and the
+* channel wiring the socket.
+*/
+function createBridgeWebSocketConnect({ endpoint, webSocketConstructor, openRetryTimeoutMs, startAbortSignal, onHello }) {
+	return async ({ abortSignal, reason }) => {
+		const isInitialOpen = reason === "open";
+		const connectAbortSignal = isInitialOpen && startAbortSignal != null ? AbortSignal.any([abortSignal, startAbortSignal]) : abortSignal;
+		const { ws, hello } = isInitialOpen && openRetryTimeoutMs != null ? await openBridgeWebSocketWithRetry({
+			endpoint,
+			webSocketConstructor,
+			abortSignal: connectAbortSignal,
+			retryTimeoutMs: openRetryTimeoutMs
+		}) : await openBridgeWebSocket({
+			endpoint,
+			webSocketConstructor,
+			abortSignal: connectAbortSignal,
+			openTimeoutMs: OPEN_TIMEOUT_MS,
+			getHelloTimeoutMs: () => HELLO_TIMEOUT_MS
+		});
+		onHello?.(hello);
+		return ws;
+	};
+}
+var BridgeWebSocketUnauthorizedError = class extends Error {};
+async function openBridgeWebSocketWithRetry({ endpoint, webSocketConstructor, abortSignal, retryTimeoutMs }) {
+	const deadline = Date.now() + retryTimeoutMs;
+	let attempt = 0;
+	let lastError;
+	while (!abortSignal.aborted && Date.now() < deadline) {
+		attempt++;
+		try {
+			const remaining = Math.max(1, deadline - Date.now());
+			return await openBridgeWebSocket({
+				endpoint,
+				webSocketConstructor,
+				abortSignal,
+				openTimeoutMs: Math.min(OPEN_TIMEOUT_MS, remaining),
+				getHelloTimeoutMs: () => Math.min(HELLO_TIMEOUT_MS, Math.max(1, deadline - Date.now()))
+			});
+		} catch (error) {
+			if (abortSignal.aborted) throw getAbortReason({ abortSignal });
+			if (error instanceof BridgeWebSocketUnauthorizedError) throw error;
+			lastError = error;
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) break;
+			await sleep({
+				ms: Math.min(250 * attempt, 1e3, remaining),
+				abortSignal
+			});
+		}
+	}
+	if (abortSignal.aborted) throw getAbortReason({ abortSignal });
+	throw new HarnessError({
+		message: `The harness bridge did not complete the WebSocket handshake within ${retryTimeoutMs}ms after ${attempt} attempt(s).`,
+		cause: lastError
+	});
+}
+function openBridgeWebSocket({ endpoint, webSocketConstructor, abortSignal, openTimeoutMs, getHelloTimeoutMs }) {
+	return new Promise((resolve, reject) => {
+		if (abortSignal.aborted) {
+			reject(getAbortReason({ abortSignal }));
+			return;
+		}
+		const ws = new webSocketConstructor(endpoint.url, { headers: endpoint.headers == null ? void 0 : { ...endpoint.headers } });
+		let opened = false;
+		let hello;
+		let settled = false;
+		let openTimer;
+		let helloTimer;
+		const cleanup = () => {
+			clearTimeout(openTimer);
+			clearTimeout(helloTimer);
+			ws.off("open", onOpen);
+			ws.off("message", onMessage);
+			ws.off("close", onClose);
+			ws.off("error", onError);
+			abortSignal.removeEventListener("abort", onAbort);
+		};
+		const fail = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			ws.on("error", () => {});
+			try {
+				ws.terminate();
+			} catch {
+				try {
+					ws.close();
+				} catch {}
+			}
+			reject(error);
+		};
+		const tryResolve = () => {
+			if (settled || !opened || hello == null) return;
+			settled = true;
+			cleanup();
+			resolve({
+				ws,
+				hello
+			});
+		};
+		const onOpen = () => {
+			opened = true;
+			clearTimeout(openTimer);
+			const helloTimeoutMs = getHelloTimeoutMs();
+			helloTimer = setTimeout(() => fail(/* @__PURE__ */ new Error(`The harness bridge did not send bridge-hello within ${helloTimeoutMs}ms.`)), helloTimeoutMs);
+			unrefTimer(helloTimer);
+			tryResolve();
+		};
+		const onMessage = (raw) => {
+			(async () => {
+				const parsed = await safeParseJSON({
+					text: webSocketMessageToString(raw),
+					schema: harnessV1BridgeHelloSchema
+				});
+				if (!parsed.success || settled) return;
+				hello = parsed.value;
+				tryResolve();
+			})();
+		};
+		const onClose = (code) => {
+			fail(code === UNAUTHORIZED_CLOSE_CODE ? new BridgeWebSocketUnauthorizedError(`The harness bridge rejected the WebSocket connection as unauthorized (code ${code}).`) : /* @__PURE__ */ new Error(`The harness bridge closed the WebSocket (code ${code}) before sending bridge-hello.`));
+		};
+		const onError = (error) => fail(error);
+		const onAbort = () => fail(getAbortReason({ abortSignal }));
+		ws.on("open", onOpen);
+		ws.on("message", onMessage);
+		ws.on("close", onClose);
+		ws.on("error", onError);
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+		openTimer = setTimeout(() => fail(/* @__PURE__ */ new Error(`The harness bridge WebSocket did not open within ${openTimeoutMs}ms.`)), openTimeoutMs);
+		unrefTimer(openTimer);
+	});
+}
+function getAbortReason({ abortSignal }) {
+	return abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+}
+function unrefTimer(timer) {
+	timer.unref?.();
+}
+function webSocketMessageToString(raw) {
+	if (typeof raw === "string") return raw;
+	if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+	if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
+	if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
+	if (ArrayBuffer.isView(raw)) return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString("utf8");
+	return String(raw);
+}
+//#endregion
 //#region src/utils/bridge-asset.ts
 function createReadBridgeAsset(assetUrls) {
 	return async (name) => readFile(assetUrls[name], "utf8");
@@ -2018,57 +2288,6 @@ function getRestrictedSandboxSession(sandboxSession) {
 	return "restricted" in sandboxSession ? sandboxSession.restricted() : sandboxSession;
 }
 //#endregion
-//#region src/errors/harness-error.ts
-const name$2 = "AI_HarnessError";
-const marker$1 = `vercel.ai.error.${name$2}`;
-const symbol$1 = Symbol.for(marker$1);
-/**
-* Base error type for failures originating in or signalled by a harness
-* adapter. Specific failure modes (e.g. unsupported capability) extend this
-* class.
-*/
-var HarnessError = class extends AISDKError {
-	constructor({ message, cause }) {
-		super({
-			name: name$2,
-			message,
-			cause
-		});
-		this[symbol$1] = true;
-	}
-	static isInstance(error) {
-		return AISDKError.hasMarker(error, marker$1);
-	}
-};
-//#endregion
-//#region src/errors/harness-capability-unsupported-error.ts
-const name$1 = "AI_HarnessCapabilityUnsupportedError";
-const marker = `vercel.ai.error.${name$1}`;
-const symbol = Symbol.for(marker);
-/**
-* Thrown when a caller asks the harness to do something the adapter (or the
-* supplied sandbox) does not support, e.g. requesting manual compaction from
-* an adapter that only auto-compacts, or invoking `getPortEndpoint` on a
-* sandbox that does not expose one.
-*
-* The caller supplies the full human-readable message. Optional `harnessId`
-* is recorded as structured context for tooling.
-*/
-var HarnessCapabilityUnsupportedError = class extends HarnessError {
-	constructor({ message, harnessId, cause }) {
-		super({
-			message,
-			cause
-		});
-		this[symbol] = true;
-		Object.defineProperty(this, "name", { value: name$1 });
-		this.harnessId = harnessId;
-	}
-	static isInstance(error) {
-		return AISDKError.hasMarker(error, marker);
-	}
-};
-//#endregion
 //#region src/utils/normalize-harness-tool-model-output.ts
 function normalizeHarnessToolModelOutput({ output }) {
 	try {
@@ -2260,6 +2479,6 @@ function convertHarnessToolModelOutput({ output }) {
 	}
 }
 //#endregion
-export { SandboxChannel, applyCredentialForwarding, classifyDiskLog, convertHarnessToolModelOutput, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, extractHarnessPromptContent, formatBridgeError, forwardBridgeProcessStream, generateSandboxCredentialPlaceholder, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, harnessPromptContentSchema, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isSandboxCredentialPlaceholder, isWindows, logBridgeError, markBridgeStarting, maskSandboxCredentials, normalizeHarnessToolModelOutput, parseJwtPayload, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveSandboxCredentialEnvironment, resolveSandboxDefaultWorkingDirectory, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeInstructions, writeSkills };
+export { SandboxChannel, applyCredentialForwarding, classifyDiskLog, convertHarnessToolModelOutput, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createBridgeWebSocketConnect, createCredentialRequestTransformation, createReadBridgeAsset, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, extractHarnessPromptContent, formatBridgeError, forwardBridgeProcessStream, generateSandboxCredentialPlaceholder, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, harnessPromptContentSchema, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isSandboxCredentialPlaceholder, isWindows, logBridgeError, markBridgeStarting, maskSandboxCredentials, normalizeHarnessToolModelOutput, parseJwtPayload, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveBridgeEndpoint, resolveBridgePort, resolveSandboxCredentialEnvironment, resolveSandboxDefaultWorkingDirectory, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, validateBridgeSandboxSettings, waitForBridgeReady, warnCredentialBrokeringUnavailable, writeInstructions, writeSkills };
 
 //# sourceMappingURL=index.js.map