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

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

@@ -0,0 +1,686 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { RemoteAgentHostConnectionStatus, getEntryAddress, RemoteAgentHostsSettingId, RemoteAgentHostAutoConnectSettingId, 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 { TunnelAgentHostsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/tunnelAgentHost';
+import { WslAutoStartSettingId } from '../../../../../platform/agentHost/common/wslRemoteAgentHost.js';
+import { CloudSandboxEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
+import { AgentHostLocalFilePermissionsSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostResourceService';
+import { NotificationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionActions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.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 { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { OpenAgentHostStateFileAction } from '../../agentHost/browser/openAgentHostStateFileAction.js';
+import { AgentHostAuthTokenCache, AgentHostAuthenticationRecovery, revokeAuthenticationForRemovedSessions, authenticateAgentProtectedResourcesWithToken, authenticateProtectedResources, authenticateProtectedResourcesWithToken, resolveAuthenticationInteractively } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostAuth.js';
+import { agentHostProviderSupportsAutoModel, AgentHostLanguageModelProvider } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostLanguageModelProvider.js';
+import { AgentHostSessionHandler } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionHandler.js';
+import { IAgentHostActiveClientService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service';
+import { ChatSessionsExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { IAgentHostFileSystemService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { isRemoteAgentHostSessionType, remoteAgentHostSessionTypeId, findRemoteAgentHostSessionTypeAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
+import { RemoteAgentPluginController, createRemoteAgentHarnessDescriptor } from './remoteAgentHostCustomizationHarness.js';
+import { RemoteAgentHostLogForwarder } from './remoteAgentHostLogForwarder.js';
+import { IRemoteAgentHostConnectionCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/remoteAgentHost/browser/remoteAgentHostConnectionCustomization.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IAgentHostTerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { logTerminalRecovery } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import './remoteAgentHostActions.js';
+import './manageRemoteAgentHosts.js';
+import '../../agentHost/browser/agentHostAgentPicker.js';
+import { AgentCustomizationItemProvider } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentCustomizationItemProvider.js';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+
+( Registry.as(ChatSessionsExtensions.AsyncActivation)).register({
+    matchSessionType: sessionType => isRemoteAgentHostSessionType(sessionType),
+    waitForActivation: waitForRemoteAgentHostActivation
+});
+async function waitForRemoteAgentHostActivation(accessor, sessionType) {
+    const remoteAgentHostService = accessor.get(IRemoteAgentHostService);
+    const address = getAddressForSessionType(sessionType, remoteAgentHostService);
+    if (!address) {
+        return false;
+    }
+    while (true) {
+        const connection = remoteAgentHostService.getConnection(address);
+        if (connection) {
+            const rootState = connection.rootState.value;
+            if (rootState instanceof Error) {
+                return false;
+            }
+            if (rootState) {
+                const authority = agentHostAuthority(address);
+                return ( rootState.agents.some(
+                    agent => remoteAgentHostSessionTypeId(authority, agent.provider) === sessionType
+                ));
+            }
+            await Promise.race([
+                Event.toPromise(connection.rootState.onDidChange),
+                Event.toPromise(remoteAgentHostService.onDidChangeConnections)
+            ]);
+            continue;
+        }
+        const connectionInfo = remoteAgentHostService.connections.find(connection => connection.address === address);
+        if (connectionInfo && !RemoteAgentHostConnectionStatus.isConnecting(connectionInfo.status) && !RemoteAgentHostConnectionStatus.isReconnecting(connectionInfo.status)) {
+            return false;
+        }
+        if (!connectionInfo && !( remoteAgentHostService.configuredEntries.some(entry => getEntryAddress(entry) === address))) {
+            return false;
+        }
+        await Event.toPromise(remoteAgentHostService.onDidChangeConnections);
+    }
+}
+function getAddressForSessionType(sessionType, remoteAgentHostService) {
+    const authorities = ( new Map());
+    for (const connection of remoteAgentHostService.connections) {
+        authorities.set(agentHostAuthority(connection.address), connection.address);
+    }
+    for (const entry of remoteAgentHostService.configuredEntries) {
+        const address = getEntryAddress(entry);
+        authorities.set(agentHostAuthority(address), address);
+    }
+    const authority = findRemoteAgentHostSessionTypeAuthority(sessionType, ( authorities.keys()));
+    return authority ? authorities.get(authority) : undefined;
+}
+class ConnectionState extends Disposable {
+    constructor(name, connection) {
+        super();
+        this.name = name;
+        this.connection = connection;
+        this.store = this._register(( new DisposableStore()));
+        this.agents = this._register(( new DisposableMap()));
+        this.modelProviders = ( new Map());
+        this.authTokenCache = ( new AgentHostAuthTokenCache());
+        this.authRecovery = ( new AgentHostAuthenticationRecovery());
+    }
+}
+let RemoteAgentHostContribution = class RemoteAgentHostContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.remoteAgentHostContribution";
+    }
+    constructor(
+        _remoteAgentHostService,
+        _chatSessionsService,
+        _languageModelsService,
+        _logService,
+        _instantiationService,
+        _authenticationService,
+        _defaultAccountService,
+        _sessionsProvidersService,
+        _agentHostFileSystemService,
+        _customizationHarnessService,
+        _agentHostTerminalService,
+        _telemetryService,
+        _activeClientService,
+        _connectionCustomizations,
+        _configurationService,
+        environmentService
+    ) {
+        super();
+        this._remoteAgentHostService = _remoteAgentHostService;
+        this._chatSessionsService = _chatSessionsService;
+        this._languageModelsService = _languageModelsService;
+        this._logService = _logService;
+        this._instantiationService = _instantiationService;
+        this._authenticationService = _authenticationService;
+        this._defaultAccountService = _defaultAccountService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._agentHostFileSystemService = _agentHostFileSystemService;
+        this._customizationHarnessService = _customizationHarnessService;
+        this._agentHostTerminalService = _agentHostTerminalService;
+        this._telemetryService = _telemetryService;
+        this._activeClientService = _activeClientService;
+        this._connectionCustomizations = _connectionCustomizations;
+        this._configurationService = _configurationService;
+        this._connections = this._register(( new DisposableMap()));
+        this._enableSmokeTestDriver = !!environmentService.enableSmokeTestDriver;
+        this._register(
+            this._remoteAgentHostService.onDidChangeConnections(() => this._reconcile())
+        );
+        this._register(
+            this._defaultAccountService.onDidChangeDefaultAccount(() => this._authenticateAllConnections())
+        );
+        this._register(
+            this._authenticationService.onDidRegisterAuthenticationProvider(() => this._authenticateAllConnections())
+        );
+        this._register(this._authenticationService.onDidChangeSessions(event => {
+            void this._handleAuthenticationSessionsChanged(event.providerId, event.event.removed ?? []);
+        }));
+        this._reconcile();
+    }
+    _reconcile() {
+        this._reconcileConnections();
+    }
+    _reconcileConnections() {
+        const currentConnections = this._remoteAgentHostService.connections;
+        ( new Set(currentConnections.filter(
+            c => RemoteAgentHostConnectionStatus.isConnected(c.status) && c.clientId !== undefined
+        ).map(c => c.address)));
+        const allAddresses = ( new Set(currentConnections.map(c => c.address)));
+        for (const [address] of this._connections) {
+            if (!( allAddresses.has(address))) {
+                this._logService.info(`[RemoteAgentHost] Removing contribution for ${address}`);
+                this._connections.deleteAndDispose(address);
+            }
+        }
+        for (const connectionInfo of currentConnections) {
+            if (!RemoteAgentHostConnectionStatus.isConnected(connectionInfo.status) || connectionInfo.clientId === undefined) {
+                continue;
+            }
+            const existing = this._connections.get(connectionInfo.address);
+            if (existing) {
+                const nameChanged = existing.name !== connectionInfo.name;
+                const clientIdChanged = existing.connection.clientId !== connectionInfo.clientId;
+                if (nameChanged || clientIdChanged) {
+                    this._logService.info(
+                        `[RemoteAgentHost] Reconnecting contribution for ${connectionInfo.address}: oldClientId=${existing.connection.clientId}, newClientId=${connectionInfo.clientId}, nameChanged=${nameChanged}`
+                    );
+                    const oldClientId = existing.connection.clientId;
+                    this._connections.deleteAndDispose(connectionInfo.address);
+                    this._setupConnection(connectionInfo);
+                    if (clientIdChanged) {
+                        const newConnection = this._remoteAgentHostService.getConnection(connectionInfo.address);
+                        if (newConnection) {
+                            this._agentHostTerminalService.reconnectTerminals(newConnection, oldClientId).then((
+                                {
+                                    recovered,
+                                    total
+                                }
+                            ) => {
+                                if (total > 0) {
+                                    this._logService.info(`[RemoteAgentHost] Terminal reconnection: ${recovered}/${total} recovered`);
+                                    logTerminalRecovery(this._telemetryService, {
+                                        recoveredCount: recovered,
+                                        totalCount: total
+                                    });
+                                }
+                            }, err => this._logService.warn("[RemoteAgentHost] Terminal reconnection failed", err));
+                        }
+                    }
+                }
+            } else {
+                this._setupConnection(connectionInfo);
+            }
+        }
+    }
+    _setupConnection(connectionInfo) {
+        const connection = this._remoteAgentHostService.getConnection(connectionInfo.address);
+        if (!connection) {
+            return;
+        }
+        const {
+            address,
+            name
+        } = connectionInfo;
+        const connState = this._instantiationService.createInstance(ConnectionState, name, connection);
+        this._connections.set(address, connState);
+        const store = connState.store;
+        store.add(
+            this._instantiationService.createInstance(RemoteAgentHostLogForwarder, connection, address, name || address)
+        );
+        const authority = agentHostAuthority(address);
+        store.add(this._agentHostFileSystemService.registerAuthority(authority, connection));
+        store.add(connection.rootState.onDidChange(rootState => {
+            this._handleRootStateChange(address, connection, rootState);
+        }));
+        store.add(connection.onDidNotification(
+            notification => this._handleAuthenticationRequiredNotification(address, connection, notification)
+        ));
+        const initialRootState = connection.rootState.value;
+        if (initialRootState && !(initialRootState instanceof Error)) {
+            this._handleRootStateChange(address, connection, initialRootState);
+        }
+    }
+    _handleRootStateChange(address, connection, rootState) {
+        const connState = this._connections.get(address);
+        if (!connState) {
+            return;
+        }
+        const incoming = ( new Set(rootState.agents.map(a => a.provider)));
+        for (const [provider] of connState.agents) {
+            if (!( incoming.has(provider))) {
+                connState.agents.deleteAndDispose(provider);
+                connState.modelProviders.delete(provider);
+            }
+        }
+        this._authenticateWithConnection(address, connection, rootState.agents).catch(() => {});
+        for (const agent of rootState.agents) {
+            if (!( connState.agents.has(agent.provider))) {
+                this._registerAgent(address, connection, agent, connState.name);
+            } else {
+                const modelProvider = connState.modelProviders.get(agent.provider);
+                modelProvider?.updateModels(agent.models);
+            }
+        }
+    }
+    _registerAgent(address, connection, agent, configuredName) {
+        const connState = this._connections.get(address);
+        if (!connState) {
+            return;
+        }
+        const agentStore = ( new DisposableStore());
+        connState.agents.set(agent.provider, agentStore);
+        connState.store.add(agentStore);
+        const sanitized = agentHostAuthority(address);
+        const providerId = `agenthost-${sanitized}`;
+        const sessionType = remoteAgentHostSessionTypeId(sanitized, agent.provider);
+        const agentId = sessionType;
+        const vendor = sessionType;
+        const hostLabel = configuredName || address;
+        const agentLabel = agent.displayName?.trim() || agent.provider;
+        const displayName = `${agentLabel} [${hostLabel}]`;
+        const sessionWorkingDirs = ( new Map());
+        agentStore.add(toDisposable(() => sessionWorkingDirs.clear()));
+        const resolveWorkingDirectory = sessionResource => {
+            const resourceKey = ( sessionResource.toString());
+            const cached = sessionWorkingDirs.get(resourceKey);
+            if (cached) {
+                return cached;
+            }
+            const provider = this._sessionsProvidersService.getProvider(providerId);
+            const session = provider?.getSessionByResource(sessionResource);
+            const workingDirectory = session?.workspace.get()?.folders[0]?.workingDirectory;
+            if (workingDirectory) {
+                sessionWorkingDirs.set(resourceKey, workingDirectory);
+                return workingDirectory;
+            }
+            return undefined;
+        };
+        const isNewSession = sessionResource => {
+            const provider = this._sessionsProvidersService.getProvider(providerId);
+            return provider?.getSessionByResource(sessionResource)?.status.get() === SessionStatus.Untitled;
+        };
+        agentStore.add(this._chatSessionsService.registerChatSessionContribution({
+            type: sessionType,
+            name: agentId,
+            displayName,
+            description: agent.description,
+            canDelegate: true,
+            requiresCustomModels: true,
+            supportsAutoModel: agentHostProviderSupportsAutoModel(agent.provider),
+            agentHostProviderId: agent.provider,
+            supportsDelegation: false,
+            capabilities: {
+                supportsCheckpoints: true,
+                supportsPromptAttachments: true,
+                supportsImageAttachments: true,
+                get terminalCommandPrefix() {
+                    return connection.initializeResult.get()?.terminalCommandPrefix;
+                }
+            }
+        }));
+        const pluginController = agentStore.add(
+            this._instantiationService.createInstance(RemoteAgentPluginController, hostLabel, sanitized, connection)
+        );
+        const syncProvider = this._activeClientService.getSyncProvider(sessionType);
+        const ambientScope = agentStore.add(this._activeClientService.acquireScope(sessionType, []));
+        const itemProvider = agentStore.add(
+            this._instantiationService.createInstance(AgentCustomizationItemProvider, sanitized, (customization, clientId) => {
+                if (clientId !== undefined) {
+                    return undefined;
+                }
+                return [{
+                    id: "remoteAgentHost.removeConfiguredPlugin",
+                    label: ( localize(4306, "Remove from Remote Host")),
+                    icon: Codicon.trash,
+                    run: () => pluginController.removeConfiguredPlugin(customization)
+                }];
+            }, syncedUri => this._activeClientService.getOrigin(syncedUri))
+        );
+        itemProvider.setDraftCustomAgents(ambientScope.customAgents);
+        itemProvider.setDraftCustomizations(ambientScope.customizations);
+        const harnessDescriptor = createRemoteAgentHarnessDescriptor(sessionType, displayName, pluginController, itemProvider, syncProvider);
+        agentStore.add(
+            this._customizationHarnessService.registerExternalHarness(harnessDescriptor)
+        );
+        const sessionHandler = agentStore.add(this._instantiationService.createInstance(AgentHostSessionHandler, {
+            provider: agent.provider,
+            backendSessionScheme: this._connectionCustomizations.get(address)?.backendSessionScheme?.(agent.provider),
+            agentId,
+            sessionType,
+            fullName: displayName,
+            description: agent.description,
+            connection,
+            connectionAuthority: sanitized,
+            extensionId: "vscode.remote-agent-host",
+            extensionDisplayName: "Remote Agent Host",
+            resolveWorkingDirectory,
+            isNewSession,
+            resolveAuthentication: resources => this._resolveAuthenticationInteractively(address, connection, resources)
+        }));
+        agentStore.add(
+            this._chatSessionsService.registerChatSessionContentProvider(sessionType, sessionHandler)
+        );
+        const vendorDescriptor = {
+            vendor,
+            displayName,
+            configuration: undefined,
+            managementCommand: undefined,
+            when: undefined
+        };
+        this._languageModelsService.deltaLanguageModelChatProviderDescriptors([vendorDescriptor], []);
+        agentStore.add(toDisposable(
+            () => this._languageModelsService.deltaLanguageModelChatProviderDescriptors([], [vendorDescriptor])
+        ));
+        const modelProvider = agentStore.add(( new AgentHostLanguageModelProvider(sessionType, vendor, this._languageModelsService)));
+        connState.modelProviders.set(agent.provider, modelProvider);
+        agentStore.add(toDisposable(() => connState.modelProviders.delete(agent.provider)));
+        agentStore.add(
+            this._languageModelsService.registerLanguageModelProvider(vendor, modelProvider)
+        );
+        modelProvider.updateModels(agent.models);
+        this._logService.info(
+            `[RemoteAgentHost] Registered agent ${agent.provider} from ${address} as ${sessionType}`
+        );
+    }
+    _authenticateAllConnections() {
+        for (const [address, connState] of this._connections) {
+            const rootState = connState.connection.rootState.value;
+            if (rootState && !(rootState instanceof Error)) {
+                this._authenticateWithConnection(address, connState.connection, rootState.agents).catch(() => {});
+            }
+        }
+    }
+    async _handleAuthenticationSessionsChanged(providerId, removedSessions) {
+        if (removedSessions.length > 0) {
+            for (const [address, connState] of this._connections) {
+                const rootState = connState.connection.rootState.value;
+                if (!rootState || rootState instanceof Error) {
+                    continue;
+                }
+                try {
+                    await this._instantiationService.invokeFunction(
+                        revokeAuthenticationForRemovedSessions,
+                        rootState.agents,
+                        providerId,
+                        removedSessions,
+                        {
+                            authTokenCache: connState.authTokenCache,
+                            logPrefix: "[RemoteAgentHost]",
+                            authenticate: this._authenticateCallback(address, connState.connection)
+                        }
+                    );
+                } catch (error) {
+                    this._logService.error(
+                        `[RemoteAgentHost] Failed to revoke removed authentication session for ${address}`,
+                        error
+                    );
+                }
+            }
+        }
+        this._authenticateAllConnections();
+    }
+    async _authenticateWithConnection(address, connection, agents) {
+        const providerId = `agenthost-${agentHostAuthority(address)}`;
+        const provider = this._sessionsProvidersService.getProvider(providerId);
+        const authTokenCache = this._connections.get(address)?.authTokenCache;
+        provider?.setAuthenticationPending(true);
+        try {
+            const testToken = this._getScenarioAutomationToken();
+            if (testToken !== undefined) {
+                await authenticateAgentProtectedResourcesWithToken(agents, testToken, {
+                    authTokenCache,
+                    authenticate: this._authenticateCallback(address, connection)
+                });
+                return;
+            }
+            await this._instantiationService.invokeFunction(authenticateProtectedResources, agents, {
+                authTokenCache,
+                logPrefix: "[RemoteAgentHost]",
+                authenticate: this._authenticateCallback(address, connection)
+            });
+        } catch (err) {
+            this._logService.error("[RemoteAgentHost] Failed to authenticate with connection", err);
+        } finally {
+            provider?.setAuthenticationPending(false);
+        }
+    }
+    _getScenarioAutomationToken() {
+        if (!this._enableSmokeTestDriver) {
+            return undefined;
+        }
+        const token = this._configurationService.getValue("chat.agentHost.unsafeTestToken");
+        return typeof token === "string" && token.length > 0 ? token : undefined;
+    }
+    _handleAuthenticationRequiredNotification(address, connection, notification) {
+        if (notification.type !== NotificationType.AuthRequired) {
+            return;
+        }
+        this._authenticateNotificationResource(address, connection, notification.resource);
+    }
+    _authenticateNotificationResource(address, connection, protectedResource) {
+        const connState = this._connections.get(address);
+        if (!connState) {
+            return;
+        }
+        const providerId = `agenthost-${agentHostAuthority(address)}`;
+        const provider = this._sessionsProvidersService.getProvider(providerId);
+        provider?.setAuthenticationPending(true);
+        this._instantiationService.invokeFunction(accessor => connState.authRecovery.recover(accessor, protectedResource, {
+            authTokenCache: connState.authTokenCache,
+            logPrefix: "[RemoteAgentHost]",
+            authenticate: this._authenticateCallback(address, connection)
+        })).catch(err => {
+            this._logService.error(
+                `[RemoteAgentHost] Failed to authenticate notified resource ${protectedResource.resource}`,
+                err
+            );
+        }).finally(() => {
+            provider?.setAuthenticationPending(false);
+        });
+    }
+    _authenticateCallback(address, connection) {
+        const transform = this._connectionCustomizations.get(address)?.authenticate;
+        if (!transform) {
+            return request => connection.authenticate(request);
+        }
+        return async request => {
+            if (!request.token) {
+                return connection.authenticate(request);
+            }
+            return connection.authenticate(await transform(request));
+        };
+    }
+    async _resolveAuthenticationInteractively(address, connection, protectedResources) {
+        const authTokenCache = this._connections.get(address)?.authTokenCache;
+        const testToken = this._getScenarioAutomationToken();
+        if (testToken !== undefined) {
+            await authenticateProtectedResourcesWithToken(protectedResources, testToken, {
+                authTokenCache,
+                authenticate: this._authenticateCallback(address, connection)
+            });
+            return protectedResources.length > 0;
+        }
+        return this._instantiationService.invokeFunction(resolveAuthenticationInteractively, protectedResources, {
+            authTokenCache,
+            logPrefix: "[RemoteAgentHost]",
+            authenticate: this._authenticateCallback(address, connection)
+        });
+    }
+};
+RemoteAgentHostContribution = ( __decorate([( __param(0, IRemoteAgentHostService)), ( __param(1, IChatSessionsService)), ( __param(2, ILanguageModelsService)), ( __param(3, ILogService)), ( __param(4, IInstantiationService)), ( __param(5, IAuthenticationService)), ( __param(6, IDefaultAccountService)), ( __param(7, ISessionsProvidersService)), ( __param(8, IAgentHostFileSystemService)), ( __param(9, ICustomizationHarnessService)), ( __param(10, IAgentHostTerminalService)), ( __param(11, ITelemetryService)), ( __param(12, IAgentHostActiveClientService)), ( __param(13, IRemoteAgentHostConnectionCustomizationService)), ( __param(14, IConfigurationService)), ( __param(15, IWorkbenchEnvironmentService))], RemoteAgentHostContribution));
+registerWorkbenchContribution2(
+    RemoteAgentHostContribution.ID,
+    RemoteAgentHostContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerAction2(OpenAgentHostStateFileAction);
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    properties: {
+        [RemoteAgentHostsEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(4307, "Enable connecting to remote agent hosts.")),
+            default: true,
+            scope: ConfigurationScope.APPLICATION,
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [RemoteAgentHostAutoConnectSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                4308,
+                "Automatically connect to online dev tunnel, SSH, and WSL remote agent hosts on startup. When disabled, cached sessions are still shown but connections are established only on demand."
+            )),
+            default: true,
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"]
+        },
+        [CloudSandboxEnabledSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                4309,
+                "Enable Copilot cloud sandbox sessions over a live Agent Host Protocol relay, for slash commands and a responsive, steerable experience instead of only polling logs. Adds a Sandbox option when starting a cloud session, and connects to the sandbox when opening one."
+            )),
+            default: false,
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"],
+            experiment: {
+                mode: "auto"
+            }
+        },
+        "chat.sshRemoteAgentHostCommand": {
+            type: "string",
+            description: ( localize(
+                4310,
+                "For development: Override the command used to start the remote agent host over SSH. When set, skips automatic CLI installation and runs this command instead. The command must print a WebSocket URL matching ws://127.0.0.1:PORT (optionally with ?tkn=TOKEN) to stdout or stderr./"
+            )),
+            default: "",
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"]
+        },
+        "chat.wslRemoteAgentHostCommand": {
+            type: "string",
+            description: ( localize(
+                4311,
+                "For development: Override the command used to start the remote agent host in WSL. When set, skips automatic CLI installation and runs this command instead. The command must print a WebSocket URL matching ws://127.0.0.1:PORT (optionally with ?tkn=TOKEN) to stdout or stderr."
+            )),
+            default: "",
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"]
+        },
+        "chat.agentHost.forwardSSHAgent": {
+            type: "boolean",
+            description: ( localize(
+                4312,
+                "When enabled, forwards the local SSH agent to the remote machine during SSH agent host connections to hosts whose SSH config has `ForwardAgent yes`. Only enable this for trusted hosts. The remote agent host process must be restarted for this setting to take effect."
+            )),
+            default: false,
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"]
+        },
+        [WslAutoStartSettingId]: {
+            type: "boolean",
+            description: ( localize(
+                4313,
+                "Automatically start a WSL distribution when opening a chat whose distribution is not running. When disabled, the chat shows a Start button instead."
+            )),
+            default: false,
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"]
+        },
+        [RemoteAgentHostsSettingId]: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        description: ( localize(
+                            4314,
+                            "The WebSocket address of the remote agent host (e.g. \"localhost:3000\")."
+                        ))
+                    },
+                    name: {
+                        type: "string",
+                        description: ( localize(4315, "A display name for this remote agent host."))
+                    },
+                    connectionToken: {
+                        type: "string",
+                        description: ( localize(
+                            4316,
+                            "An optional connection token for authenticating with the remote agent host."
+                        ))
+                    }
+                },
+                required: ["address", "name"]
+            },
+            description: ( localize(
+                4317,
+                "A list of WebSocket remote agent host addresses to connect to (e.g. \"localhost:3000\"). SSH remote agent host details are managed by VS Code."
+            )),
+            default: [],
+            scope: ConfigurationScope.APPLICATION,
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [TunnelAgentHostsSettingId]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            description: ( localize(
+                4318,
+                "Additional dev tunnel names to look for when connecting to remote agent hosts. These are looked up in addition to tunnels automatically enumerated from your account."
+            )),
+            default: [],
+            scope: ConfigurationScope.APPLICATION,
+            tags: ["experimental", "advanced"]
+        },
+        [AgentHostLocalFilePermissionsSettingId]: {
+            type: "object",
+            description: ( localize(
+                4319,
+                "Per-host filesystem grants for remote agent hosts. Maps a remote agent host address to URI strings and the access mode the host has been granted (`r` for read, `rw` for read and write). Hosts cannot read or write any files outside the granted URIs without prompting; a URI grant covers descendants. This setting is normally maintained by the agent-host permission prompts and rarely edited by hand."
+            )),
+            additionalProperties: {
+                type: "object",
+                additionalProperties: {
+                    oneOf: [{
+                        type: "string",
+                        enum: ["r", "rw"],
+                        enumDescriptions: [( localize(4320, "Read-only access.")), ( localize(4321, "Read and write access."))]
+                    }, {
+                        type: "object",
+                        properties: {
+                            mode: {
+                                type: "string",
+                                enum: ["r", "rw"]
+                            },
+                            lexicalUri: {
+                                type: "string",
+                                description: ( localize(
+                                    4322,
+                                    "Original resource URI used to display accessible directory entries."
+                                ))
+                            }
+                        },
+                        required: ["mode", "lexicalUri"],
+                        additionalProperties: false
+                    }]
+                }
+            },
+            default: {},
+            scope: ConfigurationScope.APPLICATION,
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        }
+    }
+});
+
+export { RemoteAgentHostContribution };