@ai-sdk/harness 1.0.133 → 1.0.135

package/dist/utils/index.d.ts

@@ -1,6 +1,8 @@
-import { FlexibleSchema, Experimental_SandboxSession, Experimental_SandboxProcess } from '@ai-sdk/provider-utils';
-import { WebSocket } from 'ws';
-
+import { Experimental_SandboxProcess, Experimental_SandboxSession, FlexibleSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+import { WebSocket } from "ws";
+import "@ai-sdk/provider";
+//#region src/utils/sandbox-channel.d.ts
 /**
  * Diagnostic event surfaced by {@link SandboxChannel} during its connection
  * lifecycle. Silent unless a consumer wires `onDebug`. Reconnects are otherwise
@@ -8,74 +10,74 @@ import { WebSocket } from 'ws';
  * streaming.
  */
 type SandboxChannelDebugEvent = {
-    event: 'reconnect-attempt';
-    attempt: number;
-    lastSeenEventId: number;
+  event: 'reconnect-attempt';
+  attempt: number;
+  lastSeenEventId: number;
 } | {
-    event: 'reconnected';
-    attempt: number;
-    lastSeenEventId: number;
+  event: 'reconnected';
+  attempt: number;
+  lastSeenEventId: number;
 } | {
-    event: 'reconnect-failed';
-    attempts: number;
-    lastSeenEventId: number;
-    cause: unknown;
+  event: 'reconnect-failed';
+  attempts: number;
+  lastSeenEventId: number;
+  cause: unknown;
 };
 interface SandboxChannelReconnectOptions {
-    /**
-     * 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;
+  /**
+   * 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;
+  readonly abortSignal: AbortSignal;
 }
 interface SandboxChannelOptions<TOut> {
-    /**
-     * Open a fresh WebSocket to the bridge and resolve once it is ready to carry
-     * frames (i.e. after any adapter-specific handshake such as Claude Code's
-     * `bridge-hello`). Called once by {@link SandboxChannel.open} and again on
-     * every transient reconnect. Must reject if the connection cannot be
-     * established.
-     */
-    connect: (options: SandboxChannelConnectOptions) => Promise<WebSocket>;
-    /** Schema validating inbound (bridge → host) frames. */
-    outboundSchema: FlexibleSchema<TOut>;
-    reconnect?: SandboxChannelReconnectOptions;
-    onDebug?: (event: SandboxChannelDebugEvent) => void;
-    /**
-     * Sink for forwarded bridge diagnostics — `sandbox-log` (captured
-     * console lines) and `debug-event` (structured) frames. When set, these
-     * frame types are routed here instead of the per-type listener dispatch, so
-     * they never reach the consumer's stream. Typed to the diagnostic members of
-     * `TOut`, so it is a no-op union for channels whose protocol has none.
-     */
-    onDiagnostic?: (event: Extract<TOut, {
-        type: 'sandbox-log' | 'debug-event';
-    }>) => void;
-    onBridgeError?: (event: Extract<TOut, {
-        type: 'error';
-    }>) => void;
-    /**
-     * Seed the host-side cursor before the first connect. Pass the
-     * `lastSeenEventId` persisted from a prior process so the bridge replays only
-     * events past it when this channel opens with `{ resume: true }` — the
-     * cross-process attach handshake. Defaults to `0` (fresh session).
-     */
-    initialLastSeenEventId?: number;
+  /**
+   * Open a fresh WebSocket to the bridge and resolve once it is ready to carry
+   * frames (i.e. after any adapter-specific handshake such as Claude Code's
+   * `bridge-hello`). Called once by {@link SandboxChannel.open} and again on
+   * every transient reconnect. Must reject if the connection cannot be
+   * established.
+   */
+  connect: (options: SandboxChannelConnectOptions) => Promise<WebSocket>;
+  /** Schema validating inbound (bridge → host) frames. */
+  outboundSchema: FlexibleSchema<TOut>;
+  reconnect?: SandboxChannelReconnectOptions;
+  onDebug?: (event: SandboxChannelDebugEvent) => void;
+  /**
+   * Sink for forwarded bridge diagnostics — `sandbox-log` (captured
+   * console lines) and `debug-event` (structured) frames. When set, these
+   * frame types are routed here instead of the per-type listener dispatch, so
+   * they never reach the consumer's stream. Typed to the diagnostic members of
+   * `TOut`, so it is a no-op union for channels whose protocol has none.
+   */
+  onDiagnostic?: (event: Extract<TOut, {
+    type: 'sandbox-log' | 'debug-event';
+  }>) => void;
+  onBridgeError?: (event: Extract<TOut, {
+    type: 'error';
+  }>) => void;
+  /**
+   * Seed the host-side cursor before the first connect. Pass the
+   * `lastSeenEventId` persisted from a prior process so the bridge replays only
+   * events past it when this channel opens with `{ resume: true }` — the
+   * cross-process attach handshake. Defaults to `0` (fresh session).
+   */
+  initialLastSeenEventId?: number;
 }
 type EventTypeOf<TOut extends {
-    type: string;
+  type: string;
 }> = TOut['type'];
 type Listener<TOut extends {
-    type: string;
+  type: string;
 }, T extends EventTypeOf<TOut>> = (event: Extract<TOut, {
-    type: T;
+  type: T;
 }>) => void;
 /**
  * Host-side typed wrapper around the bridge WebSocket connection.
@@ -100,148 +102,150 @@ type Listener<TOut extends {
  * in-flight turn never observes the blip — `onClose` fires only after a
  * host-initiated close or once the reconnect budget is exhausted.
  */
-declare class SandboxChannel<TOut extends {
-    type: string;
+export declare class SandboxChannel<TOut extends {
+  type: string;
 }, TIn extends {
-    type: string;
+  type: string;
 } = {
-    type: string;
+  type: string;
 }> {
-    private readonly listeners;
-    private readonly buffered;
-    private readonly bufferedByType;
-    private bufferedOffset;
-    private flushingBuffered;
-    private bufferedFlushScheduled;
-    private listenerAttachmentDepth;
-    private readonly onCloseHandlers;
-    private readonly onReconnectHandlers;
-    private readonly connectThunk;
-    private readonly outboundSchema;
-    private readonly onDebug;
-    private readonly onDiagnostic;
-    private readonly onBridgeError;
-    private readonly maxElapsedMs;
-    private readonly initialDelayMs;
-    private readonly maxDelayMs;
-    private ws;
-    private connected;
-    /** Host has begun teardown; suppresses reconnect so a bridge-side close finalises. */
-    private closing;
-    /**
-     * Host has gracefully suspended (slice boundary). Inbound frames are ignored
-     * from this point so the cursor stops advancing exactly at the last delivered
-     * event — the bridge keeps the turn running and the not-yet-delivered tail is
-     * replayed to the next process on `resume`.
-     */
-    private suspended;
-    private pinnedSuspensionCursor;
-    /** Channel is fully torn down; `send` throws and `onClose` has fired. */
-    private terminal;
-    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
-     * the adapter's resume handle) so a future process can seed
-     * {@link SandboxChannelOptions.initialLastSeenEventId} and attach.
-     */
-    get lastSeenEventId(): number;
-    /**
-     * Establish the initial connection. A single attempt — startup failures
-     * reject so the caller can fail `doStart` cleanly. Reconnect retries apply
-     * only to drops after a successful open.
-     *
-     * Pass `{ resume: true }` to attach to a bridge that is already mid-session:
-     * after the socket opens, the channel sends `{ type: 'resume', lastSeenEventId }`
-     * so the bridge replays everything past the seeded cursor. This is the
-     * cross-process attach handshake — identical to what a transient reconnect
-     * does, but triggered by the initial open from a new process.
-     */
-    open(opts?: {
-        resume?: boolean;
-    }): Promise<void>;
-    on<T extends EventTypeOf<TOut>>(type: T, listener: Listener<TOut, T>): () => void;
-    /**
-     * Hold buffered event delivery while a consumer attaches a related set of
-     * listeners, including across asynchronous boundaries. Call the returned
-     * function once registration is complete. Buffered events are then replayed
-     * in arrival order; event types that remain unhandled are retained
-     * independently so they do not block subscribed types.
-     */
-    beginListenerAttachment(): () => void;
-    onClose(handler: (code: number, reason: string) => void): void;
-    onReconnect(handler: () => void): () => void;
-    send(message: TIn): void;
-    /**
-     * Mark that the host is tearing the session down. The next socket close is
-     * then treated as terminal rather than triggering a reconnect. Call before
-     * sending a `stop` / `destroy` message whose completion closes the bridge
-     * socket.
-     */
-    beginClose(): void;
-    close(): void;
-    /**
-     * Gracefully suspend at a slice boundary: stop processing inbound frames
-     * (so the cursor freezes at the last delivered event), drain any frames
-     * already queued for dispatch, then close the socket and finalise with the
-     * close reason `'suspended'`. Resolves with the final `lastSeenEventId`.
-     *
-     * The bridge keeps the in-flight turn running (a host socket close never
-     * aborts it) and accumulates events past the cursor for the next process to
-     * `resume`. Unlike {@link close}, the consumer's active turn is wound down
-     * cleanly — adapters distinguish a suspend from an unexpected drop via the
-     * `'suspended'` close reason and resolve `done` successfully. When an event
-     * checkpoint is pinned, the returned cursor points to that event so any
-     * already-dispatched tail is replayed by the next process.
-     */
-    suspend(): Promise<number>;
-    isClosed(): boolean;
-    private wire;
-    private reconnectLoop;
-    private connect;
-    private abortActiveConnect;
-    private failReconnect;
-    private rawSend;
-    private flushPending;
-    private enqueue;
-    private handleIncoming;
-    private dispatch;
-    private flushBuffered;
-    private captureBufferedListeners;
-    private flushBufferedType;
-    private scheduleSelectiveBufferedFlush;
-    private hasListeners;
-    private attachEventCheckpoint;
-    private finalizeClose;
+  private readonly listeners;
+  private readonly buffered;
+  private readonly bufferedByType;
+  private bufferedOffset;
+  private flushingBuffered;
+  private bufferedFlushScheduled;
+  private listenerAttachmentDepth;
+  private readonly onCloseHandlers;
+  private readonly onReconnectHandlers;
+  private readonly connectThunk;
+  private readonly outboundSchema;
+  private readonly onDebug;
+  private readonly onDiagnostic;
+  private readonly onBridgeError;
+  private readonly maxElapsedMs;
+  private readonly initialDelayMs;
+  private readonly maxDelayMs;
+  private ws;
+  private connected;
+  /** Host has begun teardown; suppresses reconnect so a bridge-side close finalises. */
+  private closing;
+  /**
+   * Host has gracefully suspended (slice boundary). Inbound frames are ignored
+   * from this point so the cursor stops advancing exactly at the last delivered
+   * event — the bridge keeps the turn running and the not-yet-delivered tail is
+   * replayed to the next process on `resume`.
+   */
+  private suspended;
+  private pinnedSuspensionCursor;
+  /** Channel is fully torn down; `send` throws and `onClose` has fired. */
+  private terminal;
+  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
+   * the adapter's resume handle) so a future process can seed
+   * {@link SandboxChannelOptions.initialLastSeenEventId} and attach.
+   */
+  get lastSeenEventId(): number;
+  /**
+   * Establish the initial connection. A single attempt — startup failures
+   * reject so the caller can fail `doStart` cleanly. Reconnect retries apply
+   * only to drops after a successful open.
+   *
+   * Pass `{ resume: true }` to attach to a bridge that is already mid-session:
+   * after the socket opens, the channel sends `{ type: 'resume', lastSeenEventId }`
+   * so the bridge replays everything past the seeded cursor. This is the
+   * cross-process attach handshake — identical to what a transient reconnect
+   * does, but triggered by the initial open from a new process.
+   */
+  open(opts?: {
+    resume?: boolean;
+  }): Promise<void>;
+  on<T extends EventTypeOf<TOut>>(type: T, listener: Listener<TOut, T>): () => void;
+  /**
+   * Hold buffered event delivery while a consumer attaches a related set of
+   * listeners, including across asynchronous boundaries. Call the returned
+   * function once registration is complete. Buffered events are then replayed
+   * in arrival order; event types that remain unhandled are retained
+   * independently so they do not block subscribed types.
+   */
+  beginListenerAttachment(): () => void;
+  onClose(handler: (code: number, reason: string) => void): void;
+  onReconnect(handler: () => void): () => void;
+  send(message: TIn): void;
+  /**
+   * Mark that the host is tearing the session down. The next socket close is
+   * then treated as terminal rather than triggering a reconnect. Call before
+   * sending a `stop` / `destroy` message whose completion closes the bridge
+   * socket.
+   */
+  beginClose(): void;
+  close(): void;
+  /**
+   * Gracefully suspend at a slice boundary: stop processing inbound frames
+   * (so the cursor freezes at the last delivered event), drain any frames
+   * already queued for dispatch, then close the socket and finalise with the
+   * close reason `'suspended'`. Resolves with the final `lastSeenEventId`.
+   *
+   * The bridge keeps the in-flight turn running (a host socket close never
+   * aborts it) and accumulates events past the cursor for the next process to
+   * `resume`. Unlike {@link close}, the consumer's active turn is wound down
+   * cleanly — adapters distinguish a suspend from an unexpected drop via the
+   * `'suspended'` close reason and resolve `done` successfully. When an event
+   * checkpoint is pinned, the returned cursor points to that event so any
+   * already-dispatched tail is replayed by the next process.
+   */
+  suspend(): Promise<number>;
+  isClosed(): boolean;
+  private wire;
+  private reconnectLoop;
+  private connect;
+  private abortActiveConnect;
+  private failReconnect;
+  private rawSend;
+  private flushPending;
+  private enqueue;
+  private handleIncoming;
+  private dispatch;
+  private flushBuffered;
+  private captureBufferedListeners;
+  private flushBufferedType;
+  private scheduleSelectiveBufferedFlush;
+  private hasListeners;
+  private attachEventCheckpoint;
+  private finalizeClose;
 }
-
+//#endregion
+//#region src/utils/bridge-user-message-submitter.d.ts
 type Experimental_BridgeUserMessageRequest = {
-    type: 'user-message';
-    messageId: string;
-    text: string;
+  type: 'user-message';
+  messageId: string;
+  text: string;
 };
 type Experimental_BridgeUserMessageResponse = {
-    type: 'user-message-response';
-    messageId: string;
-    accepted: boolean;
-    error?: {
-        message: string;
-    };
+  type: 'user-message-response';
+  messageId: string;
+  accepted: boolean;
+  error?: {
+    message: string;
+  };
 };
 type Experimental_BridgeUserMessageSubmitter = {
-    submit(text: string): Promise<void>;
-    close(error?: unknown): void;
+  submit(text: string): Promise<void>;
+  close(error?: unknown): void;
 };
-declare function experimental_createBridgeUserMessageSubmitter(options: {
-    send(message: Experimental_BridgeUserMessageRequest): void;
-    onResponse(listener: (response: Experimental_BridgeUserMessageResponse) => void): () => void;
-    onReconnect(listener: () => void): () => void;
+export declare function experimental_createBridgeUserMessageSubmitter(options: {
+  send(message: Experimental_BridgeUserMessageRequest): void;
+  onResponse(listener: (response: Experimental_BridgeUserMessageResponse) => void): () => void;
+  onReconnect(listener: () => void): () => void;
 }): Experimental_BridgeUserMessageSubmitter;
-
+//#endregion
+//#region src/utils/classify-disk-log.d.ts
 /**
  * Recovery rung selected from an on-disk bridge event log when attach is not
  * possible (the bridge process is gone): `'replay'` when the log holds a
@@ -260,15 +264,17 @@ type DiskLogRecoveryMode = 'replay' | 'rerun';
  * @param eventLog Raw contents of `event-log.ndjson` (newline-delimited JSON),
  *   or `null`/`undefined`/empty when the file is absent.
  */
-declare function classifyDiskLog(eventLog: string | null | undefined): Promise<DiskLogRecoveryMode>;
-
-declare function getAiGatewayAuthFromEnv({ env, }: {
-    env: Record<string, string | undefined>;
+export declare function classifyDiskLog(eventLog: string | null | undefined): Promise<DiskLogRecoveryMode>;
+//#endregion
+//#region src/utils/ai-gateway-auth.d.ts
+export declare function getAiGatewayAuthFromEnv({ env }: {
+  env: Record<string, string | undefined>;
 }): {
-    apiKey: string | undefined;
-    baseUrl: string;
+  apiKey: string | undefined;
+  baseUrl: string;
 };
-
+//#endregion
+//#region src/v1/harness-authentication.d.ts
 /**
  * Authentication-related environment variables supplied directly to a harness.
  *
@@ -280,73 +286,80 @@ type HarnessV1AuthenticationEnvironment = Readonly<Record<string, string>>;
  * Authentication options shared by harness adapters. Adapter choices must be
  * a non-empty union of concrete string values.
  */
-type HarnessV1Authentication<ADAPTER_CHOICES extends string = 'direct'> = [
-    ADAPTER_CHOICES
-] extends [never] ? never : string extends ADAPTER_CHOICES ? never : 'auto' | 'ai-gateway' | ADAPTER_CHOICES | HarnessV1AuthenticationEnvironment;
-
-declare function isHarnessAuthenticationEnvironment(value: unknown): value is HarnessV1AuthenticationEnvironment;
-
-declare function parseJwtPayload({ token, }: {
-    token: string;
+type HarnessV1Authentication<ADAPTER_CHOICES extends string = 'direct'> = [ADAPTER_CHOICES] extends [never] ? never : string extends ADAPTER_CHOICES ? never : 'auto' | 'ai-gateway' | ADAPTER_CHOICES | HarnessV1AuthenticationEnvironment;
+//#endregion
+//#region src/utils/authentication-environment.d.ts
+export declare function isHarnessAuthenticationEnvironment(value: unknown): value is HarnessV1AuthenticationEnvironment;
+//#endregion
+//#region src/utils/native-subscription/jwt.d.ts
+export declare function parseJwtPayload({ token }: {
+  token: string;
 }): Promise<Readonly<Record<string, unknown>> | undefined>;
-declare function getJwtExpiresAt({ token, }: {
-    token: string;
+export declare function getJwtExpiresAt({ token }: {
+  token: string;
 }): Promise<number | undefined>;
-
-declare function readLinuxSecretServicePassword({ attributes, }: {
-    attributes: Readonly<Record<string, string>>;
+//#endregion
+//#region src/utils/native-subscription/linux-secret-service.d.ts
+export declare function readLinuxSecretServicePassword({ attributes }: {
+  attributes: Readonly<Record<string, string>>;
 }): Promise<string | undefined>;
-
-declare function readMacOSKeychainPassword({ service, account, }: {
-    service: string;
-    account: string;
+//#endregion
+//#region src/utils/native-subscription/macos-keychain.d.ts
+export declare function readMacOSKeychainPassword({ service, account }: {
+  service: string;
+  account: string;
 }): Promise<string | undefined>;
-
-declare function shouldResolveNativeSubscription({ auth, env, hasDirectCredential, }: {
-    auth: Extract<HarnessV1Authentication, string> | undefined;
-    env: Readonly<Record<string, string | undefined>>;
-    hasDirectCredential: boolean;
+//#endregion
+//#region src/utils/native-subscription/should-resolve-native.d.ts
+export declare function shouldResolveNativeSubscription({ auth, env, hasDirectCredential }: {
+  auth: Extract<HarnessV1Authentication, string> | undefined;
+  env: Readonly<Record<string, string | undefined>>;
+  hasDirectCredential: boolean;
 }): boolean;
-
-declare function readWindowsCredentialManagerPassword({ targetName, }: {
-    targetName: string;
+//#endregion
+//#region src/utils/native-subscription/windows-credential-manager.d.ts
+export declare function readWindowsCredentialManagerPassword({ targetName }: {
+  targetName: string;
 }): Promise<string | undefined>;
-
+//#endregion
+//#region src/utils/oauth-access-token.d.ts
 type OAuthCredential = {
-    readonly accessToken: string;
-    readonly refreshToken: string;
-    readonly expiresAt: number;
+  readonly accessToken: string;
+  readonly refreshToken: string;
+  readonly expiresAt: number;
 };
 type RefreshOAuthAccessTokenResult = {
-    readonly accessToken: string;
-    readonly expiresAt: number;
-    readonly refreshToken?: string;
+  readonly accessToken: string;
+  readonly expiresAt: number;
+  readonly refreshToken?: string;
 };
-declare function isAccessTokenExpiringSoon({ expiresAt, now, refreshWindowMs, }: {
-    readonly expiresAt: number;
-    readonly now?: number;
-    readonly refreshWindowMs?: number;
+export declare function isAccessTokenExpiringSoon({ expiresAt, now, refreshWindowMs }: {
+  readonly expiresAt: number;
+  readonly now?: number;
+  readonly refreshWindowMs?: number;
 }): boolean;
-declare function refreshOAuthAccessToken({ tokenUrl, clientId, refreshToken, requestFormat, headers, fetch: fetchImplementation, }: {
-    readonly tokenUrl: string;
-    readonly clientId: string;
-    readonly refreshToken: string;
-    readonly requestFormat?: 'json' | 'form';
-    readonly headers?: Record<string, string>;
-    readonly fetch?: typeof globalThis.fetch;
+export declare function refreshOAuthAccessToken({ tokenUrl, clientId, refreshToken, requestFormat, headers, fetch: fetchImplementation }: {
+  readonly tokenUrl: string;
+  readonly clientId: string;
+  readonly refreshToken: string;
+  readonly requestFormat?: 'json' | 'form';
+  readonly headers?: Record<string, string>;
+  readonly fetch?: typeof globalThis.fetch;
 }): Promise<RefreshOAuthAccessTokenResult>;
-
-declare function isMacOS(platform: NodeJS.Platform): boolean;
-declare function isLinux(platform: NodeJS.Platform): boolean;
-declare function isWindows(platform: NodeJS.Platform): boolean;
-
+//#endregion
+//#region src/utils/os.d.ts
+export declare function isMacOS(platform: NodeJS.Platform): boolean;
+export declare function isLinux(platform: NodeJS.Platform): boolean;
+export declare function isWindows(platform: NodeJS.Platform): boolean;
+//#endregion
+//#region src/v1/harness-v1-network-sandbox-session.d.ts
 /**
  * Connection details for a sandbox-exposed port. Headers are scoped to the
  * returned URL and must be included when opening the connection.
  */
 type HarnessV1PortEndpoint = {
-    readonly url: string;
-    readonly headers?: Readonly<Record<string, string>>;
+  readonly url: string;
+  readonly headers?: Readonly<Record<string, string>>;
 };
 /**
  * Network sandbox session returned by sandbox adapter creation and resume
@@ -360,94 +373,94 @@ type HarnessV1PortEndpoint = {
  * network access, or transform requests.
  */
 interface HarnessV1NetworkSandboxSession extends Experimental_SandboxSession {
-    /**
-     * Identifier for the sandbox session. Persist this separately from the
-     * harness session ID and resume state when reattaching across processes.
-     */
-    readonly id: string;
-    /**
-     * The sandbox's default working directory — the absolute path that
-     * `run`/`spawn` resolve relative commands against when no `workingDirectory`
-     * is given. Read from the live sandbox, never hardcoded.
-     *
-     * The framework composes each session's working directory underneath this
-     * path (`<defaultWorkingDirectory>/<harnessId>-<sessionId>`) so adapters do
-     * not bake a provider-specific base into their own paths.
-     */
-    readonly defaultWorkingDirectory: string;
-    /** Ports the sandbox exposes; resolvable via `getPortEndpoint`. */
-    readonly ports: ReadonlyArray<number>;
-    /**
-     * Resolve the connection details for a sandbox-exposed port. Bridge-backed
-     * adapters call this to open their WebSocket to the in-sandbox bridge.
-     */
-    readonly getPortEndpoint: (options: {
-        port: number;
-        protocol?: 'http' | 'https' | 'ws';
-    }) => PromiseLike<HarnessV1PortEndpoint>;
-    /**
-     * Resolve a publicly-reachable URL for a sandbox-exposed port.
-     *
-     * @deprecated Use `getPortEndpoint` instead.
-     */
-    readonly getPortUrl: (options: {
-        port: number;
-        protocol?: 'http' | 'https' | 'ws';
-    }) => PromiseLike<string>;
-    /** Stop the sandbox. Idempotent. */
-    readonly stop: () => PromiseLike<void>;
-    /**
-     * Stop the sandbox session, then perform any additional cleanup necessary
-     * to destroy it, such as deleting its backing resource or freeing resources.
-     * Implementations with no cleanup beyond stopping may delegate to `stop()`.
-     * Implementations must handle both a still-running sandbox and a previously
-     * stopped sandbox.
-     */
-    readonly destroy: () => PromiseLike<void>;
-    /**
-     * Update the sandbox's outbound network policy. Optional — implementations
-     * without a local enforcement primitive omit this. Callers
-     * use optional-call (`sandboxSession.setNetworkPolicy?.(policy)`); a
-     * missing implementation is a no-op.
-     */
-    readonly setNetworkPolicy?: (policy: HarnessV1NetworkPolicy) => PromiseLike<void>;
-    /**
-     * Replace the sandbox's outbound request-transformation rules. Optional —
-     * implementations expose this only when credentials can be injected outside
-     * the sandbox security boundary. Calling this method assumes authority over
-     * the complete transformation set; harness adapters should normally use
-     * `addRequestTransformations` instead. Adapters may preserve legacy
-     * credential-forwarding behavior when additive request transformations are
-     * unavailable.
-     */
-    readonly setRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
-    /**
-     * Add outbound request-transformation rules without replacing rules already
-     * managed by the sandbox session. Optional for the same reason as
-     * `setRequestTransformations`. Harness adapters should use this additive
-     * capability unless they explicitly own the complete transformation set.
-     */
-    readonly addRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
-    /**
-     * Replace the set of ports exposed by the sandbox. Full-replacement
-     * semantics: ports omitted from the array are deregistered. Optional —
-     * implementations that cannot expose ports omit this.
-     */
-    readonly setPorts?: (ports: ReadonlyArray<number>, options?: {
-        abortSignal?: AbortSignal;
-    }) => PromiseLike<void>;
-    /**
-     * Reduced view of this session, typed as the bare {@link SandboxSession}
-     * (file I/O, exec, spawn) — nothing that could stop the sandbox or change
-     * its network policy. Pass this to user-tool `execute()` calls and other
-     * code that must not reach the infra surface.
-     *
-     * The returned object points at exactly the same underlying sandbox
-     * resource as the network sandbox session it was produced from; it is only a
-     * narrower surface over the same resource, not a separate sandbox. In
-     * particular, it cannot mutate network access or request transformations.
-     */
-    readonly restricted: () => Experimental_SandboxSession;
+  /**
+   * Identifier for the sandbox session. Persist this separately from the
+   * harness session ID and resume state when reattaching across processes.
+   */
+  readonly id: string;
+  /**
+   * The sandbox's default working directory — the absolute path that
+   * `run`/`spawn` resolve relative commands against when no `workingDirectory`
+   * is given. Read from the live sandbox, never hardcoded.
+   *
+   * The framework composes each session's working directory underneath this
+   * path (`<defaultWorkingDirectory>/<harnessId>-<sessionId>`) so adapters do
+   * not bake a provider-specific base into their own paths.
+   */
+  readonly defaultWorkingDirectory: string;
+  /** Ports the sandbox exposes; resolvable via `getPortEndpoint`. */
+  readonly ports: ReadonlyArray<number>;
+  /**
+   * Resolve the connection details for a sandbox-exposed port. Bridge-backed
+   * adapters call this to open their WebSocket to the in-sandbox bridge.
+   */
+  readonly getPortEndpoint: (options: {
+    port: number;
+    protocol?: 'http' | 'https' | 'ws';
+  }) => PromiseLike<HarnessV1PortEndpoint>;
+  /**
+   * Resolve a publicly-reachable URL for a sandbox-exposed port.
+   *
+   * @deprecated Use `getPortEndpoint` instead.
+   */
+  readonly getPortUrl: (options: {
+    port: number;
+    protocol?: 'http' | 'https' | 'ws';
+  }) => PromiseLike<string>;
+  /** Stop the sandbox. Idempotent. */
+  readonly stop: () => PromiseLike<void>;
+  /**
+   * Stop the sandbox session, then perform any additional cleanup necessary
+   * to destroy it, such as deleting its backing resource or freeing resources.
+   * Implementations with no cleanup beyond stopping may delegate to `stop()`.
+   * Implementations must handle both a still-running sandbox and a previously
+   * stopped sandbox.
+   */
+  readonly destroy: () => PromiseLike<void>;
+  /**
+   * Update the sandbox's outbound network policy. Optional — implementations
+   * without a local enforcement primitive omit this. Callers
+   * use optional-call (`sandboxSession.setNetworkPolicy?.(policy)`); a
+   * missing implementation is a no-op.
+   */
+  readonly setNetworkPolicy?: (policy: HarnessV1NetworkPolicy) => PromiseLike<void>;
+  /**
+   * Replace the sandbox's outbound request-transformation rules. Optional —
+   * implementations expose this only when credentials can be injected outside
+   * the sandbox security boundary. Calling this method assumes authority over
+   * the complete transformation set; harness adapters should normally use
+   * `addRequestTransformations` instead. Adapters may preserve legacy
+   * credential-forwarding behavior when additive request transformations are
+   * unavailable.
+   */
+  readonly setRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
+  /**
+   * Add outbound request-transformation rules without replacing rules already
+   * managed by the sandbox session. Optional for the same reason as
+   * `setRequestTransformations`. Harness adapters should use this additive
+   * capability unless they explicitly own the complete transformation set.
+   */
+  readonly addRequestTransformations?: (transformations: ReadonlyArray<HarnessV1RequestTransformation>) => PromiseLike<void>;
+  /**
+   * Replace the set of ports exposed by the sandbox. Full-replacement
+   * semantics: ports omitted from the array are deregistered. Optional —
+   * implementations that cannot expose ports omit this.
+   */
+  readonly setPorts?: (ports: ReadonlyArray<number>, options?: {
+    abortSignal?: AbortSignal;
+  }) => PromiseLike<void>;
+  /**
+   * Reduced view of this session, typed as the bare {@link SandboxSession}
+   * (file I/O, exec, spawn) — nothing that could stop the sandbox or change
+   * its network policy. Pass this to user-tool `execute()` calls and other
+   * code that must not reach the infra surface.
+   *
+   * The returned object points at exactly the same underlying sandbox
+   * resource as the network sandbox session it was produced from; it is only a
+   * narrower surface over the same resource, not a separate sandbox. In
+   * particular, it cannot mutate network access or request transformations.
+   */
+  readonly restricted: () => Experimental_SandboxSession;
 }
 /**
  * Outbound network policy applied by the sandbox runtime.
@@ -465,37 +478,37 @@ interface HarnessV1NetworkSandboxSession extends Experimental_SandboxSession {
  * equivalent to `'deny-all'`.
  */
 type HarnessV1NetworkPolicy = {
-    mode: 'allow-all';
+  mode: 'allow-all';
 } | {
-    mode: 'deny-all';
+  mode: 'deny-all';
 } | {
-    mode: 'custom';
-    allowedHosts: ReadonlyArray<string>;
-    allowedCIDRs?: ReadonlyArray<string>;
-    deniedCIDRs?: ReadonlyArray<string>;
+  mode: 'custom';
+  allowedHosts: ReadonlyArray<string>;
+  allowedCIDRs?: ReadonlyArray<string>;
+  deniedCIDRs?: ReadonlyArray<string>;
 } | {
-    mode: 'custom';
-    allowedHosts?: ReadonlyArray<string>;
-    allowedCIDRs: ReadonlyArray<string>;
-    deniedCIDRs?: ReadonlyArray<string>;
+  mode: 'custom';
+  allowedHosts?: ReadonlyArray<string>;
+  allowedCIDRs: ReadonlyArray<string>;
+  deniedCIDRs?: ReadonlyArray<string>;
 };
 type HarnessV1RequestTransformationPathMatcher = {
-    exact: string;
+  exact: string;
 } | {
-    startsWith: string;
+  startsWith: string;
 } | {
-    regex: string;
+  regex: string;
 };
 type HarnessV1RequestTransformationKeyValuePartMatcher = {
-    exact: string;
+  exact: string;
 } | {
-    startsWith: string;
+  startsWith: string;
 } | {
-    regex: string;
+  regex: string;
 };
 type HarnessV1RequestTransformationKeyValueMatcher = {
-    readonly key?: HarnessV1RequestTransformationKeyValuePartMatcher;
-    readonly value?: HarnessV1RequestTransformationKeyValuePartMatcher;
+  readonly key?: HarnessV1RequestTransformationKeyValuePartMatcher;
+  readonly value?: HarnessV1RequestTransformationKeyValuePartMatcher;
 };
 /**
  * Outbound HTTPS request transformation applied outside the sandbox security
@@ -509,50 +522,52 @@ type HarnessV1RequestTransformationKeyValueMatcher = {
  * making transformed values available inside it.
  */
 type HarnessV1RequestTransformation = {
-    readonly match: {
-        readonly host: string;
-        readonly path?: HarnessV1RequestTransformationPathMatcher;
-        readonly method?: ReadonlyArray<string>;
-        readonly queryString?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
-        readonly headers?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
-    };
-    readonly transform: {
-        readonly headers: Readonly<Record<string, string>>;
-    };
+  readonly match: {
+    readonly host: string;
+    readonly path?: HarnessV1RequestTransformationPathMatcher;
+    readonly method?: ReadonlyArray<string>;
+    readonly queryString?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
+    readonly headers?: ReadonlyArray<HarnessV1RequestTransformationKeyValueMatcher>;
+  };
+  readonly transform: {
+    readonly headers: Readonly<Record<string, string>>;
+  };
 };
-
+//#endregion
+//#region src/v1/harness-v1-skill.d.ts
 /**
  * A self-contained instruction bundle the underlying runtime can load into
  * its context. Adapters decide how to surface skills to the runtime.
  */
 type HarnessV1Skill = {
-    /** Stable identifier for the skill (kebab-case slug). */
-    readonly name: string;
-    /**
-     * Short, model-facing description. This is what the runtime sees to
-     * decide whether the skill is relevant.
-     */
-    readonly description: string;
-    /** Full skill content the model loads when the skill is active. */
-    readonly content: string;
-    /**
-     * Additional files that belong to this skill. Adapters with native skill
-     * directories materialize these next to `SKILL.md`; adapters without native
-     * skill files include them with the skill content.
-     */
-    readonly files?: ReadonlyArray<HarnessV1SkillFile>;
+  /** Stable identifier for the skill (kebab-case slug). */
+  readonly name: string;
+  /**
+   * Short, model-facing description. This is what the runtime sees to
+   * decide whether the skill is relevant.
+   */
+  readonly description: string;
+  /** Full skill content the model loads when the skill is active. */
+  readonly content: string;
+  /**
+   * Additional files that belong to this skill. Adapters with native skill
+   * directories materialize these next to `SKILL.md`; adapters without native
+   * skill files include them with the skill content.
+   */
+  readonly files?: ReadonlyArray<HarnessV1SkillFile>;
 };
 type HarnessV1SkillFile = {
-    /**
-     * Skill-relative POSIX path, for example `reference.md` or
-     * `references/codes.md`. Absolute paths and `..` segments are rejected by
-     * adapters before writing.
-     */
-    readonly path: string;
-    /** UTF-8 text content for the file. */
-    readonly content: string;
+  /**
+   * Skill-relative POSIX path, for example `reference.md` or
+   * `references/codes.md`. Absolute paths and `..` segments are rejected by
+   * adapters before writing.
+   */
+  readonly path: string;
+  /** UTF-8 text content for the file. */
+  readonly content: string;
 };
-
+//#endregion
+//#region src/v1/harness-v1-credential-forwarding.d.ts
 /**
  * Customizes a credential value immediately before a harness adapter forwards
  * it into a sandbox process.
@@ -562,175 +577,189 @@ type HarnessV1SkillFile = {
  * otherwise access in the host process.
  */
 type HarnessV1CredentialForwarding = (options: {
-    /**
-     * The credential value that the adapter would otherwise forward. This is a
-     * generated sandbox placeholder when credential brokering is available and
-     * the real credential otherwise. Use `isSandboxCredentialPlaceholder` from
-     * `@ai-sdk/harness/utils` to distinguish generated placeholders.
-     */
-    readonly credential: string;
-    /** The environment variable name used to expose the value in the sandbox. */
-    readonly environmentVariableName: string;
+  /**
+   * The credential value that the adapter would otherwise forward. This is a
+   * generated sandbox placeholder when credential brokering is available and
+   * the real credential otherwise. Use `isSandboxCredentialPlaceholder` from
+   * `@ai-sdk/harness/utils` to distinguish generated placeholders.
+   */
+  readonly credential: string;
+  /** The environment variable name used to expose the value in the sandbox. */
+  readonly environmentVariableName: string;
 }) => string | PromiseLike<string>;
-
-declare function applyCredentialForwarding({ environment, credentialEnvironmentVariables, credentialForwarding, }: {
-    environment: Readonly<Record<string, string>>;
-    credentialEnvironmentVariables: ReadonlyArray<string>;
-    credentialForwarding: HarnessV1CredentialForwarding | undefined;
+//#endregion
+//#region src/utils/credential-forwarding.d.ts
+export declare function applyCredentialForwarding({ environment, credentialEnvironmentVariables, credentialForwarding }: {
+  environment: Readonly<Record<string, string>>;
+  credentialEnvironmentVariables: ReadonlyArray<string>;
+  credentialForwarding: HarnessV1CredentialForwarding | undefined;
 }): Promise<Record<string, string>>;
-declare function resolveSandboxCredentialEnvironment({ environment, credentialEnvironmentVariables, credentialForwarding, previousSandboxCredentialEnvironment, }: {
-    environment: Readonly<Record<string, string>>;
-    credentialEnvironmentVariables: ReadonlyArray<string>;
-    credentialForwarding: HarnessV1CredentialForwarding | undefined;
-    previousSandboxCredentialEnvironment?: Readonly<Record<string, string>>;
+export declare function resolveSandboxCredentialEnvironment({ environment, credentialEnvironmentVariables, credentialForwarding, previousSandboxCredentialEnvironment }: {
+  environment: Readonly<Record<string, string>>;
+  credentialEnvironmentVariables: ReadonlyArray<string>;
+  credentialForwarding: HarnessV1CredentialForwarding | undefined;
+  previousSandboxCredentialEnvironment?: Readonly<Record<string, string>>;
 }): Promise<Record<string, string>>;
-
-declare function generateSandboxCredentialPlaceholder(): string;
-declare function isSandboxCredentialPlaceholder(value: string): boolean;
+//#endregion
+//#region src/utils/sandbox-credential-brokering.d.ts
+export declare function generateSandboxCredentialPlaceholder(): string;
+export declare function isSandboxCredentialPlaceholder(value: string): boolean;
 /**
  * Warns when credential brokering is unavailable, but only if real credentials
  * remain among the credentials forwarded into the sandbox.
  */
-declare function warnCredentialBrokeringUnavailable(options: {
-    environment: Readonly<Record<string, string>>;
-    forwardedEnvironment: Readonly<Record<string, string>>;
-    credentialEnvironmentVariables: ReadonlyArray<string>;
+export declare function warnCredentialBrokeringUnavailable(options: {
+  environment: Readonly<Record<string, string>>;
+  forwardedEnvironment: Readonly<Record<string, string>>;
+  credentialEnvironmentVariables: ReadonlyArray<string>;
 }): void;
-declare function maskSandboxCredentials({ environment, credentialEnvironmentVariables, }: {
-    environment: Readonly<Record<string, string>>;
-    credentialEnvironmentVariables: ReadonlyArray<string>;
+export declare function maskSandboxCredentials({ environment, credentialEnvironmentVariables }: {
+  environment: Readonly<Record<string, string>>;
+  credentialEnvironmentVariables: ReadonlyArray<string>;
 }): Record<string, string>;
-declare function createCredentialRequestTransformation({ matchUrl, matchHeaders, transformHeaders, }: {
-    matchUrl: string;
-    matchHeaders: Readonly<Record<string, string>>;
-    transformHeaders: Readonly<Record<string, string>>;
+export declare function createCredentialRequestTransformation({ matchUrl, matchHeaders, transformHeaders }: {
+  matchUrl: string;
+  matchHeaders: Readonly<Record<string, string>>;
+  transformHeaders: Readonly<Record<string, string>>;
 }): HarnessV1RequestTransformation;
-
-declare function resolveSandboxHomeDir({ sandbox, abortSignal, }: {
-    sandbox: Experimental_SandboxSession;
-    abortSignal?: AbortSignal;
+//#endregion
+//#region src/utils/sandbox-home-dir.d.ts
+export declare function resolveSandboxHomeDir({ sandbox, abortSignal }: {
+  sandbox: Experimental_SandboxSession;
+  abortSignal?: AbortSignal;
 }): Promise<string>;
-
-declare function shellQuote(value: string): string;
-
+//#endregion
+//#region src/utils/shell-quote.d.ts
+export declare function shellQuote(value: string): string;
+//#endregion
+//#region src/utils/write-instructions.d.ts
 type WriteInstructionsOptions = {
-    sandbox: Experimental_SandboxSession;
-    homePath: string;
-    instructionsFile: string;
-    instructions?: string;
-    abortSignal?: AbortSignal;
+  sandbox: Experimental_SandboxSession;
+  homePath: string;
+  instructionsFile: string;
+  instructions?: string;
+  abortSignal?: AbortSignal;
 };
 type WriteInstructionsResult = {
-    changed: boolean;
-    filePath: string;
+  changed: boolean;
+  filePath: string;
 };
-declare function writeInstructions({ sandbox, homePath, instructionsFile, instructions, abortSignal, }: WriteInstructionsOptions): Promise<WriteInstructionsResult>;
-
+export declare function writeInstructions({ sandbox, homePath, instructionsFile, instructions, abortSignal }: WriteInstructionsOptions): Promise<WriteInstructionsResult>;
+//#endregion
+//#region src/utils/write-skills.d.ts
 type SkillFilePathMode = 'relative' | 'strip-leading-slashes';
 type WriteSkillsOptions = {
-    sandbox: Experimental_SandboxSession;
-    homePath: string;
-    skillsDir: string;
-    skills: ReadonlyArray<HarnessV1Skill>;
-    abortSignal?: AbortSignal;
-    skillNamePattern?: RegExp;
-    invalidSkillNameMessage?: (input: {
-        name: string;
-    }) => string;
-    filePathMode?: SkillFilePathMode;
-    invalidSkillFilePathMessage?: (input: {
-        skillName: string;
-        filePath: string;
-    }) => string;
-    trailingNewline?: boolean;
+  sandbox: Experimental_SandboxSession;
+  homePath: string;
+  skillsDir: string;
+  skills: ReadonlyArray<HarnessV1Skill>;
+  abortSignal?: AbortSignal;
+  skillNamePattern?: RegExp;
+  invalidSkillNameMessage?: (input: {
+    name: string;
+  }) => string;
+  filePathMode?: SkillFilePathMode;
+  invalidSkillFilePathMessage?: (input: {
+    skillName: string;
+    filePath: string;
+  }) => string;
+  trailingNewline?: boolean;
 };
 type WriteSkillsResult = {
-    changed: boolean;
-    written: string[];
-    removed: string[];
-    unchanged: string[];
+  changed: boolean;
+  written: string[];
+  removed: string[];
+  unchanged: string[];
 };
-declare function writeSkills({ sandbox, homePath, skillsDir, skills, abortSignal, skillNamePattern, invalidSkillNameMessage, filePathMode, invalidSkillFilePathMessage, trailingNewline, }: WriteSkillsOptions): Promise<WriteSkillsResult>;
-
+export declare function writeSkills({ sandbox, homePath, skillsDir, skills, abortSignal, skillNamePattern, invalidSkillNameMessage, filePathMode, invalidSkillFilePathMessage, trailingNewline }: WriteSkillsOptions): Promise<WriteSkillsResult>;
+//#endregion
+//#region src/utils/bridge-ready.d.ts
 type BridgeReadySource = 'stdout' | 'metadata';
 type BridgeReadyErrorContext = {
-    proc: Experimental_SandboxProcess;
-    stdoutTail: string[];
+  proc: Experimental_SandboxProcess;
+  stdoutTail: string[];
 };
 type WaitForBridgeReadyOptions = {
-    proc: Experimental_SandboxProcess;
-    sandbox: Experimental_SandboxSession;
-    bridgeStateDir: string;
-    bridgeType: string;
-    timeoutMs: number;
-    abortSignal?: AbortSignal;
-    pollIntervalMs?: number;
-    createTimeoutError?: (context: BridgeReadyErrorContext) => Error | Promise<Error>;
-    createExitError?: (context: BridgeReadyErrorContext) => Error | Promise<Error>;
+  proc: Experimental_SandboxProcess;
+  sandbox: Experimental_SandboxSession;
+  bridgeStateDir: string;
+  bridgeType: string;
+  timeoutMs: number;
+  abortSignal?: AbortSignal;
+  pollIntervalMs?: number;
+  createTimeoutError?: (context: BridgeReadyErrorContext) => Error | Promise<Error>;
+  createExitError?: (context: BridgeReadyErrorContext) => Error | Promise<Error>;
 };
 type WaitForBridgeReadyResult = {
-    port: number;
-    source: BridgeReadySource;
-    stdoutTail: string[];
+  port: number;
+  source: BridgeReadySource;
+  stdoutTail: string[];
 };
-declare function markBridgeStarting({ sandbox, bridgeStateDir, bridgeType, abortSignal, }: {
-    sandbox: Experimental_SandboxSession;
-    bridgeStateDir: string;
-    bridgeType: string;
-    abortSignal?: AbortSignal;
+export declare function markBridgeStarting({ sandbox, bridgeStateDir, bridgeType, abortSignal }: {
+  sandbox: Experimental_SandboxSession;
+  bridgeStateDir: string;
+  bridgeType: string;
+  abortSignal?: AbortSignal;
 }): Promise<void>;
-declare function waitForBridgeReady({ proc, sandbox, bridgeStateDir, bridgeType, timeoutMs, abortSignal, pollIntervalMs, createTimeoutError, createExitError, }: WaitForBridgeReadyOptions): Promise<WaitForBridgeReadyResult>;
-
-declare function createBridgeToken(): string;
-declare function withBridgeToken({ endpoint, token, }: {
-    endpoint: HarnessV1PortEndpoint;
-    token: string;
+export declare function waitForBridgeReady({ proc, sandbox, bridgeStateDir, bridgeType, timeoutMs, abortSignal, pollIntervalMs, createTimeoutError, createExitError }: WaitForBridgeReadyOptions): Promise<WaitForBridgeReadyResult>;
+//#endregion
+//#region src/utils/bridge-token.d.ts
+export declare function createBridgeToken(): string;
+export declare function withBridgeToken({ endpoint, token }: {
+  endpoint: HarnessV1PortEndpoint;
+  token: string;
 }): HarnessV1PortEndpoint;
-
-declare function createReadBridgeAsset<const ASSET_URLS extends Record<string, URL>>(assetUrls: ASSET_URLS): (name: Extract<keyof ASSET_URLS, string>) => Promise<string>;
-
+//#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>;
+//#endregion
+//#region src/utils/bridge-diagnostics.d.ts
 type BridgeProcessStreamName = 'stdout' | 'stderr';
-declare function formatBridgeError(error: unknown): string;
-declare function logBridgeError({ harnessId, sessionId, context, error, write, }: {
-    harnessId: string;
-    sessionId?: string;
-    context?: string;
-    error: unknown;
-    write?: (line: string) => void;
+export declare function formatBridgeError(error: unknown): string;
+export declare function logBridgeError({ harnessId, sessionId, context, error, write }: {
+  harnessId: string;
+  sessionId?: string;
+  context?: string;
+  error: unknown;
+  write?: (line: string) => void;
 }): void;
-declare function createBridgeErrorHandler({ harnessId, sessionId, }: {
-    harnessId: string;
-    sessionId?: string;
+export declare function createBridgeErrorHandler({ harnessId, sessionId }: {
+  harnessId: string;
+  sessionId?: string;
 }): (event: {
-    type: 'error';
-    error: unknown;
+  type: 'error';
+  error: unknown;
 }) => void;
-declare function createBridgeStartupError({ message, proc, stdoutTail, stderrTail, stderrDone, }: {
-    message: string;
-    proc: Experimental_SandboxProcess;
-    stdoutTail: string[];
-    stderrTail: string[];
-    stderrDone?: Promise<void>;
+export declare function createBridgeStartupError({ message, proc, stdoutTail, stderrTail, stderrDone }: {
+  message: string;
+  proc: Experimental_SandboxProcess;
+  stdoutTail: string[];
+  stderrTail: string[];
+  stderrDone?: Promise<void>;
 }): Promise<Error>;
-declare function forwardBridgeProcessStream({ stream, streamName, source, collectTail, tailLimit, }: {
-    stream: ReadableStream<Uint8Array>;
-    streamName: BridgeProcessStreamName;
-    source?: string;
-    collectTail?: string[];
-    tailLimit?: number;
+export declare function forwardBridgeProcessStream({ stream, streamName, source, collectTail, tailLimit }: {
+  stream: ReadableStream<Uint8Array>;
+  streamName: BridgeProcessStreamName;
+  source?: string;
+  collectTail?: string[];
+  tailLimit?: number;
 }): Promise<void>;
-declare function drainBridgeProcessStream(stream: ReadableStream<Uint8Array>): Promise<void>;
-
-declare function resolveSandboxDefaultWorkingDirectory({ sandboxSession, abortSignal, }: {
-    readonly sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
-    readonly abortSignal?: AbortSignal;
+export declare function drainBridgeProcessStream(stream: ReadableStream<Uint8Array>): Promise<void>;
+//#endregion
+//#region src/utils/resolve-sandbox-default-working-directory.d.ts
+export declare function resolveSandboxDefaultWorkingDirectory({ sandboxSession, abortSignal }: {
+  readonly sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession;
+  readonly abortSignal?: AbortSignal;
 }): Promise<string>;
-
-declare function getRestrictedSandboxSession(sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession): Experimental_SandboxSession;
-
-declare function sleep({ ms, abortSignal, }: {
-    ms: number;
-    abortSignal?: AbortSignal;
+//#endregion
+//#region src/utils/get-restricted-sandbox-session.d.ts
+export declare function getRestrictedSandboxSession(sandboxSession: HarnessV1NetworkSandboxSession | Experimental_SandboxSession): Experimental_SandboxSession;
+//#endregion
+//#region src/utils/sleep.d.ts
+export 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, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, formatBridgeError, forwardBridgeProcessStream, generateSandboxCredentialPlaceholder, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isSandboxCredentialPlaceholder, isWindows, logBridgeError, markBridgeStarting, maskSandboxCredentials, parseJwtPayload, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveSandboxCredentialEnvironment, resolveSandboxDefaultWorkingDirectory, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeInstructions, writeSkills };
+//#endregion
+export type { BridgeReadyErrorContext, BridgeReadySource, DiskLogRecoveryMode, Experimental_BridgeUserMessageRequest, Experimental_BridgeUserMessageResponse, Experimental_BridgeUserMessageSubmitter, OAuthCredential, RefreshOAuthAccessTokenResult, SandboxChannelConnectOptions, SandboxChannelDebugEvent, SandboxChannelOptions, SandboxChannelReconnectOptions, SkillFilePathMode, WaitForBridgeReadyOptions, WaitForBridgeReadyResult, WriteInstructionsOptions, WriteInstructionsResult, WriteSkillsOptions, WriteSkillsResult };
+//# sourceMappingURL=index.d.ts.map