@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -1,5 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { RunOnceScheduler, raceTimeout } from '../../../../../base/common/async.js';
+import { isPassiveRelayConnection } from '../../../../../platform/agentHost/common/meta/relayConnectionMeta.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
 import { Emitter, Event } from '../../../../../base/common/event.js';
 import { DisposableStore } from '../../../../../base/common/lifecycle.js';
@@ -10,12 +12,15 @@ import { dirname, isEqual, basename } from '../../../../../base/common/resources
 import { URI } from '../../../../../base/common/uri.js';
 import { localize } from '../../../../../nls.js';
 import { agentHostUri } from '../../../../../platform/agentHost/common/agentHostFileSystemProvider.js';
-import { toAgentHostUri, agentHostAuthority, fromAgentHostUri, toAgentHostContentUri, AGENT_HOST_SCHEME } from '../../../../../platform/agentHost/common/agentHostUri.js';
+import { toAgentHostUri, agentHostAuthority, fromAgentHostUri, normalizeRemoteAgentHostAddress, AGENT_HOST_SCHEME, toAgentHostContentUri } from '../../../../../platform/agentHost/common/agentHostUri.js';
 import { AgentSession } from '../../../../../platform/agentHost/common/agent.js';
 import { IAgentHostService } from '../../../../../platform/agentHost/common/agentService.service.js';
 import { IAgentHostConnectionsService } from '../../../../../platform/agentHost/common/agentHostConnectionsService.service.js';
 import { RemoteAgentHostConnectionStatus, removeWebSocketRemoteAgentHostEntry } from '../../../../../platform/agentHost/common/remoteAgentHostService.js';
 import { IRemoteAgentHostService } from '../../../../../platform/agentHost/common/remoteAgentHostService.service.js';
+import { ActionType } from '../../../../../platform/agentHost/common/state/protocol/common/actions.js';
+import '../../../../../platform/agentHost/common/state/protocol/common/notifications.js';
+import { StateComponents } from '../../../../../platform/agentHost/common/state/sessionState.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
 import { IFileDialogService, IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
 import { IWorkspaceTrustManagementService } from '../../../../../platform/workspace/common/workspaceTrust.service.js';
@@ -24,32 +29,67 @@ import { ILabelService } from '../../../../../platform/label/common/label.servic
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
 import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
+import { IUriIdentityService } from '../../../../../platform/uriIdentity/common/uriIdentity.service.js';
 import { IAgentHostActiveClientService } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service.js';
+import { IAgentHostSessionWorkingDirectoryResolver } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service.js';
+import { IRemoteAgentHostAuthenticationService } from '../../../../../workbench/contrib/chat/browser/remoteAgentHost/remoteAgentHostAuthentication.service.js';
 import { IChatWidgetService } from '../../../../../workbench/contrib/chat/browser/chat.service.js';
 import { IChatService } from '../../../../../workbench/contrib/chat/common/chatService/chatService.service.js';
 import { IChatSessionsService } from '../../../../../workbench/contrib/chat/common/chatSessionsService.service.js';
 import { ILanguageModelsService } from '../../../../../workbench/contrib/chat/common/languageModels.service.js';
 import { readBranchProtectionPatterns, buildAgentHostSessionWorkspace } from '../../../../common/agentHostSessionWorkspace.js';
-import { SESSION_WORKSPACE_GROUP_REMOTE } from '../../../../services/sessions/common/session.js';
+import { DevContainerIdleTimeoutSettingId } from '../../../../common/devContainerAgentHostService.js';
+import { SessionStatus, SESSION_WORKSPACE_GROUP_REMOTE, isActiveSessionStatus } from '../../../../services/sessions/common/session.js';
 import { ISessionsService } from '../../../../services/sessions/browser/sessionsService.service.js';
+import { ISessionsRecentWorkspacesService } from '../../../../services/sessions/browser/sessionsRecentWorkspacesService.service.js';
 import { IGitHubService } from '../../../github/browser/githubService.service.js';
-import { BaseAgentHostSessionsProvider } from '../../agentHost/browser/baseAgentHostSessionsProvider.js';
+import { DevContainerAgentHostSessionsProvider } from '../../agentHost/browser/devContainerAgentHostSessionsProvider.js';
+import { mapProtocolStatus } from '../../agentHost/browser/agentHostDiffs.js';
 import { ReconnectableAgentHostAutomationStore } from '../../agentHost/browser/reconnectableAgentHostAutomationStore.js';
-import { AutomationStore } from '../../../automations/browser/automationService.js';
-import { providerAutomationStorageKey } from '../../../automations/common/automationStorageService.js';
 import { remoteAgentHostSessionTypeAuthorityPrefix, remoteAgentHostSessionTypeId } from '../../../../../platform/agentHost/common/agentHostSessionType.js';
-import { readAgentDevContainerWorktreeMetadata } from '../../../../../platform/agentHost/common/meta/agentDevContainerWorktreeMeta.js';
+import { readAgentDevContainerWorktreeMetadata } from '../../../../../platform/agentHost/common/meta/vscode/agentDevContainerWorktreeMeta.js';
+import { INewSessionComposerService } from '../../../chat/browser/newSessionComposerService.service.js';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { transaction } from '../../../../../base/common/observableInternal/transaction.js';
 import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
 
 var RemoteAgentHostSessionsProvider_1;
-const CACHED_SESSIONS_STORAGE_PREFIX = "remoteAgentHost.cachedSessions.v2.";
-const CACHED_SESSIONS_STORAGE_PREFIX_LEGACY = "remoteAgentHost.cachedSessions.";
+const CACHED_SESSIONS_STORAGE_PREFIX = "remoteAgentHost.cachedSessions.v5.";
+const DEV_CONTAINER_ARCHIVE_CONFIRMATION_TIMEOUT_MS = 5000;
+const DEV_CONTAINER_IDLE_POLL_INTERVAL_MS = 60 * 1000;
+const CACHED_SESSIONS_STORAGE_PREFIXES_LEGACY = [
+    "remoteAgentHost.cachedSessions.v3.",
+    "remoteAgentHost.cachedSessions.v2.",
+    "remoteAgentHost.cachedSessions."
+];
 function toLocalProjectUri(uri, connectionAuthority) {
     return uri.scheme === Schemas.file ? toAgentHostUri(uri, connectionAuthority) : uri;
 }
-let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class RemoteAgentHostSessionsProvider extends BaseAgentHostSessionsProvider {
+let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class RemoteAgentHostSessionsProvider extends DevContainerAgentHostSessionsProvider {
+    get defaultLabel() {
+        return this._defaultLabel;
+    }
+    get label() {
+        return this._label;
+    }
+    get environment() {
+        return {
+            id: this.id,
+            label: this.label,
+            isConnected: this._environmentIsConnected
+        };
+    }
+    get devContainerSourceWorkspace() {
+        return this._devContainerSourceWorkspaceUri;
+    }
+    get browseActions() {
+        return this._browseActions;
+    }
+    get automations() {
+        return this._automationStore;
+    }
     get remoteConnectionStatus() {
         return this.connectionStatus;
     }
@@ -79,7 +119,12 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         sessionsService,
         activeClientService,
         dialogService,
-        workspaceTrustManagementService
+        workspaceTrustManagementService,
+        recentWorkspacesService,
+        uriIdentityService,
+        workingDirectoryResolver,
+        remoteAuthenticationService,
+        _newSessionComposerService
     ) {
         super(
             chatSessionsService,
@@ -94,17 +139,27 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
             activeClientService,
             storageService,
             dialogService,
-            workspaceTrustManagementService
+            workspaceTrustManagementService,
+            recentWorkspacesService,
+            uriIdentityService
         );
         this._fileDialogService = _fileDialogService;
         this._notificationService = _notificationService;
         this._localAgentHostService = _localAgentHostService;
+        this.agentHostConnectionsService = agentHostConnectionsService;
         this._remoteAgentHostService = _remoteAgentHostService;
         this._labelService = _labelService;
         this._configurationService = _configurationService;
+        this._newSessionComposerService = _newSessionComposerService;
         this.icon = Codicon.remote;
+        this.supportsQuickChats = true;
+        this._activitySources = ( new WeakMap());
         this._connectionStatus = observableValue("connectionStatus", RemoteAgentHostConnectionStatus.disconnected);
         this.connectionStatus = this._connectionStatus;
+        this._environmentIsConnected = derived(
+            this,
+            reader => RemoteAgentHostConnectionStatus.isConnected(this._connectionStatus.read(reader))
+        );
         this._authenticationPending = observableValue("authenticationPending", true);
         this._effectiveAuthenticationPending = derived(this, reader => {
             const status = this._connectionStatus.read(reader);
@@ -112,49 +167,100 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         });
         this._authenticationSettled = false;
         this._onDidDisconnect = this._register(( new Emitter()));
+        this._passiveRelay = observableValue(this, false);
+        this._allowOfflineDrafts = derived(
+            this,
+            reader => this.supportsOfflineDrafts && !this._passiveRelay.read(reader)
+        );
         this._connectionListeners = this._register(( new DisposableStore()));
         this._onDidChangeResourceLabelHomes = Event.any(this._onDidChangeSessionsImmediately, this._onDidChangeDraftSessions.event);
+        this._devContainerIdleCheckRunning = false;
+        this._devContainerIdleScheduler = this._register(( new RunOnceScheduler(() => {
+            void this._stopDevContainerIfIdle().catch(
+                error => this._logService.error(`[${this.id}] Failed to stop idle Dev Container.`, error)
+            );
+        }, DEV_CONTAINER_IDLE_POLL_INTERVAL_MS)));
         this._unpublished = false;
         this._detachedWorktreeDeletionTasks = ( new Map());
+        this._detachedWorktreeReconciliation = 0;
         this._connectionAuthority = agentHostAuthority(config.address);
+        const authenticationPending = this._register(remoteAuthenticationService.acquire(config.address)).object;
+        const resolverRegistrations = this._register(( new DisposableStore()));
+        const registerResolvers = () => {
+            resolverRegistrations.clear();
+            for (const sessionType of this.sessionTypes) {
+                resolverRegistrations.add(workingDirectoryResolver.registerResolver(
+                    this.resourceSchemeForProvider(sessionType.id),
+                    resource => this.getSessionByResource(resource)?.workspace.get()?.folders[0]?.workingDirectory,
+                    resource => this.getSessionByResource(resource)?.status.get() === SessionStatus.Untitled
+                ));
+            }
+        };
+        this._register(this.onDidChangeSessionTypes(registerResolvers));
+        registerResolvers();
         this._connectOnDemand = config.connectOnDemand;
         this._disconnectOnDemand = config.disconnectOnDemand;
+        this._removeOnDemand = config.removeOnDemand;
+        this.setDisplayName = config.setDisplayName;
+        this._retainSessionsOnDisconnect = config.retainSessionsOnDisconnect === true;
+        this._deleteSessionsOnDemand = config.deleteSessionsOnDemand;
         this._sessionSchemeAlias = config.sessionSchemeAlias;
         this._omitHostFromWorkspaceLabel = config.omitHostFromWorkspaceLabel === true;
         this._workspaceTypeIcon = config.workspaceTypeIcon;
         this._defaultChangesetKind = config.defaultChangesetKind;
+        this._devContainerSourceWorkspaceUri = config.devContainerSourceWorkspaceUri;
         this._register(
             agentHostConnectionsService.registerSessionResolutionPolicy(this._connectionAuthority, {
+                connectionAddress: config.address,
                 sessionSchemeAlias: this._sessionSchemeAlias,
                 defaultChangesetKind: this._defaultChangesetKind
             })
         );
         this._devContainerWorktreeScope = config.devContainerWorktreeScope;
+        this._devContainerLifecycle = config.devContainerLifecycle;
+        this._resolveDevContainerWorktreeConnection = config.resolveDevContainerWorktreeConnection;
         this.onDidReportConnectProgress = config.onDidReportConnectProgress;
+        this.showConnectionLog = config.showConnectionLog;
         this.autoConnect = config.autoConnect;
         this.connectionLabels = config.connectionLabels;
+        this.hostDescription = config.hostDescription;
+        this.isVisibleInEnvironmentPicker = config.isVisibleInEnvironmentPicker;
+        this.removeLabel = config.removeLabel;
+        this.canRemove = config.canRemove;
+        this.disconnectLabel = config.disconnectLabel;
         this.canConnectOnDemand = !!config.connectOnDemand;
-        this._readOnly = config.readOnlyWhenDisconnected ? derived(this, reader => {
+        this._readOnly = derived(this, reader => {
             const status = this._connectionStatus.read(reader);
-            return RemoteAgentHostConnectionStatus.isDisconnected(status) || RemoteAgentHostConnectionStatus.isConnecting(status) || RemoteAgentHostConnectionStatus.isIncompatible(status);
-        }) : constObservable(false);
+            if (this._passiveRelay.read(reader)) {
+                return true;
+            }
+            if (this.supportsOfflineDrafts) {
+                return !RemoteAgentHostConnectionStatus.isConnected(status) || this.authenticationPending.read(reader);
+            }
+            return !!config.readOnlyWhenDisconnected && (RemoteAgentHostConnectionStatus.isDisconnected(status) || RemoteAgentHostConnectionStatus.isConnecting(status) || RemoteAgentHostConnectionStatus.isIncompatible(status));
+        });
         this._register(this._onDidChangeResourceLabelHomes(() => this.updateResourceLabelHomes()));
+        if (this._devContainerLifecycle) {
+            this._register(
+                Event.any(this._onDidChangeSessionsImmediately, this._onDidChangeDraftSessions.event)(() => this._scheduleDevContainerStopIfIdle())
+            );
+        }
         this.updateResourceLabelHomes();
-        const displayName = config.name || config.address;
+        this._defaultLabel = config.name || config.address;
+        const displayName = this._remoteAgentHostService.getDisplayNameOverride(config.address) ?? this._defaultLabel;
         this.id = `agenthost-${this._connectionAuthority}`;
-        this.label = displayName;
+        this._label = displayName;
         this.remoteAddress = config.address;
         this.remoteLocationPreferenceKey = config.preferenceKey ?? config.address;
         this.hostGroup = config.hostGroup;
-        this._storageKey = `${CACHED_SESSIONS_STORAGE_PREFIX}${this._connectionAuthority}`;
-        const legacyAutomations = this._register(
-            instantiationService.createInstance(AutomationStore, providerAutomationStorageKey(this.id))
-        );
+        this._storageKey = config.sessionCacheKey ?? `${CACHED_SESSIONS_STORAGE_PREFIX}${this._connectionAuthority}`;
         this._automationStore = this._register(
-            instantiationService.createInstance(ReconnectableAgentHostAutomationStore, this.id, legacyAutomations, {
+            instantiationService.createInstance(ReconnectableAgentHostAutomationStore, this.id, {
                 toHost: resource => fromAgentHostUri(resource),
                 fromHost: resource => toAgentHostUri(resource, this._connectionAuthority),
                 resourceSchemeForProvider: provider => this.resourceSchemeForProvider(provider),
+                sessionResource: resource => this.agentHostConnectionsService.findSessionResource(resource, this._connectionAuthority) ?? (AgentSession.provider(resource) || this._sessionSchemeAlias?.backend === resource.scheme ? this.agentHostConnectionsService.getSessionResource(resource, this._connectionAuthority) : undefined),
+                onDidChangeSessionResolution: this.agentHostConnectionsService.onDidChangeSessionResolution,
                 providerForSessionScheme: scheme => this._sessionSchemeAlias?.backend === scheme ? this._sessionSchemeAlias.ui : scheme,
                 providerForResourceScheme: scheme => {
                     const prefix = remoteAgentHostSessionTypeAuthorityPrefix(this._connectionAuthority);
@@ -162,9 +268,8 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
                 }
             })
         );
-        this.automations = this._automationStore;
-        this.browseActions = [{
-            label: ( localize(4532, "Folders")),
+        this._browseActions = [{
+            label: ( localize(5471, "Folders")),
             description: displayName,
             group: SESSION_WORKSPACE_GROUP_REMOTE,
             icon: Codicon.remote,
@@ -174,17 +279,57 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }];
         this._enableSessionCachePersistence(
             this._storageKey,
-            `${CACHED_SESSIONS_STORAGE_PREFIX_LEGACY}${this._connectionAuthority}`
+            config.sessionCacheKey ? [] : CACHED_SESSIONS_STORAGE_PREFIXES_LEGACY.map(prefix => `${prefix}${this._connectionAuthority}`)
         );
         this.updateResourceLabelHomes();
+        this._register(this._remoteAgentHostService.onDidChangeDisplayName(address => {
+            if (address === normalizeRemoteAgentHostAddress(this.remoteAddress)) {
+                this._updateLabel();
+            }
+        }));
         this._register(this._configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration("git.branchProtection")) {
                 this._refreshSessionWorkspaces();
             }
+            if (e.affectsConfiguration(DevContainerIdleTimeoutSettingId)) {
+                this._devContainerIdleScheduler.cancel();
+                this._devContainerIdleSince = undefined;
+                this._scheduleDevContainerStopIfIdle();
+            }
         }));
+        this._register(autorun(
+            reader => this.setAuthenticationPending(authenticationPending.read(reader))
+        ));
+        if (this._devContainerLifecycle) {
+            this._register(autorun(reader => {
+                this._newSessionComposerService.inputVersion.read(reader);
+                this._scheduleDevContainerStopIfIdle();
+            }));
+        }
     }
     async archiveSession(sessionId) {
-        if (!this._hasSession(sessionId) || !this.connection) {
+        if (!this._hasSession(sessionId)) {
+            return;
+        }
+        if (this._devContainerLifecycle) {
+            await this._ensureDevContainerConnection();
+            await this._setDevContainerSessionArchived(sessionId, true);
+            if (( this.getKnownSessions().some(
+                session => session.sessionId !== sessionId && !session.isArchived.get() && !this._isEmptyDevContainerDraft(session)
+            ))) {
+                this._scheduleDevContainerStopIfIdle();
+                return;
+            }
+            this._devContainerIdleScheduler.cancel();
+            if (await this._devContainerLifecycle.remove()) {
+                await this._setDetachedWorktreeArchived(sessionId, true);
+            } else {
+                this._devContainerIdleSince = undefined;
+                this._scheduleDevContainerStopIfIdle();
+            }
+            return;
+        }
+        if (!this.connection) {
             return;
         }
         await this._setDetachedWorktreeArchived(sessionId, true);
@@ -193,7 +338,32 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }
     }
     async unarchiveSession(sessionId) {
-        if (!this._hasSession(sessionId) || !this.connection) {
+        if (!this._hasSession(sessionId)) {
+            return;
+        }
+        if (this._devContainerLifecycle) {
+            await this._setDetachedWorktreeArchived(sessionId, false);
+            try {
+                await this._ensureDevContainerConnection();
+                await this._setDevContainerSessionArchived(sessionId, false);
+            } catch (error) {
+                const hasOtherUnarchivedSession = ( this.getKnownSessions().some(
+                    session => session.sessionId !== sessionId && !session.isArchived.get() && !this._isEmptyDevContainerDraft(session)
+                ));
+                if (!hasOtherUnarchivedSession) {
+                    this._devContainerIdleScheduler.cancel();
+                    if (await this._devContainerLifecycle.remove()) {
+                        await this._setDetachedWorktreeArchived(sessionId, true);
+                    }
+                }
+                throw error;
+            }
+            if (this.getSessions().find(session => session.sessionId === sessionId)?.status.get() === SessionStatus.Completed) {
+                this._scheduleDevContainerStopIfIdle();
+            }
+            return;
+        }
+        if (!this.connection) {
             return;
         }
         await this._setDetachedWorktreeArchived(sessionId, false);
@@ -201,29 +371,201 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
             await this._setDetachedWorktreeArchived(sessionId, true);
         }
     }
+    async createNewChat(chatId) {
+        await this._ensureDevContainerConnection();
+        return super.createNewChat(chatId);
+    }
+    async sendRequest(chatId, chatResource, options) {
+        await this._ensureDevContainerConnection();
+        return super.sendRequest(chatId, chatResource, options);
+    }
+    async _ensureDevContainerConnection() {
+        this._devContainerIdleScheduler.cancel();
+        this._devContainerIdleSince = undefined;
+        if (!this._devContainerLifecycle) {
+            return;
+        }
+        if (this.connection && !this._devContainerIdleCheckRunning) {
+            this._scheduleDevContainerStopIfIdle();
+            return;
+        }
+        await this._devContainerLifecycle.connect();
+        if (!this.connection) {
+            throw ( new Error(( localize(5472, "Dev Container Agent Host '{0}' did not reconnect.", this.label))));
+        }
+        this._scheduleDevContainerStopIfIdle();
+    }
+    async _setDevContainerSessionArchived(sessionId, archived) {
+        const connection = this.connection;
+        const backendUri = this._getBackendSessionUri(sessionId);
+        if (!connection || !backendUri) {
+            throw ( new Error(archived ? ( localize(
+                5473,
+                "Unable to archive Dev Container session '{0}' while disconnected.",
+                sessionId
+            )) : ( localize(
+                5474,
+                "Unable to unarchive Dev Container session '{0}' while disconnected.",
+                sessionId
+            ))));
+        }
+        const subscription = connection.getSubscription(
+            StateComponents.Session,
+            backendUri,
+            "RemoteAgentHostSessionsProvider.archive"
+        );
+        const confirmationAction = Event.toPromise(
+            Event.filter(connection.onDidAction, envelope => envelope.channel === ( backendUri.toString()) && envelope.action.type === ActionType.SessionIsArchivedChanged && envelope.action.isArchived === archived)
+        );
+        try {
+            let timedOut = false;
+            const confirmation = raceTimeout(
+                confirmationAction,
+                DEV_CONTAINER_ARCHIVE_CONFIRMATION_TIMEOUT_MS,
+                () => timedOut = true
+            );
+            if (!this._setSessionArchived(sessionId, archived)) {
+                throw ( new Error(archived ? ( localize(
+                    5473,
+                    "Unable to archive Dev Container session '{0}' while disconnected.",
+                    sessionId
+                )) : ( localize(
+                    5474,
+                    "Unable to unarchive Dev Container session '{0}' while disconnected.",
+                    sessionId
+                ))));
+            }
+            const confirmationEnvelope = await confirmation;
+            if (confirmationEnvelope?.rejectionReason) {
+                this._setSessionArchivedLocally(sessionId, !archived);
+                throw ( new Error(archived ? ( localize(
+                    5475,
+                    "Unable to archive Dev Container session '{0}': {1}",
+                    sessionId,
+                    confirmationEnvelope.rejectionReason
+                )) : ( localize(
+                    5476,
+                    "Unable to unarchive Dev Container session '{0}': {1}",
+                    sessionId,
+                    confirmationEnvelope.rejectionReason
+                ))));
+            }
+            if (timedOut) {
+                this._setSessionArchivedLocally(sessionId, !archived);
+                throw ( new Error(archived ? ( localize(
+                    5477,
+                    "Timed out waiting for Dev Container session '{0}' to be archived.",
+                    sessionId
+                )) : ( localize(
+                    5478,
+                    "Timed out waiting for Dev Container session '{0}' to be unarchived.",
+                    sessionId
+                ))));
+            }
+        } finally {
+            confirmationAction.cancel();
+            subscription.dispose();
+        }
+    }
+    _scheduleDevContainerStopIfIdle() {
+        const idleTimeoutMs = this._configurationService.getValue(DevContainerIdleTimeoutSettingId) * 1000;
+        if (!this._devContainerLifecycle || !this.connection || this._store.isDisposed || idleTimeoutMs <= 0) {
+            this._devContainerIdleScheduler.cancel();
+            this._devContainerIdleSince = undefined;
+            return;
+        }
+        const previousIdleSince = this._devContainerIdleSince;
+        if (this._isDevContainerIdle()) {
+            this._devContainerIdleSince ??= Date.now();
+        } else {
+            this._devContainerIdleSince = undefined;
+        }
+        if (!this._devContainerIdleCheckRunning && (!this._devContainerIdleScheduler.isScheduled() || previousIdleSince !== this._devContainerIdleSince)) {
+            const delay = this._devContainerIdleSince === undefined ? DEV_CONTAINER_IDLE_POLL_INTERVAL_MS : Math.min(
+                DEV_CONTAINER_IDLE_POLL_INTERVAL_MS,
+                Math.max(0, idleTimeoutMs - (Date.now() - this._devContainerIdleSince))
+            );
+            this._devContainerIdleScheduler.schedule(delay);
+        }
+    }
+    _isDevContainerIdle() {
+        const sessions = this.getKnownSessions();
+        return !!this.connection && !( sessions.some(session => {
+            const status = session.status.get();
+            return (status === SessionStatus.Untitled && !this._isEmptyDevContainerDraft(session)) || isActiveSessionStatus(status);
+        }));
+    }
+    _isEmptyDevContainerDraft(session) {
+        return session.status.get() === SessionStatus.Untitled && !session.isNewSessionRequestInProgress?.get() && !this._newSessionComposerService.hasDraftInputForSession(session.resource);
+    }
+    async _stopDevContainerIfIdle() {
+        this._devContainerIdleCheckRunning = true;
+        let stopped = false;
+        try {
+            const idleTimeoutMs = this._configurationService.getValue(DevContainerIdleTimeoutSettingId) * 1000;
+            if (this._devContainerLifecycle && idleTimeoutMs > 0 && this._isDevContainerIdle() && this._devContainerIdleSince !== undefined && Date.now() - this._devContainerIdleSince >= idleTimeoutMs) {
+                this._devContainerIdleSince = undefined;
+                stopped = await this._devContainerLifecycle.stop();
+            }
+        } finally {
+            this._devContainerIdleCheckRunning = false;
+            if (!stopped) {
+                this._scheduleDevContainerStopIfIdle();
+            }
+        }
+    }
     async deleteSessions(sessionIds) {
-        const detachedWorktrees = sessionIds.filter(sessionId => this._hasSession(sessionId)).map(sessionId => ({
+        const ownerSessions = [];
+        const hostSessionIds = [];
+        for (const sessionId of sessionIds) {
+            const key = this._sessionKeyFromChatId(sessionId);
+            const backendSession = key ? this._sessionCache.get(key)?.backendUri : undefined;
+            if (backendSession && this._deleteSessionsOnDemand?.ownsSession(backendSession)) {
+                if (!key || !( this._sessionCache.has(key))) {
+                    throw ( new Error(( localize(5479, "Session not found."))));
+                }
+                ownerSessions.push(backendSession);
+            } else {
+                hostSessionIds.push(sessionId);
+            }
+        }
+        const hadSessions = ( hostSessionIds.some(sessionId => this._hasSession(sessionId)));
+        const detachedWorktrees = hostSessionIds.filter(sessionId => this._hasSession(sessionId)).map(sessionId => ({
             sessionId,
             handle: this._getDetachedWorktreeHandle(sessionId)
         })).filter(entry => !!entry.handle);
         let deleteError;
         try {
-            await super.deleteSessions(sessionIds);
+            if (hadSessions && this._devContainerLifecycle) {
+                await this._ensureDevContainerConnection();
+            }
+            await super.deleteSessions(hostSessionIds);
         } catch (error) {
             deleteError = error;
         }
         let worktreeError;
-        for (const {
-            sessionId,
-            handle
-        } of detachedWorktrees) {
-            if (this._hasSession(sessionId)) {
-                continue;
-            }
+        let canDeleteDetachedWorktrees = true;
+        if (!deleteError && this._devContainerLifecycle && hadSessions && this.getKnownSessions().every(session => this._isEmptyDevContainerDraft(session))) {
             try {
-                await this._deleteDetachedWorktree(handle);
+                this._devContainerIdleScheduler.cancel();
+                canDeleteDetachedWorktrees = await this._devContainerLifecycle.remove();
             } catch (error) {
-                worktreeError ??= error;
+                worktreeError = error;
+            }
+        }
+        if (!worktreeError && canDeleteDetachedWorktrees) {
+            for (const {
+                sessionId,
+                handle
+            } of detachedWorktrees) {
+                if (this._hasSession(sessionId)) {
+                    continue;
+                }
+                try {
+                    await this._deleteDetachedWorktree(handle);
+                } catch (error) {
+                    worktreeError ??= error;
+                }
             }
         }
         if (deleteError) {
@@ -232,6 +574,9 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         if (worktreeError) {
             throw worktreeError;
         }
+        if (ownerSessions.length > 0) {
+            await this._deleteSessionsOnDemand?.deleteSessions(ownerSessions);
+        }
     }
     _onNewSessionAbandoned(sessionId, reason) {
         if (reason === "sendFailed") {
@@ -246,7 +591,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }
     }
     _onBackendSessionRemoved(rawId) {
-        const handle = readAgentDevContainerWorktreeMetadata(this._getSessionMetadataByRawId(rawId))?.handle;
+        const handle = readAgentDevContainerWorktreeMetadata(this._getSessionMetadataByKey(rawId))?.handle;
         if (handle) {
             void this._deleteDetachedWorktree(handle).catch(error => this._logService.error(
                 `[${this.id}] Failed to delete detached worktree for remotely removed session '${rawId}'.`,
@@ -255,13 +600,21 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }
     }
     _onHostReconciledSessions(rawIds) {
-        if (!this._devContainerWorktreeScope || !this._localAgentHostService.reconcileDetachedWorktrees) {
+        const scope = this._devContainerWorktreeScope;
+        if (!scope) {
             return;
         }
         const activeHandles = [...rawIds].map(
-            rawId => readAgentDevContainerWorktreeMetadata(this._getSessionMetadataByRawId(rawId))?.handle
+            rawId => readAgentDevContainerWorktreeMetadata(this._getSessionMetadataByKey(rawId))?.handle
         ).filter(handle => !!handle);
-        void this._localAgentHostService.reconcileDetachedWorktrees(this._devContainerWorktreeScope, activeHandles).catch(error => this._logService.error(
+        const reconciliation = ++this._detachedWorktreeReconciliation;
+        void (async () => {
+            const connection = this._resolveDevContainerWorktreeConnection ? await this._resolveDevContainerWorktreeConnection() : this._localAgentHostService;
+            if (reconciliation !== this._detachedWorktreeReconciliation) {
+                return;
+            }
+            await connection.reconcileDetachedWorktrees?.(scope, activeHandles);
+        })().catch(error => this._logService.error(
             `[${this.id}] Failed to reconcile detached Dev Container worktrees.`,
             error
         ));
@@ -274,39 +627,52 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         if (!handle) {
             return;
         }
-        if (!this._localAgentHostService.setDetachedWorktreeArchived) {
+        const connection = this._resolveDevContainerWorktreeConnection ? await this._resolveDevContainerWorktreeConnection() : this._localAgentHostService;
+        if (!connection.setDetachedWorktreeArchived) {
             throw ( new Error(
-                `Local Agent Host does not support ${archived ? "archiving" : "unarchiving"} prepared worktrees.`
+                `Source Agent Host does not support ${archived ? "archiving" : "unarchiving"} prepared worktrees.`
             ));
         }
-        await this._localAgentHostService.setDetachedWorktreeArchived(handle, archived);
+        await connection.setDetachedWorktreeArchived(handle, archived);
     }
     _deleteDetachedWorktree(handle) {
         const existing = this._detachedWorktreeDeletionTasks.get(handle);
         if (existing) {
             return existing;
         }
-        if (!this._localAgentHostService.deleteDetachedWorktree) {
-            return Promise.reject(( new Error("Local Agent Host does not support deleting prepared worktrees.")));
-        }
-        const task = this._localAgentHostService.deleteDetachedWorktree(handle).finally(() => this._detachedWorktreeDeletionTasks.delete(handle));
+        const task = (async () => {
+            const connection = this._resolveDevContainerWorktreeConnection ? await this._resolveDevContainerWorktreeConnection() : this._localAgentHostService;
+            if (!connection.deleteDetachedWorktree) {
+                throw ( new Error("Source Agent Host does not support deleting prepared worktrees."));
+            }
+            await connection.deleteDetachedWorktree(handle);
+        })().finally(() => this._detachedWorktreeDeletionTasks.delete(handle));
         this._detachedWorktreeDeletionTasks.set(handle, task);
         return task;
     }
     get connection() {
         return this._connection;
     }
+    supportsDevContainerWorkspace(workspaceUri) {
+        return workspaceUri.scheme === AGENT_HOST_SCHEME && workspaceUri.authority === this._connectionAuthority && !this._devContainerWorktreeScope && !this.hostGroup;
+    }
     get authenticationPending() {
         return this._effectiveAuthenticationPending;
     }
+    get passiveRelay() {
+        return this._passiveRelay;
+    }
+    get supportsOfflineDrafts() {
+        return false;
+    }
     _shouldTrackSessionCacheChanges() {
         return !this._unpublished;
     }
     _adapterOptions() {
-        const hostLabel = this._workspaceHostLabel;
         const typeIcon = this._workspaceTypeIcon;
         return {
             readOnly: this._readOnly,
+            allowOfflineDrafts: this._allowOfflineDrafts,
             defaultChangesetKind: this._defaultChangesetKind,
             buildWorkspace: (project, workingDirectories, gitHubInfo, gitState) => {
                 const primary = workingDirectories?.[0];
@@ -318,7 +684,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
                 return RemoteAgentHostSessionsProvider_1.buildWorkspace(
                     project,
                     workingDirectories,
-                    hostLabel,
+                    this._workspaceHostLabel,
                     gitHubInfo,
                     gitState,
                     description,
@@ -350,12 +716,12 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         return toLocalProjectUri(uri, this._connectionAuthority);
     }
     _diffUriMapper() {
-        return (uri, options) => options?.contentRef ? toAgentHostContentUri(uri, this._connectionAuthority) : toAgentHostUri(uri, this._connectionAuthority);
+        return (uri, options) => options?.contentRef ? toAgentHostContentUri(uri, this._connectionAuthority, options.fileUri) : toAgentHostUri(uri, this._connectionAuthority);
     }
     _validateBeforeCreate(_sessionType) {
         if (!this._connection) {
             throw ( new Error(( localize(
-                4533,
+                5480,
                 "Cannot create session: not connected to remote agent host '{0}'.",
                 this.label
             ))));
@@ -363,14 +729,14 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
     }
     _noAgentsErrorMessage() {
         return localize(
-            4534,
+            5481,
             "Remote agent host '{0}' has not advertised any agents yet.",
             this.label
         );
     }
     _notConnectedSendErrorMessage() {
         return localize(
-            4535,
+            5482,
             "Cannot send request: not connected to remote agent host '{0}'.",
             this.label
         );
@@ -386,7 +752,9 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         this._remoteAgentHostService.reconnectNow(this.remoteAddress);
     }
     async disconnect() {
-        this.unpublishCachedSessions();
+        if (!this._retainSessionsOnDisconnect) {
+            this.unpublishCachedSessions();
+        }
         if (this._disconnectOnDemand) {
             await this._disconnectOnDemand();
             return;
@@ -394,23 +762,81 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         await removeWebSocketRemoteAgentHostEntry(this._configurationService, this.remoteAddress);
         await this._remoteAgentHostService.removeRemoteAgentHost(this.remoteAddress);
     }
+    async remove() {
+        if (this.canRemove === false) {
+            throw ( new Error(( localize(5483, "This host cannot be removed locally."))));
+        }
+        this.unpublishCachedSessions();
+        if (this._removeOnDemand) {
+            await this._removeOnDemand();
+            return;
+        }
+        await this.disconnect();
+    }
     setConnectionStatus(status) {
         this._connectionStatus.set(status, undefined);
     }
-    seedSessions(metas) {
+    setLabel(name) {
+        this._defaultLabel = name || this.remoteAddress;
+        this._updateLabel();
+    }
+    _updateLabel() {
+        const label = this._remoteAgentHostService.getDisplayNameOverride(this.remoteAddress) ?? this._defaultLabel;
+        if (this._label === label) {
+            return;
+        }
+        this._label = label;
+        this._browseActions = this._browseActions.map(action => ({
+            ...action,
+            description: label
+        }));
+        this._refreshSessionWorkspaces();
+        this._onDidChangeSessionTypes.fire();
+    }
+    seedSessions(metas, options) {
         const added = [];
         const changed = [];
         for (const rawMeta of metas) {
             const meta = this._adoptSessionMeta(rawMeta);
-            const rawId = AgentSession.id(meta.session);
+            const rawId = ( meta.session.toString());
             const existing = this._sessionCache.get(rawId);
             if (existing) {
-                if (meta.project && !existing.project && existing.backfillProject(meta.project)) {
+                let didChange = false;
+                const source = this._activitySources.get(existing);
+                if (source?.source !== "discovery" || meta.modifiedTime >= source.modifiedTime) {
+                    transaction(tx => {
+                        didChange = options?.updateExisting ? existing.updateDiscoveryMetadata({
+                            ...meta,
+                            modifiedTime: Math.max(meta.modifiedTime, existing.updatedAt.get().getTime())
+                        }, options.workspaceless) : existing.backfillProject(meta.project);
+                        if (!this._connection && source?.source !== "host") {
+                            if (meta.status !== undefined) {
+                                const status = mapProtocolStatus(meta.status);
+                                if (status !== existing.status.get()) {
+                                    existing.status.set(status, tx);
+                                    didChange = true;
+                                }
+                            }
+                            this._activitySources.set(existing, {
+                                source: "discovery",
+                                modifiedTime: meta.modifiedTime
+                            });
+                        }
+                    });
+                }
+                if (didChange) {
                     changed.push(existing);
                 }
                 continue;
             }
             const adapter = this.createAdapter(meta);
+            if (options?.updateExisting) {
+                adapter.updateDiscoveryMetadata(meta, options.workspaceless);
+            }
+            this._activitySources.set(adapter, {
+                source: "discovery",
+                modifiedTime: meta.modifiedTime
+            });
             this._sessionCache.set(rawId, adapter);
             added.push(adapter);
         }
@@ -422,21 +848,46 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
             });
         }
     }
+    createAdapter(meta) {
+        const adapter = super.createAdapter(meta);
+        if (this._connection) {
+            this._activitySources.set(adapter, {
+                source: "host"
+            });
+        }
+        return adapter;
+    }
+    registerBackendSession(backendSession, provider) {
+        this.agentHostConnectionsService.registerSessionResource(backendSession, this._connectionAuthority, provider);
+    }
+    updateAdapter(adapter, meta) {
+        this._activitySources.set(adapter, {
+            source: "host"
+        });
+        return super.updateAdapter(adapter, meta);
+    }
     _adoptSessionMeta(meta) {
         const alias = this._sessionSchemeAlias;
-        if (!alias || meta.session.scheme !== alias.backend) {
+        if (alias && meta.provider === undefined && meta.session.scheme === alias.ui) {
+            return {
+                ...meta,
+                provider: alias.ui,
+                session: meta.session.with({
+                    scheme: alias.backend
+                })
+            };
+        }
+        if (!alias || meta.provider || meta.session.scheme !== alias.backend) {
             return meta;
         }
         return {
             ...meta,
-            session: meta.session.with({
-                scheme: alias.ui
-            })
+            provider: alias.ui
         };
     }
     _backendSessionScheme(agentProvider) {
         const alias = this._sessionSchemeAlias;
-        return alias && agentProvider === alias.ui ? alias.backend : agentProvider;
+        return alias && agentProvider === alias.ui ? alias.backend : super._backendSessionScheme(agentProvider);
     }
     _logicalSessionTypeForBackendScheme(backendScheme) {
         const alias = this._sessionSchemeAlias;
@@ -462,6 +913,14 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         this._connectionListeners.clear();
         this._sessionStateSubscriptions.clearAndDisposeAll();
         this._connection = connection;
+        this._connectionListeners.add(autorun(reader => {
+            this._passiveRelay.set(
+                isPassiveRelayConnection(connection.initializeResult.read(reader)),
+                undefined
+            );
+        }));
+        this._devContainerIdleSince = undefined;
+        this._connectionChanged.trigger(undefined);
         this._automationStore.setConnection(connection);
         this._defaultDirectory = defaultDirectory;
         this._unpublished = false;
@@ -477,23 +936,28 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }
         this._attachConnectionListeners(connection, this._connectionListeners);
         this._refreshSessions(wasUnpublished);
+        this._scheduleDevContainerStopIfIdle();
     }
     clearConnection() {
+        this._devContainerIdleScheduler.cancel();
+        this._devContainerIdleSince = undefined;
         this._connectionListeners.clear();
         this._sessionStateSubscriptions.clearAndDisposeAll();
         this._onDidDisconnect.fire();
         this._connection = undefined;
+        this._passiveRelay.set(false, undefined);
+        this._connectionChanged.trigger(undefined);
         this._automationStore.clearConnection();
         this._defaultDirectory = undefined;
         this.updateResourceLabelHomes();
         this._disposeAllNewSessions();
         this._syncRootState(undefined);
-        if (this._pendingSession) {
-            const pending = this._pendingSession;
-            this._pendingSession = undefined;
+        if (this._pendingSessions.size > 0) {
+            const pending = [...( this._pendingSessions.values())];
+            this._pendingSessions.clear();
             this._onDidChangeSessions.fire({
                 added: [],
-                removed: [pending],
+                removed: pending,
                 changed: []
             });
         }
@@ -541,10 +1005,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }
     }
     _formatSessionTypeLabel(agentLabel) {
-        if (this.isWebPlatform) {
-            return agentLabel;
-        }
-        return `${agentLabel} [${this.label}]`;
+        return agentLabel;
     }
     get _workspaceHostLabel() {
         return this.isWebPlatform || this._omitHostFromWorkspaceLabel ? undefined : this.label;
@@ -605,13 +1066,28 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         }
         return this._buildWorkspaceFromUri(repositoryUri);
     }
+    canonicalizeWorkspaceUri(workspaceUri) {
+        return this._devContainerSourceWorkspaceUri ?? workspaceUri;
+    }
+    _folderBrowseUri() {
+        if (this._defaultDirectory) {
+            return agentHostUri(this._connectionAuthority, this._defaultDirectory);
+        }
+        for (const session of this.getSessions()) {
+            const root = session.workspace.get()?.folders[0]?.root;
+            if (root) {
+                return root;
+            }
+        }
+        return agentHostUri(this._connectionAuthority, "/");
+    }
     async _browseForFolder() {
         if (!this._connection && this._connectOnDemand) {
             try {
                 await this._connectOnDemand();
             } catch (err) {
                 this._notificationService.error(( localize(
-                    4536,
+                    5484,
                     "Failed to connect to remote agent host '{0}': {1}",
                     this.label,
                     err instanceof Error ? err.message : String(err)
@@ -620,23 +1096,33 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
             }
         }
         if (!this._connection) {
-            this._notificationService.error(( localize(4537, "Unable to connect to remote agent host '{0}'.", this.label)));
+            this._notificationService.error(( localize(5485, "Unable to connect to remote agent host '{0}'.", this.label)));
             return undefined;
         }
-        const defaultUri = agentHostUri(this._connectionAuthority, this._defaultDirectory ?? "/");
+        if (!this._defaultDirectory && this.getSessions().length === 0) {
+            await this._refreshSessions();
+        }
+        const defaultUri = this._folderBrowseUri();
         try {
             const selected = await this._fileDialogService.showOpenDialog({
                 canSelectFiles: false,
                 canSelectFolders: true,
                 canSelectMany: false,
-                title: ( localize(4538, "Select Folder on {0}", this.label)),
+                title: ( localize(5486, "Select Folder on {0}", this.label)),
                 availableFileSystems: [AGENT_HOST_SCHEME],
                 defaultUri
             });
             if (selected?.[0]) {
                 return this._buildWorkspaceFromUri(selected[0]);
             }
-        } catch {}
+        } catch (err) {
+            this._notificationService.error(( localize(
+                5487,
+                "Failed to browse folders on '{0}': {1}",
+                this.label,
+                err instanceof Error ? err.message : String(err)
+            )));
+        }
         return undefined;
     }
     async _listRemoteFolders(query, token) {
@@ -650,7 +1136,7 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         if (!this._connection || token.isCancellationRequested) {
             return [];
         }
-        const rootAgentHostUri = agentHostUri(this._connectionAuthority, this._defaultDirectory ?? "/");
+        const rootAgentHostUri = this._folderBrowseUri();
         const trimmed = query.trim();
         const lastSlash = trimmed.lastIndexOf("/");
         let listingAgentHostUri = rootAgentHostUri;
@@ -695,6 +1181,6 @@ let RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = class
         return folders;
     }
 };
-RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = ( __decorate([( __param(1, IFileDialogService)), ( __param(2, INotificationService)), ( __param(3, IStorageService)), ( __param(4, IAgentHostService)), ( __param(5, IAgentHostConnectionsService)), ( __param(6, IChatSessionsService)), ( __param(7, IChatService)), ( __param(8, IChatWidgetService)), ( __param(9, ILanguageModelsService)), ( __param(10, IRemoteAgentHostService)), ( __param(11, ILabelService)), ( __param(12, IConfigurationService)), ( __param(13, ILogService)), ( __param(14, IGitHubService)), ( __param(15, IInstantiationService)), ( __param(16, ISessionsService)), ( __param(17, IAgentHostActiveClientService)), ( __param(18, IDialogService)), ( __param(19, IWorkspaceTrustManagementService))], RemoteAgentHostSessionsProvider));
+RemoteAgentHostSessionsProvider = RemoteAgentHostSessionsProvider_1 = ( __decorate([( __param(1, IFileDialogService)), ( __param(2, INotificationService)), ( __param(3, IStorageService)), ( __param(4, IAgentHostService)), ( __param(5, IAgentHostConnectionsService)), ( __param(6, IChatSessionsService)), ( __param(7, IChatService)), ( __param(8, IChatWidgetService)), ( __param(9, ILanguageModelsService)), ( __param(10, IRemoteAgentHostService)), ( __param(11, ILabelService)), ( __param(12, IConfigurationService)), ( __param(13, ILogService)), ( __param(14, IGitHubService)), ( __param(15, IInstantiationService)), ( __param(16, ISessionsService)), ( __param(17, IAgentHostActiveClientService)), ( __param(18, IDialogService)), ( __param(19, IWorkspaceTrustManagementService)), ( __param(20, ISessionsRecentWorkspacesService)), ( __param(21, IUriIdentityService)), ( __param(22, IAgentHostSessionWorkingDirectoryResolver)), ( __param(23, IRemoteAgentHostAuthenticationService)), ( __param(24, INewSessionComposerService))], RemoteAgentHostSessionsProvider));
 
 export { RemoteAgentHostSessionsProvider };