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

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatContribution.d.ts

@@ -0,0 +1,77 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+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 { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+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 { IAgentHostActiveClientService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service";
+import { IAgentHostProtectedResourcesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostProtectedResourcesService.service";
+export { AgentHostSessionHandler } from "./agentHostSessionHandler.js";
+/**
+ * Discovers available agents from the agent host process and dynamically
+ * registers each one as a chat session type with its own session handler,
+ * customization harness, and language model provider.
+ *
+ * Gated on Agent Host runtime availability.
+ */
+export declare class AgentHostContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _agentHostService;
+    private readonly _chatSessionsService;
+    private readonly _defaultAccountService;
+    private readonly _authenticationService;
+    private readonly _logService;
+    private readonly _languageModelsService;
+    private readonly _instantiationService;
+    private readonly _agentHostFileSystemService;
+    private readonly _configurationService;
+    private readonly _customizationHarnessService;
+    private readonly _activeClientService;
+    private readonly _protectedResourcesService;
+    private readonly _agentHostEnablementService;
+    static readonly ID = "workbench.contrib.agentHostContribution";
+    private readonly _agentRegistrations;
+    /** Model providers keyed by agent provider, for pushing model updates. */
+    private readonly _modelProviders;
+    /** Dedupes redundant `authenticate` RPCs when the resolved token hasn't changed. */
+    private readonly _authTokenCache;
+    private readonly _authRecovery;
+    private readonly _isSessionsWindow;
+    private readonly _enableSmokeTestDriver;
+    private _initialized;
+    private readonly _enablementStore;
+    private _authenticationGeneration;
+    private _didStartInitialAuthentication;
+    private _promptCacheNotification;
+    constructor(_agentHostService: IAgentHostService, _chatSessionsService: IChatSessionsService, _defaultAccountService: IDefaultAccountService, _authenticationService: IAuthenticationService, _logService: ILogService, _languageModelsService: ILanguageModelsService, _instantiationService: IInstantiationService, _agentHostFileSystemService: IAgentHostFileSystemService, _configurationService: IConfigurationService, _customizationHarnessService: ICustomizationHarnessService, environmentService: IWorkbenchEnvironmentService, _activeClientService: IAgentHostActiveClientService, _protectedResourcesService: IAgentHostProtectedResourcesService, _agentHostEnablementService: IAgentHostEnablementService);
+    private _initialize;
+    private _enable;
+    private _shouldRegisterAgent;
+    private _handleRootStateChange;
+    private _registerAgent;
+    private _handleAuthenticationSessionsChanged;
+    private _getRootAgents;
+    /**
+     * Authenticate using protectedResources from agent info in root state.
+     * Resolves tokens via the standard VS Code authentication service.
+     */
+    private _authenticateWithServer;
+    private _authenticateNotificationResource;
+    /**
+     * Interactively prompt the user to authenticate when the server requires it.
+     * Uses protectedResources from root state, resolves the auth provider,
+     * creates a session (which triggers the login UI), and pushes the token
+     * to the server. Returns true if authentication succeeded.
+     */
+    private _resolveAuthenticationInteractively;
+    private _getScenarioAutomationToken;
+    private _isAuthenticationCurrent;
+    private _authenticateIfCurrent;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostChatContribution.js

@@ -0,0 +1,474 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableMap, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { mark } from '@codingame/monaco-vscode-api/vscode/vs/base/common/performance';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { shouldSurfaceLocalAgentHostProvider, affectsAgentHostProviderPreference } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { LOCAL_AGENT_HOST_AUTHORITY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { NotificationType } from '../../../../../../platform/agentHost/common/state/sessionActions.js';
+import { CHATGPT_SUBSCRIPTION_MODEL_SOURCE_ID } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/agentModelSource';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+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 { 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 { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { ChatSessionsExtensions, isLocalAgentHostTarget } 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 { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+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 { languageModelSourcePresentationRegistry } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/languageModelSourcePresentation';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { AgentCustomizationItemProvider } from './agentCustomizationItemProvider.js';
+import { agentHostProviderHasBuiltInGitHubMcpServer, COPILOT_CHAT_GITHUB_MCP_COLLECTION_ID } from './agentHostMcpServerSupport.js';
+import { AgentHostDownloadProgress } from './agentHostDownloadProgress.js';
+import { AgentHostAuthTokenCache, AgentHostAuthenticationRecovery, revokeAuthenticationForRemovedSessions, authenticateAgentProtectedResourcesWithToken, authenticateProtectedResources, authenticateProtectedResourcesWithToken, resolveAuthenticationInteractively } from './agentHostAuth.js';
+import { agentHostProviderSupportsAutoModel, AgentHostLanguageModelProvider } from './agentHostLanguageModelProvider.js';
+import { AgentHostSessionHandler } from './agentHostSessionHandler.js';
+import { AgentHostPromptCacheNotification } from './agentHostPromptCacheNotification.js';
+import { IAgentHostActiveClientService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service';
+import { IAgentHostProtectedResourcesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostProtectedResourcesService.service';
+import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { protectedResourcesRequireGitHubCopilotSignIn } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+
+const LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX = "agent-host-";
+languageModelSourcePresentationRegistry.register({
+    ownerVendor: "agent-host-codex",
+    sourceId: CHATGPT_SUBSCRIPTION_MODEL_SOURCE_ID,
+    label: ( localize(5988, "ChatGPT")),
+    icon: Codicon.openai,
+    description: ( localize(5989, "Models provided by your ChatGPT subscription"))
+});
+( Registry.as(ChatSessionsExtensions.AsyncActivation)).register({
+    matchSessionType: sessionType => isLocalAgentHostTarget(sessionType),
+    waitForActivation: waitForLocalAgentHostActivation
+});
+async function waitForLocalAgentHostActivation(accessor, sessionType) {
+    const agentHostEnablementService = accessor.get(IAgentHostEnablementService);
+    const agentHostService = accessor.get(IAgentHostService);
+    const configurationService = accessor.get(IConfigurationService);
+    const environmentService = accessor.get(IWorkbenchEnvironmentService);
+    if (!agentHostEnablementService.enabled.get()) {
+        return false;
+    }
+    const provider = getLocalAgentHostProviderForSessionType(sessionType);
+    if (!provider) {
+        return false;
+    }
+    while (true) {
+        const rootState = agentHostService.rootState.value;
+        if (rootState instanceof Error) {
+            return false;
+        }
+        if (rootState) {
+            return ( rootState.agents.some(
+                agent => agent.provider === provider && shouldSurfaceLocalAgentHostProvider(agent.provider, configurationService, environmentService.isSessionsWindow)
+            ));
+        }
+        const changed = await Promise.race([
+            Event.toPromise(agentHostService.rootState.onDidChange).then(() => true),
+            Event.toPromise(agentHostService.onAgentHostExit).then(() => false)
+        ]);
+        if (!changed) {
+            return false;
+        }
+    }
+}
+function getLocalAgentHostProviderForSessionType(sessionType) {
+    if (!isLocalAgentHostTarget(sessionType) || !sessionType.startsWith(LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX)) {
+        return undefined;
+    }
+    return sessionType.slice(LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX.length) || undefined;
+}
+let AgentHostContribution = class AgentHostContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostContribution";
+    }
+    constructor(
+        _agentHostService,
+        _chatSessionsService,
+        _defaultAccountService,
+        _authenticationService,
+        _logService,
+        _languageModelsService,
+        _instantiationService,
+        _agentHostFileSystemService,
+        _configurationService,
+        _customizationHarnessService,
+        environmentService,
+        _activeClientService,
+        _protectedResourcesService,
+        _agentHostEnablementService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._chatSessionsService = _chatSessionsService;
+        this._defaultAccountService = _defaultAccountService;
+        this._authenticationService = _authenticationService;
+        this._logService = _logService;
+        this._languageModelsService = _languageModelsService;
+        this._instantiationService = _instantiationService;
+        this._agentHostFileSystemService = _agentHostFileSystemService;
+        this._configurationService = _configurationService;
+        this._customizationHarnessService = _customizationHarnessService;
+        this._activeClientService = _activeClientService;
+        this._protectedResourcesService = _protectedResourcesService;
+        this._agentHostEnablementService = _agentHostEnablementService;
+        this._agentRegistrations = this._register(( new DisposableMap()));
+        this._modelProviders = ( new Map());
+        this._authTokenCache = ( new AgentHostAuthTokenCache());
+        this._authRecovery = ( new AgentHostAuthenticationRecovery());
+        this._initialized = false;
+        this._enablementStore = this._register(( new MutableDisposable()));
+        this._authenticationGeneration = 0;
+        this._didStartInitialAuthentication = false;
+        this._isSessionsWindow = environmentService.isSessionsWindow;
+        this._enableSmokeTestDriver = !!environmentService.enableSmokeTestDriver;
+        this._register(autorun(reader => {
+            const enabled = this._agentHostEnablementService.enabled.read(reader);
+            if (enabled) {
+                const wasInitialized = this._initialized;
+                this._initialize();
+                this._enable();
+                const current = this._agentHostService.rootState.value;
+                if (wasInitialized && current && !(current instanceof Error)) {
+                    this._handleRootStateChange(current);
+                }
+            } else {
+                this._authenticationGeneration++;
+                this._authTokenCache.clear();
+                this._authRecovery.clear();
+                this._enablementStore.clear();
+                this._agentHostService.setAuthenticationPending(false);
+                this._agentRegistrations.clearAndDisposeAll();
+                this._modelProviders.clear();
+            }
+        }));
+    }
+    _initialize() {
+        if (this._initialized) {
+            return;
+        }
+        this._initialized = true;
+        this._promptCacheNotification = this._register(
+            this._instantiationService.createInstance(AgentHostPromptCacheNotification)
+        );
+        this._register(
+            this._agentHostFileSystemService.registerAuthority(LOCAL_AGENT_HOST_AUTHORITY, this._agentHostService)
+        );
+        this._register(this._agentHostService.rootState.onDidChange(rootState => {
+            this._handleRootStateChange(rootState);
+        }));
+        const initialRootState = this._agentHostService.rootState.value;
+        if (initialRootState && !(initialRootState instanceof Error)) {
+            this._handleRootStateChange(initialRootState);
+        }
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (!affectsAgentHostProviderPreference(e, this._isSessionsWindow)) {
+                return;
+            }
+            const current = this._agentHostService.rootState.value;
+            if (current && !(current instanceof Error)) {
+                this._handleRootStateChange(current);
+            }
+        }));
+    }
+    _enable() {
+        if (this._enablementStore.value) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        store.add(this._agentHostService.onDidNotification(notification => {
+            if (notification.type !== NotificationType.AuthRequired) {
+                return;
+            }
+            this._authenticateNotificationResource(notification.resource);
+        }));
+        store.add(this._defaultAccountService.onDidChangeDefaultAccount(() => {
+            this._authenticateWithServer(this._getRootAgents()).catch(() => {});
+        }));
+        store.add(this._authenticationService.onDidRegisterAuthenticationProvider(() => {
+            this._authenticateWithServer(this._getRootAgents()).catch(() => {});
+        }));
+        store.add(this._authenticationService.onDidChangeSessions(event => {
+            void this._handleAuthenticationSessionsChanged(event.providerId, event.event.removed ?? []);
+        }));
+        if (!this._isSessionsWindow) {
+            const downloadProgress = store.add(this._instantiationService.createInstance(AgentHostDownloadProgress));
+            store.add(this._agentHostService.onDidNotification(n => {
+                if (n.type === NotificationType.Progress) {
+                    downloadProgress.handleProgress(n);
+                }
+            }));
+        }
+        this._enablementStore.value = store;
+    }
+    _shouldRegisterAgent(provider) {
+        return shouldSurfaceLocalAgentHostProvider(provider, this._configurationService, this._isSessionsWindow);
+    }
+    _handleRootStateChange(rootState) {
+        if (!this._agentHostEnablementService.enabled.get()) {
+            return;
+        }
+        const allowed = rootState.agents.filter(a => this._shouldRegisterAgent(a.provider));
+        const incoming = ( new Set(( allowed.map(a => a.provider))));
+        for (const [provider] of this._agentRegistrations) {
+            if (!( incoming.has(provider))) {
+                this._agentRegistrations.deleteAndDispose(provider);
+                this._modelProviders.delete(provider);
+            }
+        }
+        this._authenticateWithServer(allowed).catch(() => {});
+        for (const agent of allowed) {
+            if (!( this._agentRegistrations.has(agent.provider))) {
+                this._registerAgent(agent);
+            } else {
+                const modelProvider = this._modelProviders.get(agent.provider);
+                modelProvider?.updateModels(agent.models);
+            }
+        }
+    }
+    _registerAgent(agent) {
+        const store = ( new DisposableStore());
+        this._agentRegistrations.set(agent.provider, store);
+        const sessionType = `agent-host-${agent.provider}`;
+        const agentId = sessionType;
+        const vendor = sessionType;
+        const ahService = this._agentHostService;
+        store.add(this._chatSessionsService.registerChatSessionContribution({
+            type: sessionType,
+            name: agentId,
+            displayName: agent.displayName,
+            description: agent.description,
+            locations: agent.provider === "copilotcli" ? [
+                ChatAgentLocation.Chat,
+                ChatAgentLocation.Terminal,
+                ChatAgentLocation.EditorInline
+            ] : undefined,
+            customAgentTarget: this._isSessionsWindow ? undefined : Target.GitHubCopilot,
+            canDelegate: true,
+            requiresCustomModels: true,
+            supportsAutoModel: agentHostProviderSupportsAutoModel(agent.provider),
+            requiresCopilotSignIn: () => {
+                const resources = this._protectedResourcesService.getProtectedResources(agent.provider);
+                return resources !== undefined ? protectedResourcesRequireGitHubCopilotSignIn(resources) : true;
+            },
+            onDidChangeRequiresCopilotSignIn: Event.signal(Event.filter(
+                this._protectedResourcesService.onDidChange,
+                provider => provider === agent.provider,
+                store
+            )),
+            agentHostProviderId: agent.provider,
+            supportsDelegation: false,
+            capabilities: {
+                supportsCheckpoints: true,
+                supportsPromptAttachments: true,
+                supportsImageAttachments: true,
+                get terminalCommandPrefix() {
+                    return ahService.initializeResult.get()?.terminalCommandPrefix;
+                }
+            }
+        }));
+        const syncProvider = this._activeClientService.getSyncProvider(sessionType);
+        const ambientScope = store.add(this._activeClientService.acquireScope(sessionType, []));
+        const itemProvider = store.add(this._instantiationService.createInstance(
+            AgentCustomizationItemProvider,
+            "local",
+            undefined,
+            syncedUri => this._activeClientService.getOrigin(syncedUri)
+        ));
+        itemProvider.setDraftCustomAgents(ambientScope.customAgents);
+        itemProvider.setDraftCustomizations(ambientScope.customizations);
+        store.add(this._customizationHarnessService.registerExternalHarness({
+            id: sessionType,
+            label: agent.displayName,
+            icon: ThemeIcon.fromId(Codicon.server.id),
+            hiddenSections: agent.provider === "copilotcli" ? [AICustomizationManagementSection.Prompts] : [
+                AICustomizationManagementSection.Tools,
+                AICustomizationManagementSection.Prompts
+            ],
+            hideGenerateButton: true,
+            syncProvider,
+            itemProvider,
+            hiddenMcpServerCollectionIds: agentHostProviderHasBuiltInGitHubMcpServer(agent.provider) ? [COPILOT_CHAT_GITHUB_MCP_COLLECTION_ID] : undefined
+        }));
+        const sessionHandler = store.add(this._instantiationService.createInstance(AgentHostSessionHandler, {
+            provider: agent.provider,
+            agentId,
+            sessionType,
+            fullName: agent.displayName,
+            description: agent.description,
+            connection: this._agentHostService,
+            connectionAuthority: LOCAL_AGENT_HOST_AUTHORITY,
+            onSessionMaterialized: resource => this._chatSessionsService.notifySessionMaterialized?.(resource),
+            resolveAuthentication: resources => this._resolveAuthenticationInteractively(resources),
+            promptCacheNotification: this._promptCacheNotification
+        }));
+        store.add(
+            this._chatSessionsService.registerChatSessionContentProvider(sessionType, sessionHandler)
+        );
+        const vendorDescriptor = {
+            vendor,
+            displayName: agent.displayName,
+            configuration: undefined,
+            managementCommand: undefined,
+            when: undefined
+        };
+        this._languageModelsService.deltaLanguageModelChatProviderDescriptors([vendorDescriptor], []);
+        store.add(toDisposable(
+            () => this._languageModelsService.deltaLanguageModelChatProviderDescriptors([], [vendorDescriptor])
+        ));
+        const modelProvider = store.add(( new AgentHostLanguageModelProvider(sessionType, vendor, this._languageModelsService)));
+        this._modelProviders.set(agent.provider, modelProvider);
+        store.add(toDisposable(() => this._modelProviders.delete(agent.provider)));
+        store.add(
+            this._languageModelsService.registerLanguageModelProvider(vendor, modelProvider)
+        );
+        modelProvider.updateModels(agent.models);
+    }
+    async _handleAuthenticationSessionsChanged(providerId, removedSessions) {
+        const agents = this._getRootAgents();
+        if (removedSessions.length > 0) {
+            const generation = this._authenticationGeneration;
+            try {
+                await this._instantiationService.invokeFunction(
+                    revokeAuthenticationForRemovedSessions,
+                    agents,
+                    providerId,
+                    removedSessions,
+                    {
+                        authTokenCache: this._authTokenCache,
+                        logPrefix: "[AgentHost]",
+                        isCurrent: () => this._isAuthenticationCurrent(generation),
+                        authenticate: request => this._authenticateIfCurrent(request, generation)
+                    }
+                );
+            } catch (error) {
+                if (!isCancellationError(error)) {
+                    this._logService.error("[AgentHost] Failed to revoke removed authentication session", error);
+                }
+            }
+        }
+        await this._authenticateWithServer(agents);
+    }
+    _getRootAgents() {
+        const rootState = this._agentHostService.rootState.value;
+        const agents = (rootState && !(rootState instanceof Error)) ? rootState.agents : [];
+        return agents.filter(a => this._shouldRegisterAgent(a.provider));
+    }
+    async _authenticateWithServer(agents) {
+        const generation = this._authenticationGeneration;
+        if (!this._isAuthenticationCurrent(generation)) {
+            return;
+        }
+        const isInitialAuthentication = agents.length > 0 && !this._didStartInitialAuthentication;
+        if (isInitialAuthentication) {
+            this._didStartInitialAuthentication = true;
+            mark("code/agentHost/willAuthenticate");
+        }
+        this._agentHostService.setAuthenticationPending(true);
+        try {
+            const testToken = this._getScenarioAutomationToken();
+            if (testToken !== undefined) {
+                await authenticateAgentProtectedResourcesWithToken(agents, testToken, {
+                    authTokenCache: this._authTokenCache,
+                    isCurrent: () => this._isAuthenticationCurrent(generation),
+                    authenticate: request => this._authenticateIfCurrent(request, generation)
+                });
+                return;
+            }
+            await this._instantiationService.invokeFunction(authenticateProtectedResources, agents, {
+                authTokenCache: this._authTokenCache,
+                logPrefix: "[AgentHost]",
+                isCurrent: () => this._isAuthenticationCurrent(generation),
+                authenticate: request => this._authenticateIfCurrent(request, generation)
+            });
+        } catch (err) {
+            if (!isCancellationError(err)) {
+                this._logService.error("[AgentHost] Failed to authenticate with server", err);
+            }
+        } finally {
+            if (this._isAuthenticationCurrent(generation)) {
+                this._agentHostService.setAuthenticationPending(false);
+            }
+            if (isInitialAuthentication) {
+                mark("code/agentHost/didAuthenticate");
+            }
+        }
+    }
+    _authenticateNotificationResource(protectedResource) {
+        const generation = this._authenticationGeneration;
+        if (!this._isAuthenticationCurrent(generation)) {
+            return;
+        }
+        this._agentHostService.setAuthenticationPending(true);
+        this._instantiationService.invokeFunction(accessor => this._authRecovery.recover(accessor, protectedResource, {
+            authTokenCache: this._authTokenCache,
+            logPrefix: "[AgentHost]",
+            isCurrent: () => this._isAuthenticationCurrent(generation),
+            authenticate: request => this._authenticateIfCurrent(request, generation)
+        })).catch(err => {
+            if (!isCancellationError(err)) {
+                this._logService.error(
+                    `[AgentHost] Failed to authenticate notified resource ${protectedResource.resource}`,
+                    err
+                );
+            }
+        }).finally(() => {
+            if (this._isAuthenticationCurrent(generation)) {
+                this._agentHostService.setAuthenticationPending(false);
+            }
+        });
+    }
+    async _resolveAuthenticationInteractively(protectedResources) {
+        const generation = this._authenticationGeneration;
+        if (!this._isAuthenticationCurrent(generation)) {
+            return false;
+        }
+        const testToken = this._getScenarioAutomationToken();
+        if (testToken !== undefined) {
+            await authenticateProtectedResourcesWithToken(protectedResources, testToken, {
+                authTokenCache: this._authTokenCache,
+                isCurrent: () => this._isAuthenticationCurrent(generation),
+                authenticate: request => this._authenticateIfCurrent(request, generation)
+            });
+            return protectedResources.length > 0;
+        }
+        return this._instantiationService.invokeFunction(resolveAuthenticationInteractively, protectedResources, {
+            authTokenCache: this._authTokenCache,
+            logPrefix: "[AgentHost]",
+            isCurrent: () => this._isAuthenticationCurrent(generation),
+            authenticate: request => this._authenticateIfCurrent(request, generation)
+        });
+    }
+    _getScenarioAutomationToken() {
+        if (!this._enableSmokeTestDriver) {
+            return undefined;
+        }
+        const token = this._configurationService.getValue("chat.agentHost.unsafeTestToken");
+        return typeof token === "string" && token.length > 0 ? token : undefined;
+    }
+    _isAuthenticationCurrent(generation) {
+        return generation === this._authenticationGeneration && this._agentHostEnablementService.enabled.get();
+    }
+    _authenticateIfCurrent(request, generation) {
+        if (!this._isAuthenticationCurrent(generation)) {
+            return Promise.reject(( new CancellationError()));
+        }
+        return this._agentHostService.authenticate(request);
+    }
+};
+AgentHostContribution = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IChatSessionsService)), ( __param(2, IDefaultAccountService)), ( __param(3, IAuthenticationService)), ( __param(4, ILogService)), ( __param(5, ILanguageModelsService)), ( __param(6, IInstantiationService)), ( __param(7, IAgentHostFileSystemService)), ( __param(8, IConfigurationService)), ( __param(9, ICustomizationHarnessService)), ( __param(10, IWorkbenchEnvironmentService)), ( __param(11, IAgentHostActiveClientService)), ( __param(12, IAgentHostProtectedResourcesService)), ( __param(13, IAgentHostEnablementService))], AgentHostContribution));
+
+export { AgentHostContribution, AgentHostSessionHandler };