@codingame/monaco-vscode-chat-service-override 32.0.2 → 33.0.4

package/vscode/src/vs/platform/agentHost/browser/remoteAgentHostProtocolClient.js

@@ -1,9 +1,9 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { IntervalTimer, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { TimeoutTimer, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -11,29 +11,36 @@ import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { toFileSystemProviderErrorCode, FileSystemProviderErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { AgentSession } from '../common/agentService.js';
 import { AgentSubscriptionManager } from '../common/state/agentSubscription.js';
 import { agentHostAuthority, fromAgentHostUri, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { AgentHostPermissionMode } from '../common/agentHostPermissionService.js';
 import { IAgentHostPermissionService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostPermissionService.service';
-import { ActionType } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/actions';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/actions';
 import '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/notifications';
-import { ROOT_STATE_URI } from '@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState';
+import { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import { PROTOCOL_VERSION } from '../common/state/protocol/version/registry.js';
 import { ProtocolError, isJsonRpcRequest, isJsonRpcResponse, isJsonRpcNotification } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol';
 import { isClientTransport } from '../common/state/sessionTransport.js';
 import { AhpErrorCodes } from '../common/state/protocol/errors.js';
-import { ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
+import { ReconnectResultType, ContentEncoding } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands';
 import { decodeBase64, VSBuffer, encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { LoadEstimator } from '@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc.net';
+import { TELEMETRY_SETTING_ID, TELEMETRY_OLD_SETTING_ID, TELEMETRY_CRASH_REPORTER_SETTING_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry';
+import { getTelemetryLevel } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetryUtils';
+import { AgentHostTelemetryLevelConfigKey, telemetryLevelToAgentHostConfigValue } from '../common/agentHostSchema.js';
 import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state';
 
 const AHP_CLIENT_CONNECTION_CLOSED = -32e3;
-const WATCHDOG_CHECK_INTERVAL_MS = 5_000;
-const WATCHDOG_TIMEOUT_MS = 20_000;
-function connectionTimeoutError(address, sinceLastReadMs, oldestRequestAgeMs) {
+const RECONNECT_INITIAL_DELAY_MS = 1_000;
+const RECONNECT_MAX_DELAY_MS = 30_000;
+const PING_INTERVAL_MS = 5_000;
+const LIVENESS_TIMEOUT_MS = 20_000;
+function connectionTimeoutError(address, silenceMs) {
     return ( new ProtocolError(
         AHP_CLIENT_CONNECTION_CLOSED,
-        `Connection appears dead: ${address}; no message received for ${sinceLastReadMs}ms, oldest pending request is ${oldestRequestAgeMs}ms old.`
+        `Connection appears dead: ${address}; no message received for ${silenceMs}ms.`
     ));
 }
 function connectionClosedError(address) {
@@ -42,6 +49,16 @@ function connectionClosedError(address) {
 function connectionDisposedError(address) {
     return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Connection disposed: ${address}`));
 }
+function transportLostError(address) {
+    return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Transport lost (reconnecting): ${address}`));
+}
+var AgentHostClientState;
+(function(AgentHostClientState) {
+    AgentHostClientState["Connecting"] = "connecting";
+    AgentHostClientState["Connected"] = "connected";
+    AgentHostClientState["Reconnecting"] = "reconnecting";
+    AgentHostClientState["Closed"] = "closed";
+})(AgentHostClientState || (AgentHostClientState = {}));
 let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends Disposable {
     get clientId() {
         return this._clientId;
@@ -52,12 +69,25 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     get defaultDirectory() {
         return this._defaultDirectory;
     }
-    constructor(address, transport, _logService, _fileService, _permissionService) {
+    get connectionState() {
+        return this._state.kind;
+    }
+    constructor(
+        address,
+        transportOrFactory,
+        loadEstimator,
+        _logService,
+        _fileService,
+        _permissionService,
+        _configurationService
+    ) {
         super();
         this._logService = _logService;
         this._fileService = _fileService;
         this._permissionService = _permissionService;
+        this._configurationService = _configurationService;
         this._clientId = generateUuid();
+        this._transportListeners = this._register(( new MutableDisposable()));
         this._serverSeq = 0;
         this._nextClientSeq = 1;
         this._completionTriggerCharacters = [];
@@ -67,20 +97,27 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         this.onDidNotification = this._onDidNotification.event;
         this._onDidClose = this._register(( new Emitter()));
         this.onDidClose = this._onDidClose.event;
+        this._onDidChangeConnectionState = this._register(( new Emitter()));
+        this.onDidChangeConnectionState = this._onDidChangeConnectionState.event;
+        this._state = {
+            kind: AgentHostClientState.Connecting
+        };
         this._pendingRequests = ( new Map());
         this._nextRequestId = 1;
-        this._isClosed = false;
         this._lastReadTime = Date.now();
-        this._watchdog = this._register(( new IntervalTimer()));
+        this._pingTimer = this._register(new TimeoutTimer());
+        this._closeTimer = this._register(new TimeoutTimer());
         this._grantedCustomizationUris = ( new Set());
         this._address = address;
         this._connectionAuthority = agentHostAuthority(address);
-        this._transport = transport;
-        this._register(this._transport);
-        this._register(this._transport.onMessage(msg => this._handleMessage(msg)));
-        this._register(
-            this._transport.onClose(() => this._handleClose(connectionClosedError(this._address)))
-        );
+        this._loadEstimator = loadEstimator ?? LoadEstimator.getInstance();
+        if (typeof transportOrFactory === "function") {
+            this._transportFactory = transportOrFactory;
+            this._installTransport(transportOrFactory());
+        } else {
+            this._transportFactory = undefined;
+            this._installTransport(transportOrFactory);
+        }
         this._subscriptionManager = this._register(( new AgentSubscriptionManager(
             this._clientId,
             () => this.nextClientSeq(),
@@ -91,7 +128,43 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         this._register(this.onDidAction(envelope => {
             this._subscriptionManager.receiveEnvelope(envelope);
         }));
-        this._watchdog.cancelAndSet(() => this._watchdogTick(), WATCHDOG_CHECK_INTERVAL_MS);
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(TELEMETRY_SETTING_ID) || e.affectsConfiguration(TELEMETRY_OLD_SETTING_ID) || e.affectsConfiguration(TELEMETRY_CRASH_REPORTER_SETTING_ID)) {
+                if (this._state.kind !== AgentHostClientState.Connected) {
+                    return;
+                }
+                this._updateTelemetryLevel();
+            }
+        }));
+        this._resetLivenessTimers();
+    }
+    _installTransport(transport) {
+        const listeners = ( new DisposableStore());
+        listeners.add(transport);
+        listeners.add(transport.onMessage(msg => this._handleMessage(msg)));
+        listeners.add(transport.onClose(() => this._handleTransportClose()));
+        this._transport = transport;
+        this._transportListeners.value = listeners;
+    }
+    _transitionTo(next) {
+        if (this._state.kind === next.kind) {
+            return;
+        }
+        this._state = next;
+        this._onDidChangeConnectionState.fire(next.kind);
+    }
+    _newReconnectGate() {
+        const deferred = ( new DeferredPromise());
+        deferred.p.then(undefined, () => {});
+        return deferred;
+    }
+    _newReconnectState() {
+        return {
+            gate: this._newReconnectGate(),
+            outbox: [],
+            attempt: 0,
+            timeoutHandle: undefined
+        };
     }
     dispose() {
         this._handleClose(connectionDisposedError(this._address));
@@ -121,6 +194,192 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             }
         }
         this._completionTriggerCharacters = result.completionTriggerCharacters ?? [];
+        this._updateTelemetryLevel();
+        this._transitionTo({
+            kind: AgentHostClientState.Connected
+        });
+    }
+    _handleTransportClose() {
+        switch (this._state.kind) {
+        case AgentHostClientState.Closed:
+            return;
+        case AgentHostClientState.Connecting:
+            this._handleClose(connectionClosedError(this._address));
+            return;
+        case AgentHostClientState.Connected:
+            {
+                if (!this._transportFactory) {
+                    this._handleClose(connectionClosedError(this._address));
+                    return;
+                }
+                this._logService.info(
+                    `[RemoteAgentHostProtocol] Transport lost for ${this._address}; scheduling reconnect.`
+                );
+                this._transitionTo({
+                    kind: AgentHostClientState.Reconnecting,
+                    reconnect: this._newReconnectState()
+                });
+                this._cancelLivenessTimers();
+                this._rejectPendingRequests(transportLostError(this._address));
+                this._scheduleReconnect();
+                return;
+            }
+        case AgentHostClientState.Reconnecting:
+            this._logService.info(
+                `[RemoteAgentHostProtocol] Transport lost for ${this._address} mid-reconnect; aborting the current attempt.`
+            );
+            this._cancelLivenessTimers();
+            this._rejectPendingRequests(transportLostError(this._address));
+            return;
+        }
+    }
+    _scheduleReconnect() {
+        if (this._state.kind !== AgentHostClientState.Reconnecting || !this._transportFactory) {
+            return;
+        }
+        const reconnect = this._state.reconnect;
+        if (reconnect.timeoutHandle !== undefined) {
+            return;
+        }
+        const attempt = reconnect.attempt + 1;
+        const delay = Math.min(
+            RECONNECT_INITIAL_DELAY_MS * Math.pow(2, attempt - 1),
+            RECONNECT_MAX_DELAY_MS
+        );
+        this._logService.info(
+            `[RemoteAgentHostProtocol] Reconnecting to ${this._address} in ${delay}ms (attempt ${attempt}).`
+        );
+        reconnect.timeoutHandle = setTimeout(() => {
+            if (this._state.kind === AgentHostClientState.Reconnecting) {
+                this._state.reconnect.timeoutHandle = undefined;
+            }
+            void this._attemptReconnect();
+        }, delay);
+    }
+    async _attemptReconnect() {
+        if (this._state.kind !== AgentHostClientState.Reconnecting || !this._transportFactory) {
+            return;
+        }
+        const reconnect = this._state.reconnect;
+        reconnect.attempt++;
+        let transport;
+        try {
+            transport = this._transportFactory();
+            this._installTransport(transport);
+            if (isClientTransport(transport)) {
+                await transport.connect();
+            }
+            if (this._state.kind !== AgentHostClientState.Reconnecting) {
+                return;
+            }
+            const subscriptions = ( this._subscriptionManager.currentSubscriptionUris().map(u => ( u.toString())));
+            if (!subscriptions.includes(ROOT_STATE_URI)) {
+                subscriptions.unshift(ROOT_STATE_URI);
+            }
+            const lastSeenServerSeq = this._serverSeq;
+            const result = await this._dispatchRequest("reconnect", {
+                clientId: this._clientId,
+                lastSeenServerSeq,
+                subscriptions
+            }, {
+                bypassReconnectGate: true
+            });
+            if (this._state.kind !== AgentHostClientState.Reconnecting) {
+                return;
+            }
+            this._applyReconnectResult(result);
+            const {
+                gate
+            } = reconnect;
+            this._drainAfterReconnect(reconnect.outbox);
+            this._lastReadTime = Date.now();
+            this._resetLivenessTimers();
+            this._transitionTo({
+                kind: AgentHostClientState.Connected
+            });
+            gate.complete();
+            this._logService.info(`[RemoteAgentHostProtocol] Reconnected to ${this._address}.`);
+        } catch (err) {
+            this._logService.warn(
+                `[RemoteAgentHostProtocol] Reconnect attempt failed for ${this._address}: ${err instanceof Error ? err.message : String(err)}`
+            );
+            transport?.dispose();
+            if (this._state.kind !== AgentHostClientState.Reconnecting) {
+                return;
+            }
+            const oldGate = this._state.reconnect.gate;
+            this._state.reconnect.gate = this._newReconnectGate();
+            oldGate.error(err);
+            this._scheduleReconnect();
+        }
+    }
+    _applyReconnectResult(result) {
+        if (result.type === ReconnectResultType.Replay) {
+            let maxSeq = this._serverSeq;
+            for (const envelope of result.actions) {
+                if (envelope.origin?.clientId === this._clientId && envelope.origin.clientSeq !== undefined && !envelope.rejectionReason && hasKey(envelope.action, {
+                    session: true
+                })) {
+                    this._subscriptionManager.dropPendingSessionAction(envelope.action.session, envelope.origin.clientSeq);
+                }
+                if (envelope.serverSeq > maxSeq) {
+                    maxSeq = envelope.serverSeq;
+                }
+                this._onDidAction.fire(envelope);
+            }
+            this._serverSeq = maxSeq;
+            if (result.missing.length > 0) {
+                this._logService.info(
+                    `[RemoteAgentHostProtocol] Server cannot resume ${result.missing.length} subscription(s) after reconnect.`
+                );
+                this._subscriptionManager.markSubscriptionsMissing(( result.missing.map(u => ( URI.parse(u)))));
+            }
+        } else {
+            let maxSeq = this._serverSeq;
+            for (const snapshot of result.snapshots) {
+                this._subscriptionManager.applyReconnectSnapshot(( URI.parse(snapshot.resource)), snapshot.state, snapshot.fromSeq);
+                if (snapshot.fromSeq > maxSeq) {
+                    maxSeq = snapshot.fromSeq;
+                }
+            }
+            this._serverSeq = maxSeq;
+        }
+    }
+    _drainAfterReconnect(outbox) {
+        const queuedSeqs = ( new Set());
+        for (const msg of outbox) {
+            if (hasKey(msg, {
+                method: true
+            }) && msg.method === "dispatchAction") {
+                queuedSeqs.add(msg.params.clientSeq);
+            }
+        }
+        const replays = [];
+        for (const entry of this._subscriptionManager.getPendingSessionActions()) {
+            if (( queuedSeqs.has(entry.clientSeq))) {
+                continue;
+            }
+            this._grantImplicitReadsForOutgoingAction(entry.action);
+            replays.push({
+                jsonrpc: "2.0",
+                method: "dispatchAction",
+                params: {
+                    clientSeq: entry.clientSeq,
+                    action: entry.action
+                }
+            });
+        }
+        if (replays.length > 0) {
+            this._logService.info(
+                `[RemoteAgentHostProtocol] Replaying ${replays.length} pending action(s) after reconnect to ${this._address}.`
+            );
+        }
+        for (const msg of replays) {
+            this._transport.send(msg);
+        }
+        for (const msg of outbox) {
+            this._transport.send(msg);
+        }
     }
     get rootState() {
         return this._subscriptionManager.rootState;
@@ -191,6 +450,9 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     async completions(params) {
         return this._sendRequest("completions", params);
     }
+    async ping() {
+        await this._sendRequest("ping", {});
+    }
     async getCompletionTriggerCharacters() {
         return this._completionTriggerCharacters;
     }
@@ -283,11 +545,15 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     async resourceMove(params) {
         return this._sendRequest("resourceMove", params);
     }
+    triggerVscodeUpgrade(method) {
+        return this._dispatchRequest(method, {});
+    }
     _handleMessage(msg) {
-        if (this._isClosed) {
+        if (this._state.kind === AgentHostClientState.Closed) {
             return;
         }
         this._lastReadTime = Date.now();
+        this._resetLivenessTimers();
         if (isJsonRpcRequest(msg)) {
             this._handleReverseRequest(msg.id, msg.method, msg.params);
         } else if (isJsonRpcResponse(msg)) {
@@ -332,24 +598,37 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         }
     }
     _handleClose(error) {
-        if (this._isClosed) {
+        if (this._state.kind === AgentHostClientState.Closed) {
             return;
         }
-        this._isClosed = true;
-        this._closeError = error;
-        this._watchdog.cancel();
+        this._cancelLivenessTimers();
+        if (this._state.kind === AgentHostClientState.Reconnecting) {
+            const reconnect = this._state.reconnect;
+            if (reconnect.timeoutHandle !== undefined) {
+                clearTimeout(reconnect.timeoutHandle);
+            }
+            if (!reconnect.gate.isSettled) {
+                reconnect.gate.error(error);
+            }
+        }
         this._rejectPendingRequests(error);
         this._permissionService.connectionClosed(this._address);
         this._grantedCustomizationUris.clear();
+        this._transitionTo({
+            kind: AgentHostClientState.Closed,
+            error
+        });
         this._onDidClose.fire();
     }
     async _raceClose(promise) {
-        if (this._closeError) {
-            return Promise.reject(this._closeError);
+        if (this._state.kind === AgentHostClientState.Closed) {
+            return Promise.reject(this._state.error);
         }
         let closeListener = Disposable.None;
         const closePromise = ( new Promise((_resolve, reject) => {
-            closeListener = this.onDidClose(() => reject(this._closeError));
+            closeListener = this.onDidClose(() => reject(
+                this._state.kind === AgentHostClientState.Closed ? this._state.error : connectionClosedError(this._address)
+            ));
         }));
         try {
             return await Promise.race([promise, closePromise]);
@@ -358,8 +637,9 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         }
     }
     _handleReverseRequest(id, method, params) {
+        const transport = this._transport;
         const sendResult = result => {
-            this._transport.send({
+            transport.send({
                 jsonrpc: "2.0",
                 id,
                 result
@@ -379,7 +659,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 code = AhpErrorCodes.AlreadyExists;
                 break;
             }
-            this._transport.send({
+            transport.send({
                 jsonrpc: "2.0",
                 id,
                 error: {
@@ -389,7 +669,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             });
         };
         const sendPermissionDenied = request => {
-            this._transport.send({
+            transport.send({
                 jsonrpc: "2.0",
                 id,
                 error: {
@@ -541,33 +821,46 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         }
     }
     _sendNotification(method, params) {
-        this._transport.send({
+        if (this._state.kind === AgentHostClientState.Closed) {
+            return;
+        }
+        const message = {
             jsonrpc: "2.0",
             method,
             params
-        });
+        };
+        if (this._state.kind === AgentHostClientState.Reconnecting) {
+            this._state.reconnect.outbox.push(message);
+            return;
+        }
+        this._transport.send(message);
     }
     _sendRequest(method, params) {
-        if (this._closeError) {
-            return Promise.reject(this._closeError);
-        }
-        const id = this._nextRequestId++;
-        const deferred = ( new DeferredPromise());
-        this._pendingRequests.set(id, {
-            deferred,
-            sentAt: Date.now()
-        });
-        this._transport.send({
-            jsonrpc: "2.0",
-            id,
-            method,
-            params
-        });
-        return deferred.p;
+        return this._dispatchRequest(method, params);
     }
     _sendExtensionRequest(method, params) {
-        if (this._closeError) {
-            return Promise.reject(this._closeError);
+        return this._dispatchRequest(method, params);
+    }
+    _updateTelemetryLevel() {
+        this.dispatchAction({
+            type: ActionType.RootConfigChanged,
+            config: {
+                [AgentHostTelemetryLevelConfigKey]: telemetryLevelToAgentHostConfigValue(getTelemetryLevel(this._configurationService))
+            }
+        }, this._clientId, 0);
+    }
+    async _dispatchRequest(method, params, options = {}) {
+        while (!options.bypassReconnectGate && this._state.kind === AgentHostClientState.Reconnecting) {
+            const current = this._state;
+            if (current.kind !== AgentHostClientState.Reconnecting) {
+                break;
+            }
+            try {
+                await current.reconnect.gate.p;
+            } catch {}
+        }
+        if (this._state.kind === AgentHostClientState.Closed) {
+            throw this._state.error;
         }
         const id = this._nextRequestId++;
         const deferred = ( new DeferredPromise());
@@ -593,34 +886,47 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         }
         this._pendingRequests.clear();
     }
-    _watchdogTick() {
-        if (this._isClosed || this._pendingRequests.size === 0) {
+    _resetLivenessTimers() {
+        if (this._state.kind === AgentHostClientState.Reconnecting || this._state.kind === AgentHostClientState.Closed) {
             return;
         }
-        const now = Date.now();
-        const sinceLastRead = now - this._lastReadTime;
-        if (sinceLastRead < WATCHDOG_TIMEOUT_MS) {
+        this._pingTimer.cancelAndSet(() => this._onPingTimer(), PING_INTERVAL_MS);
+        this._closeTimer.cancelAndSet(() => this._onCloseTimer(), PING_INTERVAL_MS + LIVENESS_TIMEOUT_MS);
+    }
+    _cancelLivenessTimers() {
+        this._pingTimer.cancel();
+        this._closeTimer.cancel();
+    }
+    _onPingTimer() {
+        if (this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Reconnecting) {
             return;
         }
-        let oldestSentAt = now;
-        for (const pending of ( this._pendingRequests.values())) {
-            if (pending.sentAt < oldestSentAt) {
-                oldestSentAt = pending.sentAt;
-            }
+        void this.ping().catch(() => undefined);
+    }
+    _onCloseTimer() {
+        if (this._state.kind === AgentHostClientState.Closed || this._state.kind === AgentHostClientState.Reconnecting) {
+            return;
         }
-        const oldestAge = now - oldestSentAt;
-        if (oldestAge < WATCHDOG_TIMEOUT_MS) {
+        if (this._loadEstimator.hasHighLoad()) {
+            this._closeTimer.cancelAndSet(() => this._onCloseTimer(), PING_INTERVAL_MS);
             return;
         }
+        const silence = Date.now() - this._lastReadTime;
         this._logService.info(
-            `[RemoteAgentHostProtocol] Watchdog: connection to ${this._address} appears dead — ` + `${this._pendingRequests.size} request(s) outstanding, no message received for ${sinceLastRead}ms, ` + `oldest request ${oldestAge}ms old. Forcing close to trigger reconnect.`
+            `[RemoteAgentHostProtocol] Liveness: no message from ${this._address} for ${silence}ms; forcing close to trigger reconnect.`
         );
-        this._handleClose(connectionTimeoutError(this._address, sinceLastRead, oldestAge));
+        this._transportListeners.clear();
+        if (this._transportFactory) {
+            this._rejectPendingRequests(connectionTimeoutError(this._address, silence));
+            this._handleTransportClose();
+            return;
+        }
+        this._handleClose(connectionTimeoutError(this._address, silence));
     }
     nextClientSeq() {
         return this._nextClientSeq++;
     }
 };
-RemoteAgentHostProtocolClient = ( __decorate([( __param(2, ILogService)), ( __param(3, IFileService)), ( __param(4, IAgentHostPermissionService))], RemoteAgentHostProtocolClient));
+RemoteAgentHostProtocolClient = ( __decorate([( __param(3, ILogService)), ( __param(4, IFileService)), ( __param(5, IAgentHostPermissionService)), ( __param(6, IConfigurationService))], RemoteAgentHostProtocolClient));
 
-export { RemoteAgentHostProtocolClient };
+export { AgentHostClientState, RemoteAgentHostProtocolClient };

package/vscode/src/vs/platform/agentHost/browser/remoteAgentHostServiceImpl.d.ts

@@ -4,20 +4,29 @@ import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/plat
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { type IAgentConnection } from "../common/agentService.js";
 import { type IRemoteAgentHostConnectionInfo, type IRemoteAgentHostEntry } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService";
 import { IRemoteAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service";
+import { type IVscodeUpgradeResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocolUpgrade";
 export declare class RemoteAgentHostService extends Disposable implements IRemoteAgentHostService {
     private readonly _configurationService;
     private readonly _instantiationService;
     private readonly _logService;
     private readonly _labelService;
     private readonly _environmentService;
+    private readonly _storageService;
     private static readonly ConnectionWaitTimeout;
     /** Initial reconnect delay in milliseconds. */
     private static readonly ReconnectInitialDelay;
     /** Maximum reconnect delay in milliseconds. */
     private static readonly ReconnectMaxDelay;
+    /**
+     * How long to wait for a server-upgrade trigger to be acknowledged.
+     * The CLI awaits the binary download synchronously before responding,
+     * so this needs to accommodate first-time downloads on slow networks.
+     */
+    private static readonly UpgradeRequestTimeout;
     readonly _serviceBrand: undefined;
     private readonly _onDidChangeConnections;
     readonly onDidChangeConnections: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
@@ -43,11 +52,12 @@ export declare class RemoteAgentHostService extends Disposable implements IRemot
      * label for an agent host URI gets the friendly name.
      */
     private readonly _labelFormatters;
-    constructor(_configurationService: IConfigurationService, _instantiationService: IInstantiationService, _logService: ILogService, _labelService: ILabelService, _environmentService: IEnvironmentService);
+    constructor(_configurationService: IConfigurationService, _instantiationService: IInstantiationService, _logService: ILogService, _labelService: ILabelService, _environmentService: IEnvironmentService, _storageService: IStorageService);
     get connections(): readonly IRemoteAgentHostConnectionInfo[];
     get configuredEntries(): readonly IRemoteAgentHostEntry[];
     getConnection(address: string): IAgentConnection | undefined;
     getEntryByAddress(address: string): IRemoteAgentHostEntry | undefined;
+    triggerServerUpgrade(address: string, method: string): Promise<IVscodeUpgradeResult>;
     reconnect(address: string): void;
     addRemoteAgentHost(input: IRemoteAgentHostEntry): Promise<IRemoteAgentHostConnectionInfo>;
     addManagedConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection, transportDisposable?: IDisposable): Promise<IRemoteAgentHostConnectionInfo>;
@@ -69,6 +79,13 @@ export declare class RemoteAgentHostService extends Disposable implements IRemot
     private _upsertConfiguredEntry;
     private _getConfigurationTarget;
     private _storeConfiguredEntries;
+    private _getConfiguredSettingEntries;
+    private _getConfiguredSettingEntriesForTarget;
+    private _getConfiguredRawEntriesForTarget;
+    private _getStoredSSHEntries;
+    private _storeStoredSSHEntries;
+    private _migrateSSHEntriesFromSetting;
+    private _mergeConfiguredEntries;
     private _getOrCreateConnectionWait;
     private _resolvePendingConnectionWait;
     private _rejectPendingConnectionWait;