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

package/vscode/src/vs/workbench/contrib/chat/browser/aiCustomization/mcpListWidget.js

@@ -2,61 +2,82 @@
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
-import { $ as $$1, append, createTextNode, addDisposableListener, getWindow, DisposableResizeObserver, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
-import { DisposableStore, Disposable, MutableDisposable, isDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { $ as $$1, append, DisposableResizeObserver, addDisposableListener, EventType, clearNode, addDisposableGenericMouseDownListener, EventHelper, getWindow, createTextNode, scheduleAtNextAnimationFrame } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable, DisposableStore, MutableDisposable, isDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
 import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
-import { defaultInputBoxStyles, defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { Switch } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/switch';
+import { getButtonStyles, defaultButtonStyles, defaultInputBoxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { mcpAccessConfig, McpAccessValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpManagement';
-import { McpConnectionState, McpServerInstallState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpGalleryManifestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpGalleryManifest.service';
+import { MCP_PLUGIN_COLLECTION_ID_PREFIX, McpConnectionState, McpServerInstallState, McpServerTransportType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
 import { IMcpWorkbenchService, IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
 import { IMcpRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpRegistryTypes.service';
-import { MCP_PLUGIN_COLLECTION_ID_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/discovery/pluginMcpDiscovery';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/discovery/pluginMcpDiscovery';
 import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
-import { isContributionDisabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
+import { ContributionEnablementState, isContributionDisabled, isContributionEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
 import { McpCommandIds } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { defaultGenerator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/idGenerator';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { InputBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { InputBox, MessageType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
 import { IContextViewService, IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
 import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Action, Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
-import { getContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpServerActions';
+import { StartServerAction, StopServerAction, RestartServerAction, ConfigureModelAccessAction, ShowSamplingRequestsAction, EnableMcpServerGloballyAction, EnableMcpServerForWorkspaceAction, DisableMcpServerGloballyAction, DisableMcpServerForWorkspaceAction, ShowServerOutputAction, getContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpServerActions';
 import { LocalMcpServerScope } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService';
 import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
 import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
-import { mcpServerIcon, workspaceIcon, userIcon, pluginIcon, extensionIcon, builtinIcon } from './aiCustomizationIcons.js';
+import { mcpServerIcon } from './aiCustomizationIcons.js';
 import { formatDisplayName } from './aiCustomizationListWidget.js';
 import { getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
 import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
 import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
-import { CUSTOMIZATION_GROUP_HEADER_HEIGHT, CUSTOMIZATION_GROUP_HEADER_HEIGHT_WITH_SEPARATOR, CustomizationGroupHeaderRenderer } from './customizationGroupHeaderRenderer.js';
 import { AgentPluginItemKind } from '../agentPluginEditor/agentPluginItems.js';
+import { getCustomizationDisabledLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService';
 import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
 import { IAgentHostCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
-import { McpServerStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { McpServerStatus, CustomizationEnablementKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
-import { GalleryItemInstallState, GalleryItemRenderer } from './galleryItemRenderer.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
+import { getCustomizationScopeEnablement } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement';
+import { createAgentHostEnablePluginAction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentPluginActions';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { getErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
+import { createWorkbenchMcpServerDetailInput } from './embeddedMcpServerDetail.js';
+import { setVirtualizedRowActionsTabbable, createCustomizationCardPrimaryAction, setupCollapsibleSection, CustomizationCardListController, layoutVirtualizedSections, getVirtualizedSectionMinimumHeight, renderVirtualizedSectionLoadingPlaceholder } from './customizationCardList.js';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 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 { truncateToFirstLine } from './aiCustomizationListWidgetUtils.js';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
 
 registerCss(aiCustomizationManagement);
 const $ = $$1;
-const MCP_ITEM_HEIGHT = 36;
 const PLUGIN_COLLECTION_PREFIX = MCP_PLUGIN_COLLECTION_ID_PREFIX;
+const MCP_SECTION_ITEM_HEIGHT = 66;
+const MCP_ERROR_PREVIEW_LENGTH = 300;
 const COPILOT_EXTENSION_IDS = ["github.copilot", "github.copilot-chat"];
 function isCopilotExtension(id) {
     return ( COPILOT_EXTENSION_IDS.some(copilotId => ExtensionIdentifier.equals(id, copilotId)));
@@ -64,57 +85,181 @@ function isCopilotExtension(id) {
 function getPluginUriFromCollectionId(collectionId) {
     return collectionId?.startsWith(PLUGIN_COLLECTION_PREFIX) ? collectionId.slice(PLUGIN_COLLECTION_PREFIX.length) : undefined;
 }
-class McpServerItemDelegate {
-    getHeight(element) {
-        if (element.type === "group-header") {
-            return element.isFirst ? CUSTOMIZATION_GROUP_HEADER_HEIGHT : CUSTOMIZATION_GROUP_HEADER_HEIGHT_WITH_SEPARATOR;
-        }
-        if (element.type === "server-item" && element.server.gallery && (element.marketplace || !element.server.local)) {
-            return 62;
-        }
-        return MCP_ITEM_HEIGHT;
+function createBuiltinActiveSessionMcpEntries(servers) {
+    return ( servers.map(server => ({
+        type: "session-server-item",
+        server
+    })));
+}
+function isMcpServerCollectionVisible(collectionId, hiddenCollectionIds) {
+    return !hiddenCollectionIds?.includes(collectionId);
+}
+class McpSectionDelegate {
+    getHeight() {
+        return MCP_SECTION_ITEM_HEIGHT;
     }
     getTemplateId(element) {
-        if (element.type === "group-header") {
-            return "mcpGroupHeader";
-        }
-        if (element.type === "builtin-item") {
-            return "mcpServerItem";
-        }
-        if (element.type === "session-server-item") {
-            return "mcpServerItem";
-        }
-        const server = element.server;
-        return server.gallery && (element.marketplace || !server.local) ? MCP_GALLERY_ITEM_TEMPLATE_ID : "mcpServerItem";
+        return element.type === "marketplace-item" ? "mcpMarketplaceItem" : "mcpServerItem";
+    }
+    hasDynamicHeight(element) {
+        return element.type !== "marketplace-item";
     }
 }
-let McpServerItemRenderer = class McpServerItemRenderer {
-    constructor(workspaceService, agentPluginService, hoverService) {
+function getToggledMcpEnablementState(state) {
+    switch (state) {
+    case ContributionEnablementState.EnabledWorkspace:
+        return ContributionEnablementState.DisabledWorkspace;
+    case ContributionEnablementState.DisabledWorkspace:
+        return ContributionEnablementState.EnabledWorkspace;
+    case ContributionEnablementState.EnabledProfile:
+        return ContributionEnablementState.DisabledProfile;
+    case ContributionEnablementState.DisabledProfile:
+        return ContributionEnablementState.EnabledProfile;
+    }
+}
+let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
+    constructor(
+        _renderManagementActions,
+        workspaceService,
+        agentPluginService,
+        hoverService,
+        agentHostCustomizationService,
+        customizationHarnessService
+    ) {
+        super();
+        this._renderManagementActions = _renderManagementActions;
         this.workspaceService = workspaceService;
         this.agentPluginService = agentPluginService;
         this.hoverService = hoverService;
+        this.agentHostCustomizationService = agentHostCustomizationService;
+        this.customizationHarnessService = customizationHarnessService;
         this.templateId = "mcpServerItem";
+        this._templates = ( new Set());
+        this._focusedIndex = -1;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this.errorExpansionChanged = observableSignal(this);
+        this.expandedErrors = ( new Map());
+    }
+    readErrorExpansion(reader) {
+        this.errorExpansionChanged.read(reader);
+    }
+    syncError(element, error) {
+        const session = this.customizationHarnessService.activeSessionResource.get();
+        if (!isEqual(session, this.expansionSession)) {
+            this.expansionSession = session;
+            if (this.expandedErrors.size) {
+                this.expandedErrors.clear();
+                this.errorExpansionChanged.trigger(undefined);
+            }
+        }
+        const key = getMcpRowKey(element);
+        if (( this.expandedErrors.has(key)) && this.expandedErrors.get(key) !== error) {
+            this.expandedErrors.delete(key);
+            this.errorExpansionChanged.trigger(undefined);
+        }
+    }
+    isErrorExpanded(element, error) {
+        return error !== undefined && isEqual(
+            this.expansionSession,
+            this.customizationHarnessService.activeSessionResource.get()
+        ) && this.expandedErrors.get(getMcpRowKey(element)) === error;
+    }
+    isErrorClipped(element) {
+        return ( [...this._templates].some(
+            template => template.currentIndex >= 0 && template.renderedRowKey === getMcpRowKey(element) && template.isClipped
+        ));
     }
     renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
         container.classList.add("mcp-server-item");
+        container.style.minHeight = `${MCP_SECTION_ITEM_HEIGHT}px`;
         const typeIcon = append(container, $(".mcp-server-icon"));
         typeIcon.classList.add(...ThemeIcon.asClassNameArray(mcpServerIcon));
         const details = append(container, $(".mcp-server-details"));
         const nameRow = append(details, $(".mcp-server-name-row"));
         const name = append(nameRow, $(".mcp-server-name"));
+        const statusBadge = append(nameRow, $(".plugin-list-item-status.mcp-runtime-status-badge"));
+        statusBadge.setAttribute("aria-hidden", "true");
         const description = append(details, $(".mcp-server-description"));
-        const status = append(container, $(".mcp-server-status"));
-        return {
+        description.id = defaultGenerator.nextId();
+        const descriptionHover = templateDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), description, "")
+        );
+        const expandButton = templateDisposables.add(( new Button(details, {
+            ...getButtonStyles({
+                buttonBackground: undefined,
+                buttonHoverBackground: undefined,
+                buttonForeground: undefined,
+                buttonBorder: undefined
+            })
+        })));
+        expandButton.element.classList.add("mcp-server-error-toggle");
+        expandButton.element.style.display = "none";
+        expandButton.element.setAttribute("aria-controls", description.id);
+        const actions = append(container, $(".mcp-server-actions"));
+        const template = {
             container,
             typeIcon,
             name,
+            statusBadge,
             description,
-            status,
-            disposables: ( new DisposableStore())
+            descriptionHover,
+            expandButton,
+            actions,
+            templateDisposables,
+            elementDisposables: ( new DisposableStore()),
+            actionDisposables: ( new DisposableStore()),
+            currentIndex: -1,
+            isRendering: false,
+            isExpanded: false,
+            isClipped: false
         };
+        registerMcpInlineButtonAction(templateDisposables, expandButton, () => {
+            if (!template.currentElement || !template.currentError) {
+                return;
+            }
+            const key = getMcpRowKey(template.currentElement);
+            if (template.isExpanded) {
+                this.expandedErrors.delete(key);
+            } else {
+                this.expandedErrors.set(key, template.currentError);
+            }
+            this.renderDescription(template);
+            this.errorExpansionChanged.trigger(undefined);
+        });
+        const resizeObserver = templateDisposables.add(new DisposableResizeObserver(
+            "McpServerItemRenderer.description",
+            () => this.updateExpandButton(template)
+        ));
+        templateDisposables.add(resizeObserver.observe(description));
+        templateDisposables.add(addDisposableListener(
+            expandButton.element,
+            EventType.BLUR,
+            () => this.updateExpandButton(template)
+        ));
+        this._templates.add(template);
+        return template;
     }
     renderElement(element, index, templateData) {
-        templateData.disposables.clear();
+        templateData.isRendering = true;
+        try {
+            this.renderEntry(element, index, templateData);
+        } finally {
+            templateData.isRendering = false;
+        }
+    }
+    renderEntry(element, index, templateData) {
+        templateData.currentIndex = index;
+        templateData.currentElement = element;
+        const rowKey = getMcpRowKey(element);
+        if (templateData.renderedRowKey !== rowKey) {
+            templateData.renderedRowKey = rowKey;
+            templateData.renderedStatusSignature = undefined;
+            templateData.actionDisposables.clear();
+            clearNode(templateData.actions);
+        }
+        templateData.elementDisposables.clear();
         if (element.type === "builtin-item") {
             templateData.container.classList.add("builtin");
             templateData.container.classList.toggle("has-detail", false);
@@ -123,16 +268,17 @@ let McpServerItemRenderer = class McpServerItemRenderer {
                 templateData.description.textContent = truncateToFirstLine(element.description);
                 templateData.description.style.display = "";
             } else {
+                templateData.description.textContent = "";
                 templateData.description.style.display = "none";
             }
-            this.updateKnownServerStatus(templateData, element.localServer, element.activeSessionServer);
+            this.updateKnownServerStatus(templateData, element);
             const pluginUriStr = getPluginUriFromCollectionId(element.collectionId);
             if (pluginUriStr) {
-                templateData.disposables.add(this.hoverService.setupDelayedHover(templateData.container, () => {
+                templateData.elementDisposables.add(this.hoverService.setupDelayedHover(templateData.container, () => {
                     const plugin = this.agentPluginService.plugins.get().find(p => ( p.uri.toString()) === pluginUriStr);
                     if (plugin) {
                         return {
-                            content: `${element.label}\n${( localize(6023, "Plugin: {0}", plugin.label))}`,
+                            content: `${element.label}\n${( localize(6862, "Plugin: {0}", plugin.label))}`,
                             appearance: {
                                 compact: true,
                                 skipFadeInAnimation: true
@@ -154,8 +300,9 @@ let McpServerItemRenderer = class McpServerItemRenderer {
             templateData.container.classList.remove("builtin");
             templateData.container.classList.toggle("has-detail", false);
             templateData.name.textContent = formatDisplayName(element.server.name);
+            templateData.description.textContent = "";
             templateData.description.style.display = "none";
-            this.updateActiveSessionStatus(templateData, element.server);
+            this.updateActiveSessionStatus(templateData, element);
             return;
         }
         templateData.container.classList.remove("builtin");
@@ -168,127 +315,532 @@ let McpServerItemRenderer = class McpServerItemRenderer {
             templateData.description.textContent = truncateToFirstLine(description);
             templateData.description.style.display = "";
         } else {
+            templateData.description.textContent = "";
             templateData.description.style.display = "none";
         }
-        if (element.activeSessionServer) {
-            this.updateKnownServerStatus(templateData, element.localServer, element.activeSessionServer);
+        if (element.activeSessionServer !== undefined) {
+            this.updateKnownServerStatus(templateData, element);
         } else if (this.workspaceService.isSessionsWindow) {
-            this.updateKnownServerStatus(templateData, element.localServer, undefined);
+            this.updateKnownServerStatus(templateData, element);
         } else {
-            templateData.disposables.add(autorun(reader => {
+            templateData.elementDisposables.add(autorun(reader => {
                 const disabled = element.localServer ? isContributionDisabled(element.localServer.enablement.read(reader)) : false;
                 const connectionState = element.localServer?.connectionState.read(reader);
                 templateData.container.classList.toggle("disabled", disabled);
-                this.updateStatus(templateData.status, disabled ? "disabled" : connectionState?.state);
+                this.updateStatus(
+                    templateData,
+                    element,
+                    element,
+                    disabled ? "disabled" : connectionState?.state,
+                    undefined,
+                    connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined
+                );
             }));
         }
     }
-    updateKnownServerStatus(templateData, localServer, activeSessionServer) {
-        templateData.disposables.add(autorun(reader => {
-            const localDisabled = localServer ? isContributionDisabled(localServer.enablement.read(reader)) : false;
-            templateData.container.classList.toggle("disabled", localDisabled || activeSessionServer?.enabled === false);
+    updateKnownServerStatus(templateData, element) {
+        let localDisabled = false;
+        let connectionState;
+        const update = () => {
+            const currentEntry = resolveMcpEntry(
+                element,
+                this.agentHostCustomizationService,
+                this.customizationHarnessService.activeSessionResource.get()
+            );
+            const activeSessionServer = currentEntry && getActiveSessionServer(currentEntry);
+            if (element.activeSessionServer !== undefined) {
+                const presentation = activeSessionServer && getActiveSessionServerPresentation(activeSessionServer);
+                templateData.container.classList.toggle("disabled", presentation?.enabled === false);
+                this.updateStatus(
+                    templateData,
+                    element,
+                    currentEntry,
+                    presentation?.status,
+                    presentation?.enabled ? undefined : activeSessionServer?.disabledReason,
+                    activeSessionServer?.state?.kind === McpServerStatus.Error ? activeSessionServer.state.error?.message : undefined
+                );
+                return;
+            }
+            templateData.container.classList.toggle("disabled", localDisabled);
+            const localError = !this.workspaceService.isSessionsWindow && connectionState?.state === McpConnectionState.Kind.Error ? connectionState : undefined;
             this.updateStatus(
-                templateData.status,
-                localDisabled ? "disabled" : activeSessionServer ? (activeSessionServer.enabled ? activeSessionServer.status : "disabled") : undefined
+                templateData,
+                element,
+                currentEntry,
+                localDisabled ? "disabled" : localError?.state,
+                undefined,
+                localError?.message
             );
+        };
+        templateData.elementDisposables.add(autorun(reader => {
+            this.customizationHarnessService.activeSessionResource.read(reader);
+            localDisabled = element.localServer ? isContributionDisabled(element.localServer.enablement.read(reader)) : false;
+            connectionState = element.localServer?.connectionState.read(reader);
+            update();
         }));
+        templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
     }
-    updateActiveSessionStatus(templateData, server) {
-        const disabled = server?.enabled === false;
-        templateData.container.classList.toggle("disabled", disabled);
-        this.updateStatus(templateData.status, disabled ? "disabled" : server?.status);
+    updateActiveSessionStatus(templateData, element) {
+        const update = () => {
+            const currentEntry = resolveMcpEntry(
+                element,
+                this.agentHostCustomizationService,
+                this.customizationHarnessService.activeSessionResource.get()
+            );
+            const server = currentEntry && getActiveSessionServer(currentEntry);
+            const presentation = server && getActiveSessionServerPresentation(server);
+            templateData.container.classList.toggle("disabled", presentation?.enabled === false);
+            this.updateStatus(
+                templateData,
+                element,
+                currentEntry,
+                presentation?.status,
+                server?.disabledReason,
+                server?.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined
+            );
+        };
+        templateData.elementDisposables.add(autorun(reader => {
+            this.customizationHarnessService.activeSessionResource.read(reader);
+            update();
+        }));
+        templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
     }
-    updateStatus(statusElement, state) {
-        statusElement.className = "mcp-server-status";
-        const presentation = getMcpStatusPresentation(state);
+    updateStatus(templateData, element, currentEntry, state, disabledReason, errorMessage) {
+        const error = getMcpErrorMessage(state, errorMessage);
+        this.syncError(element, error);
+        templateData.currentError = error;
+        this.renderDescription(templateData);
+        const presentation = getMcpStatusPresentation(state, disabledReason);
+        templateData.statusBadge.className = "plugin-list-item-status mcp-runtime-status-badge";
+        if (presentation) {
+            templateData.statusBadge.textContent = presentation.label;
+            templateData.statusBadge.classList.add(presentation.className);
+            templateData.statusBadge.style.display = "";
+        } else {
+            templateData.statusBadge.textContent = "";
+            templateData.statusBadge.style.display = "none";
+        }
+        const activeSessionServer = currentEntry && getActiveSessionServer(currentEntry);
+        const label = getMcpEntryLabel(currentEntry ?? element);
+        const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
+        const localServer = element.type === "session-server-item" ? undefined : element.localServer;
+        const signature = getMcpStatusRenderSignature({
+            rowKey: getMcpRowKey(element),
+            label,
+            state,
+            statusLabel: presentation?.label,
+            statusClassName: presentation?.className,
+            statusIconId: presentation?.icon?.id,
+            activeSessionServerId: activeSessionServer?.id,
+            logOutputChannelId: activeSessionServer?.logOutputChannelId,
+            localServerId: localServer?.definition.id,
+            activeSessionResource: ( activeSessionResource.toString())
+        });
+        if (templateData.renderedStatusSignature === signature) {
+            return;
+        }
+        templateData.renderedStatusSignature = signature;
+        templateData.actionDisposables.clear();
+        clearNode(templateData.actions);
+        if (!currentEntry) {
+            return;
+        }
+        const getEntry = () => resolveMcpEntry(currentEntry, this.agentHostCustomizationService, activeSessionResource);
         if (!presentation) {
-            statusElement.style.display = "none";
+            this._renderManagementActions(
+                getEntry,
+                templateData.actions,
+                templateData.actionDisposables,
+                () => this.updateActionsTabbability(templateData)
+            );
+            this.updateActionsTabbability(templateData);
+            return;
+        }
+        if (state === McpServerStatus.AuthRequired && activeSessionServer !== undefined) {
+            const signInButton = createMcpSignInButton(templateData.actions, templateData.actionDisposables, label);
+            registerMcpInlineButtonAction(templateData.actionDisposables, signInButton, async () => {
+                signInButton.enabled = false;
+                try {
+                    await authenticateMcpServer(
+                        this.agentHostCustomizationService,
+                        activeSessionResource,
+                        activeSessionServer.id
+                    );
+                } finally {
+                    signInButton.enabled = true;
+                }
+            });
+        }
+        if (!presentation.icon || error !== undefined) {
+            this._renderManagementActions(
+                getEntry,
+                templateData.actions,
+                templateData.actionDisposables,
+                () => this.updateActionsTabbability(templateData)
+            );
+            this.updateActionsTabbability(templateData);
+            return;
+        }
+        const statusElement = append(templateData.actions, $(".mcp-server-status"));
+        statusElement.classList.add(presentation.className, ...ThemeIcon.asClassNameArray(presentation.icon));
+        statusElement.setAttribute("aria-hidden", "true");
+        templateData.actionDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), statusElement, presentation.label)
+        );
+        this._renderManagementActions(
+            getEntry,
+            templateData.actions,
+            templateData.actionDisposables,
+            () => this.updateActionsTabbability(templateData)
+        );
+        this.updateActionsTabbability(templateData);
+    }
+    setFocusedIndex(index) {
+        this._focusedIndex = index;
+        for (const template of this._templates) {
+            this.updateActionsTabbability(template);
+        }
+    }
+    updateActionsTabbability(templateData) {
+        setVirtualizedRowActionsTabbable(templateData.actions, templateData.currentIndex === this._focusedIndex);
+        templateData.expandButton.element.tabIndex = templateData.currentIndex === this._focusedIndex ? 0 : -1;
+    }
+    notifyHeightChange(template) {
+        if (!template.isRendering && template.currentIndex >= 0) {
+            this._onDidChangeHeight.fire({
+                index: template.currentIndex,
+                text: template.currentError === undefined ? undefined : template.renderedDescription,
+                expanded: template.isExpanded
+            });
+        }
+    }
+    renderDescription(template) {
+        const element = template.currentElement;
+        if (!element) {
+            return;
+        }
+        const error = template.currentError;
+        const expanded = this.isErrorExpanded(element, error);
+        const description = error === undefined ? element.type === "session-server-item" ? "" : element.type === "builtin-item" ? element.description : element.server.description?.trim() ?? "" : expanded ? error : getMcpErrorPreview(error).text;
+        const text = error === undefined ? truncateToFirstLine(description) : description;
+        const changed = template.renderedDescription !== description || template.isExpanded !== expanded || template.description.classList.contains("error") !== (error !== undefined);
+        if (template.description.textContent !== text) {
+            template.description.textContent = text;
+        }
+        template.isExpanded = expanded;
+        template.description.classList.toggle("expanded", expanded);
+        template.description.classList.toggle("error", error !== undefined);
+        template.container.classList.toggle("has-error", error !== undefined);
+        template.description.style.display = description ? "" : "none";
+        if (template.renderedDescription !== description) {
+            template.renderedDescription = description;
+            template.descriptionHover.update(description);
+        }
+        if (changed) {
+            this.updateExpandButton(template);
+            this.notifyHeightChange(template);
+        }
+    }
+    updateExpandButton(template) {
+        if (!template.currentElement) {
             return;
         }
-        statusElement.style.display = "";
-        statusElement.textContent = presentation.label;
-        statusElement.classList.add(presentation.className);
+        const clipped = template.currentError !== undefined && !template.isExpanded && template.description.clientWidth > 0 && template.description.scrollHeight > template.description.clientHeight;
+        if (clipped !== template.isClipped) {
+            template.isClipped = clipped;
+            this.errorExpansionChanged.trigger(undefined);
+        }
+        const visible = template.currentError !== undefined && (template.isExpanded || getMcpErrorPreview(template.currentError).truncated || clipped || template.expandButton.hasFocus());
+        const display = visible ? "" : "none";
+        if (template.expandButton.element.style.display !== display) {
+            template.expandButton.element.style.display = display;
+            this.notifyHeightChange(template);
+        }
+        template.expandButton.label = template.isExpanded ? ( localize(6863, "Show Less")) : ( localize(6864, "Show More"));
+        template.expandButton.element.setAttribute("aria-expanded", String(template.isExpanded));
+        this.updateActionsTabbability(template);
+    }
+    disposeElement(_element, _index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.descriptionHover.hide();
+        templateData.descriptionHover.update("");
+        templateData.description.textContent = "";
+        templateData.renderedDescription = undefined;
+        templateData.currentElement = undefined;
+        templateData.currentError = undefined;
+        templateData.isClipped = false;
+        templateData.currentIndex = -1;
     }
     disposeTemplate(templateData) {
-        templateData.disposables.dispose();
+        this._templates.delete(templateData);
+        templateData.templateDisposables.dispose();
+        templateData.elementDisposables.dispose();
+        templateData.actionDisposables.dispose();
+    }
+    dispose() {
+        this.expandedErrors.clear();
+        super.dispose();
     }
 };
-McpServerItemRenderer = ( __decorate([( __param(0, IAICustomizationWorkspaceService)), ( __param(1, IAgentPluginService)), ( __param(2, IHoverService))], McpServerItemRenderer));
-function getMcpStatusPresentation(state) {
+McpServerItemRenderer = ( __decorate([( __param(1, IAICustomizationWorkspaceService)), ( __param(2, IAgentPluginService)), ( __param(3, IHoverService)), ( __param(4, IAgentHostCustomizationService)), ( __param(5, ICustomizationHarnessService))], McpServerItemRenderer));
+class McpMarketplaceItemRenderer {
+    constructor(_install) {
+        this._install = _install;
+        this.templateId = "mcpMarketplaceItem";
+        this._templates = ( new Set());
+        this._focusedIndex = -1;
+    }
+    renderTemplate(container) {
+        container.classList.add("plugin-list-item", "plugin-marketplace-home-row");
+        const details = append(container, $(".plugin-list-item-details"));
+        const name = append(
+            append(details, $(".plugin-list-item-name-row")),
+            $(".plugin-list-item-name")
+        );
+        const description = append(details, $(".plugin-list-item-description"));
+        const actionContainer = append(container, $(".plugin-list-item-action"));
+        const installButton = ( new Button(actionContainer, defaultButtonStyles));
+        installButton.element.classList.add("plugin-list-item-install-button");
+        const templateDisposables = ( new DisposableStore());
+        templateDisposables.add(installButton);
+        templateDisposables.add(
+            addDisposableGenericMouseDownListener(installButton.element, event => EventHelper.stop(event, true))
+        );
+        const template = {
+            container,
+            name,
+            description,
+            installButton,
+            elementDisposables: ( new DisposableStore()),
+            templateDisposables,
+            currentIndex: -1
+        };
+        this._templates.add(template);
+        return template;
+    }
+    renderElement(element, index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.currentIndex = index;
+        templateData.name.textContent = element.server.label;
+        templateData.description.textContent = truncateToFirstLine(element.server.description || ( localize(6865, "No description provided.")));
+        templateData.installButton.label = ( localize(6866, "Install"));
+        templateData.installButton.enabled = true;
+        templateData.installButton.element.tabIndex = index === this._focusedIndex ? 0 : -1;
+        templateData.elementDisposables.add(templateData.installButton.onDidClick(event => {
+            EventHelper.stop(event, true);
+            void this._install(element.server, templateData.installButton);
+        }));
+    }
+    setFocusedIndex(index) {
+        this._focusedIndex = index;
+        for (const template of this._templates) {
+            template.installButton.element.tabIndex = template.currentIndex === index ? 0 : -1;
+        }
+    }
+    disposeElement(_element, _index, templateData) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        this._templates.delete(templateData);
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposables.dispose();
+    }
+}
+function createMcpSignInButton(parent, store, serverLabel) {
+    const signInLabel = ( localize(6867, "Sign in to {0}", serverLabel));
+    const signInButton = store.add(( new Button(parent, {
+        ...defaultButtonStyles,
+        secondary: true,
+        small: true,
+        title: signInLabel,
+        ariaLabel: signInLabel
+    })));
+    signInButton.label = ( localize(6868, "Sign In"));
+    signInButton.element.classList.add("mcp-server-sign-in");
+    return signInButton;
+}
+function registerMcpInlineButtonAction(store, button, action) {
+    store.add(
+        addDisposableGenericMouseDownListener(button.element, event => EventHelper.stop(event, true))
+    );
+    store.add(button.onDidClick(event => {
+        EventHelper.stop(event, true);
+        void action();
+    }));
+}
+function authenticateMcpServer(agentHostCustomizationService, sessionResource, serverId) {
+    return agentHostCustomizationService.authenticateMcpServer(sessionResource, serverId);
+}
+function getMcpServerOutputHandler(
+    outputService,
+    localServer,
+    activeSessionServer,
+    closeCustomizationEditor,
+    showActiveSessionOutput
+) {
+    const outputChannelId = activeSessionServer?.logOutputChannelId;
+    if (showActiveSessionOutput) {
+        return () => showActiveSessionOutput(closeCustomizationEditor);
+    }
+    if (outputChannelId) {
+        return async () => {
+            await closeCustomizationEditor?.();
+            await outputService.showChannel(outputChannelId);
+        };
+    }
+    if (localServer) {
+        return async () => {
+            await closeCustomizationEditor?.();
+            await localServer.showOutput();
+        };
+    }
+    return undefined;
+}
+function getMcpStatusPresentation(state, disabledReason) {
     if (state === undefined) {
         return undefined;
     }
     if (state === "disabled") {
         return {
-            label: ( localize(6024, "Disabled")),
-            className: "disabled"
+            label: getCustomizationDisabledLabel(disabledReason),
+            className: "disabled",
+            icon: Codicon.circleSlash
         };
     }
     switch (state) {
     case McpConnectionState.Kind.Running:
     case McpServerStatus.Ready:
         return {
-            label: ( localize(6025, "Running")),
-            className: "running"
+            label: ( localize(6869, "Running")),
+            className: "running",
+            icon: Codicon.check
         };
     case McpConnectionState.Kind.Starting:
     case McpServerStatus.Starting:
         return {
-            label: ( localize(6026, "Starting")),
-            className: "starting"
+            label: ( localize(6870, "Starting")),
+            className: "starting",
+            icon: ThemeIcon.modify(Codicon.loading, "spin")
         };
     case McpServerStatus.AuthRequired:
         return {
-            label: ( localize(6027, "Authentication required")),
-            className: "auth-required"
+            label: ( localize(6871, "Authentication required")),
+            className: "auth-required",
+            icon: Codicon.account
         };
     case McpConnectionState.Kind.Error:
     case McpServerStatus.Error:
         return {
-            label: ( localize(6028, "Error")),
-            className: "error"
+            label: ( localize(6872, "Error")),
+            className: "error",
+            icon: Codicon.error
         };
     case McpConnectionState.Kind.Stopped:
     case McpServerStatus.Stopped:
     default:
         return {
-            label: ( localize(6029, "Stopped")),
+            label: ( localize(6873, "Stopped")),
             className: "stopped"
         };
     }
 }
+function getMcpErrorMessage(state, message) {
+    if (state !== McpServerStatus.Error && state !== McpConnectionState.Kind.Error) {
+        return undefined;
+    }
+    return message && /\S/u.test(message) ? message : ( localize(6874, "The server reported an error without additional details."));
+}
+function getMcpErrorPreview(message) {
+    let end = 0;
+    const characters = [];
+    for (let count = 0; count < MCP_ERROR_PREVIEW_LENGTH && end < message.length; count++) {
+        const codePoint = message.codePointAt(end);
+        characters.push(String.fromCodePoint(codePoint));
+        end += codePoint > 0xFFFF ? 2 : 1;
+    }
+    const truncated = end < message.length;
+    return {
+        text: characters.join("") + (truncated ? "…" : ""),
+        truncated
+    };
+}
+function getActiveSessionServer(entry) {
+    return entry.type === "session-server-item" ? entry.server : entry.activeSessionServer;
+}
+function resolveMcpEntry(entry, customizations, sessionResource) {
+    const activeSessionServer = getActiveSessionServer(entry);
+    if (!activeSessionServer) {
+        return entry;
+    }
+    const server = customizations.getMcpServers(sessionResource).find(server => server.id === activeSessionServer.id);
+    return server ? entry.type === "session-server-item" ? {
+        ...entry,
+        server
+    } : {
+        ...entry,
+        activeSessionServer: server
+    } : undefined;
+}
+function getMcpRowKey(entry) {
+    switch (entry.type) {
+    case "server-item":
+        return `server:${entry.server.id}:${entry.marketplace ? 1 : 0}`;
+    case "session-server-item":
+        return `session:${entry.server.id}`;
+    case "builtin-item":
+        return `builtin:${entry.id}`;
+    }
+}
+function getMcpStatusRenderSignature(input) {
+    return JSON.stringify([
+        input.rowKey,
+        input.label,
+        input.state ?? null,
+        input.statusLabel ?? null,
+        input.statusClassName ?? null,
+        input.statusIconId ?? null,
+        input.activeSessionServerId ?? null,
+        input.logOutputChannelId ?? null,
+        input.localServerId ?? null,
+        input.activeSessionResource ?? null
+    ]);
+}
+function getMcpEntryLabel(element) {
+    return element.type === "session-server-item" ? element.server.name : element.type === "builtin-item" ? element.label : element.server.label;
+}
 function getMcpStatusKind(entry, isSessionsWindow) {
     if (entry.type === "session-server-item") {
-        return entry.server.enabled ? entry.server.status : "disabled";
+        return getActiveSessionServerPresentation(entry.server).status;
+    }
+    if (entry.activeSessionServer !== undefined) {
+        return getActiveSessionServerPresentation(entry.activeSessionServer).status;
     }
     if (entry.localServer && isContributionDisabled(entry.localServer.enablement.get())) {
         return "disabled";
     }
-    if (entry.activeSessionServer) {
-        return entry.activeSessionServer.enabled ? entry.activeSessionServer.status : "disabled";
-    }
     if (entry.type === "server-item" && !isSessionsWindow) {
         return entry.localServer?.connectionState.get().state;
     }
     return undefined;
 }
 function getMcpEntryAriaLabel(element, isSessionsWindow) {
-    if (element.type === "group-header") {
-        return localize(
-            6030,
-            "{0}, {1} items, {2}",
-            element.label,
-            element.count,
-            element.collapsed ? ( localize(6031, "collapsed")) : ( localize(6032, "expanded"))
-        );
+    const label = getMcpEntryLabel(element);
+    const statusKind = getMcpStatusKind(element, isSessionsWindow);
+    const disabledReason = statusKind === "disabled" ? getMcpDisabledReason(element) : undefined;
+    const status = getMcpStatusPresentation(statusKind, disabledReason);
+    return status ? ( localize(6875, "{0}, {1}", label, status.label)) : label;
+}
+function getMcpDisabledReason(entry) {
+    if (entry.type === "session-server-item") {
+        return entry.server.disabledReason;
+    }
+    if (entry.activeSessionServer !== undefined) {
+        return entry.activeSessionServer.disabledReason;
     }
-    const label = element.type === "session-server-item" ? element.server.name : element.type === "builtin-item" ? element.label : element.server.label;
-    const status = getMcpStatusPresentation(getMcpStatusKind(element, isSessionsWindow));
-    return status ? ( localize(6033, "{0}, {1}", label, status.label)) : label;
+    return undefined;
 }
 function normalizeMcpMatchKey(value) {
-    const key = value?.trim().toLowerCase();
-    return key || undefined;
+    return value || undefined;
 }
 function getUniqueMcpMatchKeys(values) {
     const keys = ( new Set());
@@ -306,7 +858,9 @@ class ActiveSessionMcpServerMatcher {
         this.byKey = ( new Map());
         this.matchedIds = ( new Set());
         for (const server of servers) {
-            for (const key of getUniqueMcpMatchKeys([server.id, server.name])) {
+            const separator = server.id.indexOf("/");
+            const rawId = separator >= 0 ? server.id.slice(separator + 1) : server.id;
+            for (const key of getUniqueMcpMatchKeys([rawId, server.name])) {
                 let bucket = this.byKey.get(key);
                 if (!bucket) {
                     bucket = [];
@@ -318,11 +872,10 @@ class ActiveSessionMcpServerMatcher {
     }
     take(keys) {
         for (const key of getUniqueMcpMatchKeys(keys)) {
-            const matches = this.byKey.get(key);
-            const match = matches?.find(server => !( this.matchedIds.has(server.id)));
-            if (match) {
-                this.matchedIds.add(match.id);
-                return match;
+            const matches = this.byKey.get(key)?.filter(server => !( this.matchedIds.has(server.id)));
+            if (matches?.length === 1) {
+                this.matchedIds.add(matches[0].id);
+                return matches[0];
             }
         }
         return undefined;
@@ -336,15 +889,20 @@ class LocalMcpServerMatcher {
         this.byKey = ( new Map());
         for (const server of servers) {
             for (const key of getRuntimeServerMatchKeys(server)) {
-                this.byKey.set(key, server);
+                let matches = this.byKey.get(key);
+                if (!matches) {
+                    matches = [];
+                    this.byKey.set(key, matches);
+                }
+                matches.push(server);
             }
         }
     }
     find(keys) {
         for (const key of getUniqueMcpMatchKeys(keys)) {
-            const server = this.byKey.get(key);
-            if (server) {
-                return server;
+            const matches = this.byKey.get(key);
+            if (matches?.length === 1) {
+                return matches[0];
             }
         }
         return undefined;
@@ -362,17 +920,299 @@ function getWorkbenchServerMatchKeys(server) {
 function getRuntimeServerMatchKeys(server) {
     return getUniqueMcpMatchKeys([server.definition.id, server.definition.label]);
 }
-function getActiveSessionServerOptionsAction(commandService, sessionResource, server) {
-    return (new Action(
-        "mcpServer.activeSession.options",
-        localize(6034, "Server Options"),
+function getActiveSessionServerPresentation(server) {
+    return {
+        enabled: server.enabled,
+        status: server.enabled ? server.status : "disabled"
+    };
+}
+function updateMcpCardRuntimePresentation(
+    statusBadge,
+    primaryAction,
+    description,
+    statusKind,
+    disabledReason,
+    ariaLabel,
+    descriptionText
+) {
+    const statusPresentation = getMcpStatusPresentation(statusKind, disabledReason);
+    statusBadge.className = "plugin-list-item-status mcp-runtime-status-badge";
+    statusBadge.style.display = statusPresentation ? "" : "none";
+    statusBadge.textContent = statusPresentation?.label ?? "";
+    if (statusPresentation) {
+        statusBadge.classList.add(statusPresentation.className);
+    }
+    primaryAction.setAttribute("aria-label", ariaLabel);
+    description.textContent = descriptionText;
+}
+function shouldLoadMcpGallerySnapshot(visible, query, itemCount, failed, loading, accessEnabled) {
+    return accessEnabled && visible && !query.trim() && itemCount === 0 && !failed && !loading;
+}
+function hasSameMcpMembership(previous, current) {
+    return previous === current;
+}
+function getActiveSessionServerLifecycleAction(server) {
+    if (!getActiveSessionServerPresentation(server).enabled) {
+        return undefined;
+    }
+    return server.status === McpServerStatus.Stopped || server.status === McpServerStatus.Error ? ( new Action("mcpServer.activeSession.start", ( localize(6876, "Start Server")), undefined, true, () => server.start())) : ( new Action("mcpServer.activeSession.stop", ( localize(6877, "Stop Server")), undefined, true, () => server.stop()));
+}
+function isHostOwnedPluginMcpServer(server) {
+    return server.isPluginProvided === true && !server.isClientBundled;
+}
+const agentHostMcpServerEnablementActionInfo = {
+    global: {
+        kind: CustomizationEnablementKind.Global,
+        enableLabel: () => ( localize(6878, "Enable")),
+        disableLabel: () => ( localize(6879, "Disable"))
+    },
+    workspace: {
+        kind: CustomizationEnablementKind.Workspace,
+        enableLabel: () => ( localize(6880, "Enable (Workspace)")),
+        disableLabel: () => ( localize(6881, "Disable (Workspace)"))
+    },
+    session: {
+        kind: CustomizationEnablementKind.Session,
+        enableLabel: () => ( localize(6882, "Enable (Session)")),
+        disableLabel: () => ( localize(6883, "Disable (Session)"))
+    }
+};
+function getAgentHostMcpServerEnablementActions(
+    agentHostCustomizations,
+    agentPluginService,
+    sessionResource,
+    server,
+    scopes = ["global", "workspace", "session"]
+) {
+    if (server.disabledReason?.source === "plugin") {
+        const decision = server.disabledReason.plugin.enablement?.[0];
+        if (!decision) {
+            return [];
+        }
+        const action = createAgentHostEnablePluginAction(
+            agentHostCustomizations,
+            agentPluginService,
+            sessionResource,
+            server.disabledReason.plugin,
+            decision.kind
+        );
+        return [( new Action(action.id, action.label, undefined, true, action.run))];
+    }
+    const enablement = getCustomizationScopeEnablement(server);
+    const actions = [];
+    if (scopes.includes("global")) {
+        actions.push(createAgentHostMcpServerEnablementAction(
+            agentHostCustomizations,
+            sessionResource,
+            server,
+            !enablement.global,
+            "global"
+        ));
+    }
+    if (scopes.includes("workspace") && agentHostCustomizations.getWorkingDirectories(sessionResource).length > 0) {
+        actions.push(createAgentHostMcpServerEnablementAction(
+            agentHostCustomizations,
+            sessionResource,
+            server,
+            !enablement.workspace,
+            "workspace"
+        ));
+    }
+    if (scopes.includes("session")) {
+        actions.push(createAgentHostMcpServerEnablementAction(
+            agentHostCustomizations,
+            sessionResource,
+            server,
+            !enablement.session,
+            "session"
+        ));
+    }
+    return actions;
+}
+function setPrimaryMcpServerEnablement(
+    mcpService,
+    agentHostCustomizations,
+    sessionResource,
+    localServerId,
+    activeSessionServer,
+    enabled
+) {
+    if (activeSessionServer && isHostOwnedPluginMcpServer(activeSessionServer)) {
+        agentHostCustomizations.setCustomizationEnablement(
+            sessionResource,
+            activeSessionServer.id,
+            activeSessionServer.enablement,
+            CustomizationEnablementKind.Global,
+            enabled
+        );
+        return;
+    }
+    if (localServerId) {
+        const current = mcpService.enablementModel.readEnabled(localServerId);
+        const next = getToggledMcpEnablementState(current);
+        if (isContributionEnabled(next) !== enabled) {
+            throw ( new Error(`Unexpected MCP enablement transition for ${localServerId}.`));
+        }
+        mcpService.enablementModel.setEnabled(localServerId, next);
+        return;
+    }
+    if (!activeSessionServer) {
+        throw ( new Error("Cannot update MCP enablement without a durable server target."));
+    }
+    agentHostCustomizations.setCustomizationEnablement(
+        sessionResource,
+        activeSessionServer.id,
+        activeSessionServer.enablement,
+        CustomizationEnablementKind.Global,
+        enabled
+    );
+}
+function isPrimaryMcpServerEnabled(mcpService, localServerId, activeSessionServer) {
+    if (activeSessionServer && isHostOwnedPluginMcpServer(activeSessionServer)) {
+        return getCustomizationScopeEnablement(activeSessionServer).global;
+    }
+    if (localServerId) {
+        return isContributionEnabled(mcpService.enablementModel.readEnabled(localServerId));
+    }
+    if (activeSessionServer) {
+        return getCustomizationScopeEnablement(activeSessionServer).global;
+    }
+    return true;
+}
+function createAgentHostMcpServerEnablementAction(agentHostCustomizations, sessionResource, server, enabled, scope) {
+    const actionInfo = agentHostMcpServerEnablementActionInfo[scope];
+    return ( new Action(
+        `mcpServer.agentHost.${enabled ? "enable" : "disable"}.${scope}`,
+        enabled ? actionInfo.enableLabel() : actionInfo.disableLabel(),
         undefined,
         true,
-        async () => {
-            await commandService.executeCommand(McpCommandIds.AgentHostServerOptions, sessionResource, server.id);
-        }
+        () => agentHostCustomizations.setCustomizationEnablement(sessionResource, server.id, server.enablement, actionInfo.kind, enabled)
     ));
 }
+function getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkbench, options = {}) {
+    const includeWorkspace = options.includeWorkspace ?? true;
+    const disabled = options.activeSessionServer ? !getActiveSessionServerPresentation(options.activeSessionServer).enabled : isContributionDisabled(mcpService.enablementModel.readEnabled(serverId));
+    const actions = [];
+    if (disabled) {
+        actions.push(( new Action("mcpServer.builtin.enable", ( localize(6884, "Enable")), undefined, true, () => {
+            mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.EnabledProfile);
+        })));
+        if (includeWorkspace && !isEmptyWorkbench) {
+            actions.push(( new Action("mcpServer.builtin.enableWorkspace", ( localize(6885, "Enable (Workspace)")), undefined, true, () => {
+                mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.EnabledWorkspace);
+            })));
+        }
+    } else {
+        actions.push(( new Action("mcpServer.builtin.disable", ( localize(6886, "Disable")), undefined, true, () => {
+            mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.DisabledProfile);
+        })));
+        if (includeWorkspace && !isEmptyWorkbench) {
+            actions.push(( new Action("mcpServer.builtin.disableWorkspace", ( localize(6887, "Disable (Workspace)")), undefined, true, () => {
+                mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.DisabledWorkspace);
+            })));
+        }
+    }
+    return actions;
+}
+function getBuiltinMcpServerEnablementActions(
+    mcpService,
+    serverId,
+    isEmptyWorkbench,
+    agentHostCustomizations,
+    agentPluginService,
+    sessionResource,
+    activeSessionServer
+) {
+    if (activeSessionServer === undefined) {
+        return getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkbench);
+    }
+    if (isHostOwnedPluginMcpServer(activeSessionServer)) {
+        return getAgentHostMcpServerEnablementActions(
+            agentHostCustomizations,
+            agentPluginService,
+            sessionResource,
+            activeSessionServer
+        );
+    }
+    return [
+        ...getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkbench, {
+            includeWorkspace: false,
+            activeSessionServer
+        }),
+        ...getAgentHostMcpServerEnablementActions(
+            agentHostCustomizations,
+            agentPluginService,
+            sessionResource,
+            activeSessionServer,
+            ["workspace", "session"]
+        )
+    ];
+}
+function getActiveSessionServerOptionsActions(
+    commandService,
+    agentHostCustomizations,
+    agentPluginService,
+    sessionResource,
+    server
+) {
+    const actions = [];
+    const lifecycleAction = getActiveSessionServerLifecycleAction(server);
+    if (lifecycleAction) {
+        actions.push(lifecycleAction);
+    }
+    const durableActions = getAgentHostMcpServerEnablementActions(agentHostCustomizations, agentPluginService, sessionResource, server);
+    if (durableActions.length > 0) {
+        if (actions.length > 0) {
+            actions.push(( new Separator()));
+        }
+        actions.push(...durableActions);
+    }
+    actions.push(( new Separator()));
+    actions.push(( new Action("mcpServer.activeSession.options", ( localize(6888, "Server Options")), undefined, true, async () => {
+        await commandService.executeCommand(McpCommandIds.AgentHostServerOptions, sessionResource, server.id);
+    })));
+    return actions;
+}
+function shouldHideLocalActionForActiveSessionServer(action) {
+    return action instanceof StartServerAction || action instanceof StopServerAction || action instanceof RestartServerAction || action instanceof ConfigureModelAccessAction || action instanceof ShowSamplingRequestsAction || isLocalMcpServerWorkspaceEnablementAction(action);
+}
+function isLocalMcpServerEnablementAction(action) {
+    return action.id === EnableMcpServerGloballyAction.ID || action.id === EnableMcpServerForWorkspaceAction.ID || action.id === DisableMcpServerGloballyAction.ID || action.id === DisableMcpServerForWorkspaceAction.ID;
+}
+function isLocalMcpServerWorkspaceEnablementAction(action) {
+    return action.id === EnableMcpServerForWorkspaceAction.ID || action.id === DisableMcpServerForWorkspaceAction.ID;
+}
+function getServerItemContextMenuActions(
+    menuActionGroups,
+    activeSessionServer,
+    activeSessionLifecycleAction,
+    agentHostEnablementActions
+) {
+    const actions = [];
+    const hasActiveSession = activeSessionServer !== undefined;
+    let agentHostEnablementAdded = false;
+    if (activeSessionLifecycleAction) {
+        actions.push(activeSessionLifecycleAction, ( new Separator()));
+    }
+    for (const menuActions of menuActionGroups) {
+        const visibleMenuActions = hasActiveSession ? menuActions.filter(action => !shouldHideLocalActionForActiveSessionServer(action)) : menuActions;
+        actions.push(...visibleMenuActions);
+        if (hasActiveSession && ( menuActions.some(isLocalMcpServerEnablementAction))) {
+            actions.push(...agentHostEnablementActions);
+            agentHostEnablementAdded = true;
+        }
+        if (visibleMenuActions.length > 0) {
+            actions.push(( new Separator()));
+        }
+    }
+    if (hasActiveSession && !agentHostEnablementAdded) {
+        actions.push(...agentHostEnablementActions);
+    }
+    if (actions[actions.length - 1] instanceof Separator) {
+        actions.pop();
+    }
+    return actions;
+}
 function createBuiltinEntry(server, activeSessionServer) {
     return {
         type: "builtin-item",
@@ -384,43 +1224,57 @@ function createBuiltinEntry(server, activeSessionServer) {
         localServer: server
     };
 }
-const MCP_GALLERY_ITEM_TEMPLATE_ID = "mcpGalleryItem";
-class McpGalleryItemProvider {
-    constructor(mcpWorkbenchService) {
-        this.mcpWorkbenchService = mcpWorkbenchService;
-    }
-    getLabel(element) {
-        return element.server.label;
-    }
-    getPublisherDisplayName(element) {
-        return element.server.publisherDisplayName;
-    }
-    getDescription(element) {
-        return element.server.description;
-    }
-    getInstallState(element) {
-        switch (element.server.installState) {
-        case McpServerInstallState.Installed:
-            return GalleryItemInstallState.Installed;
-        case McpServerInstallState.Installing:
-            return GalleryItemInstallState.Installing;
-        default:
-            return GalleryItemInstallState.Uninstalled;
-        }
-    }
-    canInstall(element) {
-        return this.mcpWorkbenchService.canInstall(element.server) === true;
+function createInstalledMcpServerDetailInput(entry) {
+    if (entry.type === "server-item") {
+        return createWorkbenchMcpServerDetailInput(entry.server);
     }
-    async install(element) {
-        await this.mcpWorkbenchService.install(element.server);
-    }
-    onDidChangeInstallState(element, listener) {
-        return this.mcpWorkbenchService.onChange(changed => {
-            if (!changed || changed.id === element.server.id) {
-                listener();
-            }
-        });
+    const activeSessionServer = getActiveSessionServer(entry);
+    const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
+    const localDefinitions = localServer?.readDefinitions().get();
+    const localDefinition = localDefinitions?.server;
+    const collectionOrigin = localDefinitions?.collection?.presentation?.origin;
+    const localSource = localDefinition?.presentation?.origin ?? (collectionOrigin ? {
+        uri: collectionOrigin
+    } : undefined);
+    const activeSessionSource = activeSessionServer?.sourceUri ? {
+        uri: activeSessionServer.sourceUri,
+        range: activeSessionServer.sourceRange ? ( new Range(
+            activeSessionServer.sourceRange.start.line + 1,
+            activeSessionServer.sourceRange.start.character + 1,
+            activeSessionServer.sourceRange.end.line + 1,
+            activeSessionServer.sourceRange.end.character + 1
+        )) : undefined
+    } : undefined;
+    return {
+        id: getMcpRowKey(entry),
+        name: getMcpEntryLabel(entry),
+        label: getMcpEntryLabel(entry),
+        installState: McpServerInstallState.Installed,
+        config: localDefinition ? getMcpServerConfiguration(localDefinition) : undefined,
+        source: localSource ?? activeSessionSource
+    };
+}
+function getMcpServerConfiguration(definition) {
+    const launch = definition.launch;
+    if (launch.type === McpServerTransportType.HTTP) {
+        return {
+            type: McpServerType.REMOTE,
+            url: ( launch.uri.toString(true)),
+            headers: launch.headers.length > 0 ? Object.fromEntries(launch.headers) : undefined,
+            oauth: launch.oauth,
+            dev: definition.devMode
+        };
     }
+    return {
+        type: McpServerType.LOCAL,
+        command: launch.command,
+        args: launch.args,
+        env: launch.env,
+        envFile: launch.envFile,
+        cwd: launch.cwd,
+        sandboxEnabled: definition.sandboxEnabled,
+        dev: definition.devMode
+    };
 }
 let McpListWidget = class McpListWidget extends Disposable {
     constructor(
@@ -432,13 +1286,15 @@ let McpListWidget = class McpListWidget extends Disposable {
         openerService,
         contextViewService,
         contextMenuService,
-        hoverService,
         agentPluginService,
         dialogService,
         configurationService,
         customizationHarnessService,
         agentHostCustomizationService,
-        workspaceService
+        workspaceService,
+        notificationService,
+        outputService,
+        mcpGalleryManifestService
     ) {
         super();
         this.instantiationService = instantiationService;
@@ -449,13 +1305,14 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.openerService = openerService;
         this.contextViewService = contextViewService;
         this.contextMenuService = contextMenuService;
-        this.hoverService = hoverService;
         this.agentPluginService = agentPluginService;
         this.dialogService = dialogService;
         this.configurationService = configurationService;
         this.customizationHarnessService = customizationHarnessService;
         this.agentHostCustomizationService = agentHostCustomizationService;
         this.workspaceService = workspaceService;
+        this.notificationService = notificationService;
+        this.outputService = outputService;
         this._onDidSelectServer = this._register(( new Emitter()));
         this.onDidSelectServer = this._onDidSelectServer.event;
         this._onDidChangeItemCount = this._register(( new Emitter()));
@@ -466,20 +1323,55 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.filteredServers = [];
         this.filteredBuiltinCount = 0;
         this.filteredActiveSessionCount = 0;
-        this.displayEntries = [];
+        this.installedEntries = [];
+        this.gallerySnapshotServers = [];
         this.galleryServers = [];
         this.searchQuery = "";
-        this.browseMode = false;
+        this.gallerySnapshotFailed = false;
+        this.gallerySnapshotLoading = false;
+        this.gallerySearchLoading = false;
+        this.visible = false;
+        this.mcpAccessEnabled = false;
+        this.narrowLayout = false;
+        this.wideLayout = false;
         this.lastHeight = 0;
         this.lastWidth = 0;
         this.lastHeaderHeight = 0;
         this._layoutDeferred = false;
-        this.collapsedGroups = ( new Set());
+        this.revealLastItemScheduler = this._register(( new MutableDisposable()));
+        this.sectionScrollPositions = ( new Map());
+        this.cardDisposables = this._register(( new DisposableStore()));
+        this.pendingSectionLayout = this._register(( new MutableDisposable()));
+        this.cardListControllers = ( new WeakMap());
+        this.sectionLists = [];
+        this.collapsedSections = ( new Set());
         this.delayedFilter = ( new Delayer(200));
         this.delayedGallerySearch = ( new Delayer(400));
-        this.element = $(".mcp-list-widget");
+        this.agentHostCustomizationsChanged = observableSignalFromEvent(this, this.agentHostCustomizationService.onDidChangeCustomizations);
+        this.element = $(".mcp-list-widget.plugin-list-widget");
         this.create();
+        const resizeObserver = this._register(new DisposableResizeObserver(
+            "McpListWidget",
+            () => this.updateResponsiveLayout(this.element.offsetWidth),
+            getWindow(this.element)
+        ));
+        this._register(resizeObserver.observe(this.element));
         this.updateAccessState();
+        this._register(mcpGalleryManifestService.onDidChangeMcpGalleryManifest(() => {
+            this.galleryCts?.dispose(true);
+            this.galleryCts = undefined;
+            this.gallerySnapshotServers = [];
+            this.galleryServers = [];
+            this.gallerySnapshotFailed = false;
+            this.gallerySnapshotLoading = false;
+            if (this.searchQuery.trim()) {
+                void this.queryMcpSearch();
+            } else {
+                void this.refresh();
+            }
+        }));
+        void mcpGalleryManifestService.getMcpGalleryManifest();
+        void this.refresh();
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             if (e.affectsConfiguration(mcpAccessConfig)) {
                 this.updateAccessState();
@@ -487,7 +1379,9 @@ let McpListWidget = class McpListWidget extends Disposable {
         }));
         this._register({
             dispose: () => {
-                this.galleryCts?.dispose();
+                this.delayedFilter.cancel();
+                this.delayedGallerySearch.cancel();
+                this.galleryCts?.dispose(true);
             }
         });
     }
@@ -495,16 +1389,16 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.sectionTitleHeader = append(this.element, $(".section-title-header"));
         const titleRow = append(this.sectionTitleHeader, $(".section-title-row"));
         const sectionTitle = append(titleRow, $("h2.section-title"));
-        sectionTitle.textContent = ( localize(6035, "MCP Servers"));
+        sectionTitle.textContent = ( localize(6889, "MCP Servers"));
         const sectionTitleDescription = append(this.sectionTitleHeader, $("p.section-title-description"));
         const sectionTitleDescriptionText = append(sectionTitleDescription, $("span.section-title-description-text"));
         sectionTitleDescriptionText.textContent = ( localize(
-            6036,
+            6890,
             "An open standard that lets AI use external tools and services. MCP servers provide tools for file operations, databases, APIs, and more."
         ));
         sectionTitleDescription.appendChild(createTextNode(" "));
         this.sectionLink = append(sectionTitleDescription, $("a.section-title-link"));
-        this.sectionLink.textContent = ( localize(6037, "Learn more about MCP servers"));
+        this.sectionLink.textContent = ( localize(6891, "Learn more about MCP servers"));
         this.sectionLink.href = "https://code.visualstudio.com/docs/agent-customization/mcp-servers?referrer=in-product";
         this._register(addDisposableListener(this.sectionLink, "click", e => {
             e.preventDefault();
@@ -530,150 +1424,106 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.searchAndButtonContainer = append(this.element, $(".list-search-and-button-container"));
         const searchContainer = append(this.searchAndButtonContainer, $(".list-search-container"));
         this.searchInput = this._register(( new InputBox(searchContainer, this.contextViewService, {
-            placeholder: ( localize(6038, "Type to search...")),
+            placeholder: ( localize(6892, "Type to search...")),
             inputBoxStyles: defaultInputBoxStyles
         })));
         this._register(this.searchInput.onDidChange(() => {
             this.searchQuery = this.searchInput.value;
-            if (this.browseMode) {
-                this.delayedGallerySearch.trigger(() => this.queryGallery());
+            this.galleryCts?.dispose(true);
+            this.galleryCts = undefined;
+            this.searchInput.hideMessage();
+            const query = this.searchQuery.toLowerCase().trim();
+            this.galleryServers = query ? this.gallerySnapshotServers.filter(server => this.matchesGalleryServerQuery(server, query)) : [...this.gallerySnapshotServers];
+            this.delayedFilter.trigger(() => this.filterServers());
+            if (!this.mcpAccessEnabled) {
+                this.gallerySearchLoading = false;
+                this.delayedGallerySearch.cancel();
+                return;
+            }
+            if (query) {
+                this.gallerySearchLoading = true;
+                this.delayedGallerySearch.trigger(() => this.queryMcpSearch());
             } else {
-                this.delayedFilter.trigger(() => this.filterServers());
+                this.gallerySearchLoading = false;
+                this.delayedGallerySearch.cancel();
+                if (this.visible && this.gallerySnapshotServers.length === 0) {
+                    this.delayedGallerySearch.trigger(() => this.queryGallerySnapshot());
+                }
             }
         }));
-        const buttonContainer = append(this.searchAndButtonContainer, $(".list-button-group"));
-        const backButtonContainer = append(buttonContainer, $(".list-add-button-container"));
-        this.backButton = this._register(( new Button(backButtonContainer, {
-            ...defaultButtonStyles,
-            secondary: true,
-            supportIcons: true,
-            title: ( localize(6039, "Back to installed servers")),
-            ariaLabel: ( localize(6039, "Back to installed servers"))
+        this.emptyContainer = append(this.element, $(".mcp-empty-state"));
+        const emptyHeader = append(this.emptyContainer, $(".empty-state-header"));
+        this.emptyText = append(emptyHeader, $(".empty-text"));
+        this.emptySubtext = append(this.emptyContainer, $(".empty-subtext"));
+        this.disabledContainer = append(this.element, $(".mcp-disabled-state"));
+        const disabledHeader = append(this.disabledContainer, $(".empty-state-header"));
+        this.disabledIcon = append(disabledHeader, $(".empty-icon"));
+        const disabledText = append(disabledHeader, $(".empty-text"));
+        disabledText.textContent = ( localize(6893, "MCP servers are disabled"));
+        this.disabledMessage = append(this.disabledContainer, $(".empty-subtext"));
+        this.cardContainer = $(".plugin-card-container");
+        this.cardScrollable = this._register(( new DomScrollableElement(this.cardContainer, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
         })));
-        this.backButton.label = `$(${Codicon.arrowLeft.id}) ${( localize(6040, "Back"))}`;
-        this.backButton.element.classList.add("list-add-button");
-        backButtonContainer.style.display = "none";
-        this._register(this.backButton.onDidClick(() => {
-            this.toggleBrowseMode(false);
-        }));
-        const browseButtonContainer = append(buttonContainer, $(".list-add-button-container"));
-        this.browseButton = this._register(( new Button(browseButtonContainer, {
-            ...defaultButtonStyles,
-            secondary: true,
-            supportIcons: true
-        })));
-        this.browseButton.label = `$(${Codicon.library.id}) ${( localize(6041, "Browse Marketplace"))}`;
-        this.browseButton.element.classList.add("list-add-button");
-        this._register(this.browseButton.onDidClick(() => {
-            this.toggleBrowseMode(!this.browseMode);
-        }));
-        this.addButton = this._register(( new Button(buttonContainer, {
-            ...defaultButtonStyles,
-            secondary: true,
-            supportIcons: true,
-            title: ( localize(6042, "Add Server")),
-            ariaLabel: ( localize(6042, "Add Server"))
-        })));
-        this.addButton.label = `$(${Codicon.add.id})`;
-        this.addButton.element.classList.add("list-icon-button");
         this._register(
-            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), this.addButton.element, ( localize(6043, "Add Server")))
+            addDisposableListener(this.cardContainer, EventType.SCROLL, () => {
+                this.cardScrollable.setScrollPosition({
+                    scrollTop: this.cardContainer.scrollTop
+                });
+            })
         );
-        this._register(this.addButton.onDidClick(() => {
-            this.commandService.executeCommand(McpCommandIds.AddConfiguration);
-        }));
-        this.emptyContainer = append(this.element, $(".mcp-empty-state"));
-        const emptyHeader = append(this.emptyContainer, $(".empty-state-header"));
-        this.emptyText = append(emptyHeader, $(".empty-text"));
-        this.emptySubtext = append(this.emptyContainer, $(".empty-subtext"));
-        this.disabledContainer = append(this.element, $(".mcp-disabled-state"));
-        const disabledHeader = append(this.disabledContainer, $(".empty-state-header"));
-        this.disabledIcon = append(disabledHeader, $(".empty-icon"));
-        const disabledText = append(disabledHeader, $(".empty-text"));
-        disabledText.textContent = ( localize(6044, "MCP servers are disabled"));
-        this.disabledMessage = append(this.disabledContainer, $(".empty-subtext"));
-        this.listContainer = append(this.element, $(".mcp-list-container"));
-        const delegate = ( new McpServerItemDelegate());
-        const groupHeaderRenderer = ( new CustomizationGroupHeaderRenderer("mcpGroupHeader", this.hoverService));
-        const localRenderer = this.instantiationService.createInstance(McpServerItemRenderer);
-        const galleryRenderer = ( new GalleryItemRenderer(MCP_GALLERY_ITEM_TEMPLATE_ID, ( new McpGalleryItemProvider(this.mcpWorkbenchService))));
-        this.list = this._register(this.instantiationService.createInstance(
-            WorkbenchList,
-            "McpManagementList",
-            this.listContainer,
-            delegate,
-            [groupHeaderRenderer, localRenderer, galleryRenderer],
-            {
-                multipleSelectionSupport: false,
-                setRowLineHeight: false,
-                horizontalScrolling: false,
-                accessibilityProvider: {
-                    getAriaLabel: element => {
-                        return getMcpEntryAriaLabel(element, this.workspaceService.isSessionsWindow);
-                    },
-                    getWidgetAriaLabel() {
-                        return localize(6045, "MCP Servers");
-                    }
-                },
-                openOnSingleClick: true,
-                identityProvider: {
-                    getId(element) {
-                        if (element.type === "group-header") {
-                            return element.id;
-                        }
-                        if (element.type === "builtin-item") {
-                            return element.id;
-                        }
-                        return element.server.id;
-                    }
-                }
-            }
-        ));
-        this._register(this.list.onDidOpen(e => {
-            if (e.element) {
-                if (e.element.type === "group-header") {
-                    this.toggleGroup(e.element);
-                } else if (e.element.type === "server-item") {
-                    const server = e.element.server;
-                    const isGallery = e.element.marketplace || !server.local;
-                    if (isGallery || server.description) {
-                        this._onDidSelectServer.fire(server);
-                    }
-                } else if (e.element.type === "session-server-item") {
-                    this.openActiveSessionServerOptions(e.element.server);
-                }
-            }
-        }));
-        this._register(this.list.onContextMenu(e => this.onContextMenu(e)));
+        this.cardScrollableNode = this.cardScrollable.getDomNode();
+        this.cardScrollableNode.classList.add("plugin-card-scrollable");
+        this.cardScrollableNode.style.display = "none";
+        this.element.appendChild(this.cardScrollableNode);
+        const cardResizeObserver = this._register(
+            new DisposableResizeObserver("McpListWidget.cardScrollable", () => this.cardScrollable.scanDomNode())
+        );
+        this._register(cardResizeObserver.observe(this.cardScrollableNode));
         this._register(this.mcpWorkbenchService.onChange(() => {
-            if (!this.browseMode) {
-                this.refresh();
-            }
+            this.refresh();
         }));
         this._register(autorun(reader => {
-            this.mcpService.servers.read(reader);
-            if (!this.browseMode) {
-                this.refresh();
+            const servers = this.mcpService.servers.read(reader);
+            for (const server of servers) {
+                server.enablement.read(reader);
             }
+            this.refresh();
         }));
         this._register(autorun(reader => {
             this.customizationHarnessService.activeSessionResource.read(reader);
-            if (!this.browseMode) {
-                this.refresh();
-            }
+            this.refresh();
         }));
         this._register(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
-            if (!this.browseMode) {
-                this.refresh();
+            const previousMembership = this.getInstalledEntryMembershipSignature();
+            this.filterServers(false);
+            if (!hasSameMcpMembership(previousMembership, this.getInstalledEntryMembershipSignature())) {
+                this.renderFilteredServers();
             }
         }));
-        void this.refresh();
     }
     async refresh() {
-        if (this.browseMode) {
-            await this.queryGallery();
-        } else {
-            this.filterServers();
+        this.filterServers();
+        if (shouldLoadMcpGallerySnapshot(
+            this.visible,
+            this.searchQuery,
+            this.gallerySnapshotServers.length,
+            this.gallerySnapshotFailed,
+            this.gallerySnapshotLoading,
+            this.mcpAccessEnabled
+        )) {
+            await this.queryGallerySnapshot();
+        }
+    }
+    setVisible(visible) {
+        if (this.visible === visible) {
+            return;
+        }
+        this.visible = visible;
+        if (visible) {
+            void this.refresh();
         }
     }
     updateAccessState() {
@@ -681,8 +1531,16 @@ let McpListWidget = class McpListWidget extends Disposable {
         const value = inspect.value ?? inspect.defaultValue;
         const disabled = value === McpAccessValue.None;
         const policyLocked = inspect.policyValue === McpAccessValue.None;
+        const accessChanged = this.mcpAccessEnabled === disabled;
+        this.mcpAccessEnabled = !disabled;
         this.element.classList.toggle("access-disabled", disabled);
         if (disabled) {
+            this.delayedGallerySearch.cancel();
+            this.galleryCts?.dispose(true);
+            this.galleryCts = undefined;
+            this.gallerySnapshotLoading = false;
+            this.gallerySearchLoading = false;
+            this.searchInput.hideMessage();
             this.disabledIcon.className = "empty-icon";
             this.disabledIcon.classList.add(
                 ...ThemeIcon.asClassNameArray(policyLocked ? Codicon.shield : mcpServerIcon)
@@ -691,13 +1549,13 @@ let McpListWidget = class McpListWidget extends Disposable {
             this.disabledLinkListener.clear();
             if (policyLocked) {
                 this.disabledMessage.textContent = ( localize(
-                    6046,
+                    6894,
                     "Access to MCP servers is disabled by your organization. Contact your organization administrator for more information."
                 ));
             } else {
-                this.disabledMessage.appendChild(createTextNode(( localize(6047, "MCP servers are disabled in settings. "))));
+                this.disabledMessage.appendChild(createTextNode(( localize(6895, "MCP servers are disabled in settings. "))));
                 const link = append(this.disabledMessage, $("a.mcp-disabled-settings-link"));
-                link.textContent = ( localize(6048, "Configure in settings."));
+                link.textContent = ( localize(6896, "Configure in settings."));
                 link.href = "#";
                 link.setAttribute("role", "button");
                 this.disabledLinkListener.value = addDisposableListener(link, "click", e => {
@@ -705,81 +1563,750 @@ let McpListWidget = class McpListWidget extends Disposable {
                     this.commandService.executeCommand("workbench.action.openSettings", `@id:${mcpAccessConfig}`);
                 });
             }
+        } else if (accessChanged && this.visible) {
+            if (this.searchQuery.trim()) {
+                void this.queryMcpSearch();
+            } else {
+                void this.refresh();
+            }
         }
     }
     showBrowseMarketplace() {
-        if (!this.browseMode) {
-            this.toggleBrowseMode(true);
+        if (!this.mcpAccessEnabled) {
+            return;
         }
-    }
-    toggleBrowseMode(browse) {
-        this.browseMode = browse;
         this.searchInput.value = "";
         this.searchQuery = "";
-        this.addButton.element.style.display = browse ? "none" : "";
-        this.browseButton.element.parentElement.style.display = browse ? "none" : "";
-        this.backButton.element.parentElement.style.display = browse ? "" : "none";
-        this.searchInput.setPlaceHolder(browse ? ( localize(6049, "Search MCP marketplace...")) : ( localize(6038, "Type to search...")));
-        if (browse) {
-            void this.queryGallery();
-        } else {
-            this.galleryCts?.dispose(true);
-            this.galleryServers = [];
-            this.filterServers();
+        void this.queryGallerySnapshot(true);
+    }
+    async queryGallerySnapshot(revealMarketplace = false) {
+        if (!this.mcpAccessEnabled) {
+            return;
+        }
+        this.galleryCts?.dispose(true);
+        const cts = this.galleryCts = ( new CancellationTokenSource());
+        this.gallerySnapshotLoading = true;
+        if (!revealMarketplace && !this.searchQuery.trim()) {
+            this.renderMcpHome();
         }
-        if (this.lastHeight > 0) {
-            this.layout(this.lastHeight, this.lastWidth);
+        try {
+            const pager = await this.mcpWorkbenchService.queryGallery(undefined, cts.token);
+            if (this.galleryCts !== cts || cts.token.isCancellationRequested || !this.mcpAccessEnabled || this.searchQuery.trim()) {
+                return;
+            }
+            this.gallerySnapshotServers = pager.firstPage.items;
+            this.galleryServers = [...this.gallerySnapshotServers];
+            this.gallerySnapshotFailed = false;
+            this.gallerySnapshotLoading = false;
+            this.renderMcpHome();
+            if (revealMarketplace) {
+                this.availableSection?.scrollIntoView({
+                    block: "start"
+                });
+            }
+        } catch {
+            if (this.galleryCts === cts && !cts.token.isCancellationRequested && this.mcpAccessEnabled) {
+                this.gallerySnapshotServers = [];
+                this.galleryServers = [];
+                this.gallerySnapshotFailed = true;
+                this.gallerySnapshotLoading = false;
+                this.renderMcpHome();
+            }
+        } finally {
+            if (this.galleryCts === cts) {
+                this.gallerySnapshotLoading = false;
+            }
         }
     }
-    async queryGallery() {
+    async queryMcpSearch() {
+        const query = this.searchQuery.trim();
+        if (!query || !this.mcpAccessEnabled) {
+            return;
+        }
         this.galleryCts?.dispose(true);
         const cts = this.galleryCts = ( new CancellationTokenSource());
-        this.emptyContainer.style.display = "flex";
-        this.listContainer.style.display = "none";
-        this.emptyText.textContent = ( localize(6050, "Loading marketplace..."));
-        this.emptySubtext.textContent = "";
+        this.gallerySearchLoading = true;
         try {
             const pager = await this.mcpWorkbenchService.queryGallery({
-                text: this.searchQuery.trim() || undefined
+                text: query
             }, cts.token);
-            if (cts.token.isCancellationRequested) {
+            if (this.galleryCts !== cts || cts.token.isCancellationRequested || !this.mcpAccessEnabled || this.searchQuery.trim() !== query) {
                 return;
             }
             this.galleryServers = pager.firstPage.items;
-            this.updateGalleryList();
+            this.searchInput.hideMessage();
         } catch {
-            if (!cts.token.isCancellationRequested) {
-                this.galleryServers = [];
-                this.emptyContainer.style.display = "flex";
-                this.listContainer.style.display = "none";
-                this.emptyText.textContent = ( localize(6051, "Unable to load marketplace"));
-                this.emptySubtext.textContent = ( localize(6052, "Check your connection and try again"));
+            if (this.galleryCts === cts && !cts.token.isCancellationRequested && this.mcpAccessEnabled && this.searchQuery.trim() === query) {
+                this.galleryServers = this.gallerySnapshotServers.filter(server => this.matchesGalleryServerQuery(server, query.toLowerCase()));
+                this.searchInput.showMessage({
+                    content: ( localize(
+                        6897,
+                        "Marketplace results are unavailable. Showing installed MCP servers only."
+                    )),
+                    type: MessageType.WARNING
+                });
+            }
+        } finally {
+            if (this.galleryCts === cts && this.mcpAccessEnabled && this.searchQuery.trim() === query) {
+                this.gallerySearchLoading = false;
+                this.filterServers();
             }
         }
     }
-    updateGalleryList() {
-        if (this.galleryServers.length === 0) {
-            this.emptyContainer.style.display = "flex";
-            this.listContainer.style.display = "none";
-            if (this.searchQuery.trim()) {
-                this.emptyText.textContent = ( localize(6053, "No servers match '{0}'", this.searchQuery));
-                this.emptySubtext.textContent = ( localize(6054, "Try a different search term"));
+    showCardSurface() {
+        this.emptyContainer.style.display = "none";
+        this.cardScrollableNode.style.display = "";
+    }
+    showEmptySurface(message, detail) {
+        this.cardScrollableNode.style.display = "none";
+        this.emptyContainer.style.display = "flex";
+        this.emptyText.textContent = message;
+        this.emptySubtext.textContent = detail;
+    }
+    createCardScrollContent(...classNames) {
+        const content = append(this.cardContainer, $(".plugin-card-scroll.plugin-card-scroll-content"));
+        content.classList.add(...classNames);
+        this.sectionLayoutContainer = classNames.includes("distributed-section-layout") ? content : undefined;
+        const resizeObserver = this.cardDisposables.add(
+            new DisposableResizeObserver("McpListWidget.cardScrollContent", () => this.scheduleMcpSectionLayout())
+        );
+        this.cardDisposables.add(resizeObserver.observe(content));
+        return content;
+    }
+    addSurfaceActivation(surface, label, callback, ...classNames) {
+        const primaryAction = createCustomizationCardPrimaryAction(surface, label, ...classNames);
+        this.firstCardFocusElement ??= primaryAction;
+        this.cardDisposables.add(addDisposableListener(primaryAction, "click", callback));
+        return primaryAction;
+    }
+    renderCardSection(parent, title, description, className, count, renderActions) {
+        const section = append(parent, $(".plugin-card-section"));
+        section.classList.add(className);
+        const header = append(section, $(".plugin-card-section-header"));
+        const text = append(header, $(".plugin-card-section-text"));
+        const headingRow = append(text, $(".plugin-card-section-heading-row"));
+        const heading = append(headingRow, $("h3.plugin-card-section-title"));
+        heading.textContent = title;
+        if (count !== undefined) {
+            const countElement = append(headingRow, $(".plugin-card-section-count"));
+            countElement.textContent = String(count);
+        }
+        if (description) {
+            const descriptionElement = append(text, $(".plugin-card-section-description"));
+            descriptionElement.textContent = description;
+        }
+        renderActions?.(header);
+        const list = append(section, $(".plugin-card-grid"));
+        list.dataset.virtualizedSectionKey = className;
+        const collapsedSections = this.collapsedSections ??= ( new Set());
+        setupCollapsibleSection(headingRow, list, title, this.cardDisposables, ( collapsedSections.has(className)), collapsed => {
+            if (collapsed) {
+                collapsedSections.add(className);
             } else {
-                this.emptyText.textContent = ( localize(6055, "No MCP servers available"));
-                this.emptySubtext.textContent = "";
+                collapsedSections.delete(className);
+            }
+            this.scheduleMcpSectionLayout();
+        });
+        this.cardListControllers.set(list, this.cardDisposables.add(( new CustomizationCardListController(list, title))));
+        return list;
+    }
+    createMcpSectionList(container, label, entries) {
+        const key = container.dataset.virtualizedSectionKey ?? label;
+        container.style.height = `${MCP_SECTION_ITEM_HEIGHT}px`;
+        container.classList.add("virtualized-section-list");
+        this.cardListControllers.get(container)?.dispose();
+        this.cardListControllers.delete(container);
+        container.removeAttribute("role");
+        container.removeAttribute("aria-label");
+        const itemRenderer = this.cardDisposables.add(this.instantiationService.createInstance(
+            McpServerItemRenderer,
+            (getEntry, actions, disposables, updateTabbability) => this.renderMcpListActions(getEntry, actions, disposables, updateTabbability)
+        ));
+        const marketplaceRenderer = ( new McpMarketplaceItemRenderer((server, button) => this.installMarketplaceServer(server, button)));
+        const list = this.cardDisposables.add(
+            this.instantiationService.createInstance(WorkbenchList, `McpManagementList.${label}`, container, ( new McpSectionDelegate()), [itemRenderer, marketplaceRenderer], {
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                horizontalScrolling: false,
+                supportDynamicHeights: true,
+                accessibilityProvider: {
+                    getAriaLabel: entry => entry.type === "marketplace-item" ? ( localize(
+                        6898,
+                        "{0}. Available to install from the MCP marketplace.",
+                        entry.server.label
+                    )) : this.getMcpEntryAriaLabel(entry, itemRenderer),
+                    getWidgetAriaLabel: () => label,
+                    getSetSize: (_entry, _index, listLength) => listLength,
+                    getPosInSet: (_entry, index) => index + 1
+                },
+                openOnSingleClick: true,
+                identityProvider: {
+                    getId: entry => entry.type === "marketplace-item" ? `marketplace:${entry.server.id}` : getMcpRowKey(entry)
+                }
+            })
+        );
+        this.cardDisposables.add(list.onDidChangeContentHeight(() => this.scheduleMcpSectionLayout()));
+        list.splice(0, 0, entries);
+        const section = {
+            list,
+            entries,
+            container,
+            key,
+            pendingMeasurements: ( new Set()),
+            deferredMeasurements: ( new Set())
+        };
+        this.sectionLists.push(section);
+        this.cardDisposables.add(list.onDidScroll(() => {
+            if (( [...section.deferredMeasurements].some(index => index >= list.firstVisibleIndex && index <= list.lastVisibleIndex))) {
+                this.scheduleMcpSectionLayout();
             }
+        }));
+        const heightInputs = ( new Map());
+        this.cardDisposables.add(itemRenderer.onDidChangeHeight((
+            {
+                index,
+                text,
+                expanded
+            }
+        ) => {
+            const entry = entries[index];
+            if (entry && entry.type !== "marketplace-item") {
+                heightInputs.set(entry, {
+                    text,
+                    expanded
+                });
+            }
+            section.pendingMeasurements.add(index);
+            this.scheduleMcpSectionLayout();
+        }));
+        this.cardDisposables.add(autorun(reader => {
+            this.agentHostCustomizationsChanged.read(reader);
+            const sessionResource = this.customizationHarnessService.activeSessionResource.read(reader);
+            const servers = ( new Map(( this.agentHostCustomizationService.getMcpServers(sessionResource).map(server => [server.id, server]))));
+            for (let index = 0; index < entries.length; index++) {
+                const entry = entries[index];
+                if (entry.type === "marketplace-item") {
+                    continue;
+                }
+                const host = getActiveSessionServer(entry);
+                let error;
+                if (host) {
+                    const server = servers.get(host.id);
+                    error = server?.enabled && server.status === McpServerStatus.Error ? getMcpErrorMessage(
+                        server.status,
+                        server.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined
+                    ) : undefined;
+                } else if (!this.workspaceService.isSessionsWindow && entry.type !== "session-server-item") {
+                    const state = entry.localServer?.connectionState.read(reader);
+                    const enabled = !entry.localServer || isContributionEnabled(entry.localServer.enablement.read(reader));
+                    error = enabled && state?.state === McpConnectionState.Kind.Error ? getMcpErrorMessage(state.state, state.message) : undefined;
+                }
+                itemRenderer.syncError(entry, error);
+                const expanded = itemRenderer.isErrorExpanded(entry, error);
+                const text = error === undefined ? undefined : expanded ? error : getMcpErrorPreview(error).text;
+                const previous = heightInputs.get(entry);
+                heightInputs.set(entry, {
+                    text,
+                    expanded
+                });
+                if (previous && (previous.text !== text || previous.expanded !== expanded)) {
+                    section.pendingMeasurements.add(index);
+                }
+            }
+            if (section.pendingMeasurements.size) {
+                this.scheduleMcpSectionLayout();
+            }
+        }));
+        list.scrollTop = this.sectionScrollPositions.get(key) ?? 0;
+        this.cardDisposables.add(list.onDidOpen(event => {
+            const entry = event.element;
+            if (!entry) {
+                return;
+            }
+            this._onDidSelectServer.fire(
+                entry.type === "marketplace-item" ? createWorkbenchMcpServerDetailInput(entry.server) : createInstalledMcpServerDetailInput(entry)
+            );
+        }));
+        this.cardDisposables.add(list.onContextMenu(event => {
+            if (event.element && event.element.type !== "marketplace-item") {
+                this.showMcpServerActions(event.element, event.anchor);
+            }
+        }));
+        this.cardDisposables.add(list.onDidChangeFocus(event => {
+            const index = event.indexes[0] ?? -1;
+            itemRenderer.setFocusedIndex(index);
+            marketplaceRenderer.setFocusedIndex(index);
+        }));
+        this.cardDisposables.add(list.onDidFocus(() => {
+            if (list.getFocus().length === 0 && entries.length > 0) {
+                list.setFocus([0]);
+            }
+        }));
+    }
+    captureSectionScrollPositions() {
+        for (const section of this.sectionLists) {
+            this.sectionScrollPositions.set(section.key, section.list.scrollTop);
+        }
+    }
+    getMcpEntryAriaLabel(entry, renderer) {
+        return derived(this, reader => {
+            renderer?.readErrorExpansion(reader);
+            this.agentHostCustomizationsChanged.read(reader);
+            const label = getMcpEntryLabel(entry);
+            const activeSessionResource = this.customizationHarnessService.activeSessionResource.read(reader);
+            let statusKind;
+            let disabledReason;
+            let errorMessage;
+            const activeSessionServer = getActiveSessionServer(entry);
+            if (activeSessionServer !== undefined) {
+                const server = this.agentHostCustomizationService.getMcpServers(activeSessionResource).find(server => server.id === activeSessionServer.id);
+                const presentation = server && getActiveSessionServerPresentation(server);
+                statusKind = presentation?.status;
+                disabledReason = presentation?.enabled ? undefined : server?.disabledReason;
+                errorMessage = server?.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined;
+            } else if (entry.type !== "session-server-item" && entry.localServer && isContributionDisabled(entry.localServer.enablement.read(reader))) {
+                statusKind = "disabled";
+                disabledReason = getMcpDisabledReason(entry);
+            } else if (entry.type !== "session-server-item" && !this.workspaceService.isSessionsWindow) {
+                const connectionState = entry.localServer?.connectionState.read(reader);
+                statusKind = entry.type === "server-item" || connectionState?.state === McpConnectionState.Kind.Error ? connectionState?.state : undefined;
+                errorMessage = connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined;
+            }
+            const status = getMcpStatusPresentation(statusKind, disabledReason);
+            const error = getMcpErrorMessage(statusKind, errorMessage);
+            if (status && error) {
+                const preview = getMcpErrorPreview(error);
+                const expanded = renderer?.isErrorExpanded(entry, error);
+                const text = expanded ? error : preview.text;
+                return !expanded && (preview.truncated || renderer?.isErrorClipped(entry)) ? ( localize(
+                    6899,
+                    "{0}, {1}, {2}. Use Show More to read the full error.",
+                    label,
+                    status.label,
+                    text
+                )) : ( localize(6900, "{0}, {1}, {2}", label, status.label, text));
+            }
+            return status ? ( localize(6875, "{0}, {1}", label, status.label)) : label;
+        });
+    }
+    renderMcpListActions(getEntry, actions, disposables, updateTabbability) {
+        const entry = getEntry();
+        if (!entry) {
+            return;
+        }
+        const label = getMcpEntryLabel(entry);
+        let enabled = this.isInstalledEntryEnabled(entry);
+        const toggle = disposables.add(( new Switch({
+            ariaLabel: label,
+            checked: enabled
+        })));
+        append(actions, toggle.domNode);
+        const update = () => {
+            const currentEntry = getEntry();
+            enabled = currentEntry ? this.isInstalledEntryEnabled(currentEntry) : false;
+            const blockedByPlugin = currentEntry && getMcpDisabledReason(currentEntry)?.source === "plugin";
+            const toggleLabel = enabled ? ( localize(6901, "Disable {0}", label)) : ( localize(6902, "Enable {0}", label));
+            const accessibleLabel = blockedByPlugin ? ( localize(6903, "{0} is disabled by its plugin", label)) : toggleLabel;
+            toggle.disabled = !currentEntry || !!blockedByPlugin;
+            toggle.checked = enabled;
+            toggle.setAriaLabel(accessibleLabel);
+            updateTabbability();
+        };
+        update();
+        disposables.add(
+            addDisposableGenericMouseDownListener(toggle.domNode, event => EventHelper.stop(event, true))
+        );
+        disposables.add(toggle.onChange(checked => {
+            const currentEntry = getEntry();
+            if (!currentEntry) {
+                update();
+                return;
+            }
+            enabled = checked;
+            this.setInstalledEntryEnabled(currentEntry, enabled);
+            update();
+            status(enabled ? ( localize(6904, "{0} enabled.", label)) : ( localize(6905, "{0} disabled.", label)));
+        }));
+        if (entry.type !== "session-server-item" && entry.localServer) {
+            disposables.add(autorun(reader => {
+                entry.localServer?.enablement.read(reader);
+                update();
+            }));
+        }
+        disposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
+        const more = disposables.add(( new Button(actions, {
+            ...getButtonStyles({
+                buttonSecondaryBackground: undefined,
+                buttonSecondaryBorder: undefined
+            }),
+            secondary: true,
+            supportIcons: true,
+            ariaLabel: ( localize(6906, "More actions for {0}", label))
+        })));
+        more.element.classList.add("plugin-card-icon-button");
+        more.label = `$(${Codicon.ellipsis.id})`;
+        registerMcpInlineButtonAction(disposables, more, () => {
+            const currentEntry = getEntry();
+            if (currentEntry) {
+                this.showMcpServerActions(currentEntry, more.element);
+            }
+        });
+    }
+    layoutMcpSectionLists() {
+        const content = this.sectionLayoutContainer;
+        if (!content || content.clientWidth === 0) {
+            return;
+        }
+        const heights = layoutVirtualizedSections(content, ( this.sectionLists.map(section => ({
+            container: section.container,
+            contentHeight: section.list.contentHeight,
+            minimumHeight: getVirtualizedSectionMinimumHeight(( section.entries.map((_entry, index) => index)), index => section.list.getElementHeight(index))
+        }))));
+        for (let index = 0; index < this.sectionLists.length; index++) {
+            const section = this.sectionLists[index];
+            const height = heights[index];
+            section.container.style.height = `${height}px`;
+            if (height > 0) {
+                section.list.layout(height, section.container.clientWidth || undefined);
+                for (const index of section.deferredMeasurements) {
+                    if (index >= section.list.firstVisibleIndex && index <= section.list.lastVisibleIndex) {
+                        section.deferredMeasurements.delete(index);
+                        section.pendingMeasurements.add(index);
+                    }
+                }
+                const pending = [...section.pendingMeasurements];
+                section.pendingMeasurements.clear();
+                for (const index of pending) {
+                    if (index >= section.list.firstVisibleIndex && index <= section.list.lastVisibleIndex) {
+                        section.list.updateElementHeight(index, undefined);
+                    } else {
+                        section.list.updateElementHeight(index, MCP_SECTION_ITEM_HEIGHT);
+                        section.deferredMeasurements.add(index);
+                    }
+                }
+            }
+        }
+    }
+    scheduleMcpSectionLayout() {
+        this.pendingSectionLayout.value = scheduleAtNextAnimationFrame(getWindow(this.element), () => {
+            this.layoutMcpSectionLists();
+            this.cardScrollable.scanDomNode();
+        });
+    }
+    renderMcpHome() {
+        if (this.searchQuery.trim()) {
+            return;
+        }
+        this.captureSectionScrollPositions();
+        this.cardDisposables.clear();
+        this.sectionLists = [];
+        this.installedAddButton = undefined;
+        this.firstCardFocusElement = undefined;
+        this.availableSection = undefined;
+        clearNode(this.cardContainer);
+        this.showCardSurface();
+        const content = this.createCardScrollContent("distributed-section-layout");
+        const installedList = this.renderCardSection(content, ( localize(6907, "Installed")), undefined, "installed-mcp-servers-section", this.installedEntries.length, header => this.renderInstalledSectionActions(header));
+        installedList.classList.add("plugin-inventory-list");
+        if (this.installedEntries.length === 0) {
+            const empty = append(installedList, $(".plugin-inventory-empty"));
+            empty.textContent = ( localize(6908, "No MCP servers are installed."));
         } else {
-            this.emptyContainer.style.display = "none";
-            this.listContainer.style.display = "";
+            this.createMcpSectionList(installedList, ( localize(6907, "Installed")), ( this.installedEntries.map(presentation => presentation.entry)));
         }
-        const entries = ( this.galleryServers.map(server => ({
-            type: "server-item",
-            server,
-            marketplace: true
+        this.renderAvailableServers(content, this.getAvailableGalleryServers(), true);
+        this.scheduleMcpSectionLayout();
+    }
+    renderInstalledSectionActions(header) {
+        const actions = append(header, $(".plugin-card-section-actions"));
+        const addLabel = ( localize(6909, "Add Server"));
+        const add = this.installedAddButton = this.cardDisposables.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            secondary: true,
+            ariaLabel: addLabel
         })));
-        this.list.splice(0, this.list.length, entries);
+        add.element.classList.add("plugin-installed-action");
+        add.label = this.narrowLayout ? ( localize(6910, "Add")) : addLabel;
+        this.firstCardFocusElement ??= add.element;
+        this.cardDisposables.add(
+            add.onDidClick(() => this.commandService.executeCommand(McpCommandIds.AddConfiguration))
+        );
+    }
+    renderAvailableServers(parent, servers, showDescription) {
+        const availableList = this.renderCardSection(parent, ( localize(6911, "Available")), showDescription ? ( localize(6912, "Browse and install MCP servers from the marketplace.")) : undefined, "available-mcp-servers-section", servers.length);
+        this.availableSection = availableList.parentElement ?? undefined;
+        availableList.classList.add("plugin-inventory-list");
+        if (servers.length === 0) {
+            if (this.gallerySnapshotLoading) {
+                renderVirtualizedSectionLoadingPlaceholder(availableList, ( localize(6913, "Loading marketplace MCP servers...")), MCP_SECTION_ITEM_HEIGHT);
+            } else {
+                const empty = append(availableList, $(".plugin-inventory-empty"));
+                empty.textContent = ( localize(6914, "No marketplace MCP servers are available."));
+            }
+            this.cardListControllers.get(availableList)?.finalize();
+            return;
+        }
+        this.createMcpSectionList(availableList, ( localize(6911, "Available")), ( servers.map(server => ({
+            type: "marketplace-item",
+            server
+        }))));
+    }
+    appendInstalledServerRow(parent, presentation) {
+        let entry = presentation.entry;
+        const rowKey = getMcpRowKey(entry);
+        const label = getMcpEntryLabel(entry);
+        const row = append(parent, $(".plugin-list-item.plugin-home-row.mcp-installed-home-row"));
+        const enabled = this.isInstalledEntryEnabled(entry);
+        row.classList.toggle("disabled", !enabled);
+        const primaryAction = this.addSurfaceActivation(
+            row,
+            getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+            () => this._onDidSelectServer.fire(createInstalledMcpServerDetailInput(entry))
+        );
+        const details = append(primaryAction, $(".plugin-list-item-details"));
+        const nameRow = append(details, $(".plugin-list-item-name-row"));
+        const name = append(nameRow, $(".plugin-list-item-name"));
+        name.textContent = formatDisplayName(label);
+        name.title = label;
+        const statusBadge = append(nameRow, $(".plugin-list-item-status.mcp-runtime-status-badge"));
+        const description = append(details, $(".plugin-list-item-description"));
+        const actions = append(row, $(".plugin-list-item-action"));
+        const getEntry = () => entry;
+        const signIn = this.appendInstalledServerSignIn(actions, getEntry);
+        const toggle = this.appendInstalledServerToggle(actions, getEntry);
+        const more = this.cardDisposables.add(( new Button(actions, {
+            ...getButtonStyles({
+                buttonSecondaryBackground: undefined,
+                buttonSecondaryBorder: undefined
+            }),
+            secondary: true,
+            supportIcons: true,
+            ariaLabel: ( localize(6906, "More actions for {0}", label))
+        })));
+        more.element.classList.add("plugin-card-icon-button");
+        more.label = `$(${Codicon.ellipsis.id})`;
+        this.cardDisposables.add(more.onDidClick(() => this.showMcpServerActions(entry, more.element)));
+        this.cardListControllers.get(parent)?.addItem({
+            row,
+            primaryAction,
+            label,
+            actions: [signIn?.element, toggle.element, more.element].filter(action => action !== undefined),
+            contextMenuAction: more.element
+        });
+        this.cardDisposables.add(autorun(reader => {
+            if (entry.type !== "session-server-item") {
+                entry.localServer?.connectionState.read(reader);
+            }
+            updateMcpCardRuntimePresentation(
+                statusBadge,
+                primaryAction,
+                description,
+                getMcpStatusKind(entry, this.workspaceService.isSessionsWindow),
+                getMcpDisabledReason(entry),
+                getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+                this.getInstalledEntryDescription(entry)
+            );
+        }));
+        this.cardDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
+            const updated = this.installedEntries.find(candidate => getMcpRowKey(candidate.entry) === rowKey)?.entry;
+            if (!updated) {
+                return;
+            }
+            entry = updated;
+            updateMcpCardRuntimePresentation(
+                statusBadge,
+                primaryAction,
+                description,
+                getMcpStatusKind(entry, this.workspaceService.isSessionsWindow),
+                getMcpDisabledReason(entry),
+                getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+                this.getInstalledEntryDescription(entry)
+            );
+            signIn?.update();
+            toggle.update();
+            row.classList.toggle("disabled", !this.isInstalledEntryEnabled(entry));
+        }));
+    }
+    appendInstalledServerSignIn(parent, getEntry) {
+        if (getActiveSessionServer(getEntry()) === undefined) {
+            return undefined;
+        }
+        const label = getMcpEntryLabel(getEntry());
+        const signInButton = createMcpSignInButton(parent, this.cardDisposables, label);
+        registerMcpInlineButtonAction(this.cardDisposables, signInButton, async () => {
+            const activeSessionServer = getActiveSessionServer(getEntry());
+            if (!activeSessionServer) {
+                return;
+            }
+            signInButton.enabled = false;
+            try {
+                await authenticateMcpServer(
+                    this.agentHostCustomizationService,
+                    this.customizationHarnessService.activeSessionResource.get(),
+                    activeSessionServer.id
+                );
+            } catch (error) {
+                this.notificationService.error(( localize(6915, "Unable to sign in to {0}: {1}", label, getErrorMessage(error))));
+            } finally {
+                signInButton.enabled = true;
+            }
+        });
+        const update = () => {
+            signInButton.element.style.display = getMcpStatusKind(getEntry(), this.workspaceService.isSessionsWindow) === McpServerStatus.AuthRequired ? "" : "none";
+        };
+        update();
+        return {
+            element: signInButton.element,
+            update
+        };
+    }
+    appendInstalledServerToggle(parent, getEntry) {
+        const label = getMcpEntryLabel(getEntry());
+        let enabled = this.isInstalledEntryEnabled(getEntry());
+        const toggle = this.cardDisposables.add(( new Switch({
+            ariaLabel: label,
+            checked: enabled
+        })));
+        const switchElement = toggle.domNode;
+        append(parent, switchElement);
+        const updateLabel = () => {
+            const blockedByPlugin = getMcpDisabledReason(getEntry())?.source === "plugin";
+            const toggleLabel = enabled ? ( localize(6901, "Disable {0}", label)) : ( localize(6902, "Enable {0}", label));
+            const accessibleLabel = blockedByPlugin ? ( localize(6903, "{0} is disabled by its plugin", label)) : toggleLabel;
+            toggle.setAriaLabel(accessibleLabel);
+        };
+        updateLabel();
+        this.cardDisposables.add(toggle.onChange(checked => {
+            enabled = checked;
+            updateLabel();
+            this.setInstalledEntryEnabled(getEntry(), enabled);
+            status(enabled ? ( localize(6904, "{0} enabled.", label)) : ( localize(6905, "{0} disabled.", label)));
+        }));
+        const update = () => {
+            enabled = this.isInstalledEntryEnabled(getEntry());
+            toggle.disabled = getMcpDisabledReason(getEntry())?.source === "plugin";
+            toggle.checked = enabled;
+            updateLabel();
+        };
+        update();
+        return {
+            element: switchElement,
+            update
+        };
+    }
+    appendMarketplaceServerRow(parent, server) {
+        const row = append(parent, $(".plugin-list-item.plugin-home-row.plugin-marketplace-home-row"));
+        const primaryAction = this.addSurfaceActivation(row, ( localize(6898, "{0}. Available to install from the MCP marketplace.", server.label)), () => this._onDidSelectServer.fire(createWorkbenchMcpServerDetailInput(server)));
+        const details = append(primaryAction, $(".plugin-list-item-details"));
+        const nameRow = append(details, $(".plugin-list-item-name-row"));
+        const name = append(nameRow, $(".plugin-list-item-name"));
+        name.textContent = server.label;
+        name.title = server.label;
+        const description = append(details, $(".plugin-list-item-description"));
+        description.textContent = truncateToFirstLine(server.description || ( localize(6865, "No description provided.")));
+        const actions = append(row, $(".plugin-list-item-action"));
+        const install = this.cardDisposables.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            ariaLabel: ( localize(6916, "Install {0}", server.label))
+        })));
+        install.element.classList.add("plugin-list-item-install-button");
+        install.label = ( localize(6866, "Install"));
+        this.cardDisposables.add(install.onDidClick(() => this.installMarketplaceServer(server, install)));
+        this.cardListControllers.get(parent)?.addItem({
+            row,
+            primaryAction,
+            label: server.label,
+            actions: [install.element]
+        });
     }
-    filterServers() {
+    async installMarketplaceServer(server, button) {
+        button.label = ( localize(6917, "Installing..."));
+        button.enabled = false;
+        try {
+            await this.mcpWorkbenchService.install(server);
+            status(( localize(6918, "{0} installed.", server.label)));
+            await this.refresh();
+        } catch (error) {
+            button.label = ( localize(6866, "Install"));
+            button.enabled = true;
+            this.notificationService.error(( localize(6919, "Unable to install MCP server: {0}", getErrorMessage(error))));
+        }
+    }
+    getAvailableGalleryServers() {
+        const installedKeys = ( new Set());
+        for (const presentation of this.installedEntries) {
+            const entry = presentation.entry;
+            if (entry.type === "server-item") {
+                for (const key of getWorkbenchServerMatchKeys(entry.server)) {
+                    installedKeys.add(key.toLowerCase());
+                }
+            } else if (entry.type === "builtin-item") {
+                installedKeys.add(entry.label.toLowerCase());
+                if (entry.localServer) {
+                    for (const key of getRuntimeServerMatchKeys(entry.localServer)) {
+                        installedKeys.add(key.toLowerCase());
+                    }
+                }
+            } else {
+                installedKeys.add(entry.server.name.toLowerCase());
+            }
+        }
+        return this.galleryServers.filter(
+            server => server.installState === McpServerInstallState.Uninstalled && !( getWorkbenchServerMatchKeys(server).some(key => ( installedKeys.has(key.toLowerCase()))))
+        );
+    }
+    matchesGalleryServerQuery(server, query) {
+        return server.label.toLowerCase().includes(query) || server.description.toLowerCase().includes(query) || server.publisherDisplayName?.toLowerCase().includes(query) === true;
+    }
+    getInstalledEntryDescription(entry) {
+        const description = entry.type === "server-item" ? entry.server.description : entry.type === "builtin-item" ? entry.description : "";
+        return truncateToFirstLine(description || ( localize(6865, "No description provided.")));
+    }
+    isInstalledEntryEnabled(entry) {
+        const activeSessionServer = getActiveSessionServer(entry);
+        const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
+        const serverId = localServer?.definition.id ?? (entry.type === "server-item" ? entry.server.id : undefined);
+        return isPrimaryMcpServerEnabled(this.mcpService, serverId, activeSessionServer);
+    }
+    setInstalledEntryEnabled(entry, enabled) {
+        const activeSessionServer = getActiveSessionServer(entry);
+        const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
+        const serverId = localServer?.definition.id ?? (entry.type === "server-item" ? entry.server.id : undefined);
+        setPrimaryMcpServerEnablement(
+            this.mcpService,
+            this.agentHostCustomizationService,
+            this.customizationHarnessService.activeSessionResource.get(),
+            serverId,
+            activeSessionServer,
+            enabled
+        );
+    }
+    updateSearchResults() {
+        const available = this.getAvailableGalleryServers();
+        if (this.installedEntries.length === 0 && available.length === 0) {
+            this.showEmptySurface(this.gallerySearchLoading ? ( localize(6920, "Searching the MCP marketplace...")) : ( localize(6921, "No servers match '{0}'", this.searchQuery)), this.gallerySearchLoading ? "" : ( localize(6922, "Try a different search term")));
+            return;
+        }
+        this.captureSectionScrollPositions();
+        this.cardDisposables.clear();
+        this.sectionLists = [];
+        this.installedAddButton = undefined;
+        this.firstCardFocusElement = undefined;
+        this.availableSection = undefined;
+        clearNode(this.cardContainer);
+        this.showCardSurface();
+        const content = this.createCardScrollContent("plugin-search-results", "distributed-section-layout");
+        if (this.installedEntries.length > 0) {
+            const installedList = this.renderCardSection(content, ( localize(6923, "Installed")), undefined, "installed-mcp-servers-section", this.installedEntries.length);
+            installedList.classList.add("plugin-inventory-list");
+            this.createMcpSectionList(installedList, ( localize(6923, "Installed")), ( this.installedEntries.map(presentation => presentation.entry)));
+        }
+        if (available.length > 0) {
+            this.renderAvailableServers(content, available, false);
+        }
+        this.scheduleMcpSectionLayout();
+    }
+    filterServers(render = true) {
         const query = this.searchQuery.toLowerCase().trim();
         const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
         const activeSessionMatcher = ( new ActiveSessionMcpServerMatcher(this.agentHostCustomizationService.getMcpServers(activeSessionResource)));
@@ -792,72 +2319,26 @@ let McpListWidget = class McpListWidget extends Disposable {
             this.filteredServers = [...this.mcpWorkbenchService.local];
         }
         const localIds = ( new Set(( this.filteredServers.map(s => s.id))));
-        const builtinServers = this.mcpService.servers.get().filter(s => !( localIds.has(s.definition.id))).filter(s => !query || s.definition.label.toLowerCase().includes(query));
+        const hiddenCollectionIds = this.customizationHarnessService.getActiveDescriptor().hiddenMcpServerCollectionIds;
+        const builtinServers = this.mcpService.servers.get().filter(s => !( localIds.has(s.definition.id))).filter(s => isMcpServerCollectionVisible(s.collection.id, hiddenCollectionIds)).filter(s => !query || s.definition.label.toLowerCase().includes(query));
         const groups = [{
-            scope: LocalMcpServerScope.Workspace,
-            label: ( localize(6056, "Workspace")),
-            icon: workspaceIcon,
-            description: ( localize(
-                6057,
-                "MCP servers configured in your workspace settings, shared with your team via version control."
-            )),
-            servers: []
+            entries: []
         }, {
-            scope: LocalMcpServerScope.User,
-            label: ( localize(6058, "User")),
-            icon: userIcon,
-            description: ( localize(
-                6059,
-                "MCP servers configured in your user settings. Private to you and available across all projects."
-            )),
-            servers: []
+            entries: []
         }];
         for (const server of this.filteredServers) {
             const entry = {
+                type: "server-item",
                 server,
                 activeSessionServer: activeSessionMatcher.take(getWorkbenchServerMatchKeys(server)),
                 localServer: localServerMatcher.find(getWorkbenchServerMatchKeys(server))
             };
             const scope = server.local?.scope;
             if (scope === LocalMcpServerScope.Workspace) {
-                groups[0].servers.push(entry);
+                groups[0].entries.push(entry);
             } else {
-                groups[1].servers.push(entry);
-            }
-        }
-        const entries = [];
-        let isFirst = true;
-        for (const group of groups) {
-            if (group.servers.length === 0) {
-                continue;
-            }
-            const collapsed = ( this.collapsedGroups.has(group.scope));
-            entries.push({
-                type: "group-header",
-                id: `mcp-group-${group.scope}`,
-                scope: group.scope,
-                label: group.label,
-                icon: group.icon,
-                count: group.servers.length,
-                isFirst,
-                description: group.description,
-                collapsed
-            });
-            if (!collapsed) {
-                for (const {
-                    server,
-                    activeSessionServer,
-                    localServer
-                } of group.servers) {
-                    entries.push({
-                        type: "server-item",
-                        server,
-                        activeSessionServer,
-                        localServer
-                    });
-                }
+                groups[1].entries.push(entry);
             }
-            isFirst = false;
         }
         const collectionSources = ( new Map(( this.mcpRegistry.collections.get().map(c => [c.id, c.source]))));
         const pluginServers = [];
@@ -878,117 +2359,57 @@ let McpListWidget = class McpListWidget extends Disposable {
             }
         }
         const activeSessionOnlyServers = activeSessionMatcher.unmatched(query);
-        if (this.filteredServers.length === 0 && builtinServers.length === 0 && activeSessionOnlyServers.length === 0) {
-            this.emptyContainer.style.display = "flex";
-            this.listContainer.style.display = "none";
-            if (this.searchQuery.trim()) {
-                this.emptyText.textContent = ( localize(6060, "No servers match '{0}'", this.searchQuery));
-                this.emptySubtext.textContent = ( localize(6054, "Try a different search term"));
-            } else {
-                this.emptyText.textContent = ( localize(6061, "No MCP servers configured"));
-                this.emptySubtext.textContent = ( localize(6062, "Add an MCP server configuration to get started"));
-            }
-        } else {
-            this.emptyContainer.style.display = "none";
-            this.listContainer.style.display = "";
-        }
-        if (activeSessionOnlyServers.length > 0) {
-            const collapsed = ( this.collapsedGroups.has("active-session"));
-            entries.push({
-                type: "group-header",
-                id: "mcp-group-active-session",
-                scope: "active-session",
-                label: ( localize(6063, "Active Session")),
-                icon: mcpServerIcon,
-                count: activeSessionOnlyServers.length,
-                isFirst,
-                description: ( localize(6064, "MCP servers reported by the active session.")),
-                collapsed
-            });
-            if (!collapsed) {
-                for (const server of activeSessionOnlyServers) {
-                    entries.push({
-                        type: "session-server-item",
-                        server
-                    });
-                }
-            }
-            isFirst = false;
-        }
-        if (pluginServers.length > 0) {
-            const collapsed = ( this.collapsedGroups.has("plugin"));
-            entries.push({
-                type: "group-header",
-                id: "mcp-group-plugin",
-                scope: "plugin",
-                label: ( localize(6065, "Plugins")),
-                icon: pluginIcon,
-                count: pluginServers.length,
-                isFirst,
-                description: ( localize(6066, "MCP servers provided by installed plugins.")),
-                collapsed
-            });
-            if (!collapsed) {
-                for (const {
-                    server,
-                    activeSessionServer
-                } of pluginServers) {
-                    entries.push(createBuiltinEntry(server, activeSessionServer));
-                }
+        const activeSessionBuiltinEntries = createBuiltinActiveSessionMcpEntries(activeSessionOnlyServers);
+        this.installedEntries = [...groups.flatMap(group => ( group.entries.map(entry => ({
+            entry
+        })))), ...( pluginServers.map((
+            {
+                server,
+                activeSessionServer
             }
-            isFirst = false;
-        }
-        if (extensionServers.length > 0) {
-            const collapsed = ( this.collapsedGroups.has("extension"));
-            entries.push({
-                type: "group-header",
-                id: "mcp-group-extension",
-                scope: "extension",
-                label: ( localize(6067, "Extensions")),
-                icon: extensionIcon,
-                count: extensionServers.length,
-                isFirst,
-                description: ( localize(6068, "MCP servers contributed by installed VS Code extensions.")),
-                collapsed
-            });
-            if (!collapsed) {
-                for (const {
-                    server,
-                    activeSessionServer
-                } of extensionServers) {
-                    entries.push(createBuiltinEntry(server, activeSessionServer));
-                }
+        ) => ({
+            entry: createBuiltinEntry(server, activeSessionServer)
+        }))), ...( extensionServers.map((
+            {
+                server,
+                activeSessionServer
             }
-            isFirst = false;
-        }
-        if (otherBuiltinServers.length > 0) {
-            const collapsed = ( this.collapsedGroups.has("builtin"));
-            entries.push({
-                type: "group-header",
-                id: "mcp-group-builtin",
-                scope: "builtin",
-                label: ( localize(6069, "Built-in")),
-                icon: builtinIcon,
-                count: otherBuiltinServers.length,
-                isFirst,
-                description: ( localize(6070, "MCP servers built into VS Code. These are available automatically.")),
-                collapsed
-            });
-            if (!collapsed) {
-                for (const {
-                    server,
-                    activeSessionServer
-                } of otherBuiltinServers) {
-                    entries.push(createBuiltinEntry(server, activeSessionServer));
-                }
+        ) => ({
+            entry: createBuiltinEntry(server, activeSessionServer)
+        }))), ...( otherBuiltinServers.map((
+            {
+                server,
+                activeSessionServer
             }
-            isFirst = false;
-        }
-        this.displayEntries = entries;
-        this.list.splice(0, this.list.length, this.displayEntries);
+        ) => ({
+            entry: createBuiltinEntry(server, activeSessionServer)
+        }))), ...( activeSessionBuiltinEntries.map(entry => ({
+            entry
+        })))];
         this.filteredBuiltinCount = builtinServers.length;
         this.filteredActiveSessionCount = activeSessionOnlyServers.length;
         this._onDidChangeItemCount.fire(this.itemCount);
+        if (render) {
+            this.renderFilteredServers();
+        }
+    }
+    renderFilteredServers() {
+        if (this.searchQuery.trim()) {
+            this.updateSearchResults();
+        } else {
+            this.renderMcpHome();
+        }
+    }
+    getInstalledEntryMembershipSignature() {
+        return ( this.installedEntries.map((
+            {
+                entry
+            }
+        ) => [
+            getMcpRowKey(entry),
+            getActiveSessionServer(entry) ? "session" : "",
+            entry.type !== "session-server-item" && entry.localServer ? "local" : ""
+        ].join(":"))).join("|");
     }
     get itemCount() {
         return this.filteredServers.length + this.filteredBuiltinCount + this.filteredActiveSessionCount;
@@ -996,26 +2417,19 @@ let McpListWidget = class McpListWidget extends Disposable {
     fireItemCount() {
         this._onDidChangeItemCount.fire(this.itemCount);
     }
-    toggleGroup(entry) {
-        if (( this.collapsedGroups.has(entry.scope))) {
-            this.collapsedGroups.delete(entry.scope);
-        } else {
-            this.collapsedGroups.add(entry.scope);
-        }
-        this.filterServers();
-    }
     isInBrowseMode() {
-        return this.browseMode;
-    }
-    exitBrowseMode() {
-        if (this.browseMode) {
-            this.toggleBrowseMode(false);
-        }
+        return false;
     }
+    exitBrowseMode() {}
     layout(height, width) {
         this.lastHeight = height;
         this.lastWidth = width;
+        if (!this.visible || this.element.parentElement?.style.display === "none") {
+            return;
+        }
         this.element.style.height = `${height}px`;
+        this.updateResponsiveLayout(width);
+        const availableHeight = this.element.clientHeight || height;
         const searchBarHeight = this.searchAndButtonContainer.offsetHeight;
         if (searchBarHeight === 0 && !this._layoutDeferred) {
             this._layoutDeferred = true;
@@ -1030,119 +2444,213 @@ let McpListWidget = class McpListWidget extends Disposable {
         }
         const headerHeight = this.sectionTitleHeader.offsetHeight;
         this.lastHeaderHeight = headerHeight;
-        const listHeight = Math.max(0, height - searchBarHeight - headerHeight);
-        this.listContainer.style.height = `${listHeight}px`;
-        this.list.layout(listHeight, width);
+        const listHeight = Math.max(0, availableHeight - searchBarHeight - headerHeight);
+        this.cardScrollableNode.style.height = `${listHeight}px`;
+        this.scheduleMcpSectionLayout();
     }
     focusSearch() {
         this.searchInput.focus();
     }
     revealLastItem() {
-        if (this.list.length > 0) {
-            this.list.reveal(this.list.length - 1);
-        }
+        const reveal = () => {
+            const section = this.sectionLists.at(-1);
+            if (section?.entries.length) {
+                section.list.reveal(section.entries.length - 1);
+            }
+            this.cardScrollable.scanDomNode();
+            this.cardScrollable.setScrollPosition({
+                scrollTop: this.cardContainer.scrollHeight
+            });
+        };
+        reveal();
+        this.revealLastItemScheduler.value = scheduleAtNextAnimationFrame(getWindow(this.element), reveal);
     }
     focus() {
-        this.list.domFocus();
-        const servers = this.list.length;
-        if (servers > 0) {
-            this.list.setFocus([0]);
+        if (this.cardScrollableNode.style.display !== "none") {
+            if (this.firstCardFocusElement) {
+                this.firstCardFocusElement.focus();
+            } else {
+                const section = this.sectionLists[0];
+                if (section?.entries.length) {
+                    section.list.setFocus([0]);
+                    section.list.domFocus();
+                }
+            }
         }
     }
-    openActiveSessionServerOptions(server) {
-        void this.commandService.executeCommand(
-            McpCommandIds.AgentHostServerOptions,
-            this.customizationHarnessService.activeSessionResource.get(),
-            server.id
-        );
+    updateResponsiveLayout(width) {
+        const narrow = width < 500;
+        const wide = width >= 600;
+        if (this.narrowLayout === narrow && this.wideLayout === wide) {
+            return;
+        }
+        this.narrowLayout = narrow;
+        this.wideLayout = wide;
+        this.element.classList.toggle("narrow-layout", narrow);
+        this.element.classList.toggle("wide-layout", wide);
+        if (this.installedAddButton) {
+            this.installedAddButton.label = narrow ? ( localize(6910, "Add")) : ( localize(6909, "Add Server"));
+        }
     }
-    onContextMenu(e) {
-        if (!e.element) {
+    showMcpServerActions(entry, anchor) {
+        const disposables = ( new DisposableStore());
+        const actions = this.getMcpServerActions(entry, disposables);
+        if (actions.length === 0) {
+            disposables.dispose();
             return;
         }
-        if (e.element.type === "session-server-item") {
-            const disposables = ( new DisposableStore());
-            const optionsAction = disposables.add(getActiveSessionServerOptionsAction(
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => actions,
+            onHide: () => disposables.dispose()
+        });
+    }
+    getMcpServerActions(entry, disposables) {
+        const sessionResource = this.customizationHarnessService.activeSessionResource.get();
+        const currentEntry = resolveMcpEntry(entry, this.agentHostCustomizationService, sessionResource);
+        if (!currentEntry) {
+            return [];
+        }
+        entry = currentEntry;
+        const activeSessionServer = getActiveSessionServer(entry);
+        const actions = this.getMcpServerManagementActions(entry, disposables);
+        if (!activeSessionServer && entry.type === "server-item") {
+            return actions;
+        }
+        const showOutput = activeSessionServer ? getMcpServerOutputHandler(
+            this.outputService,
+            undefined,
+            activeSessionServer,
+            undefined,
+            () => this.agentHostCustomizationService.showMcpServerLog(sessionResource, activeSessionServer.id)
+        ) : getMcpServerOutputHandler(
+            this.outputService,
+            entry.type === "session-server-item" ? undefined : entry.localServer,
+            undefined
+        );
+        const outputIndex = actions.findIndex(action => action instanceof ShowServerOutputAction);
+        if (outputIndex !== -1) {
+            actions.splice(outputIndex, 1);
+        }
+        if (showOutput) {
+            const outputAction = disposables.add(( new Action("mcpServer.showOutput", ( localize(6924, "Show Output")), undefined, true, showOutput)));
+            if (outputIndex !== -1) {
+                actions.splice(outputIndex, 0, outputAction);
+            } else {
+                if (actions.length > 0) {
+                    actions.push(( new Separator()));
+                }
+                actions.push(outputAction);
+            }
+        }
+        return actions;
+    }
+    getMcpServerManagementActions(entry, disposables) {
+        if (entry.type === "session-server-item") {
+            const actions = getActiveSessionServerOptionsActions(
                 this.commandService,
+                this.agentHostCustomizationService,
+                this.agentPluginService,
                 this.customizationHarnessService.activeSessionResource.get(),
-                e.element.server
-            ));
-            this.contextMenuService.showContextMenu({
-                getAnchor: () => e.anchor,
-                getActions: () => [optionsAction],
-                onHide: () => disposables.dispose()
-            });
-            return;
+                entry.server
+            );
+            actions.forEach(action => isDisposable(action) && disposables.add(action));
+            return actions;
         }
-        if (e.element.type === "builtin-item") {
-            const collectionId = e.element.collectionId;
+        if (entry.type === "builtin-item") {
+            const collectionId = entry.collectionId;
             const pluginUriStr = getPluginUriFromCollectionId(collectionId);
-            if (!pluginUriStr) {
-                return;
+            const plugin = pluginUriStr ? this.agentPluginService.plugins.get().find(p => ( p.uri.toString()) === pluginUriStr) : undefined;
+            const actions = [];
+            const lifecycleAction = entry.activeSessionServer !== undefined ? getActiveSessionServerLifecycleAction(entry.activeSessionServer) : undefined;
+            if (lifecycleAction) {
+                actions.push(disposables.add(lifecycleAction));
             }
-            const plugin = this.agentPluginService.plugins.get().find(p => ( p.uri.toString()) === pluginUriStr);
-            if (!plugin) {
-                return;
+            if (entry.localServer) {
+                const isEmptyWorkbench = this.workspaceService.getActiveProjectRoot() === undefined;
+                const enablementActions = getBuiltinMcpServerEnablementActions(
+                    this.mcpService,
+                    entry.localServer.definition.id,
+                    isEmptyWorkbench,
+                    this.agentHostCustomizationService,
+                    this.agentPluginService,
+                    this.customizationHarnessService.activeSessionResource.get(),
+                    entry.activeSessionServer
+                );
+                if (enablementActions.length > 0) {
+                    if (actions.length > 0) {
+                        actions.push(( new Separator()));
+                    }
+                    for (const enablementAction of enablementActions) {
+                        if (isDisposable(enablementAction)) {
+                            disposables.add(enablementAction);
+                        }
+                        actions.push(enablementAction);
+                    }
+                }
             }
-            const disposables = ( new DisposableStore());
-            const showPluginAction = disposables.add(( new Action("mcpServer.showPlugin", ( localize(6071, "Show Plugin")), undefined, true, async () => {
-                const item = {
-                    kind: AgentPluginItemKind.Installed,
-                    name: plugin.label,
-                    description: plugin.fromMarketplace?.description ?? "",
-                    marketplace: plugin.fromMarketplace?.marketplace,
-                    plugin
-                };
-                this._onDidRequestShowPlugin.fire(item);
-            })));
-            const uninstallAction = disposables.add(( new Action("mcpServer.uninstallPlugin", ( localize(6072, "Uninstall Plugin")), undefined, true, async () => {
-                const result = await this.dialogService.confirm({
-                    message: ( localize(6073, "This MCP server is provided by the plugin '{0}'", plugin.label)),
-                    detail: ( localize(
-                        6074,
-                        "Individual MCP servers from a plugin cannot be removed separately. Would you like to uninstall the entire plugin?"
-                    )),
-                    primaryButton: ( localize(6075, "Uninstall Plugin")),
-                    type: "question"
-                });
-                if (result.confirmed) {
-                    plugin.remove?.();
+            if (plugin) {
+                if (actions.length > 0) {
+                    actions.push(( new Separator()));
                 }
-            })));
-            this.contextMenuService.showContextMenu({
-                getAnchor: () => e.anchor,
-                getActions: () => [showPluginAction, uninstallAction],
-                onHide: () => disposables.dispose()
-            });
-            return;
-        }
-        if (e.element.type !== "server-item") {
-            return;
+                actions.push(disposables.add(( new Action("mcpServer.showPlugin", ( localize(6925, "Show Plugin")), undefined, true, async () => {
+                    const item = {
+                        kind: AgentPluginItemKind.Installed,
+                        name: plugin.label,
+                        description: plugin.fromMarketplace?.description ?? "",
+                        marketplace: plugin.fromMarketplace?.marketplace,
+                        plugin
+                    };
+                    this._onDidRequestShowPlugin.fire(item);
+                }))));
+                actions.push(disposables.add(( new Action("mcpServer.uninstallPlugin", ( localize(6926, "Uninstall Plugin")), undefined, true, async () => {
+                    const result = await this.dialogService.confirm({
+                        message: ( localize(6927, "This MCP server is provided by the plugin '{0}'", plugin.label)),
+                        detail: ( localize(
+                            6928,
+                            "Individual MCP servers from a plugin cannot be removed separately. Would you like to uninstall the entire plugin?"
+                        )),
+                        primaryButton: ( localize(6929, "Uninstall Plugin")),
+                        type: "question"
+                    });
+                    if (result.confirmed) {
+                        await plugin.remove?.();
+                    }
+                }))));
+            }
+            return actions;
         }
-        const serverEntry = e.element;
-        const disposables = ( new DisposableStore());
-        const mcpServer = this.mcpWorkbenchService.local.find(local => local.id === serverEntry.server.id) || serverEntry.server;
+        const mcpServer = this.mcpWorkbenchService.local.find(local => local.id === entry.server.id) || entry.server;
         const groups = getContextMenuActions(mcpServer, false, this.instantiationService);
-        const actions = [];
+        const activeSessionServer = entry.activeSessionServer;
+        const activeSessionLifecycleAction = activeSessionServer !== undefined ? getActiveSessionServerLifecycleAction(activeSessionServer) : undefined;
+        const agentHostEnablementActions = activeSessionServer !== undefined ? getAgentHostMcpServerEnablementActions(
+            this.agentHostCustomizationService,
+            this.agentPluginService,
+            this.customizationHarnessService.activeSessionResource.get(),
+            activeSessionServer,
+            ["workspace", "session"]
+        ) : [];
         for (const menuActions of groups) {
             for (const menuAction of menuActions) {
-                actions.push(menuAction);
                 if (isDisposable(menuAction)) {
                     disposables.add(menuAction);
                 }
             }
-            actions.push(( new Separator()));
         }
-        if (actions.length > 0 && actions[actions.length - 1] instanceof Separator) {
-            actions.pop();
+        for (const action of [activeSessionLifecycleAction, ...agentHostEnablementActions]) {
+            if (action && isDisposable(action)) {
+                disposables.add(action);
+            }
         }
-        this.contextMenuService.showContextMenu({
-            getAnchor: () => e.anchor,
-            getActions: () => actions,
-            onHide: () => disposables.dispose()
-        });
+        return getServerItemContextMenuActions(
+            groups,
+            activeSessionServer,
+            activeSessionLifecycleAction,
+            agentHostEnablementActions
+        );
     }
 };
-McpListWidget = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IMcpWorkbenchService)), ( __param(2, IMcpService)), ( __param(3, IMcpRegistry)), ( __param(4, ICommandService)), ( __param(5, IOpenerService)), ( __param(6, IContextViewService)), ( __param(7, IContextMenuService)), ( __param(8, IHoverService)), ( __param(9, IAgentPluginService)), ( __param(10, IDialogService)), ( __param(11, IConfigurationService)), ( __param(12, ICustomizationHarnessService)), ( __param(13, IAgentHostCustomizationService)), ( __param(14, IAICustomizationWorkspaceService))], McpListWidget));
+McpListWidget = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IMcpWorkbenchService)), ( __param(2, IMcpService)), ( __param(3, IMcpRegistry)), ( __param(4, ICommandService)), ( __param(5, IOpenerService)), ( __param(6, IContextViewService)), ( __param(7, IContextMenuService)), ( __param(8, IAgentPluginService)), ( __param(9, IDialogService)), ( __param(10, IConfigurationService)), ( __param(11, ICustomizationHarnessService)), ( __param(12, IAgentHostCustomizationService)), ( __param(13, IAICustomizationWorkspaceService)), ( __param(14, INotificationService)), ( __param(15, IOutputService)), ( __param(16, IMcpGalleryManifestService))], McpListWidget));
 
-export { McpListWidget };
+export { MCP_ERROR_PREVIEW_LENGTH, McpListWidget, McpServerItemRenderer, authenticateMcpServer, createBuiltinActiveSessionMcpEntries, createInstalledMcpServerDetailInput, getActiveSessionServerLifecycleAction, getActiveSessionServerOptionsActions, getActiveSessionServerPresentation, getAgentHostMcpServerEnablementActions, getBuiltinMcpServerEnablementActions, getLocalMcpServerEnablementActions, getMcpErrorPreview, getMcpServerOutputHandler, getMcpStatusPresentation, getMcpStatusRenderSignature, getServerItemContextMenuActions, getToggledMcpEnablementState, hasSameMcpMembership, isMcpServerCollectionVisible, isPrimaryMcpServerEnabled, registerMcpInlineButtonAction, setPrimaryMcpServerEnablement, shouldLoadMcpGallerySnapshot, updateMcpCardRuntimePresentation };