@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/tunnelAgentHost.contribution.js

@@ -0,0 +1,438 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { RemoteAgentHostsEnabledSettingId, RemoteAgentHostConnectionStatus, RemoteAgentHostAutoConnectSettingId } 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 { TUNNEL_ADDRESS_PREFIX, isTunnelHosted, TUNNEL_MIN_PROTOCOL_VERSION } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost';
+import { ITunnelAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IRemoteTunnelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/remoteTunnel/common/remoteTunnel.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { logTunnelConnectAttempt, logTunnelConnectResolved, logTunnelDiscoveryResult } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { IAgentHostFilterService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/agentHostFilter/common/agentHostFilter.service';
+import { RemoteAgentHostSessionsProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostSessionsProvider';
+import { watchForIncompatibleNotifications } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteHostOptions';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+const STATUS_CHECK_INTERVAL = 5 * 60 * 1000;
+let TunnelAgentHostContribution = class TunnelAgentHostContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.tunnelAgentHostContribution";
+    }
+    constructor(
+        _tunnelService,
+        _remoteAgentHostService,
+        _sessionsProvidersService,
+        _configurationService,
+        _instantiationService,
+        _notificationService,
+        _logService,
+        _authenticationService,
+        _telemetryService,
+        _hostService,
+        _remoteTunnelService,
+        agentHostFilterService
+    ) {
+        super();
+        this._tunnelService = _tunnelService;
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._notificationService = _notificationService;
+        this._logService = _logService;
+        this._authenticationService = _authenticationService;
+        this._telemetryService = _telemetryService;
+        this._hostService = _hostService;
+        this._remoteTunnelService = _remoteTunnelService;
+        this._providerStores = this._register(( new DisposableMap()));
+        this._providerInstances = ( new Map());
+        this._pendingConnects = ( new Map());
+        this._lastStatusCheck = 0;
+        this._hostedTunnelSuppressions = ( new Set());
+        this._remoteTunnelStatus = {
+            type: "uninitialized"
+        };
+        this._hasReceivedRemoteTunnelStatus = false;
+        this._initialStatusChecked = false;
+        this._wiredAddresses = ( new Set());
+        this._syncHostedTunnelSuppression();
+        this._reconcileProviders();
+        this._register(
+            agentHostFilterService.registerDiscoveryHandler(() => this._silentStatusCheck())
+        );
+        this._register(this._remoteAgentHostService.onDidChangeConnections(() => {
+            this._updateConnectionStatuses();
+            this._wireConnections();
+        }));
+        this._register(this._tunnelService.onDidChangeTunnels(() => {
+            this._syncHostedTunnelSuppression();
+            this._reconcileProviders();
+        }));
+        this._register(this._remoteTunnelService.onDidChangeTunnelStatus(status => {
+            this._hasReceivedRemoteTunnelStatus = true;
+            this._remoteTunnelStatus = status;
+            this._syncHostedTunnelSuppression();
+            void this._silentStatusCheck();
+        }));
+        void this._loadRemoteTunnelStatus();
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._reconcileProviders();
+            }
+        }));
+        this._register(this._authenticationService.onDidChangeSessions(e => {
+            if (e.providerId !== "github") {
+                return;
+            }
+            this._handleSessionsChange(e);
+        }));
+        this._register(this._hostService.onDidChangeFocus(focused => {
+            if (focused) {
+                void this._silentStatusCheck();
+                this._requestServiceReconnects();
+            }
+        }));
+        agentHostFilterService.rediscover();
+    }
+    async checkTunnelStatuses() {
+        if (Date.now() - this._lastStatusCheck < STATUS_CHECK_INTERVAL) {
+            return;
+        }
+        await this._silentStatusCheck();
+    }
+    _reconcileProviders() {
+        const enabled = this._configurationService.getValue(RemoteAgentHostsEnabledSettingId);
+        const cached = enabled ? this._getProviderTunnels() : [];
+        const desiredAddresses = ( new Set(cached.map(t => `${TUNNEL_ADDRESS_PREFIX}${t.tunnelId}`)));
+        for (const [address] of this._providerStores) {
+            if (!( desiredAddresses.has(address))) {
+                this._providerStores.deleteAndDispose(address);
+                this._providerInstances.delete(address);
+            }
+        }
+        for (const tunnel of cached) {
+            const address = `${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`;
+            if (!( this._providerStores.has(address))) {
+                this._createProvider(address, tunnel.name);
+            }
+        }
+    }
+    _getProviderTunnels() {
+        return this._tunnelService.getCachedTunnels().filter(tunnel => !this._tunnelService.isTunnelDismissed(tunnel.tunnelId));
+    }
+    _isHostedTunnel(tunnel) {
+        return isTunnelHosted(
+            this._remoteTunnelStatus.type === "connected" ? this._remoteTunnelStatus.info : undefined,
+            tunnel
+        );
+    }
+    async _loadRemoteTunnelStatus() {
+        const status = await this._remoteTunnelService.getTunnelStatus();
+        if (!this._hasReceivedRemoteTunnelStatus) {
+            this._remoteTunnelStatus = status;
+        }
+        this._syncHostedTunnelSuppression();
+    }
+    _syncHostedTunnelSuppression() {
+        const hostedTunnelIds = ( new Set());
+        for (const tunnel of this._tunnelService.getCachedTunnels()) {
+            if (!this._isHostedTunnel(tunnel)) {
+                continue;
+            }
+            hostedTunnelIds.add(tunnel.tunnelId);
+            if (!this._tunnelService.isAutoConnectSuppressed(tunnel.tunnelId)) {
+                this._hostedTunnelSuppressions.add(tunnel.tunnelId);
+                this._tunnelService.suppressAutoConnect(tunnel.tunnelId);
+            }
+            const address = `${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`;
+            if (( this._remoteAgentHostService.connections.some(
+                connection => connection.address === address && RemoteAgentHostConnectionStatus.isConnected(connection.status)
+            ))) {
+                void this._tunnelService.disconnect(address);
+            }
+        }
+        for (const tunnelId of this._hostedTunnelSuppressions) {
+            if (!( hostedTunnelIds.has(tunnelId))) {
+                this._hostedTunnelSuppressions.delete(tunnelId);
+                this._tunnelService.clearAutoConnectSuppression(tunnelId);
+            }
+        }
+    }
+    _createProvider(address, name) {
+        const store = ( new DisposableStore());
+        const provider = this._instantiateProvider(address, name);
+        provider.setConnectionStatus(RemoteAgentHostConnectionStatus.connecting);
+        store.add(provider);
+        store.add(this._sessionsProvidersService.registerProvider(provider));
+        store.add(
+            watchForIncompatibleNotifications(provider, this._instantiationService, this._notificationService)
+        );
+        this._providerInstances.set(address, provider);
+        store.add(toDisposable(() => {
+            this._providerInstances.delete(address);
+            this._wiredAddresses.delete(address);
+        }));
+        this._providerStores.set(address, store);
+    }
+    _instantiateProvider(address, name) {
+        return this._instantiationService.createInstance(RemoteAgentHostSessionsProvider, {
+            address,
+            name,
+            connectOnDemand: () => this._connectTunnel(address, {
+                userInitiated: true
+            }),
+            disconnectOnDemand: () => this._disconnectTunnel(address)
+        });
+    }
+    _updateConnectionStatuses() {
+        for (const [address, provider] of this._providerInstances) {
+            const connectionInfo = this._remoteAgentHostService.connections.find(c => c.address === address);
+            if (connectionInfo) {
+                provider.setConnectionStatus(connectionInfo.status);
+                continue;
+            }
+            if (RemoteAgentHostConnectionStatus.isIncompatible(provider.connectionStatus.get())) {
+                continue;
+            }
+            if (( this._pendingConnects.has(address))) {
+                provider.setConnectionStatus(RemoteAgentHostConnectionStatus.connecting);
+            } else if (!this._initialStatusChecked) {
+                provider.setConnectionStatus(RemoteAgentHostConnectionStatus.connecting);
+            } else {
+                provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+            }
+        }
+    }
+    _wireConnections() {
+        for (const [address, provider] of this._providerInstances) {
+            const connectionInfo = this._remoteAgentHostService.connections.find(c => c.address === address);
+            if (connectionInfo && RemoteAgentHostConnectionStatus.isConnected(connectionInfo.status)) {
+                const connection = this._remoteAgentHostService.getConnection(address);
+                if (connection) {
+                    provider.setConnection(connection, connectionInfo.defaultDirectory);
+                    this._wiredAddresses.add(address);
+                }
+            } else if (( this._wiredAddresses.has(address)) && !RemoteAgentHostConnectionStatus.isConnecting(connectionInfo?.status) && !RemoteAgentHostConnectionStatus.isReconnecting(connectionInfo?.status)) {
+                this._wiredAddresses.delete(address);
+                provider.clearConnection();
+            }
+        }
+    }
+    _connectTunnel(address, options) {
+        const existing = this._pendingConnects.get(address);
+        if (existing) {
+            return existing;
+        }
+        const tunnelId = address.slice(TUNNEL_ADDRESS_PREFIX.length);
+        if (options.userInitiated) {
+            this._tunnelService.clearTunnelDismissal(tunnelId);
+        }
+        const cached = this._tunnelService.getCachedTunnels().find(t => t.tunnelId === tunnelId);
+        const attemptStart = Date.now();
+        const promise = (async () => {
+            let handle;
+            const timer = options.userInitiated && cached ? setTimeout(() => {
+                handle = this._notificationService.notify({
+                    severity: Severity.Info,
+                    message: ( localize(4460, "Connecting to tunnel '{0}'...", cached.name)),
+                    progress: {
+                        infinite: true
+                    }
+                });
+            }, 1000) : undefined;
+            try {
+                if (!cached || this._isHostedTunnel(cached)) {
+                    return;
+                }
+                const tunnelInfo = {
+                    tunnelId: cached.tunnelId,
+                    clusterId: cached.clusterId,
+                    name: cached.name,
+                    tags: [],
+                    protocolVersion: cached.protocolVersion ?? TUNNEL_MIN_PROTOCOL_VERSION,
+                    hostConnectionCount: 0
+                };
+                await this._tunnelService.connect(tunnelInfo, cached.authProvider, {
+                    userInitiated: options.userInitiated
+                });
+                logTunnelConnectAttempt(this._telemetryService, {
+                    isReconnect: false,
+                    attempt: 1,
+                    durationMs: Date.now() - attemptStart,
+                    success: true
+                });
+                logTunnelConnectResolved(this._telemetryService, {
+                    isReconnect: false,
+                    totalAttempts: 1,
+                    totalDurationMs: Date.now() - attemptStart,
+                    success: true
+                });
+            } catch (err) {
+                this._logService.warn(`[TunnelAgentHost] Connect to ${cached?.name ?? address} failed:`, err);
+                logTunnelConnectAttempt(this._telemetryService, {
+                    isReconnect: false,
+                    attempt: 1,
+                    durationMs: Date.now() - attemptStart,
+                    success: false,
+                    errorCategory: "other"
+                });
+                logTunnelConnectResolved(this._telemetryService, {
+                    isReconnect: false,
+                    totalAttempts: 1,
+                    totalDurationMs: Date.now() - attemptStart,
+                    success: false
+                });
+                throw err;
+            } finally {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+                handle?.close();
+                this._pendingConnects.delete(address);
+                this._updateConnectionStatuses();
+            }
+        })();
+        this._pendingConnects.set(address, promise);
+        return promise;
+    }
+    async _disconnectTunnel(address) {
+        const tunnelId = address.slice(TUNNEL_ADDRESS_PREFIX.length);
+        this._tunnelService.dismissTunnel(tunnelId);
+        this._tunnelService.removeCachedTunnel(tunnelId);
+        await this._tunnelService.disconnect(address);
+    }
+    _requestServiceReconnects() {
+        if (!this._configurationService.getValue(RemoteAgentHostAutoConnectSettingId)) {
+            return;
+        }
+        for (const tunnel of this._tunnelService.getCachedTunnels()) {
+            if (this._isHostedTunnel(tunnel) || this._tunnelService.isAutoConnectSuppressed(tunnel.tunnelId)) {
+                continue;
+            }
+            const address = `${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`;
+            const status = this._remoteAgentHostService.connections.find(connection => connection.address === address)?.status;
+            if (RemoteAgentHostConnectionStatus.isConnected(status) || RemoteAgentHostConnectionStatus.isConnecting(status) || RemoteAgentHostConnectionStatus.isReconnecting(status) || RemoteAgentHostConnectionStatus.isIncompatible(status)) {
+                continue;
+            }
+            this._remoteAgentHostService.reconnect(address, false);
+        }
+    }
+    _handleSessionsChange(e) {
+        if ((e.event.removed?.length ?? 0) > 0) {
+            for (const tunnel of this._tunnelService.getCachedTunnels()) {
+                if (tunnel.authProvider === e.providerId) {
+                    void this._tunnelService.disconnect(`${TUNNEL_ADDRESS_PREFIX}${tunnel.tunnelId}`);
+                }
+            }
+        }
+        if ((e.event.added?.length ?? 0) > 0) {
+            void this._silentStatusCheck("sessionChange");
+        }
+    }
+    async _silentStatusCheck(trigger) {
+        const resolvedTrigger = trigger ?? (this._initialStatusChecked ? "rediscover" : "startup");
+        const hostsEnabled = this._configurationService.getValue(RemoteAgentHostsEnabledSettingId);
+        const autoConnectEnabled = this._configurationService.getValue(RemoteAgentHostAutoConnectSettingId);
+        if (!hostsEnabled) {
+            this._initialStatusChecked = true;
+            this._updateConnectionStatuses();
+            logTunnelDiscoveryResult(this._telemetryService, {
+                trigger: resolvedTrigger,
+                totalFound: 0,
+                withActiveHost: 0,
+                cachedBefore: this._tunnelService.getCachedTunnels().length,
+                autoConnectEnabled,
+                hostsEnabled,
+                success: true
+            });
+            return;
+        }
+        this._lastStatusCheck = Date.now();
+        const cachedBefore = this._tunnelService.getCachedTunnels().length;
+        let onlineTunnels;
+        try {
+            onlineTunnels = await this._tunnelService.listTunnels({
+                silent: true
+            });
+        } catch {
+            this._initialStatusChecked = true;
+            this._updateConnectionStatuses();
+            logTunnelDiscoveryResult(this._telemetryService, {
+                trigger: resolvedTrigger,
+                totalFound: 0,
+                withActiveHost: 0,
+                cachedBefore,
+                autoConnectEnabled,
+                hostsEnabled,
+                success: false
+            });
+            return;
+        }
+        const cached = this._tunnelService.getCachedTunnels();
+        if (onlineTunnels) {
+            const onlineIds = ( new Set(onlineTunnels.map(t => t.tunnelId)));
+            for (const tunnel of cached) {
+                if (!( onlineIds.has(tunnel.tunnelId))) {
+                    this._tunnelService.removeCachedTunnel(tunnel.tunnelId);
+                }
+            }
+            const cachedIds = ( new Set(cached.map(t => t.tunnelId)));
+            for (const tunnel of onlineTunnels) {
+                if (!( cachedIds.has(tunnel.tunnelId)) && !this._tunnelService.isTunnelDismissed(tunnel.tunnelId)) {
+                    this._tunnelService.cacheTunnel(tunnel, "github");
+                }
+            }
+            const onlineTunnelMap = ( new Map(onlineTunnels.map(t => [t.tunnelId, t])));
+            for (const [address, provider] of this._providerInstances) {
+                const hasConnection = ( this._remoteAgentHostService.connections.some(
+                    c => c.address === address && (RemoteAgentHostConnectionStatus.isConnected(c.status) || RemoteAgentHostConnectionStatus.isReconnecting(c.status))
+                ));
+                if (hasConnection) {
+                    continue;
+                }
+                const tunnelId = address.slice(TUNNEL_ADDRESS_PREFIX.length);
+                const info = onlineTunnelMap.get(tunnelId);
+                if (info && info.hostConnectionCount > 0) {
+                    provider.setConnectionStatus(RemoteAgentHostConnectionStatus.connected);
+                } else {
+                    provider.setConnectionStatus(RemoteAgentHostConnectionStatus.disconnected);
+                    provider.unpublishCachedSessions();
+                }
+            }
+        }
+        this._initialStatusChecked = true;
+        this._updateConnectionStatuses();
+        const totalFound = onlineTunnels?.length ?? 0;
+        const withActiveHost = onlineTunnels?.filter(t => t.hostConnectionCount > 0).length ?? 0;
+        this._logService.info(
+            `[TunnelAgentHost] Silent status check (${resolvedTrigger}): totalFound=${totalFound}, withActiveHost=${withActiveHost}, cachedBefore=${cachedBefore}, autoConnect=${autoConnectEnabled}`
+        );
+        logTunnelDiscoveryResult(this._telemetryService, {
+            trigger: resolvedTrigger,
+            totalFound,
+            withActiveHost,
+            cachedBefore,
+            autoConnectEnabled,
+            hostsEnabled,
+            success: true
+        });
+    }
+};
+TunnelAgentHostContribution = ( __decorate([( __param(0, ITunnelAgentHostService)), ( __param(1, IRemoteAgentHostService)), ( __param(2, ISessionsProvidersService)), ( __param(3, IConfigurationService)), ( __param(4, IInstantiationService)), ( __param(5, INotificationService)), ( __param(6, ILogService)), ( __param(7, IAuthenticationService)), ( __param(8, ITelemetryService)), ( __param(9, IHostService)), ( __param(10, IRemoteTunnelService)), ( __param(11, IAgentHostFilterService))], TunnelAgentHostContribution));
+registerWorkbenchContribution2(
+    TunnelAgentHostContribution.ID,
+    TunnelAgentHostContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { TunnelAgentHostContribution };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/webSocketAgentHost.contribution.d.ts

@@ -0,0 +1,14 @@
+import { type IRemoteAgentHostEntry, RemoteAgentHostEntryType } 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 { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { EntryDrivenProviderContribution } from "./entryDrivenProviderContribution.js";
+export declare class WebSocketAgentHostContribution extends EntryDrivenProviderContribution implements IWorkbenchContribution {
+    static readonly ID = "sessions.contrib.webSocketAgentHostContribution";
+    protected readonly _entryType = RemoteAgentHostEntryType.WebSocket;
+    constructor(remoteAgentHostService: IRemoteAgentHostService, configurationService: IConfigurationService, instantiationService: IInstantiationService, sessionsProvidersService: ISessionsProvidersService, notificationService: INotificationService);
+    protected _getProviderOptions(_entry: IRemoteAgentHostEntry): {};
+}

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/webSocketAgentHost.contribution.js

@@ -0,0 +1,52 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RemoteAgentHostEntryType, RemoteAgentHostsSettingId, RemoteAgentHostsEnabledSettingId } 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { EntryDrivenProviderContribution } from './entryDrivenProviderContribution.js';
+
+let WebSocketAgentHostContribution = class WebSocketAgentHostContribution extends EntryDrivenProviderContribution {
+    static {
+        this.ID = "sessions.contrib.webSocketAgentHostContribution";
+    }
+    constructor(
+        remoteAgentHostService,
+        configurationService,
+        instantiationService,
+        sessionsProvidersService,
+        notificationService
+    ) {
+        super(
+            remoteAgentHostService,
+            configurationService,
+            instantiationService,
+            sessionsProvidersService,
+            notificationService
+        );
+        this._entryType = RemoteAgentHostEntryType.WebSocket;
+        this._register(
+            this._remoteAgentHostService.onDidChangeConnections(() => this._reconcile())
+        );
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(RemoteAgentHostsSettingId) || e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._reconcile();
+            }
+        }));
+        this._reconcile();
+    }
+    _getProviderOptions(_entry) {
+        return {};
+    }
+};
+WebSocketAgentHostContribution = ( __decorate([( __param(0, IRemoteAgentHostService)), ( __param(1, IConfigurationService)), ( __param(2, IInstantiationService)), ( __param(3, ISessionsProvidersService)), ( __param(4, INotificationService))], WebSocketAgentHostContribution));
+registerWorkbenchContribution2(
+    WebSocketAgentHostContribution.ID,
+    WebSocketAgentHostContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { WebSocketAgentHostContribution };

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/wslAgentHost.contribution.d.ts

@@ -0,0 +1,44 @@
+import { type IRemoteAgentHostEntry, RemoteAgentHostEntryType } 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 { IWSLRemoteAgentHostService } from "../../../../../platform/agentHost/common/wslRemoteAgentHost.service.js";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { type IAgentHostAutoConnect } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ManagedReconnectAgentHostContribution } from "./managedReconnectAgentHostContribution.js";
+export declare function shouldPauseWSLReconnectAfterFailure(err: unknown): boolean;
+/**
+ * Manages session providers for WSL-backed remote agent hosts. The remote
+ * agent host service owns automatic dialing and retry of cached distros.
+ */
+export declare class WSLAgentHostContribution extends ManagedReconnectAgentHostContribution implements IWorkbenchContribution {
+    private readonly _wslService;
+    static readonly ID = "sessions.contrib.wslAgentHostContribution";
+    protected readonly _entryType = RemoteAgentHostEntryType.WSL;
+    private readonly _autoConnect;
+    constructor(remoteAgentHostService: IRemoteAgentHostService, _wslService: IWSLRemoteAgentHostService, configurationService: IConfigurationService, logService: ILogService, instantiationService: IInstantiationService, sessionsProvidersService: ISessionsProvidersService, notificationService: INotificationService);
+    /**
+     * Ask the service to redial cached distros that are running but not
+     * connected. Discovery is this contribution's job; the dial itself stays
+     * with the service, which owns every connection's lifecycle.
+     */
+    private _reconnectNewlyRunningDistros;
+    protected _getProviderEntries(): readonly IRemoteAgentHostEntry[];
+    protected _getProviderOptions(entry: IRemoteAgentHostEntry): {
+        connectOnDemand?: undefined;
+        disconnectOnDemand?: undefined;
+        onDidReportConnectProgress?: undefined;
+        autoConnect?: undefined;
+    } | {
+        connectOnDemand: () => Promise<void>;
+        disconnectOnDemand: () => Promise<void>;
+        onDidReportConnectProgress: import("@codingame/monaco-vscode-api/vscode/vs/sessions/sessions.web.main.internal").Event<import("../../../../../platform/agentHost/common/wslRemoteAgentHost.js").IWSLConnectProgress>;
+        autoConnect: IAgentHostAutoConnect;
+    };
+    private _connectWSLOnDemand;
+    private _attemptWSLReconnect;
+    private _disconnectWSLOnDemand;
+}