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

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

@@ -1,146 +1,330 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { DeferredPromise, Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isRemoteAgentHostSessionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
+import { CopilotSemanticSearchEnabledSettingId, CLIENT_SEMANTIC_SEARCH_TOOL_ID, SEMANTIC_SEARCH_TOOL_NAME, CLIENT_SEMANTIC_SEARCH_REFERENCE_NAME } from '../../../../../../platform/agentHost/common/semanticSearchConstants.js';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { IConfigurationResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service';
 import { AgentCustomizationSyncProvider } from './agentCustomizationSyncProvider.js';
-import { resolveCustomizationRefs } from './agentHostLocalCustomizations.js';
+import { resolveCustomizationRefs, resolveLocalCustomAgents } from './agentHostLocalCustomizations.js';
 import { toolDataToDefinition } from './agentHostToolUtils.js';
-import { isToolEnabledInSet } from './agentHostToolSetEnablementService.js';
+import { isCopilotCliSessionType, isToolEnabledInSet } from './agentHostToolSetEnablementService.js';
 import { IAgentHostToolSetEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service';
+import { AgentHostMcpServerSupportScope } from './agentHostMcpServerSupportScope.js';
 import { SyncedCustomizationBundler } from './syncedCustomizationBundler.js';
-import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
-let AgentHostActiveClientService = class AgentHostActiveClientService extends Disposable {
+let AgentCustomizationScope = class AgentCustomizationScope extends Disposable {
+    get customizations() {
+        return this._customizations;
+    }
+    get customAgents() {
+        return this._customAgents;
+    }
+    get tools() {
+        return this._getClientTools(this._sessionType);
+    }
+    get isResolved() {
+        return this._isResolved;
+    }
     constructor(
-        _toolsService,
+        _sessionType,
+        _roots,
+        scopeKey,
+        _syncProvider,
+        _options,
+        _getClientTools,
+        _onDispose,
+        _fileService,
         _promptsService,
         _agentPluginService,
-        _storageService,
-        _instantiationService,
-        _fileService,
+        instantiationService,
         _mcpService,
-        _configurationResolverService,
-        _toolSetEnablementService
+        _configurationResolverService
     ) {
         super();
-        this._toolsService = _toolsService;
+        this._sessionType = _sessionType;
+        this._roots = _roots;
+        this._syncProvider = _syncProvider;
+        this._options = _options;
+        this._getClientTools = _getClientTools;
+        this._onDispose = _onDispose;
+        this._fileService = _fileService;
         this._promptsService = _promptsService;
         this._agentPluginService = _agentPluginService;
-        this._storageService = _storageService;
-        this._instantiationService = _instantiationService;
-        this._fileService = _fileService;
         this._mcpService = _mcpService;
         this._configurationResolverService = _configurationResolverService;
-        this._toolSetEnablementService = _toolSetEnablementService;
-        this._clientToolsByType = ( new Map());
-        this._customizationsByType = observableValue("agentHostCustomizationsByType", ( new Map()));
-        this._allToolsObs = this._toolsService.observeTools(undefined);
-        this._allToolSetsObs = this._toolsService.toolSets;
-    }
-    registerForAgent(sessionType) {
-        const store = ( new DisposableStore());
-        const syncProvider = store.add(( new AgentCustomizationSyncProvider(sessionType, this._storageService)));
-        const bundler = store.add(
-            this._instantiationService.createInstance(SyncedCustomizationBundler, sessionType)
+        this._customizations = observableValue("agentCustomizations", []);
+        this._customAgents = observableValue("agentCustomAgents", []);
+        this._isResolved = observableValue("agentCustomizationsResolved", false);
+        this._initialResolution = ( new DeferredPromise());
+        this._activeClients = ( new Map());
+        this._refCount = 0;
+        this._updateSeq = 0;
+        this._isDisposed = false;
+        this._bundler = this._register(
+            instantiationService.createInstance(SyncedCustomizationBundler, createScopeAuthority(_sessionType, scopeKey))
         );
-        const customizations = observableValue("agentCustomizations", []);
-        let updateSeq = 0;
+        this._updateDelayer = this._register(( new Delayer(CUSTOMIZATION_UPDATE_DEBOUNCE_DELAY)));
         const updateCustomizations = async () => {
-            const seq = ++updateSeq;
+            const seq = ++this._updateSeq;
+            let completedInitialResolution = false;
             try {
-                const refs = await resolveCustomizationRefs(
+                const [refs, agents] = await Promise.all([resolveCustomizationRefs(
                     this._fileService,
                     this._promptsService,
-                    syncProvider,
+                    this._syncProvider,
                     this._agentPluginService,
                     this._mcpService,
                     this._configurationResolverService,
-                    bundler,
-                    sessionType
-                );
-                if (seq !== updateSeq) {
-                    return;
-                }
-                if (equals(customizations.get(), refs)) {
+                    this._bundler,
+                    this._sessionType,
+                    this._options,
+                    this._roots
+                ), resolveLocalCustomAgents(
+                    this._fileService,
+                    this._promptsService,
+                    this._syncProvider,
+                    this._agentPluginService,
+                    this._sessionType,
+                    this._options
+                )]);
+                if (seq !== this._updateSeq) {
                     return;
                 }
-                customizations.set(refs, undefined);
+                transaction(tx => {
+                    if (!equals(this._customizations.get(), refs)) {
+                        this._customizations.set(refs, tx);
+                    }
+                    if (!equals(this._customAgents.get(), agents)) {
+                        this._customAgents.set(agents, tx);
+                    }
+                    this._isResolved.set(true, tx);
+                });
+                completedInitialResolution = true;
             } catch (err) {
                 onUnexpectedError(err);
+                if (seq === this._updateSeq) {
+                    transaction(tx => this._isResolved.set(true, tx));
+                    completedInitialResolution = true;
+                }
+            } finally {
+                if (completedInitialResolution && !this._initialResolution.isSettled) {
+                    this._initialResolution.complete();
+                }
             }
         };
-        const updateDelayer = store.add(( new Delayer(CUSTOMIZATION_UPDATE_DEBOUNCE_DELAY)));
         const scheduleUpdate = () => {
-            updateDelayer.trigger(() => updateCustomizations()).catch(() => {});
+            this._updateDelayer.trigger(() => updateCustomizations()).catch(() => {});
         };
-        store.add(syncProvider.onDidChange(() => scheduleUpdate()));
-        store.add(Event.any(
+        this._register(this._syncProvider.onDidChange(() => scheduleUpdate()));
+        this._register(Event.any(
             this._promptsService.onDidChangeCustomAgents,
             this._promptsService.onDidChangeSlashCommands,
             this._promptsService.onDidChangeSkills,
             this._promptsService.onDidChangeInstructions
         )(() => scheduleUpdate()));
-        store.add(autorun(reader => {
+        this._register(autorun(reader => {
+            for (const plugin of this._agentPluginService.plugins.read(reader)) {
+                plugin.enablement.read(reader);
+                plugin.hooks.read(reader);
+                plugin.commands.read(reader);
+                plugin.skills.read(reader);
+                plugin.agents.read(reader);
+                plugin.instructions.read(reader);
+                plugin.mcpServerDefinitions.read(reader);
+            }
+            scheduleUpdate();
+        }));
+        this._register(autorun(reader => {
             for (const server of this._mcpService.servers.read(reader)) {
                 server.enablement.read(reader);
                 server.readDefinitions().read(reader);
             }
             scheduleUpdate();
         }));
-        store.add(this._setCustomizations(sessionType, customizations));
+    }
+    acquire() {
+        this._refCount++;
+        let released = false;
         return {
-            syncProvider,
-            dispose: () => store.dispose()
+            customizations: this.customizations,
+            customAgents: this.customAgents,
+            tools: this.tools,
+            isResolved: this.isResolved,
+            whenResolved: () => this._initialResolution.p,
+            activeClient: clientId => this.activeClient(clientId),
+            dispose: () => {
+                if (!released) {
+                    released = true;
+                    this._release();
+                }
+            }
         };
     }
-    _setCustomizations(sessionType, customizations) {
-        const next = ( new Map(this._customizationsByType.get()));
-        next.set(sessionType, customizations);
-        this._customizationsByType.set(next, undefined);
-        return toDisposable(() => {
-            const current = this._customizationsByType.get();
-            if (current.get(sessionType) !== customizations) {
-                return;
+    getOrigin(syncedUri) {
+        return this._bundler.getOrigin(syncedUri);
+    }
+    isBundledMcpServer(pluginUri, serverName) {
+        return this._bundler.isBundledMcpServer(pluginUri, serverName);
+    }
+    activeClient(clientId) {
+        let activeClient = this._activeClients.get(clientId);
+        if (!activeClient) {
+            activeClient = derived(reader => {
+                this._customAgents.read(reader);
+                return {
+                    clientId,
+                    tools: [...this.tools.read(reader)],
+                    customizations: [...this._customizations.read(reader)]
+                };
+            });
+            this._activeClients.set(clientId, activeClient);
+        }
+        return activeClient;
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._updateSeq++;
+        if (!this._initialResolution.isSettled) {
+            this._initialResolution.complete();
+        }
+        super.dispose();
+        this._onDispose();
+    }
+    _release() {
+        if (--this._refCount === 0) {
+            this.dispose();
+        }
+    }
+};
+AgentCustomizationScope = ( __decorate([( __param(7, IFileService)), ( __param(8, IPromptsService)), ( __param(9, IAgentPluginService)), ( __param(10, IInstantiationService)), ( __param(11, IMcpService)), ( __param(12, IConfigurationResolverService))], AgentCustomizationScope));
+let AgentHostActiveClientService = class AgentHostActiveClientService extends Disposable {
+    constructor(
+        _toolsService,
+        _storageService,
+        _instantiationService,
+        _toolSetEnablementService,
+        _uriIdentityService,
+        configurationService
+    ) {
+        super();
+        this._toolsService = _toolsService;
+        this._storageService = _storageService;
+        this._instantiationService = _instantiationService;
+        this._toolSetEnablementService = _toolSetEnablementService;
+        this._uriIdentityService = _uriIdentityService;
+        this._clientToolsByType = ( new Map());
+        this._scopes = ( new Map());
+        this._mcpServerSupportScopes = ( new Map());
+        this._syncProviders = ( new Map());
+        this._isDisposed = false;
+        this._allToolsObs = this._toolsService.observeTools(undefined);
+        this._allToolSetsObs = this._toolsService.toolSets;
+        this._semanticSearchEnabled = observableConfigValue(CopilotSemanticSearchEnabledSettingId, false, configurationService);
+    }
+    acquireScope(sessionType, roots) {
+        const normalizedRoots = normalizeRoots(roots, this._uriIdentityService.extUri);
+        const scopeKey = getScopeKey(normalizedRoots, this._uriIdentityService.extUri);
+        const serviceScopeKey = getServiceScopeKey(sessionType, scopeKey);
+        let scope = this._scopes.get(serviceScopeKey);
+        if (!scope) {
+            const options = isRemoteAgentHostSessionType(sessionType) ? {
+                includeUserStorage: true
+            } : undefined;
+            const createdScope = this._instantiationService.createInstance(
+                AgentCustomizationScope,
+                sessionType,
+                normalizedRoots,
+                scopeKey,
+                this.getSyncProvider(sessionType),
+                options,
+                type => this._getClientTools(type),
+                () => this._removeScope(serviceScopeKey, createdScope)
+            );
+            scope = createdScope;
+            this._scopes.set(serviceScopeKey, scope);
+        }
+        return scope.acquire();
+    }
+    acquireMcpServerSupportScope(sessionType, roots) {
+        if (!isCopilotCliSessionType(sessionType)) {
+            return undefined;
+        }
+        const normalizedRoots = roots === undefined ? undefined : normalizeRoots(roots, this._uriIdentityService.extUri);
+        const rootsKey = normalizedRoots === undefined ? undefined : getScopeKey(normalizedRoots, this._uriIdentityService.extUri);
+        const serviceScopeKey = JSON.stringify([sessionType, rootsKey]);
+        let scope = this._mcpServerSupportScopes.get(serviceScopeKey);
+        if (!scope) {
+            const createdScope = this._instantiationService.createInstance(
+                AgentHostMcpServerSupportScope,
+                sessionType,
+                normalizedRoots,
+                () => this._removeMcpServerSupportScope(serviceScopeKey, createdScope)
+            );
+            scope = createdScope;
+            this._mcpServerSupportScopes.set(serviceScopeKey, scope);
+        }
+        return scope.acquire();
+    }
+    getSyncProvider(sessionType) {
+        let syncProvider = this._syncProviders.get(sessionType);
+        if (!syncProvider) {
+            syncProvider = this._register(( new AgentCustomizationSyncProvider(sessionType, this._storageService)));
+            this._syncProviders.set(sessionType, syncProvider);
+        }
+        return syncProvider;
+    }
+    getOrigin(syncedUri) {
+        for (const scope of ( this._scopes.values())) {
+            const origin = scope.getOrigin(syncedUri);
+            if (origin) {
+                return origin;
             }
-            const removed = ( new Map(current));
-            removed.delete(sessionType);
-            this._customizationsByType.set(removed, undefined);
-        });
+        }
+        return undefined;
     }
-    getActiveClient(sessionType, clientId) {
-        return {
-            clientId,
-            tools: [...this.getClientTools(sessionType).get()],
-            customizations: [...(this._customizationsByType.get().get(sessionType)?.get() ?? [])]
-        };
+    areScopeRootsEqual(first, second) {
+        return areCustomizationScopeRootsEqual(first, second, this._uriIdentityService.extUri);
     }
-    getCustomizations(sessionType) {
-        return derived(
-            reader => this._customizationsByType.read(reader).get(sessionType)?.read(reader) ?? EMPTY_CUSTOMIZATIONS
-        );
+    isBundledMcpServer(pluginUri, serverName) {
+        return ( Iterable.some([...( this._scopes.values())], scope => scope.isBundledMcpServer(pluginUri, serverName)));
     }
-    getClientTools(sessionType) {
+    _getClientTools(sessionType) {
         let obs = this._clientToolsByType.get(sessionType);
         if (!obs) {
             obs = derived(reader => {
                 const tools = this._allToolsObs.read(reader);
                 const toolSets = this._allToolSetsObs.read(reader);
                 const enablement = this._toolSetEnablementService.observe(sessionType).read(reader);
+                const isCopilotSession = isCopilotCliSessionType(sessionType);
+                const semanticSearchEnabled = isCopilotSession && this._semanticSearchEnabled.read(reader);
+                const semanticSearchTool = isCopilotSession ? tools.find(tool => tool.id === CLIENT_SEMANTIC_SEARCH_TOOL_ID) : undefined;
                 const enabledToolIds = ( new Set());
                 for (const ts of toolSets) {
                     if (ts.deprecated) {
@@ -152,15 +336,81 @@ let AgentHostActiveClientService = class AgentHostActiveClientService extends Di
                         }
                     }
                 }
-                return ( tools.filter(t => ( enabledToolIds.has(t.id))).map(toolDataToDefinition));
+                return coalesce(( tools.filter(tool => ( enabledToolIds.has(tool.id)) || (semanticSearchEnabled && tool === semanticSearchTool)).map(tool => {
+                    if (!isCopilotSession) {
+                        return toolDataToDefinition(tool);
+                    }
+                    if (tool === semanticSearchTool) {
+                        return semanticSearchEnabled ? {
+                            ...toolDataToDefinition(tool),
+                            name: SEMANTIC_SEARCH_TOOL_NAME
+                        } : undefined;
+                    }
+                    if (tool.toolReferenceName === CLIENT_SEMANTIC_SEARCH_REFERENCE_NAME || tool.toolReferenceName === SEMANTIC_SEARCH_TOOL_NAME) {
+                        return undefined;
+                    }
+                    return toolDataToDefinition(tool);
+                })));
             });
             this._clientToolsByType.set(sessionType, obs);
         }
         return obs;
     }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        const scopes = [...( this._scopes.values())];
+        this._scopes.clear();
+        const mcpServerSupportScopes = [...( this._mcpServerSupportScopes.values())];
+        this._mcpServerSupportScopes.clear();
+        for (const scope of scopes) {
+            scope.dispose();
+        }
+        for (const scope of mcpServerSupportScopes) {
+            scope.dispose();
+        }
+        super.dispose();
+    }
+    _removeScope(scopeKey, scope) {
+        if (this._scopes.get(scopeKey) === scope) {
+            this._scopes.delete(scopeKey);
+        }
+    }
+    _removeMcpServerSupportScope(scopeKey, scope) {
+        if (this._mcpServerSupportScopes.get(scopeKey) === scope) {
+            this._mcpServerSupportScopes.delete(scopeKey);
+        }
+    }
 };
-AgentHostActiveClientService = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IPromptsService)), ( __param(2, IAgentPluginService)), ( __param(3, IStorageService)), ( __param(4, IInstantiationService)), ( __param(5, IFileService)), ( __param(6, IMcpService)), ( __param(7, IConfigurationResolverService)), ( __param(8, IAgentHostToolSetEnablementService))], AgentHostActiveClientService));
-const EMPTY_CUSTOMIZATIONS = ( Object.freeze([]));
+AgentHostActiveClientService = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IStorageService)), ( __param(2, IInstantiationService)), ( __param(3, IAgentHostToolSetEnablementService)), ( __param(4, IUriIdentityService)), ( __param(5, IConfigurationService))], AgentHostActiveClientService));
+function normalizeRoots(roots, extUri) {
+    const rootsByUri = ( new ResourceMap(root => extUri.getComparisonKey(root)));
+    for (const root of roots) {
+        rootsByUri.set(root, root);
+    }
+    return [...( rootsByUri.values())].sort((a, b) => {
+        const left = extUri.getComparisonKey(a);
+        const right = extUri.getComparisonKey(b);
+        return left < right ? -1 : left > right ? 1 : 0;
+    });
+}
+function areCustomizationScopeRootsEqual(first, second, extUri) {
+    const toComparisonKey = root => extUri.getComparisonKey(root);
+    const firstRoots = ( new ResourceSet(first ?? [], toComparisonKey));
+    const secondRoots = ( new ResourceSet(second, toComparisonKey));
+    return firstRoots.size === secondRoots.size && [...firstRoots].every(root => ( secondRoots.has(root)));
+}
+function getScopeKey(roots, extUri) {
+    return ( roots.map(root => extUri.getComparisonKey(root))).join("\n");
+}
+function getServiceScopeKey(sessionType, scopeKey) {
+    return JSON.stringify([sessionType, scopeKey]);
+}
+function createScopeAuthority(sessionType, scopeKey) {
+    return `${sessionType}-${hash(scopeKey)}`;
+}
 const CUSTOMIZATION_UPDATE_DEBOUNCE_DELAY = 50;
 
-export { AgentHostActiveClientService };
+export { AgentHostActiveClientService, areCustomizationScopeRootsEqual };

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

@@ -1,11 +1,17 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { type Customization, type RootConfigState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
-import { AgentCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IAgentHostResourceUriMapper } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { CustomizationEnablementKind, McpServerCustomization, type Customization, type CustomizationEnablement, type PluginCustomization, type RootConfigState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { AgentCustomization, type ISessionFolderPickerDecision } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+import { IAgentHostActiveClientService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service";
 import { IAgentHostMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostMcpServer";
 import { IAgentHostCustomizationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service";
 export declare class NullAgentHostCustomizationService implements IAgentHostCustomizationService {
@@ -14,22 +20,34 @@ export declare class NullAgentHostCustomizationService implements IAgentHostCust
     readonly onDidChangeCustomizations: Event<any>;
     getCustomAgents(_sessionResource: URI): readonly AgentCustomization[];
     getCustomizations(_sessionResource: URI): readonly Customization[];
+    whenCustomizationsReady(_sessionResource: URI, _token?: CancellationToken): Promise<void>;
+    getFolderPickerDecision(_sessionResource: URI): ISessionFolderPickerDecision | undefined;
     getWorkingDirectory(sessionResource: URI): string | undefined;
+    getWorkingDirectories(_sessionResource: URI): readonly string[];
+    getClientWorkingDirectoryUris(_sessionResource: URI): readonly URI[];
     getMcpServers(_sessionResource: URI): readonly IAgentHostMcpServer[];
     addMcpServer(_sessionResource: URI, _name: string, _config: IMcpServerConfiguration): void;
     authenticateMcpServer(_sessionResource: URI, _serverId: string): Promise<boolean>;
+    setCustomizationEnablement(_sessionResource: URI, _customizationId: string, _currentEnablement: readonly CustomizationEnablement[] | undefined, _kind: CustomizationEnablementKind, _enabled: boolean): void;
+    showMcpServerLog(_sessionResource: URI, _serverId: string, beforeShow?: () => Promise<void>): Promise<void>;
 }
 export interface IAgentHostCustomizationTarget {
     readonly customizations: readonly Customization[];
+    readonly resourceUris: IAgentHostResourceUriMapper;
+    readonly folderPickerDecision?: ISessionFolderPickerDecision;
     readonly workingDirectory?: string;
-    readonly logOutputChannelId?: string;
+    /** Host-side URI strings, also used in protocol enablement decisions. */
+    readonly workingDirectories?: readonly string[];
     readonly rootConfig?: RootConfigState;
+    isBundledMcpServer(pluginUri: string, serverName: string): boolean;
     authenticate(request: {
         resource: string;
         scopes?: readonly string[];
         token: string;
     }): Promise<unknown>;
-    setCustomizationEnabled(rawId: string, enabled: boolean): void;
+    setCustomizationEnablement(rawId: string, enablement: readonly CustomizationEnablement[]): void;
+    startMcpServer(rawId: string): Promise<void>;
+    stopMcpServer(rawId: string): Promise<void>;
     setRootConfigValue(property: string, value: unknown): void;
 }
 export declare abstract class AbstractAgentHostCustomizationService extends Disposable implements IAgentHostCustomizationService {
@@ -40,18 +58,107 @@ export declare abstract class AbstractAgentHostCustomizationService extends Disp
     private readonly _onDidChangeCustomizations;
     readonly onDidChangeCustomAgents: Event<void>;
     readonly onDidChangeCustomizations: Event<void>;
+    private readonly _mcpLogRegistry;
+    /**
+     * Sessions whose MCP diagnostics we mirror into per-server Output channels.
+     * A session is tracked once the user reveals a server's output; from then
+     * on every state change is recorded via {@link onDidChangeCustomizations},
+     * so subsequent failures and recoveries land in the channel history.
+     */
+    private readonly _mcpDiagnosticSessions;
     protected constructor(_instantiationService: IInstantiationService, _logService: ILogService);
     protected abstract _resolveTarget(sessionResource: URI): IAgentHostCustomizationTarget | undefined;
     getCustomAgents(sessionResource: URI): readonly AgentCustomization[];
     getCustomizations(sessionResource: URI): readonly Customization[];
+    /**
+     * Targets resolved by this base are backed by already-materialized provider
+     * state, so a snapshot is available as soon as the target resolves.
+     */
+    whenCustomizationsReady(_sessionResource: URI, _token?: CancellationToken): Promise<void>;
+    getFolderPickerDecision(sessionResource: URI): ISessionFolderPickerDecision | undefined;
     getWorkingDirectory(sessionResource: URI): string | undefined;
+    getWorkingDirectories(sessionResource: URI): readonly string[];
+    getClientWorkingDirectoryUris(sessionResource: URI): readonly URI[];
     getMcpServers(sessionResource: URI): readonly IAgentHostMcpServer[];
+    showMcpServerLog(sessionResource: URI, serverId: string, beforeShow?: () => Promise<void>): Promise<void>;
+    /**
+     * Registers `sessionResource` for MCP diagnostics mirroring and records the
+     * currently-observed state of each of its servers. Idempotent: registering
+     * an already-tracked session simply re-records (dedup'd by state signature).
+     */
+    private _trackMcpDiagnostics;
+    /** Re-records every tracked session's MCP server states (on any customizations change). */
+    private _recordMcpDiagnostics;
+    /** Stops mirroring and disposes all MCP diagnostics channels for a session that is going away. */
+    protected _disposeMcpDiagnostics(sessionResource: URI): void;
     addMcpServer(sessionResource: URI, name: string, config: IMcpServerConfiguration): void;
     authenticateMcpServer(sessionResource: URI, serverId: string): Promise<boolean>;
+    setCustomizationEnablement(sessionResource: URI, customizationId: string, currentEnablement: readonly CustomizationEnablement[] | undefined, kind: CustomizationEnablementKind, enabled: boolean): void;
+    private _workspaceEnablementEntry;
     protected _fireCustomAgentsChanged(): void;
     protected _fireCustomizationsChanged(): void;
-    private _flattenMcpServers;
     private _findMcpServer;
+    private _findCustomization;
     protected _scopedMcpServerId(sessionResource: URI, rawId: string): string;
     private _isScopedMcpServerIdForRawId;
 }
+/** One MCP server customization, with the position it was published at. */
+export interface IMcpServerCustomizationEntry {
+    readonly server: McpServerCustomization;
+    /**
+     * The plugin that declares this server. Absent both for a server published at the top level
+     * and for one declared by a {@link CustomizationType.Directory} container, so it says nothing
+     * about where in the tree the server sits -- use {@link isTopLevel} for that.
+     */
+    readonly plugin?: PluginCustomization;
+    /** Whether the agent host published this server as a customization of the session itself. */
+    readonly isTopLevel: boolean;
+}
+/** Every MCP server customization in a session, including duplicates of the same server. */
+export declare function flattenMcpServerCustomizations(customizations: readonly Customization[]): readonly IMcpServerCustomizationEntry[];
+/**
+ * The MCP servers to *show* for a session: one entry per server.
+ *
+ * A session can carry two customizations for one server: the declaration, published as a child of
+ * whatever declared it, and a top-level entry the agent host mints for a server the SDK reports
+ * before that child resolves by name. A child is dropped when a top-level customization already
+ * speaks for its name, because the top-level copy is the one the host keeps live and resolves for
+ * lifecycle and enablement.
+ *
+ * Tree position is the signal, not the shape of the minted id and not the absence of an owning
+ * plugin -- a directory-declared child has none either. Only presentation dedupes; lookups
+ * elsewhere walk every customization, so an id from either copy still resolves. Servers of the
+ * same name from different containers are left alone, because they are different servers.
+ */
+export declare function getPresentableMcpServerCustomizations(customizations: readonly Customization[]): readonly IMcpServerCustomizationEntry[];
+export declare class WorkbenchAgentHostCustomizationService extends AbstractAgentHostCustomizationService {
+    private readonly _connectionsService;
+    private readonly _provisionalSessionService;
+    private readonly _chatService;
+    private readonly _activeClientService;
+    private readonly _sessionStateSubscriptions;
+    /** Overridable so tests can exercise the timeout without real-time waits. */
+    protected readonly _snapshotTimeoutMs: number;
+    constructor(_connectionsService: IAgentHostConnectionsService, _provisionalSessionService: IAgentHostUntitledProvisionalSessionService, instantiationService: IInstantiationService, logService: ILogService, _chatService: IChatService, _activeClientService: IAgentHostActiveClientService);
+    protected _resolveTarget(sessionResource: URI): IAgentHostCustomizationTarget | undefined;
+    /**
+     * Session state arrives asynchronously over the protocol, so a freshly
+     * created subscription reports `undefined` until its first snapshot lands.
+     *
+     * The wait is memoized per subscription so that the many source-folder
+     * queries behind a single migration hint observe one shared deadline rather
+     * than restarting it per prompt type. It is bounded because the chat request
+     * path blocks on this before sending the user's message: once it elapses,
+     * callers fall back to the current (possibly empty) snapshot rather than
+     * stalling the send again on every subsequent query.
+     */
+    whenCustomizationsReady(sessionResource: URI, token?: CancellationToken): Promise<void>;
+    private _awaitFirstSnapshot;
+    private _ensureSessionStateSubscription;
+    /**
+     * Resolves a chat session resource to the backend agent-session URI plus
+     * the {@link IAgentConnection} (local or remote) that owns it. Returns
+     * `undefined` for sessions not backed by an agent host.
+     */
+    private _resolveSessionTarget;
+}