@codingame/monaco-vscode-chat-service-override 31.0.0 → 32.0.0

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

@@ -1,6 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { IntervalTimer, 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 { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
@@ -13,14 +14,34 @@ import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/fi
 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 '@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 { PROTOCOL_VERSION } from '../common/state/sessionCapabilities.js';
-import { isJsonRpcRequest, isJsonRpcResponse, isJsonRpcNotification } from '../common/state/sessionProtocol.js';
+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 '../common/state/protocol/commands.js';
+import { 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 { 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) {
+    return ( new ProtocolError(
+        AHP_CLIENT_CONNECTION_CLOSED,
+        `Connection appears dead: ${address}; no message received for ${sinceLastReadMs}ms, oldest pending request is ${oldestRequestAgeMs}ms old.`
+    ));
+}
+function connectionClosedError(address) {
+    return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Connection closed: ${address}`));
+}
+function connectionDisposedError(address) {
+    return ( new ProtocolError(AHP_CLIENT_CONNECTION_CLOSED, `Connection disposed: ${address}`));
+}
 let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends Disposable {
     get clientId() {
         return this._clientId;
@@ -31,13 +52,15 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
     get defaultDirectory() {
         return this._defaultDirectory;
     }
-    constructor(address, transport, _logService, _fileService) {
+    constructor(address, transport, _logService, _fileService, _permissionService) {
         super();
         this._logService = _logService;
         this._fileService = _fileService;
+        this._permissionService = _permissionService;
         this._clientId = generateUuid();
         this._serverSeq = 0;
         this._nextClientSeq = 1;
+        this._completionTriggerCharacters = [];
         this._onDidAction = this._register(( new Emitter()));
         this.onDidAction = this._onDidAction.event;
         this._onDidNotification = this._register(( new Emitter()));
@@ -46,12 +69,18 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         this.onDidClose = this._onDidClose.event;
         this._pendingRequests = ( new Map());
         this._nextRequestId = 1;
+        this._isClosed = false;
+        this._lastReadTime = Date.now();
+        this._watchdog = this._register(( new IntervalTimer()));
+        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._onDidClose.fire()));
+        this._register(
+            this._transport.onClose(() => this._handleClose(connectionClosedError(this._address)))
+        );
         this._subscriptionManager = this._register(( new AgentSubscriptionManager(
             this._clientId,
             () => this.nextClientSeq(),
@@ -62,13 +91,18 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         this._register(this.onDidAction(envelope => {
             this._subscriptionManager.receiveEnvelope(envelope);
         }));
+        this._watchdog.cancelAndSet(() => this._watchdogTick(), WATCHDOG_CHECK_INTERVAL_MS);
+    }
+    dispose() {
+        this._handleClose(connectionDisposedError(this._address));
+        super.dispose();
     }
     async connect() {
         if (isClientTransport(this._transport)) {
-            await this._transport.connect();
+            await this._raceClose(this._transport.connect());
         }
         const result = await this._sendRequest("initialize", {
-            protocolVersion: PROTOCOL_VERSION,
+            protocolVersions: [PROTOCOL_VERSION],
             clientId: this._clientId,
             initialSubscriptions: [ROOT_STATE_URI]
         });
@@ -86,6 +120,7 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 this._defaultDirectory = URI.revive(dir).path;
             }
         }
+        this._completionTriggerCharacters = result.completionTriggerCharacters ?? [];
     }
     get rootState() {
         return this._subscriptionManager.rootState;
@@ -112,20 +147,28 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         });
     }
     dispatchAction(action, _clientId, clientSeq) {
+        this._grantImplicitReadsForOutgoingAction(action);
         this._sendNotification("dispatchAction", {
             clientSeq,
             action
         });
     }
     async createSession(config) {
-        const provider = config?.provider ?? "copilot";
-        const session = AgentSession.uri(provider, generateUuid());
+        const provider = config?.provider;
+        if (!provider) {
+            throw ( new Error("Cannot create remote agent host session without a provider."));
+        }
+        const session = config?.session ?? AgentSession.uri(provider, generateUuid());
+        if (config?.activeClient?.customizations) {
+            this._grantImplicitReadsForCustomizations(config.activeClient.customizations);
+        }
         await this._sendRequest("createSession", {
             session: ( session.toString()),
             provider,
             model: config?.model,
             workingDirectory: config?.workingDirectory ? ( fromAgentHostUri(config.workingDirectory).toString()) : undefined,
-            config: config?.config
+            config: config?.config,
+            activeClient: config?.activeClient
         });
         return session;
     }
@@ -145,6 +188,12 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             query: params.query
         });
     }
+    async completions(params) {
+        return this._sendRequest("completions", params);
+    }
+    async getCompletionTriggerCharacters() {
+        return this._completionTriggerCharacters;
+    }
     async authenticate(params) {
         await this._sendRequest("authenticate", params);
         return {
@@ -181,14 +230,37 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             } : {}),
             summary: s.title,
             status: s.status,
+            activity: s.activity,
             workingDirectory: typeof s.workingDirectory === "string" ? toAgentHostUri(( URI.parse(s.workingDirectory)), this._connectionAuthority) : undefined,
-            isRead: s.isRead,
-            isDone: s.isDone
+            isRead: !!(s.status & SessionStatus.IsRead),
+            isArchived: !!(s.status & SessionStatus.IsArchived),
+            diffs: s.diffs
         })));
     }
     _toLocalProjectUri(uri) {
         return uri.scheme === Schemas.file ? toAgentHostUri(uri, this._connectionAuthority) : uri;
     }
+    _grantImplicitReadsForOutgoingAction(action) {
+        if (action.type === ActionType.SessionActiveClientChanged && action.activeClient?.customizations) {
+            this._grantImplicitReadsForCustomizations(action.activeClient.customizations);
+        }
+    }
+    _grantImplicitReadsForCustomizations(refs) {
+        for (const ref of refs) {
+            let uri;
+            try {
+                uri = ( URI.parse(ref.uri));
+            } catch {
+                continue;
+            }
+            const key = ( uri.toString());
+            if (( this._grantedCustomizationUris.has(key))) {
+                continue;
+            }
+            this._grantedCustomizationUris.add(key);
+            this._permissionService.grantImplicitRead(this._address, uri);
+        }
+    }
     async resourceList(uri) {
         return await this._sendRequest("resourceList", {
             uri: ( uri.toString())
@@ -212,6 +284,10 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         return this._sendRequest("resourceMove", params);
     }
     _handleMessage(msg) {
+        if (this._isClosed) {
+            return;
+        }
+        this._lastReadTime = Date.now();
         if (isJsonRpcRequest(msg)) {
             this._handleReverseRequest(msg.id, msg.method, msg.params);
         } else if (isJsonRpcResponse(msg)) {
@@ -222,9 +298,9 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                     error: true
                 })) {
                     this._logService.warn(`[RemoteAgentHostProtocol] Request ${msg.id} failed:`, msg.error);
-                    pending.error(( new Error(msg.error.message)));
+                    pending.deferred.error(this._toProtocolError(msg.error));
                 } else {
-                    pending.complete(msg.result);
+                    pending.deferred.complete(msg.result);
                 }
             } else {
                 this._logService.warn(
@@ -255,6 +331,32 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
             this._logService.warn(`[RemoteAgentHostProtocol] Unrecognized message:`, JSON.stringify(msg));
         }
     }
+    _handleClose(error) {
+        if (this._isClosed) {
+            return;
+        }
+        this._isClosed = true;
+        this._closeError = error;
+        this._watchdog.cancel();
+        this._rejectPendingRequests(error);
+        this._permissionService.connectionClosed(this._address);
+        this._grantedCustomizationUris.clear();
+        this._onDidClose.fire();
+    }
+    async _raceClose(promise) {
+        if (this._closeError) {
+            return Promise.reject(this._closeError);
+        }
+        let closeListener = Disposable.None;
+        const closePromise = ( new Promise((_resolve, reject) => {
+            closeListener = this.onDidClose(() => reject(this._closeError));
+        }));
+        try {
+            return await Promise.race([promise, closePromise]);
+        } finally {
+            closeListener.dispose();
+        }
+    }
     _handleReverseRequest(id, method, params) {
         const sendResult = result => {
             this._transport.send({
@@ -286,68 +388,153 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
                 }
             });
         };
-        const handle = fn => {
-            fn().then(sendResult, sendError);
+        const sendPermissionDenied = request => {
+            this._transport.send({
+                jsonrpc: "2.0",
+                id,
+                error: {
+                    code: AhpErrorCodes.PermissionDenied,
+                    message: request ? `Access to ${request.uri} is not granted.` : "Access to the requested resource is not granted.",
+                    data: request ? {
+                        request
+                    } : undefined
+                }
+            });
+        };
+        const gateAndHandle = async (uri, mode, deniedRequest, fn) => {
+            try {
+                if (!(await this._permissionService.check(this._address, uri, mode))) {
+                    sendPermissionDenied(deniedRequest);
+                    return;
+                }
+                sendResult(await fn());
+            } catch (err) {
+                sendError(err);
+            }
         };
         const p = params;
         switch (method) {
         case "resourceList":
-            if (!p.uri) {
-                sendError(( new Error("Missing uri")));
-                return;
+            {
+                if (!p.uri) {
+                    sendError(( new Error("Missing uri")));
+                    return;
+                }
+                const uri = ( URI.parse(p.uri));
+                return void gateAndHandle(uri, AgentHostPermissionMode.Read, {
+                    uri: ( uri.toString()),
+                    read: true
+                }, async () => {
+                    const stat = await this._fileService.resolve(uri);
+                    return {
+                        entries: ( (stat.children ?? []).map(c => ({
+                            name: c.name,
+                            type: c.isDirectory ? "directory" : "file"
+                        })))
+                    };
+                });
             }
-            return handle(async () => {
-                const stat = await this._fileService.resolve(( URI.parse(p.uri)));
-                return {
-                    entries: ( (stat.children ?? []).map(c => ({
-                        name: c.name,
-                        type: c.isDirectory ? "directory" : "file"
-                    })))
-                };
-            });
         case "resourceRead":
-            if (!p.uri) {
-                sendError(( new Error("Missing uri")));
-                return;
+            {
+                if (!p.uri) {
+                    sendError(( new Error("Missing uri")));
+                    return;
+                }
+                const uri = ( URI.parse(p.uri));
+                return void gateAndHandle(uri, AgentHostPermissionMode.Read, {
+                    uri: ( uri.toString()),
+                    read: true
+                }, async () => {
+                    const content = await this._fileService.readFile(uri);
+                    return {
+                        data: encodeBase64(content.value),
+                        encoding: ContentEncoding.Base64
+                    };
+                });
             }
-            return handle(async () => {
-                const content = await this._fileService.readFile(( URI.parse(p.uri)));
-                return {
-                    data: encodeBase64(content.value),
-                    encoding: ContentEncoding.Base64
-                };
-            });
         case "resourceWrite":
-            if (!p.uri || !p.data) {
-                sendError(( new Error("Missing uri or data")));
-                return;
-            }
-            return handle(async () => {
-                const writeUri = ( URI.parse(p.uri));
-                const buf = p.encoding === ContentEncoding.Base64 ? decodeBase64(p.data) : VSBuffer.fromString(p.data);
-                if (p.createOnly) {
-                    await this._fileService.createFile(writeUri, buf, {
-                        overwrite: false
-                    });
-                } else {
-                    await this._fileService.writeFile(writeUri, buf);
+            {
+                if (!p.uri || !p.data) {
+                    sendError(( new Error("Missing uri or data")));
+                    return;
                 }
-                return {};
-            });
+                const writeUri = ( URI.parse(p.uri));
+                return void gateAndHandle(writeUri, AgentHostPermissionMode.Write, {
+                    uri: ( writeUri.toString()),
+                    write: true
+                }, async () => {
+                    const buf = p.encoding === ContentEncoding.Base64 ? decodeBase64(p.data) : VSBuffer.fromString(p.data);
+                    if (p.createOnly) {
+                        await this._fileService.createFile(writeUri, buf, {
+                            overwrite: false
+                        });
+                    } else {
+                        await this._fileService.writeFile(writeUri, buf);
+                    }
+                    return {};
+                });
+            }
         case "resourceDelete":
-            if (!p.uri) {
-                sendError(( new Error("Missing uri")));
-                return;
+            {
+                if (!p.uri) {
+                    sendError(( new Error("Missing uri")));
+                    return;
+                }
+                const deleteUri = ( URI.parse(p.uri));
+                return void gateAndHandle(deleteUri, AgentHostPermissionMode.Write, {
+                    uri: ( deleteUri.toString()),
+                    write: true
+                }, () => this._fileService.del(deleteUri, {
+                    recursive: !!p.recursive
+                }).then(() => ({})));
             }
-            return handle(() => this._fileService.del(( URI.parse(p.uri)), {
-                recursive: !!p.recursive
-            }).then(() => ({})));
         case "resourceMove":
-            if (!p.source || !p.destination) {
-                sendError(( new Error("Missing source or destination")));
+            {
+                if (!p.source || !p.destination) {
+                    sendError(( new Error("Missing source or destination")));
+                    return;
+                }
+                const sourceUri = ( URI.parse(p.source));
+                const destUri = ( URI.parse(p.destination));
+                return void (async () => {
+                    try {
+                        const [sourceOk, destOk] = await Promise.all([
+                            this._permissionService.check(this._address, sourceUri, AgentHostPermissionMode.Write),
+                            this._permissionService.check(this._address, destUri, AgentHostPermissionMode.Write)
+                        ]);
+                        if (!sourceOk) {
+                            sendPermissionDenied({
+                                uri: ( sourceUri.toString()),
+                                write: true
+                            });
+                            return;
+                        }
+                        if (!destOk) {
+                            sendPermissionDenied({
+                                uri: ( destUri.toString()),
+                                write: true
+                            });
+                            return;
+                        }
+                        await this._fileService.move(sourceUri, destUri, !p.failIfExists);
+                        sendResult({});
+                    } catch (err) {
+                        sendError(err);
+                    }
+                })();
+            }
+        case "resourceRequest":
+            {
+                const requestParams = p;
+                this._permissionService.request(this._address, requestParams).then(() => sendResult({})).catch(err => {
+                    if (err instanceof CancellationError) {
+                        sendPermissionDenied(undefined);
+                    } else {
+                        sendError(err);
+                    }
+                });
                 return;
             }
-            return handle(() => this._fileService.move(( URI.parse(p.source)), ( URI.parse(p.destination)), !p.failIfExists).then(() => ({})));
         default:
             this._logService.warn(`[RemoteAgentHostProtocol] Unhandled reverse request: ${method}`);
             sendError(( new Error(`Unknown method: ${method}`)));
@@ -361,9 +548,15 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         });
     }
     _sendRequest(method, params) {
+        if (this._closeError) {
+            return Promise.reject(this._closeError);
+        }
         const id = this._nextRequestId++;
         const deferred = ( new DeferredPromise());
-        this._pendingRequests.set(id, deferred);
+        this._pendingRequests.set(id, {
+            deferred,
+            sentAt: Date.now()
+        });
         this._transport.send({
             jsonrpc: "2.0",
             id,
@@ -373,21 +566,61 @@ let RemoteAgentHostProtocolClient = class RemoteAgentHostProtocolClient extends
         return deferred.p;
     }
     _sendExtensionRequest(method, params) {
+        if (this._closeError) {
+            return Promise.reject(this._closeError);
+        }
         const id = this._nextRequestId++;
         const deferred = ( new DeferredPromise());
-        this._pendingRequests.set(id, deferred);
-        this._transport.send({
+        this._pendingRequests.set(id, {
+            deferred,
+            sentAt: Date.now()
+        });
+        const request = {
             jsonrpc: "2.0",
             id,
             method,
             params
-        });
+        };
+        this._transport.send(request);
         return deferred.p;
     }
+    _toProtocolError(error) {
+        return ( new ProtocolError(error.code, error.message, error.data));
+    }
+    _rejectPendingRequests(error) {
+        for (const pending of ( this._pendingRequests.values())) {
+            pending.deferred.error(error);
+        }
+        this._pendingRequests.clear();
+    }
+    _watchdogTick() {
+        if (this._isClosed || this._pendingRequests.size === 0) {
+            return;
+        }
+        const now = Date.now();
+        const sinceLastRead = now - this._lastReadTime;
+        if (sinceLastRead < WATCHDOG_TIMEOUT_MS) {
+            return;
+        }
+        let oldestSentAt = now;
+        for (const pending of ( this._pendingRequests.values())) {
+            if (pending.sentAt < oldestSentAt) {
+                oldestSentAt = pending.sentAt;
+            }
+        }
+        const oldestAge = now - oldestSentAt;
+        if (oldestAge < WATCHDOG_TIMEOUT_MS) {
+            return;
+        }
+        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.`
+        );
+        this._handleClose(connectionTimeoutError(this._address, sinceLastRead, oldestAge));
+    }
     nextClientSeq() {
         return this._nextClientSeq++;
     }
 };
-RemoteAgentHostProtocolClient = ( __decorate([( __param(2, ILogService)), ( __param(3, IFileService))], RemoteAgentHostProtocolClient));
+RemoteAgentHostProtocolClient = ( __decorate([( __param(2, ILogService)), ( __param(3, IFileService)), ( __param(4, IAgentHostPermissionService))], RemoteAgentHostProtocolClient));
 
 export { RemoteAgentHostProtocolClient };

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

@@ -1,14 +1,18 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 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 type { IAgentConnection } from "../common/agentService.js";
+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";
 export declare class RemoteAgentHostService extends Disposable implements IRemoteAgentHostService {
     private readonly _configurationService;
     private readonly _instantiationService;
     private readonly _logService;
+    private readonly _labelService;
+    private readonly _environmentService;
     private static readonly ConnectionWaitTimeout;
     /** Initial reconnect delay in milliseconds. */
     private static readonly ReconnectInitialDelay;
@@ -22,7 +26,7 @@ export declare class RemoteAgentHostService extends Disposable implements IRemot
     private readonly _tokens;
     /**
      * Stores the original {@link IRemoteAgentHostEntry} for connections
-     * registered via {@link addSSHConnection}. This is needed because
+     * registered via {@link addManagedConnection}. This is needed because
      * tunnel entries are not persisted to settings and therefore don't
      * appear in {@link configuredEntries}.
      */
@@ -32,14 +36,21 @@ export declare class RemoteAgentHostService extends Disposable implements IRemot
     private readonly _reconnectTimeouts;
     /** Current reconnect attempt count per address for exponential backoff. */
     private readonly _reconnectAttempts;
-    constructor(_configurationService: IConfigurationService, _instantiationService: IInstantiationService, _logService: ILogService);
+    /**
+     * Per-address {@link ILabelService} formatter handles for the
+     * {@link AGENT_HOST_SCHEME}. The formatter advertises the entry's
+     * human-readable name as the host label so any UI looking up the host
+     * label for an agent host URI gets the friendly name.
+     */
+    private readonly _labelFormatters;
+    constructor(_configurationService: IConfigurationService, _instantiationService: IInstantiationService, _logService: ILogService, _labelService: ILabelService, _environmentService: IEnvironmentService);
     get connections(): readonly IRemoteAgentHostConnectionInfo[];
     get configuredEntries(): readonly IRemoteAgentHostEntry[];
     getConnection(address: string): IAgentConnection | undefined;
     getEntryByAddress(address: string): IRemoteAgentHostEntry | undefined;
     reconnect(address: string): void;
     addRemoteAgentHost(input: IRemoteAgentHostEntry): Promise<IRemoteAgentHostConnectionInfo>;
-    addSSHConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection): Promise<IRemoteAgentHostConnectionInfo>;
+    addManagedConnection(entry: IRemoteAgentHostEntry, connection: IAgentConnection, transportDisposable?: IDisposable): Promise<IRemoteAgentHostConnectionInfo>;
     removeRemoteAgentHost(address: string): Promise<void>;
     private _removeConnection;
     private _reconcileConnections;
@@ -61,5 +72,13 @@ export declare class RemoteAgentHostService extends Disposable implements IRemot
     private _getOrCreateConnectionWait;
     private _resolvePendingConnectionWait;
     private _rejectPendingConnectionWait;
+    /**
+     * Register (or re-register) the {@link AGENT_HOST_SCHEME} label formatter
+     * for the given address so that {@link ILabelService.getHostLabel} resolves
+     * to the entry's human-readable name. Called when an entry is added or its
+     * name changes.
+     */
+    private _updateHostLabelFormatter;
+    private _clearHostLabelFormatter;
     dispose(): void;
 }