@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -1,36 +1,77 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { raceTimeout, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
 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 { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { AgentHostAhpJsonlLoggingSettingId } from '../common/agentService.js';
-import { RemoteAgentHostsSettingId, RemoteAgentHostsEnabledSettingId, RemoteAgentHostEntryType, getEntryAddress, RemoteAgentHostConnectionStatus, entryToRawEntry, rawEntryToEntry } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
-import { RemoteAgentHostProtocolClient, AgentHostClientState } from './remoteAgentHostProtocolClient.js';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { AgentHostAhpJsonlLoggingSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { RemoteAgentHostEntryType, RemoteAgentHostsSettingId, isRawRemoteAgentHostEntry, isLegacySshRawEntry, WEBSOCKET_ENTRY_TYPE_CONFIG, RemoteAgentHostsEnabledSettingId, RemoteAgentHostAutoConnectSettingId, getEntryTypeConfig, RemoteAgentHostConnectionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { hasExhaustedReconnectAttempts, computeReconnectDelay } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/reconnectPolicy';
+import { NonReconnectableTransportError, AgentHostTransportFailureReason } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionTransport';
+import { AgentHostProtocolClient, InitialAuthenticationError } from './agentHostProtocolClient.js';
 import { WebSocketClientTransport } from './webSocketClientTransport.js';
 import { normalizeRemoteAgentHostAddress, agentHostAuthority, AGENT_HOST_LABEL_FORMATTER, AGENT_HOST_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { PROTOCOL_VERSION } from '../common/state/protocol/version/registry.js';
+import { editorWindowAgentHostClientInfo } from '../common/agentHostClientInfo.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 var RemoteAgentHostService_1;
-const SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY = "remoteAgentHost.sshConnections";
 function disposeEntry(entry) {
     entry.store.dispose();
     entry.transportDisposable?.dispose();
 }
-function isRawRemoteAgentHostEntry(value) {
-    if (typeof value !== "object" || value === null) {
-        return false;
+function isTerminalConnectError(err) {
+    return err instanceof NonReconnectableTransportError || isCancellationError(err);
+}
+class WebSocketConnectionFactory extends Disposable {
+    constructor(
+        _instantiationService,
+        _configurationService,
+        _environmentService,
+        _clientInfo
+    ) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._configurationService = _configurationService;
+        this._environmentService = _environmentService;
+        this._clientInfo = _clientInfo;
+        this.kind = RemoteAgentHostEntryType.WebSocket;
+        this._rawEntries = observableConfigValue(RemoteAgentHostsSettingId, [], this._configurationService);
+        this.entries = derived(this, reader => ( this._rawEntries.read(reader).filter(isRawRemoteAgentHostEntry).filter(entry => !isLegacySshRawEntry(entry)).map(entry => WEBSOCKET_ENTRY_TYPE_CONFIG.fromRaw(entry))));
+    }
+    createConnection(entry, _options) {
+        if (entry.connection.type !== RemoteAgentHostEntryType.WebSocket) {
+            throw ( new Error(`WebSocket factory cannot create a ${entry.connection.type} connection.`));
+        }
+        const address = entry.connection.address;
+        const ahpLoggingEnabled = !!this._configurationService.getValue(AgentHostAhpJsonlLoggingSettingId);
+        const transportFactory = () => this._instantiationService.createInstance(
+            WebSocketClientTransport,
+            address,
+            entry.connectionToken,
+            ahpLoggingEnabled ? {
+                logsHome: this._environmentService.logsHome,
+                connectionId: address,
+                transport: "websocket"
+            } : undefined
+        );
+        const connection = this._instantiationService.createInstance(AgentHostProtocolClient, address, transportFactory, {
+            clientInfo: this._clientInfo()
+        });
+        return Promise.resolve({
+            connection
+        });
     }
-    const candidate = value;
-    return typeof candidate.address === "string" && typeof candidate.name === "string" && (candidate.connectionToken === undefined || typeof candidate.connectionToken === "string") && (candidate.sshConfigHost === undefined || typeof candidate.sshConfigHost === "string") && (candidate.sshHostName === undefined || typeof candidate.sshHostName === "string") && (candidate.sshUser === undefined || typeof candidate.sshUser === "string") && (candidate.sshPort === undefined || typeof candidate.sshPort === "number");
 }
 let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     static {
@@ -39,22 +80,18 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     static {
         this.ConnectionWaitTimeout = 10000;
     }
-    static {
-        this.ReconnectInitialDelay = 1000;
-    }
-    static {
-        this.ReconnectMaxDelay = 30000;
-    }
     static {
         this.UpgradeRequestTimeout = 5 * 60 * 1000;
     }
+    get clientInfo() {
+        return editorWindowAgentHostClientInfo;
+    }
     constructor(
         _configurationService,
         _instantiationService,
         _logService,
         _labelService,
-        _environmentService,
-        _storageService
+        _environmentService
     ) {
         super();
         this._configurationService = _configurationService;
@@ -62,30 +99,62 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         this._logService = _logService;
         this._labelService = _labelService;
         this._environmentService = _environmentService;
-        this._storageService = _storageService;
         this._onDidChangeConnections = this._register(( new Emitter()));
         this.onDidChangeConnections = this._onDidChangeConnections.event;
         this._entries = ( new Map());
+        this._connectionFactories = ( new Map());
+        this._connectionFactoriesObservable = observableValue(this, []);
+        this._configuredEntries = derived(this, reader => {
+            let entries = [];
+            for (const factory of this._connectionFactoriesObservable.read(reader)) {
+                for (const entry of factory.entries.read(reader)) {
+                    entries = this._upsertEntry(entries, entry);
+                }
+            }
+            return entries;
+        });
+        this._pendingConnects = ( new Map());
         this._names = ( new Map());
         this._tokens = ( new Map());
-        this._registeredEntries = ( new Map());
         this._pendingConnectionWaits = ( new Map());
+        this._failedReconnects = ( new Map());
         this._reconnectTimeouts = ( new Map());
         this._reconnectAttempts = ( new Map());
         this._labelFormatters = ( new Map());
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(RemoteAgentHostsSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
-                this._reconcileConnections();
-            }
+        this._remoteAgentHostsEnabled = observableConfigValue(RemoteAgentHostsEnabledSettingId, true, this._configurationService);
+        this._remoteAgentHostsAutoConnect = observableConfigValue(RemoteAgentHostAutoConnectSettingId, true, this._configurationService);
+        this._register(this.registerConnectionFactory(this._register(( new WebSocketConnectionFactory(
+            this._instantiationService,
+            this._configurationService,
+            this._environmentService,
+            () => this.clientInfo
+        )))));
+        this._register(autorun(reader => {
+            this._configuredEntries.read(reader);
+            this._remoteAgentHostsEnabled.read(reader);
+            this._remoteAgentHostsAutoConnect.read(reader);
+            this._reconcileConnections();
         }));
-        this._register(
-            this._storageService.onDidChangeValue(StorageScope.APPLICATION, SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY, this._store)(() => {
-                this._reconcileConnections();
-                this._onDidChangeConnections.fire();
-            })
-        );
-        this._migrateSSHEntriesFromSetting();
-        this._reconcileConnections();
+    }
+    _entryAddress(entry) {
+        const config = getEntryTypeConfig(entry.connection.type);
+        const address = config.address(entry.connection);
+        return config.normalizedAddress ? normalizeRemoteAgentHostAddress(address) : address;
+    }
+    _normalizeEntry(entry) {
+        const config = getEntryTypeConfig(entry.connection.type);
+        if (!config.normalizedAddress || !hasKey(entry.connection, {
+            address: true
+        })) {
+            return entry;
+        }
+        return {
+            ...entry,
+            connection: {
+                ...entry.connection,
+                address: normalizeRemoteAgentHostAddress(entry.connection.address)
+            }
+        };
     }
     get connections() {
         const result = [];
@@ -93,26 +162,30 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             result.push({
                 address,
                 name: this._names.get(address) ?? address,
-                clientId: entry.client.clientId,
-                defaultDirectory: entry.client.defaultDirectory,
+                clientId: entry.client?.clientId,
+                defaultDirectory: entry.client?.defaultDirectory,
                 status: entry.status
             });
         }
         return result;
     }
     get configuredEntries() {
-        return ( this._getConfiguredEntries().map(e => {
-            if (e.connection.type === RemoteAgentHostEntryType.Tunnel) {
-                return e;
+        return ( this._configuredEntries.get().map(entry => this._normalizeEntry(entry)));
+    }
+    registerConnectionFactory(factory) {
+        if (( this._connectionFactories.has(factory.kind))) {
+            throw ( new Error(
+                `A remote agent host connection factory is already registered for ${factory.kind}.`
+            ));
+        }
+        this._connectionFactories.set(factory.kind, factory);
+        this._connectionFactoriesObservable.set([...( this._connectionFactories.values())], undefined);
+        return toDisposable(() => {
+            if (this._connectionFactories.get(factory.kind) === factory) {
+                this._connectionFactories.delete(factory.kind);
+                this._connectionFactoriesObservable.set([...( this._connectionFactories.values())], undefined);
             }
-            return {
-                ...e,
-                connection: {
-                    ...e.connection,
-                    address: normalizeRemoteAgentHostAddress(e.connection.address)
-                }
-            };
-        }));
+        });
     }
     getConnection(address) {
         const normalized = normalizeRemoteAgentHostAddress(address);
@@ -129,20 +202,16 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     }
     getEntryByAddress(address) {
         const normalized = normalizeRemoteAgentHostAddress(address);
-        const registered = this._registeredEntries.get(normalized);
-        if (registered) {
-            return registered;
-        }
-        return this.configuredEntries.find(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalized);
+        return this.configuredEntries.find(entry => this._entryAddress(entry) === normalized);
     }
     async triggerServerUpgrade(address, method) {
         const normalized = normalizeRemoteAgentHostAddress(address);
-        const entry = this._entries.get(normalized);
-        if (!entry) {
-            throw ( new Error(`No remote agent host entry found for ${address}.`));
+        const client = this._entries.get(normalized)?.client;
+        if (!client) {
+            throw ( new Error(`No usable remote agent host client found for ${address}.`));
         }
         const result = await raceTimeout(
-            entry.client.triggerVscodeUpgrade(method),
+            client.triggerVscodeUpgrade(method),
             RemoteAgentHostService_1.UpgradeRequestTimeout
         );
         if (result === undefined) {
@@ -152,119 +221,98 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         return result;
     }
-    reconnect(address) {
+    reconnect(address, userInitiated = true) {
+        if (this._store.isDisposed) {
+            return;
+        }
         const normalized = normalizeRemoteAgentHostAddress(address);
-        const configuredEntry = this._getConfiguredEntries().find(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalized);
-        if (configuredEntry && configuredEntry.connection.type !== RemoteAgentHostEntryType.WebSocket) {
+        if (( this._pendingConnects.has(normalized))) {
+            if (userInitiated) {
+                this._failedReconnects.delete(normalized);
+                this._cancelReconnect(normalized);
+                this._reconnectAttempts.delete(normalized);
+            }
             return;
         }
-        const token = this._tokens.get(normalized);
+        this._failedReconnects.delete(normalized);
+        const configuredEntry = this._configuredEntries.get().find(entry => this._entryAddress(entry) === normalized);
+        if (!configuredEntry) {
+            this._failedReconnects.set(normalized, ( new Error(`No remote agent host entry is staged for ${normalized}.`)));
+            return;
+        }
+        if (!( this._connectionFactories.has(configuredEntry.connection.type))) {
+            this._failedReconnects.set(normalized, ( new Error(
+                `No connection factory is registered for ${configuredEntry.connection.type}.`
+            )));
+            return;
+        }
+        const entryToReconnect = {
+            ...configuredEntry,
+            connectionToken: this._tokens.get(normalized) ?? configuredEntry.connectionToken
+        };
         this._cancelReconnect(normalized);
-        this._reconnectAttempts.delete(normalized);
+        if (userInitiated) {
+            this._reconnectAttempts.delete(normalized);
+        }
         const entry = this._entries.get(normalized);
         if (entry) {
             this._entries.delete(normalized);
             entry.store.dispose();
+            if (!entry.reconnectTransfersTransportOwnership) {
+                entry.transportDisposable?.dispose();
+            }
+            this._onDidChangeConnections.fire();
         }
-        this._connectTo(normalized, token);
+        void this._connectTo(entryToReconnect, {
+            userInitiated
+        });
     }
-    async addRemoteAgentHost(input) {
-        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
-            throw ( new Error("Remote agent host connections are not enabled."));
+    reconnectNow(address) {
+        const normalized = normalizeRemoteAgentHostAddress(address);
+        if (this._entries.get(normalized)?.client?.reconnectNow()) {
+            return;
         }
-        const entry = input.connection.type === RemoteAgentHostEntryType.Tunnel ? input : {
-            ...input,
-            connection: {
-                ...input.connection,
-                address: normalizeRemoteAgentHostAddress(input.connection.address)
-            }
-        };
-        const address = getEntryAddress(entry);
-        const existingConnection = this._getConnectionInfo(address);
-        await this._storeConfiguredEntries(this._upsertConfiguredEntry(entry));
-        if (existingConnection) {
-            return {
-                ...existingConnection,
-                name: entry.name
-            };
+        this.reconnect(normalized, true);
+    }
+    async waitForConnection(address) {
+        if (this._store.isDisposed) {
+            throw ( new Error("Remote agent host service is disposed."));
         }
-        if (entry.connection.type === RemoteAgentHostEntryType.SSH) {
-            return {
-                address,
-                name: entry.name,
-                clientId: "",
-                status: RemoteAgentHostConnectionStatus.disconnected
-            };
+        if (!this._remoteAgentHostsEnabled.get()) {
+            throw ( new Error("Remote agent host connections are not enabled."));
         }
-        const connectedConnection = this._getConnectionInfo(address);
-        if (connectedConnection) {
-            return connectedConnection;
+        const normalizedAddress = normalizeRemoteAgentHostAddress(address);
+        const existingConnection = this._getConnectionInfo(normalizedAddress);
+        if (existingConnection) {
+            return existingConnection;
+        }
+        const reconnectFailure = this._failedReconnects.get(normalizedAddress);
+        if (reconnectFailure) {
+            throw reconnectFailure;
+        }
+        const wait = this._getOrCreateConnectionWait(normalizedAddress);
+        const pendingConnect = this._pendingConnects.get(normalizedAddress);
+        if (pendingConnect) {
+            await pendingConnect;
+            const connected = this._getConnectionInfo(normalizedAddress);
+            if (connected) {
+                return connected;
+            }
+            return wait.p;
         }
-        const wait = this._getOrCreateConnectionWait(address);
         const connection = await raceTimeout(wait.p, RemoteAgentHostService_1.ConnectionWaitTimeout, () => {
-            this._pendingConnectionWaits.delete(address);
+            this._pendingConnectionWaits.delete(normalizedAddress);
         });
         if (!connection) {
-            throw ( new Error(`Timed out connecting to ${address}`));
+            throw ( new Error(`Timed out connecting to ${normalizedAddress}`));
         }
         return connection;
     }
-    async addManagedConnection(
-        entry,
-        connection,
-        transportDisposable,
-        status = RemoteAgentHostConnectionStatus.connected
-    ) {
-        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
-            throw ( new Error("Remote agent host connections are not enabled."));
-        }
-        const address = getEntryAddress(entry);
-        const existingEntry = this._entries.get(address);
-        if (existingEntry) {
-            this._entries.delete(address);
-            existingEntry.store.dispose();
-        }
-        const store = ( new DisposableStore());
-        const protocolClient = connection;
-        store.add(protocolClient);
-        const connEntry = {
-            store,
-            client: protocolClient,
-            transportDisposable,
-            connected: RemoteAgentHostConnectionStatus.isConnected(status),
-            status
-        };
-        this._entries.set(address, connEntry);
-        this._names.set(address, entry.name);
-        this._registeredEntries.set(address, entry);
-        this._updateHostLabelFormatter(address, entry.name);
-        if (entry.connectionToken) {
-            this._tokens.set(address, entry.connectionToken);
-        }
-        store.add(protocolClient.onDidClose(() => {
-            if (this._entries.get(address) === connEntry) {
-                connEntry.connected = false;
-                connEntry.status = RemoteAgentHostConnectionStatus.disconnected;
-                this._onDidChangeConnections.fire();
-            }
-        }));
-        await this._storeConfiguredEntries(this._upsertConfiguredEntry(entry));
-        this._onDidChangeConnections.fire();
-        return {
-            address,
-            name: entry.name,
-            clientId: protocolClient.clientId,
-            defaultDirectory: protocolClient.defaultDirectory,
-            status
-        };
-    }
     async removeRemoteAgentHost(address) {
         const normalized = normalizeRemoteAgentHostAddress(address);
-        const entries = this._getConfiguredEntries().filter(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) !== normalized);
-        await this._storeConfiguredEntries(entries);
         this._names.delete(normalized);
         this._tokens.delete(normalized);
-        this._registeredEntries.delete(normalized);
+        this._failedReconnects.delete(normalized);
         this._clearHostLabelFormatter(normalized);
         this._cancelReconnect(normalized);
         this._reconnectAttempts.delete(normalized);
@@ -282,19 +330,22 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
     notifyConnectionClosed(address) {
         const normalized = normalizeRemoteAgentHostAddress(address);
         const entry = this._entries.get(normalized);
-        if (entry) {
+        if (entry?.client) {
             this._logService.info(
                 `[RemoteAgentHost] notifyConnectionClosed: notifying protocol client for ${normalized}`
             );
             entry.client.notifyTransportClosed();
         } else {
             this._logService.info(
-                `[RemoteAgentHost] notifyConnectionClosed: no entry found for ${normalized} (already removed?)`
+                `[RemoteAgentHost] notifyConnectionClosed: no active client found for ${normalized}`
             );
         }
     }
     _reconcileConnections() {
-        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        if (!this._remoteAgentHostsEnabled.get()) {
             for (const address of [...( this._entries.keys())]) {
                 this._cancelReconnect(address);
                 this._removeConnection(address);
@@ -303,16 +354,14 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             this._tokens.clear();
             this._reconnectAttempts.clear();
             for (const address of [...( this._labelFormatters.keys())]) {
-                if (!( this._registeredEntries.has(address))) {
-                    this._clearHostLabelFormatter(address);
-                }
+                this._clearHostLabelFormatter(address);
             }
             return;
         }
-        const configuredEntries = this._getConfiguredEntries();
-        const entriesWithAddress = ( configuredEntries.map(e => ({
-            entry: e,
-            address: normalizeRemoteAgentHostAddress(getEntryAddress(e))
+        const configuredEntries = this._configuredEntries.get();
+        const entriesWithAddress = ( configuredEntries.map(entry => ({
+            entry,
+            address: this._entryAddress(entry)
         })));
         const desired = ( new Set(( entriesWithAddress.map(e => e.address))));
         this._logService.info(
@@ -334,7 +383,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             }
         }
         for (const address of [...( this._labelFormatters.keys())]) {
-            if (!( desired.has(address)) && !( this._registeredEntries.has(address))) {
+            if (!( desired.has(address))) {
                 this._clearHostLabelFormatter(address);
             }
         }
@@ -350,72 +399,162 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             entry,
             address
         } of entriesWithAddress) {
-            if (!( this._entries.has(address)) && entry.connection.type === RemoteAgentHostEntryType.WebSocket) {
-                this._connectTo(address, entry.connectionToken);
+            if (!( this._entries.has(address)) && !( this._pendingConnects.has(address)) && this._shouldAutoConnect(entry)) {
+                void this._connectTo(entry, {
+                    userInitiated: false
+                });
             }
         }
         if (namesChanged) {
             this._onDidChangeConnections.fire();
         }
     }
-    _connectTo(address, connectionToken) {
-        if (!this._configurationService.getValue(RemoteAgentHostsEnabledSettingId)) {
+    _connectTo(entryToConnect, options) {
+        if (this._store.isDisposed) {
+            return Promise.resolve();
+        }
+        const entryToCreate = this._normalizeEntry(entryToConnect);
+        const address = this._entryAddress(entryToCreate);
+        const existingPendingConnect = this._pendingConnects.get(address);
+        if (existingPendingConnect) {
+            return existingPendingConnect;
+        }
+        const pendingConnect = ( new DeferredPromise());
+        this._pendingConnects.set(address, pendingConnect.p);
+        void (async () => {
+            try {
+                await this._createAndConnect(entryToCreate, address, options);
+            } catch (err) {
+                this._logService.error(`[RemoteAgentHost] Unexpected error connecting to ${address}`, err);
+            } finally {
+                if (this._pendingConnects.get(address) === pendingConnect.p) {
+                    this._pendingConnects.delete(address);
+                }
+                void pendingConnect.complete();
+            }
+        })();
+        return pendingConnect.p;
+    }
+    async _createAndConnect(entryToCreate, address, options) {
+        if (this._store.isDisposed || !this._remoteAgentHostsEnabled.get()) {
+            return;
+        }
+        const factory = this._connectionFactories.get(entryToCreate.connection.type);
+        if (!factory) {
+            const error = ( new Error(
+                `No connection factory is registered for ${entryToCreate.connection.type}.`
+            ));
+            this._logService.error(`[RemoteAgentHost] ${error.message} at ${address}`);
+            this._failedReconnects.set(address, error);
+            this._rejectPendingConnectionWait(address, error);
             return;
         }
         const existingEntry = this._entries.get(address);
         if (existingEntry) {
             this._entries.delete(address);
-            existingEntry.store.dispose();
+            disposeEntry(existingEntry);
+        }
+        let createdConnection;
+        try {
+            createdConnection = await factory.createConnection(entryToCreate, options);
+        } catch (err) {
+            this._logService.error(
+                `[RemoteAgentHost] Failed to create a connection to ${address}. Verify address and connectionToken`,
+                err
+            );
+            const disconnectReason = err instanceof NonReconnectableTransportError ? err.reason : AgentHostTransportFailureReason.Unknown;
+            this._entries.set(address, {
+                store: ( new DisposableStore()),
+                connected: false,
+                status: RemoteAgentHostConnectionStatus.disconnectedBecause(disconnectReason),
+                reconnectTransfersTransportOwnership: false
+            });
+            this._rejectPendingConnectionWait(address, err);
+            this._pendingConnects.delete(address);
+            this._onDidChangeConnections.fire();
+            if (!isTerminalConnectError(err) && !this._store.isDisposed && this._remoteAgentHostsEnabled.get()) {
+                this._scheduleReconnect(address, entryToCreate.connectionToken);
+            }
+            return;
+        }
+        if (this._store.isDisposed || !this._remoteAgentHostsEnabled.get() || !( this._configuredEntries.get().some(entry => this._entryAddress(entry) === address)) || ( this._entries.has(address))) {
+            createdConnection.connection.dispose();
+            createdConnection.transportDisposable?.dispose();
+            this._rejectPendingConnectionWait(address, ( new Error(
+                `Connection attempt for ${address} was discarded because it is no longer active.`
+            )));
+            return;
         }
         const store = ( new DisposableStore());
-        const ahpLoggingEnabled = !!this._configurationService.getValue(AgentHostAhpJsonlLoggingSettingId);
-        const transportFactory = () => this._instantiationService.createInstance(WebSocketClientTransport, address, connectionToken, ahpLoggingEnabled ? {
-            logsHome: this._environmentService.logsHome,
-            connectionId: address,
-            transport: "websocket"
-        } : undefined);
-        const client = store.add(
-            this._instantiationService.createInstance(RemoteAgentHostProtocolClient, address, transportFactory, undefined)
-        );
+        const client = store.add(createdConnection.connection);
         const entry = {
             store,
             client,
+            transportDisposable: createdConnection.transportDisposable,
+            reconnectTransfersTransportOwnership: createdConnection.reconnectTransfersTransportOwnership ?? false,
             connected: false,
             status: RemoteAgentHostConnectionStatus.connecting
         };
         this._entries.set(address, entry);
         const isCurrentEntry = () => this._entries.get(address) === entry;
-        store.add(client.onDidClose(() => {
+        store.add(client.onDidClose(reason => {
             if (!isCurrentEntry()) {
                 return;
             }
             this._logService.warn(`[RemoteAgentHost] Connection closed: ${address}`);
             entry.connected = false;
-            entry.status = RemoteAgentHostConnectionStatus.disconnected;
+            entry.status = RemoteAgentHostConnectionStatus.disconnectedBecause(reason ?? AgentHostTransportFailureReason.Unknown);
+            entry.client = undefined;
+            disposeEntry(entry);
+            this._onDidChangeConnections.fire();
+            this._scheduleReconnect(address, entryToCreate.connectionToken);
+        }));
+        store.add(client.onDidScheduleReconnect(() => {
+            if (!isCurrentEntry() || entry.status.kind !== "reconnecting") {
+                return;
+            }
+            entry.status = RemoteAgentHostConnectionStatus.reconnectingUntil(client.nextReconnectAt);
             this._onDidChangeConnections.fire();
-            this._scheduleReconnect(address, connectionToken);
         }));
         store.add(client.onDidChangeConnectionState(state => {
             if (!isCurrentEntry()) {
                 return;
             }
             switch (state) {
-            case AgentHostClientState.Reconnecting:
+            case "reconnecting":
                 entry.connected = false;
-                entry.status = RemoteAgentHostConnectionStatus.connecting;
+                entry.status = RemoteAgentHostConnectionStatus.reconnectingUntil(client.nextReconnectAt);
                 this._onDidChangeConnections.fire();
                 break;
-            case AgentHostClientState.Connected:
+            case "connected":
                 entry.connected = true;
                 entry.status = RemoteAgentHostConnectionStatus.connected;
+                this._reconnectAttempts.delete(address);
+                this._resolvePendingConnectionWait(address);
+                this._onDidChangeConnections.fire();
+                break;
+            case "connecting":
+            case "closed":
+                break;
+            case "incompatible":
+                entry.connected = false;
+                entry.status = RemoteAgentHostConnectionStatus.incompatible(
+                    "Authentication failed during connection initialization.",
+                    [PROTOCOL_VERSION]
+                );
+                this._reconnectAttempts.delete(address);
                 this._onDidChangeConnections.fire();
                 break;
             }
         }));
-        this._logService.info(`[RemoteAgentHost] Connecting to ${address}`);
-        this._onDidChangeConnections.fire();
-        client.connect().then(() => {
-            if (store.isDisposed) {
+        try {
+            this._logService.info(`[RemoteAgentHost] Connecting to ${address}`);
+            this._onDidChangeConnections.fire();
+            await client.connect();
+            if (store.isDisposed || !isCurrentEntry()) {
+                if (!store.isDisposed) {
+                    disposeEntry(entry);
+                }
                 return;
             }
             this._logService.info(`[RemoteAgentHost] Connected to ${address}`);
@@ -424,11 +563,14 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             this._reconnectAttempts.delete(address);
             this._resolvePendingConnectionWait(address);
             this._onDidChangeConnections.fire();
-        }).catch(err => {
+        } catch (err) {
             if (!isCurrentEntry()) {
+                if (!store.isDisposed) {
+                    disposeEntry(entry);
+                }
                 return;
             }
-            const incompatible = RemoteAgentHostConnectionStatus.fromConnectError(err, [PROTOCOL_VERSION]);
+            const incompatible = err instanceof InitialAuthenticationError ? RemoteAgentHostConnectionStatus.incompatible(err.message, [PROTOCOL_VERSION]) : RemoteAgentHostConnectionStatus.fromConnectError(err, [PROTOCOL_VERSION]);
             if (incompatible) {
                 this._logService.warn(
                     `[RemoteAgentHost] Incompatible with ${address}: ${incompatible.kind === "incompatible" ? incompatible.message : ""}`
@@ -443,37 +585,72 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
                 `[RemoteAgentHost] Failed to connect to ${address}. Verify address and connectionToken`,
                 err
             );
-            entry.status = RemoteAgentHostConnectionStatus.disconnected;
-            this._entries.delete(address);
-            entry.store.dispose();
+            if (RemoteAgentHostConnectionStatus.isReconnecting(entry.status)) {
+                this._logService.info(
+                    `[RemoteAgentHost] Handshake with ${address} was interrupted; the protocol client is restoring the connection`
+                );
+                return;
+            }
+            const disconnectReason = err instanceof NonReconnectableTransportError ? err.reason : AgentHostTransportFailureReason.Unknown;
+            entry.status = RemoteAgentHostConnectionStatus.disconnectedBecause(disconnectReason);
+            entry.client = undefined;
+            disposeEntry(entry);
             this._rejectPendingConnectionWait(address, err);
             this._onDidChangeConnections.fire();
-            this._scheduleReconnect(address, connectionToken);
-        });
+            this._scheduleReconnect(address, entryToCreate.connectionToken);
+        }
     }
     _scheduleReconnect(address, connectionToken) {
-        if (!this._isAddressConfigured(address)) {
+        const configuredEntry = this._configuredEntries.get().find(entry => this._entryAddress(entry) === address);
+        if (!configuredEntry) {
             this._logService.info(`[RemoteAgentHost] Not reconnecting to ${address}: no longer configured`);
             return;
         }
-        const attempt = (this._reconnectAttempts.get(address) ?? 0) + 1;
+        const reconnectPolicy = getEntryTypeConfig(configuredEntry.connection.type).reconnect;
+        if (!reconnectPolicy.autoRestore) {
+            this._logService.info(
+                `[RemoteAgentHost] Not reconnecting to ${address}: automatic restore is disabled`
+            );
+            return;
+        }
+        if (getEntryTypeConfig(configuredEntry.connection.type).dialedFromEntries && !this._shouldAutoConnect(configuredEntry)) {
+            this._logService.info(
+                `[RemoteAgentHost] Not reconnecting to ${address}: automatic connection is disabled`
+            );
+            return;
+        }
+        const previousAttempts = this._reconnectAttempts.get(address) ?? 0;
+        if (hasExhaustedReconnectAttempts(reconnectPolicy, previousAttempts)) {
+            this._logService.warn(
+                `[RemoteAgentHost] Stopped reconnecting to ${address}: reached attempt limit (${previousAttempts})`
+            );
+            return;
+        }
+        const attempt = previousAttempts + 1;
         this._reconnectAttempts.set(address, attempt);
-        const delay = Math.min(
-            RemoteAgentHostService_1.ReconnectInitialDelay * Math.pow(2, attempt - 1),
-            RemoteAgentHostService_1.ReconnectMaxDelay
-        );
+        const delay = computeReconnectDelay(reconnectPolicy, attempt);
         this._logService.info(
             `[RemoteAgentHost] Scheduling reconnect to ${address} in ${delay}ms (attempt ${attempt})`
         );
         this._cancelReconnect(address);
         const timeout = setTimeout(() => {
             this._reconnectTimeouts.delete(address);
-            if (this._isAddressConfigured(address)) {
-                this._connectTo(address, connectionToken ?? this._tokens.get(address));
+            const currentEntry = this._configuredEntries.get().find(entry => this._entryAddress(entry) === address);
+            if (currentEntry && (!getEntryTypeConfig(currentEntry.connection.type).dialedFromEntries || this._shouldAutoConnect(currentEntry))) {
+                void this._connectTo({
+                    ...currentEntry,
+                    connectionToken: connectionToken ?? this._tokens.get(address) ?? currentEntry.connectionToken
+                }, {
+                    userInitiated: false
+                });
             }
         }, delay);
         this._reconnectTimeouts.set(address, timeout);
     }
+    _shouldAutoConnect(entry) {
+        const config = getEntryTypeConfig(entry.connection.type);
+        return config.dialedFromEntries && (!config.autoConnectGated || this._remoteAgentHostsAutoConnect.get());
+    }
     _cancelReconnect(address) {
         const timeout = this._reconnectTimeouts.get(address);
         if (timeout !== undefined) {
@@ -481,128 +658,15 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             this._reconnectTimeouts.delete(address);
         }
     }
-    _isAddressConfigured(address) {
-        const entries = this._getConfiguredEntries();
-        return ( entries.some(e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === address));
-    }
     _getConnectionInfo(address) {
         return this.connections.find(
             connection => connection.address === address && RemoteAgentHostConnectionStatus.isConnected(connection.status)
         );
     }
-    _getConfiguredEntries() {
-        return this._mergeConfiguredEntries(this._getConfiguredSettingEntries(), this._getStoredSSHEntries());
-    }
-    _upsertConfiguredEntry(entry) {
-        const configuredEntries = this._mergeConfiguredEntries(this._getConfiguredSettingEntriesForTarget(), this._getStoredSSHEntries());
-        const normalizedAddress = normalizeRemoteAgentHostAddress(getEntryAddress(entry));
-        const existingIndex = configuredEntries.findIndex(
-            e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalizedAddress
-        );
-        if (existingIndex === -1) {
-            return [...configuredEntries, entry];
-        }
-        return ( configuredEntries.map((e, index) => index === existingIndex ? entry : e));
-    }
-    _getConfigurationTarget() {
-        const inspected = this._configurationService.inspect(RemoteAgentHostsSettingId);
-        if (inspected.userLocalValue !== undefined) {
-            return ConfigurationTarget.USER_LOCAL;
-        }
-        if (inspected.userRemoteValue !== undefined) {
-            return ConfigurationTarget.USER_REMOTE;
-        }
-        if (inspected.userValue !== undefined) {
-            return ConfigurationTarget.USER;
-        }
-        return ConfigurationTarget.USER;
-    }
-    async _storeConfiguredEntries(entries) {
-        this._storeStoredSSHEntries(
-            entries.filter(entry => entry.connection.type === RemoteAgentHostEntryType.SSH)
-        );
-        const raw = ( entries.filter(entry => entry.connection.type !== RemoteAgentHostEntryType.SSH).map(entryToRawEntry)).filter(isDefined);
-        await this._configurationService.updateValue(RemoteAgentHostsSettingId, raw, this._getConfigurationTarget());
-    }
-    _getConfiguredSettingEntries() {
-        return ( (this._configurationService.getValue(RemoteAgentHostsSettingId) ?? []).map(rawEntryToEntry)).filter(isDefined);
-    }
-    _getConfiguredSettingEntriesForTarget() {
-        return ( this._getConfiguredRawEntriesForTarget().map(rawEntryToEntry)).filter(isDefined);
-    }
-    _getConfiguredRawEntriesForTarget() {
-        const target = this._getConfigurationTarget();
-        const inspected = this._configurationService.inspect(RemoteAgentHostsSettingId);
-        switch (target) {
-        case ConfigurationTarget.USER_LOCAL:
-            return inspected.userLocalValue ?? [];
-        case ConfigurationTarget.USER_REMOTE:
-            return inspected.userRemoteValue ?? [];
-        default:
-            return inspected.userValue ?? [];
-        }
-    }
-    _getStoredSSHEntries() {
-        const raw = this._storageService.get(SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY, StorageScope.APPLICATION);
-        if (!raw) {
-            return [];
-        }
-        try {
-            const parsed = JSON.parse(raw);
-            if (!Array.isArray(parsed)) {
-                return [];
-            }
-            return ( parsed.map(
-                item => isRawRemoteAgentHostEntry(item) ? rawEntryToEntry(item) : undefined
-            )).filter(entry => entry?.connection.type === RemoteAgentHostEntryType.SSH);
-        } catch {
-            return [];
-        }
-    }
-    _storeStoredSSHEntries(entries) {
-        const raw = ( entries.filter(entry => entry.connection.type === RemoteAgentHostEntryType.SSH).map(entryToRawEntry)).filter(isDefined);
-        if (raw.length === 0) {
-            this._storageService.remove(SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY, StorageScope.APPLICATION);
-        } else {
-            this._storageService.store(
-                SSH_REMOTE_AGENT_HOSTS_STORAGE_KEY,
-                JSON.stringify(raw),
-                StorageScope.APPLICATION,
-                StorageTarget.USER
-            );
-        }
-    }
-    _migrateSSHEntriesFromSetting() {
-        const configuredEntries = this._getConfiguredSettingEntriesForTarget();
-        const sshEntries = configuredEntries.filter(entry => entry.connection.type === RemoteAgentHostEntryType.SSH);
-        if (sshEntries.length === 0) {
-            return;
-        }
-        const migratedEntries = this._mergeConfiguredEntries(this._getStoredSSHEntries(), sshEntries);
-        this._storeStoredSSHEntries(migratedEntries);
-        const nonSSHEntries = configuredEntries.filter(entry => entry.connection.type !== RemoteAgentHostEntryType.SSH);
-        const raw = ( nonSSHEntries.map(entryToRawEntry)).filter(isDefined);
-        this._configurationService.updateValue(RemoteAgentHostsSettingId, raw, this._getConfigurationTarget()).catch(err => {
-            this._logService.error(
-                "[RemoteAgentHost] Failed to migrate SSH connection details from settings to storage",
-                err
-            );
-        });
-    }
-    _mergeConfiguredEntries(base, incoming) {
-        let result = base;
-        for (const entry of incoming) {
-            const normalizedAddress = normalizeRemoteAgentHostAddress(getEntryAddress(entry));
-            const existingIndex = result.findIndex(
-                e => normalizeRemoteAgentHostAddress(getEntryAddress(e)) === normalizedAddress
-            );
-            if (existingIndex === -1) {
-                result = [...result, entry];
-            } else {
-                result = ( result.map((e, index) => index === existingIndex ? entry : e));
-            }
-        }
-        return result;
+    _upsertEntry(entries, entry) {
+        const address = this._entryAddress(entry);
+        const existingIndex = entries.findIndex(candidate => this._entryAddress(candidate) === address);
+        return existingIndex === -1 ? [...entries, entry] : ( entries.map((candidate, index) => index === existingIndex ? entry : candidate));
     }
     _getOrCreateConnectionWait(address) {
         let wait = this._pendingConnectionWaits.get(address);
@@ -616,6 +680,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
             return immediateWait;
         }
         wait = ( new DeferredPromise());
+        wait.p.then(undefined, () => {});
         this._pendingConnectionWaits.set(address, wait);
         return wait;
     }
@@ -662,6 +727,7 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         }
         this._reconnectTimeouts.clear();
         this._reconnectAttempts.clear();
+        this._pendingConnects.clear();
         for (const [address, wait] of this._pendingConnectionWaits) {
             void wait.error(( new Error(`Remote agent host service disposed before connecting to ${address}`)));
         }
@@ -677,6 +743,6 @@ let RemoteAgentHostService = class RemoteAgentHostService extends Disposable {
         super.dispose();
     }
 };
-RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService)), ( __param(3, ILabelService)), ( __param(4, IEnvironmentService)), ( __param(5, IStorageService))], RemoteAgentHostService));
+RemoteAgentHostService = RemoteAgentHostService_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IInstantiationService)), ( __param(2, ILogService)), ( __param(3, ILabelService)), ( __param(4, IEnvironmentService))], RemoteAgentHostService));
 
 export { RemoteAgentHostService };