Agent Host: show reconnect backoff and offer a manual retry

While a protocol client waits out its exponential backoff the banner now reads
"Reconnecting to <host> in 5s" and counts down, with a Try Now action that skips
the remaining delay.

Try Now accelerates the client's in-place retry rather than redialling, so the
outbox and session state survive. It falls back to a fresh dial only when there
is no client to accelerate, which happens now that a rejected factory retains a
client-less entry.

The backoff deadline travels on the `reconnecting` status. The client stays in
that state across rounds, so the deadline is refreshed through a dedicated
`onDidScheduleReconnect` event rather than by re-firing the connection-state
event: consumers of that event do real work per transition, and repeating it
each round would have unclear blast radius.

Also offers a Retry action on the generic "Cannot reach <host>" state, on both
the banner and the centered recovery surface. A tunnel that dies is usually
transient. This stays manual: unlike a stopped WSL distro there is nothing local
to start, so retrying automatically would only hammer an unreachable endpoint.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: connor4312

src/vs/platform/agentHost/browser/agentHostProtocolClient.ts

@@ -156,6 +156,8 @@ interface IReconnectState {
 	attempt: number;
 	/** Timer for the next scheduled attempt, if any. */
 	timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+	/** Deadline for the next scheduled attempt, if any. */
+	nextAttemptAt: number | undefined;
 }
 
 /**
@@ -256,6 +258,8 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 
 	private readonly _onDidChangeConnectionState = this._register(new Emitter<AgentHostClientState>());
 	readonly onDidChangeConnectionState = this._onDidChangeConnectionState.event;
+	private readonly _onDidScheduleReconnect = this._register(new Emitter<void>());
+	readonly onDidScheduleReconnect = this._onDidScheduleReconnect.event;
 
 	/**
 	 * Discriminated state union. Read via narrowing (`_state.kind === ...`);
@@ -329,6 +333,13 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		return this._state.kind;
 	}
 
+	/** Deadline for the next scheduled reconnect attempt, if one is pending. */
+	get nextReconnectAt(): number | undefined {
+		return this._state.kind === AgentHostClientState.Reconnecting
+			? this._state.reconnect.nextAttemptAt
+			: undefined;
+	}
+
 	/**
 	 * The latest `initialize` response from the host, or `undefined` if
 	 * the handshake has not completed yet. Exposed observably so callers can
@@ -456,6 +467,14 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		if (this._state.kind === next.kind) {
 			return;
 		}
+		if (this._state.kind === AgentHostClientState.Reconnecting) {
+			const reconnect = this._state.reconnect;
+			if (reconnect.timeoutHandle !== undefined) {
+				clearTimeout(reconnect.timeoutHandle);
+				reconnect.timeoutHandle = undefined;
+			}
+			reconnect.nextAttemptAt = undefined;
+		}
 		this._state = next;
 		this._onDidChangeConnectionState.fire(next.kind);
 	}
@@ -470,7 +489,7 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 	}
 
 	private _newReconnectState(): IReconnectState {
-		return { gate: this._newReconnectGate(), outbox: [], attempt: 0, timeoutHandle: undefined };
+		return { gate: this._newReconnectGate(), outbox: [], attempt: 0, timeoutHandle: undefined, nextAttemptAt: undefined };
 	}
 
 	override dispose(): void {
@@ -663,6 +682,24 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		return true;
 	}
 
+	/**
+	 * Skips the remaining backoff and retries immediately. Returns `false` when
+	 * there is no pending retry to accelerate.
+	 */
+	reconnectNow(): boolean {
+		if (this._state.kind !== AgentHostClientState.Reconnecting || this._state.reconnect.timeoutHandle === undefined) {
+			return false;
+		}
+		const reconnect = this._state.reconnect;
+		clearTimeout(reconnect.timeoutHandle);
+		reconnect.timeoutHandle = undefined;
+		reconnect.nextAttemptAt = undefined;
+		reconnect.attempt = 0;
+		this._onDidScheduleReconnect.fire();
+		void this._attemptReconnect();
+		return true;
+	}
+
 	private _scheduleReconnect(userInitiated = false): void {
 		if (this._state.kind !== AgentHostClientState.Reconnecting || !this._transportFactory) {
 			return;
@@ -686,12 +723,15 @@ export class AgentHostProtocolClient extends Disposable implements IAgentConnect
 		const attempt = reconnect.attempt + 1;
 		const delay = computeReconnectDelay(this._reconnectPolicy, attempt);
 		this._logService.info(`[RemoteAgentHostProtocol] Reconnecting to ${this._address} in ${delay}ms (attempt ${attempt}).`);
+		reconnect.nextAttemptAt = Date.now() + delay;
 		reconnect.timeoutHandle = setTimeout(() => {
 			if (this._state.kind === AgentHostClientState.Reconnecting) {
 				this._state.reconnect.timeoutHandle = undefined;
+				this._state.reconnect.nextAttemptAt = undefined;
 			}
 			void this._attemptReconnect();
 		}, delay);
+		this._onDidScheduleReconnect.fire();
 	}
 
 	private async _attemptReconnect(): Promise<void> {

src/vs/platform/agentHost/browser/remoteAgentHostServiceImpl.ts

@@ -365,6 +365,17 @@ export class RemoteAgentHostService extends Disposable implements IRemoteAgentHo
 		void this._connectTo(entryToReconnect, { userInitiated });
 	}
 
+	/**
+	 * Skips a protocol client's pending backoff, or starts a fresh user-initiated dial.
+	 */
+	reconnectNow(address: string): void {
+		const normalized = normalizeRemoteAgentHostAddress(address);
+		if (this._entries.get(normalized)?.client?.reconnectNow()) {
+			return;
+		}
+		this.reconnect(normalized, true);
+	}
+
 	async waitForConnection(address: string): Promise<IRemoteAgentHostConnectionInfo> {
 		if (this._store.isDisposed) {
 			throw new Error('Remote agent host service is disposed.');
@@ -650,14 +661,23 @@ export class RemoteAgentHostService extends Disposable implements IRemoteAgentHo
 
 		// Surface self-healing transport drops separately so outer reconnect
 		// loops do not replace the protocol client while it restores itself.
+		store.add(client.onDidScheduleReconnect(() => {
+			// The client stays `reconnecting` across backoff rounds, so only this
+			// event reports that the deadline moved.
+			if (!isCurrentEntry() || entry.status.kind !== 'reconnecting') {
+				return;
+			}
+			entry.status = RemoteAgentHostConnectionStatus.reconnectingUntil(client.nextReconnectAt);
+			this._onDidChangeConnections.fire();
+		}));
 		store.add(client.onDidChangeConnectionState(state => {
 			if (!isCurrentEntry()) {
 				return;
 			}
 			switch (state) {
 				case 'reconnecting':
 					entry.connected = false;
-					entry.status = RemoteAgentHostConnectionStatus.reconnecting;
+					entry.status = RemoteAgentHostConnectionStatus.reconnectingUntil(client.nextReconnectAt);
 					this._onDidChangeConnections.fire();
 					break;
 				case 'connected':

src/vs/platform/agentHost/common/remoteAgentHostService.ts

@@ -36,7 +36,11 @@ export type RemoteAgentHostConnectionStatus =
 	 * preserving session state. Distinct from `connecting` (initial dial) and
 	 * `disconnected` (no connection, nothing in flight).
 	 */
-	| { readonly kind: 'reconnecting' }
+	| {
+		readonly kind: 'reconnecting';
+		/** When the next automatic attempt fires, if one is scheduled. Absent while an attempt is in flight. */
+		readonly nextAttemptAt?: number;
+	}
 	| { readonly kind: 'disconnected'; readonly reason: AgentHostTransportFailureReason }
 	| {
 		readonly kind: 'incompatible';
@@ -62,6 +66,12 @@ export namespace RemoteAgentHostConnectionStatus {
 	export const connecting: RemoteAgentHostConnectionStatus = Object.freeze({ kind: 'connecting' });
 	/** Singleton "reconnecting" status. */
 	export const reconnecting: RemoteAgentHostConnectionStatus = Object.freeze({ kind: 'reconnecting' });
+	/** Build a reconnecting status carrying its backoff deadline. */
+	export function reconnectingUntil(nextAttemptAt: number | undefined): RemoteAgentHostConnectionStatus {
+		return nextAttemptAt === undefined
+			? reconnecting
+			: Object.freeze({ kind: 'reconnecting', nextAttemptAt });
+	}
 	/** Singleton "disconnected" status. */
 	export const disconnected: RemoteAgentHostConnectionStatus = Object.freeze({ kind: 'disconnected', reason: AgentHostTransportFailureReason.Unknown });
 	/** Build a disconnected status with a machine-readable reason. */
@@ -250,9 +260,20 @@ export type RemoteAgentHostProtocolClientState = 'connecting' | 'incompatible' |
  */
 export interface IRemoteAgentHostProtocolClient extends IAgentConnection, IDisposable {
 	readonly defaultDirectory: string | undefined;
+	/** Deadline for the next scheduled reconnect attempt, if one is pending. */
+	readonly nextReconnectAt: number | undefined;
 	readonly onDidClose: Event<AgentHostTransportFailureReason | undefined>;
 	readonly onDidChangeConnectionState: Event<RemoteAgentHostProtocolClientState>;
+	/**
+	 * Fires whenever the pending reconnect schedule changes — a backoff being
+	 * armed, or cleared by an immediate retry. Separate from
+	 * {@link onDidChangeConnectionState} because the client state is still
+	 * `reconnecting` throughout, and consumers of that event do real work on
+	 * each transition that must not be repeated per backoff round.
+	 */
+	readonly onDidScheduleReconnect: Event<void>;
 	connect(): Promise<void>;
+	reconnectNow(): boolean;
 	notifyTransportClosed(): void;
 	triggerVscodeUpgrade(method: string): Promise<IVscodeUpgradeResult>;
 }
@@ -711,6 +732,12 @@ export interface IRemoteAgentHostService {
 	 * with reset backoff.
 	 */
 	reconnect(address: string, userInitiated?: boolean): void;
+	/**
+	 * Skips a pending reconnect backoff for this address and retries at once.
+	 * Prefers the protocol client's in-place retry, which preserves session
+	 * state, and falls back to a fresh dial when there is no client to accelerate.
+	 */
+	reconnectNow(address: string): void;
 
 	/**
 	 * Force the protocol client at `address` (if any) to treat its
@@ -775,6 +802,7 @@ export class NullRemoteAgentHostService implements IRemoteAgentHostService {
 	}
 	async removeRemoteAgentHost(_address: string): Promise<void> { }
 	reconnect(_address: string, _userInitiated?: boolean): void { }
+	reconnectNow(_address: string): void { }
 	notifyConnectionClosed(_address: string): void { }
 	getEntryByAddress(): IRemoteAgentHostEntry | undefined { return undefined; }
 	async triggerServerUpgrade(): Promise<IVscodeUpgradeResult> {

src/vs/platform/agentHost/test/electron-browser/agentHostProtocolClient.test.ts

@@ -2439,6 +2439,74 @@ suite('AgentHostProtocolClient', () => {
 			});
 		});
 
+		test('reports the deadline for each scheduled reconnect backoff', async function () {
+			this.timeout(10_000);
+			return runWithFakedTimers({ useFakeTimers: true, maxTaskCount: 10_000 }, async () => {
+				const reconnectPolicy: IRemoteAgentHostReconnectPolicy = {
+					autoRestore: true,
+					initialDelayMs: 60_000,
+					maxDelayMs: 60_000,
+					maxAttempts: 3,
+				};
+				const { client, transports } = createFactoryClient(createPermissionService(), undefined, NullTelemetryService, reconnectPolicy);
+				const connectPromise = client.connect();
+				await completeHandshake(transports[0], connectPromise);
+				const reconnectDeadlines: (number | undefined)[] = [];
+				const stateListener = client.onDidChangeConnectionState(state => {
+					if (state === AgentHostClientState.Reconnecting) {
+						reconnectDeadlines.push(client.nextReconnectAt);
+					}
+				});
+
+				transports[0].fireClose();
+				const firstDeadline = client.nextReconnectAt;
+				assert.ok(firstDeadline !== undefined);
+				await timeout(reconnectPolicy.initialDelayMs);
+				transports[1].connectDeferred.error(new Error('reconnect failed'));
+				await flushMicrotasks();
+				const secondDeadline = client.nextReconnectAt;
+				assert.ok(secondDeadline !== undefined);
+
+				assert.deepStrictEqual(reconnectDeadlines, [undefined, firstDeadline, secondDeadline]);
+				stateListener.dispose();
+				client.dispose();
+			});
+		});
+
+		test('reconnectNow clears a pending backoff and retries immediately', async function () {
+			this.timeout(10_000);
+			return runWithFakedTimers({ useFakeTimers: true, maxTaskCount: 10_000 }, async () => {
+				const reconnectPolicy: IRemoteAgentHostReconnectPolicy = {
+					autoRestore: true,
+					initialDelayMs: 60_000,
+					maxDelayMs: 60_000,
+					maxAttempts: 3,
+				};
+				const { client, transports } = createFactoryClient(createPermissionService(), undefined, NullTelemetryService, reconnectPolicy);
+				const connectPromise = client.connect();
+				await completeHandshake(transports[0], connectPromise);
+
+				transports[0].fireClose();
+				assert.strictEqual(client.reconnectNow(), true);
+				await timeout(reconnectPolicy.initialDelayMs - 1);
+
+				assert.deepStrictEqual({
+					nextReconnectAt: client.nextReconnectAt,
+					transportCount: transports.length,
+				}, {
+					nextReconnectAt: undefined,
+					transportCount: 2,
+				});
+				client.dispose();
+			});
+		});
+
+		test('reconnectNow returns false when no reconnect backoff is pending', () => {
+			const { client } = createFactoryClient();
+
+			assert.strictEqual(client.reconnectNow(), false);
+		});
+
 		test('does not automatically reconnect when the policy disables automatic restore', async () => {
 			const reconnectPolicy: IRemoteAgentHostReconnectPolicy = {
 				autoRestore: false,