@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -2,29 +2,37 @@
 import { registerCss } from '../../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
-import { $ as $$1, append, DisposableResizeObserver, addDisposableListener, EventType, clearNode, addDisposableGenericMouseDownListener, EventHelper, getWindow, createTextNode, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
-import { Disposable, DisposableStore, MutableDisposable, isDisposable } from '../../../../../base/common/lifecycle.js';
+import './aiCustomizationColors.js';
+import { $ as $$1, append, clearNode, addDisposableListener, EventType, addStandardDisposableListener, addDisposableGenericMouseDownListener, EventHelper, DisposableResizeObserver, getWindow, createTextNode, scheduleAtNextAnimationFrame } from '../../../../../base/browser/dom.js';
+import { renderFormattedText } from '../../../../../base/browser/formattedTextRenderer.js';
+import { Disposable, DisposableStore, toDisposable, MutableDisposable, isDisposable } from '../../../../../base/common/lifecycle.js';
 import { Emitter } from '../../../../../base/common/event.js';
+import { KeyCode } from '../../../../../base/common/keyCodes.js';
 import { localize } from '../../../../../nls.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { RenderIndentGuides } from '../../../../../base/browser/ui/tree/abstractTree.js';
+import { ObjectTreeElementCollapseState } from '../../../../../base/browser/ui/tree/tree.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
 import { Button } from '../../../../../base/browser/ui/button/button.js';
-import { Switch } from '../../../../../base/browser/ui/toggle/switch.js';
-import { getButtonStyles, defaultButtonStyles, defaultInputBoxStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
+import { getButtonStyles, defaultInputBoxStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
 import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { ICustomizationMarketplaceService } from '../../../../../platform/customizationMarketplace/common/customizationMarketplaceService.service.js';
+import { CustomizationMarketplaceConfiguration } from '../../../../../platform/customizationMarketplace/common/customizationMarketplaceSources.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
 import { mcpAccessConfig, McpAccessValue } from '../../../../../platform/mcp/common/mcpManagement.js';
 import { IMcpGalleryManifestService } from '../../../../../platform/mcp/common/mcpGalleryManifest.service.js';
-import { MCP_PLUGIN_COLLECTION_ID_PREFIX, McpConnectionState, McpServerInstallState, McpServerTransportType } from '../../../mcp/common/mcpTypes.js';
+import { MCP_PLUGIN_COLLECTION_ID_PREFIX, McpConnectionState, McpCollectionProvenance, McpCollectionDefinition, McpServerInstallState, McpServerTransportType } from '../../../mcp/common/mcpTypes.js';
 import { IMcpWorkbenchService, IMcpService } from '../../../mcp/common/mcpTypes.service.js';
 import { IMcpRegistry } from '../../../mcp/common/mcpRegistryTypes.service.js';
 import '../../../mcp/common/discovery/pluginMcpDiscovery.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
 import { ContributionEnablementState, isContributionDisabled, isContributionEnabled } from '../../common/enablement.js';
+import { ICustomizationMarketplaceInstallService } from '../../common/customizationMarketplaceInstallService.service.js';
 import { McpCommandIds } from '../../../mcp/common/mcpCommandIds.js';
 import '../../../../../base/common/observableInternal/index.js';
-import { defaultGenerator } from '../../../../../base/common/idGenerator.js';
 import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { isEqual } from '../../../../../base/common/resources.js';
@@ -39,12 +47,15 @@ import { IAgentPluginService } from '../../common/plugins/agentPluginService.ser
 import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
 import { mcpServerIcon } from './aiCustomizationIcons.js';
 import { formatDisplayName } from './aiCustomizationListWidget.js';
+import { MiddleEllipsisPathLabel, truncateToFirstLine } from './aiCustomizationListWidgetUtils.js';
 import { getDefaultHoverDelegate } from '../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
 import { IHoverService } from '../../../../../platform/hover/browser/hover.service.js';
+import { ILogService } from '../../../../../platform/log/common/log.service.js';
 import { IAICustomizationWorkspaceService } from '../../common/aiCustomizationWorkspaceService.service.js';
 import { AgentPluginItemKind } from '../agentPluginEditor/agentPluginItems.js';
 import { getCustomizationDisabledLabel } from '../../common/customizationHarnessService.js';
 import { ICustomizationHarnessService } from '../../common/customizationHarnessService.service.js';
+import { getMcpServerDisplayLabel } from '../agentSessions/agentHost/agentHostCustomizationService.js';
 import { IAgentHostCustomizationService } from '../agentSessions/agentHost/agentHostCustomizationService.service.js';
 import '../../../../../platform/agentHost/common/state/protocol/channels-root/state.js';
 import { McpServerStatus, CustomizationEnablementKind } from '../../../../../platform/agentHost/common/state/protocol/channels-session/state.js';
@@ -55,29 +66,63 @@ import '../../../../../platform/agentHost/common/state/protocol/channels-resourc
 import '../../../../../platform/agentHost/common/state/protocol/channels-automation/state.js';
 import '../../../../../platform/agentHost/common/state/protocol/channels-automation-run/state.js';
 import { IOutputService } from '../../../../services/output/common/output.service.js';
-import { getCustomizationScopeEnablement } from '../../../../../platform/agentHost/common/customizationEnablement.js';
-import { createAgentHostEnablePluginAction } from '../agentPluginActions.js';
+import { ChatConfiguration } from '../../common/constants.js';
+import { runCustomizationMarketplaceInstallWithTelemetry, getAvailableCustomizationMarketplaceInstallTelemetryContext } from '../../common/customizationMarketplaceInstallTelemetry.js';
+import { getCustomizationDisabledReason, getCustomizationScopeEnablement, getCustomizationEnablementDecision } from '../../../../../platform/agentHost/common/customizationEnablement.js';
+import { createAgentHostEnablePluginAction, removePluginWithMarketplaceOwnership } from '../agentPluginActions.js';
 import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
-import { getErrorMessage } from '../../../../../base/common/errors.js';
+import { isCancellationError, getErrorMessage } from '../../../../../base/common/errors.js';
 import { status } from '../../../../../base/browser/ui/aria/aria.js';
 import { Range } from '../../../../../editor/common/core/range.js';
 import { McpServerType } from '../../../../../platform/mcp/common/mcpPlatformTypes.js';
 import { createWorkbenchMcpServerDetailInput } from './embeddedMcpServerDetail.js';
-import { setVirtualizedRowActionsTabbable, createCustomizationCardPrimaryAction, setupCollapsibleSection, CustomizationCardListController, layoutVirtualizedSections, getVirtualizedSectionMinimumHeight, renderVirtualizedSectionLoadingPlaceholder } from './customizationCardList.js';
+import { setVirtualizedRowActionsTabbable, createCustomizationCardPrimaryAction, trackCustomizationCardPrimaryActionFocus, layoutVirtualizedSections, getVirtualizedSectionMinimumHeight } from './customizationCardList.js';
 import { DomScrollableElement } from '../../../../../base/browser/ui/scrollbar/scrollableElement.js';
 import { ScrollbarVisibility } from '../../../../../base/common/scrollable.js';
-import { WorkbenchList } from '../../../../../platform/list/browser/listService.js';
+import { WorkbenchObjectTree } from '../../../../../platform/list/browser/listService.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { ExtensionEditorTab } from '../../../extensions/common/extensions.js';
+import { IExtensionsWorkbenchService } from '../../../extensions/common/extensions.service.js';
+import { getRuntimeServerMatchKeys, getUniqueMcpMatchKeys, isMcpServerInUse, ActiveSessionMcpServerMatcher } from './mcpServerCount.js';
+import { getConnectorActionLabel } from './connectorPresentation.js';
+import { ICopilotConnectorsService } from './copilotConnectorsService.service.js';
+import { CUSTOMIZATION_GROUP_HEADER_HEIGHT, CUSTOMIZATION_GROUP_HEADER_HEIGHT_WITH_SEPARATOR, CustomizationGroupHeaderRenderer } from './customizationGroupHeaderRenderer.js';
+import { asTreeRenderer, customizationTreeStyles, getCustomizationTreeContentHeight } from './customizationTree.js';
+import { CustomizationToggle } from './customizationToggle.js';
+import { affectsCustomizationDiscoveryAvailability, isCustomizationDiscoveryAvailable } from './customizationMarketplaceConfiguration.js';
+import { renderCustomizationMarketplaceIcon } from './aiCustomizationPresentation.js';
+import { getAICustomizationWorkspaceGroups, getAICustomizationWorkspaceGroupForResource, isAICustomizationWorkspaceGroupKey } from './aiCustomizationWorkspaceGroups.js';
+import { IWorkspaceContextService } from '../../../../../platform/workspace/common/workspace.service.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
 import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
 import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
-import { truncateToFirstLine } from './aiCustomizationListWidgetUtils.js';
-import { observableSignal } from '../../../../../base/common/observableInternal/observables/observableSignal.js';
 
 registerCss(aiCustomizationManagement, 1);
 const $ = $$1;
 const PLUGIN_COLLECTION_PREFIX = MCP_PLUGIN_COLLECTION_ID_PREFIX;
-const MCP_SECTION_ITEM_HEIGHT = 66;
-const MCP_ERROR_PREVIEW_LENGTH = 300;
+const MCP_INSTALLED_ITEM_HEIGHT = 44;
+const MCP_MARKETPLACE_ITEM_HEIGHT = 58;
+const MCP_UNINSTALL_ACTION_ID = "extensions.uninstall";
+function getMarketplaceMcpManagementAction(action, serverId, marketplaceInstallService) {
+    const marketplace = marketplaceInstallService.installations.get().findByTarget({
+        kind: "mcp",
+        id: serverId
+    });
+    if (!marketplace || action.id !== MCP_UNINSTALL_ACTION_ID) {
+        return action;
+    }
+    const marketplaceUninstall = ( new Action(
+        action.id,
+        action.label,
+        action.class,
+        action.enabled,
+        () => marketplaceInstallService.uninstall(marketplace.resource)
+    ));
+    marketplaceUninstall.tooltip = action.tooltip;
+    marketplaceUninstall.checked = action.checked;
+    return marketplaceUninstall;
+}
 const COPILOT_EXTENSION_IDS = ["github.copilot", "github.copilot-chat"];
 function isCopilotExtension(id) {
     return ( COPILOT_EXTENSION_IDS.some(copilotId => ExtensionIdentifier.equals(id, copilotId)));
@@ -85,6 +130,15 @@ function isCopilotExtension(id) {
 function getPluginUriFromCollectionId(collectionId) {
     return collectionId?.startsWith(PLUGIN_COLLECTION_PREFIX) ? collectionId.slice(PLUGIN_COLLECTION_PREFIX.length) : undefined;
 }
+function createInstalledPluginItem(plugin) {
+    return {
+        kind: AgentPluginItemKind.Installed,
+        name: plugin.label,
+        description: plugin.fromMarketplace?.description ?? "",
+        marketplace: plugin.fromMarketplace?.marketplace,
+        plugin
+    };
+}
 function createBuiltinActiveSessionMcpEntries(servers) {
     return servers.map(server => ({
         type: "session-server-item",
@@ -94,16 +148,58 @@ function createBuiltinActiveSessionMcpEntries(servers) {
 function isMcpServerCollectionVisible(collectionId, hiddenCollectionIds) {
     return !hiddenCollectionIds?.includes(collectionId);
 }
+function hasMcpInstalledEntryIcon(entry) {
+    return getMcpInstalledEntryIcon(entry) !== undefined;
+}
+function getMcpInstalledEntryIcon(entry) {
+    if (entry.type === "connector-item") {
+        return entry.connector.connector.icon;
+    }
+    if (entry.type === "provider-item") {
+        return entry.marketplaceRecord.resource.icon;
+    }
+    if (entry.type !== "server-item") {
+        return undefined;
+    }
+    if (entry.marketplaceRecord?.resource.icon) {
+        return entry.marketplaceRecord.resource.icon;
+    }
+    const icon = entry.server.icon;
+    return icon ? {
+        light: ( URI.parse(icon.light)),
+        dark: ( URI.parse(icon.dark))
+    } : undefined;
+}
 class McpSectionDelegate {
-    getHeight() {
-        return MCP_SECTION_ITEM_HEIGHT;
+    constructor(getInstalledHeight) {
+        this.getInstalledHeight = getInstalledHeight;
+    }
+    getHeight(element) {
+        if (element.type === "group-header") {
+            return element.isFirst ? CUSTOMIZATION_GROUP_HEADER_HEIGHT : CUSTOMIZATION_GROUP_HEADER_HEIGHT_WITH_SEPARATOR;
+        }
+        return element.type === "marketplace-item" ? MCP_MARKETPLACE_ITEM_HEIGHT : this.getInstalledHeight(element);
     }
     getTemplateId(element) {
+        if (element.type === "group-header") {
+            return "mcpGroupHeader";
+        }
         return element.type === "marketplace-item" ? "mcpMarketplaceItem" : "mcpServerItem";
     }
-    hasDynamicHeight(element) {
-        return element.type !== "marketplace-item";
-    }
+}
+function preserveMcpEntryOrder(entries, order) {
+    let nextOrder = order.size;
+    for (const {
+        entry
+    } of entries) {
+        const key = getMcpRowKey(entry);
+        if (!( order.has(key))) {
+            order.set(key, nextOrder++);
+        }
+    }
+    return [...entries].sort(
+        (left, right) => order.get(getMcpRowKey(left.entry)) - order.get(getMcpRowKey(right.entry))
+    );
 }
 function getToggledMcpEnablementState(state) {
     switch (state) {
@@ -120,137 +216,104 @@ function getToggledMcpEnablementState(state) {
 let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
     constructor(
         _renderManagementActions,
+        _getCompatibilityKind,
+        _openPlugin,
+        _openMigrations,
         workspaceService,
         agentPluginService,
         hoverService,
         agentHostCustomizationService,
-        customizationHarnessService
+        customizationHarnessService,
+        labelService,
+        extensionsWorkbenchService,
+        themeService
     ) {
         super();
         this._renderManagementActions = _renderManagementActions;
+        this._getCompatibilityKind = _getCompatibilityKind;
+        this._openPlugin = _openPlugin;
+        this._openMigrations = _openMigrations;
         this.workspaceService = workspaceService;
         this.agentPluginService = agentPluginService;
         this.hoverService = hoverService;
         this.agentHostCustomizationService = agentHostCustomizationService;
         this.customizationHarnessService = customizationHarnessService;
+        this.labelService = labelService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.themeService = themeService;
         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);
+        this._register(this.themeService.onDidColorThemeChange(() => {
+            for (const template of this._templates) {
+                if (template.currentElement) {
+                    this.renderIcon(template.currentElement, template);
+                }
             }
-        }
-        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));
+        container.style.minHeight = `${MCP_INSTALLED_ITEM_HEIGHT}px`;
+        const icon = append(container, $(".mcp-server-icon"));
+        const iconDisposables = templateDisposables.add(( new DisposableStore()));
         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 secondaryLine = append(details, $(".mcp-server-secondary-line"));
+        const compatibilityMessage = append(secondaryLine, $(".mcp-server-compatibility-message"));
+        const compatibilityMessageDisposables = templateDisposables.add(( new DisposableStore()));
+        const sourcePath = append(secondaryLine, $("a.mcp-server-source-path"));
+        const sourcePathLabel = templateDisposables.add(( new MiddleEllipsisPathLabel(sourcePath)));
+        const sourcePathHover = templateDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), sourcePath, "")
+        );
         const description = append(details, $(".mcp-server-description"));
-        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 issue = append(details, $(".mcp-server-issue"));
+        const issueHover = templateDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), issue, "")
+        );
         const actions = append(container, $(".mcp-server-actions"));
         const template = {
             container,
-            typeIcon,
+            icon,
+            iconDisposables,
             name,
-            statusBadge,
+            secondaryLine,
+            compatibilityMessage,
+            compatibilityMessageDisposables,
+            sourcePath,
+            sourcePathLabel,
+            sourcePathHover,
             description,
             descriptionHover,
-            expandButton,
+            issue,
+            issueHover,
             actions,
             templateDisposables,
             elementDisposables: ( new DisposableStore()),
-            actionDisposables: ( new DisposableStore()),
-            currentIndex: -1,
-            isRendering: false,
-            isExpanded: false,
-            isClipped: false
+            actionDisposables: ( new DisposableStore())
         };
-        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.isRendering = true;
-        try {
-            this.renderEntry(element, index, templateData);
-        } finally {
-            templateData.isRendering = false;
-        }
+    renderElement(element, _index, templateData) {
+        this.renderEntry(element, templateData);
+    }
+    renderIcon(element, templateData) {
+        templateData.iconDisposables.clear();
+        renderCustomizationMarketplaceIcon(
+            templateData.icon,
+            mcpServerIcon,
+            getMcpInstalledEntryIcon(element),
+            this.themeService.getColorTheme().type,
+            templateData.iconDisposables
+        );
     }
-    renderEntry(element, index, templateData) {
-        templateData.currentIndex = index;
+    renderEntry(element, templateData) {
         templateData.currentElement = element;
         const rowKey = getMcpRowKey(element);
         if (templateData.renderedRowKey !== rowKey) {
@@ -260,17 +323,75 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
             clearNode(templateData.actions);
         }
         templateData.elementDisposables.clear();
+        this.renderIcon(element, templateData);
+        const source = getMcpEntrySource(
+            element,
+            this.labelService,
+            this.agentPluginService,
+            this.extensionsWorkbenchService,
+            this._openPlugin
+        );
+        if (source) {
+            templateData.secondaryLine.classList.add("has-source");
+            templateData.sourcePathLabel.set(source.label);
+            templateData.sourcePath.style.display = "";
+            templateData.sourcePathHover.update(source.hover);
+            templateData.sourcePath.classList.toggle("source-link", source.open !== undefined);
+            if (source.open && source.ariaLabel) {
+                templateData.sourcePath.setAttribute("href", "#");
+                templateData.sourcePath.setAttribute("aria-label", source.ariaLabel);
+                templateData.elementDisposables.add(addDisposableListener(
+                    templateData.sourcePath,
+                    EventType.MOUSE_DOWN,
+                    event => event.stopPropagation()
+                ));
+                templateData.elementDisposables.add(
+                    addStandardDisposableListener(templateData.sourcePath, EventType.KEY_DOWN, event => {
+                        if (event.keyCode === KeyCode.Enter) {
+                            event.stopPropagation();
+                        }
+                    })
+                );
+                templateData.elementDisposables.add(
+                    addDisposableListener(templateData.sourcePath, EventType.CLICK, event => {
+                        event.preventDefault();
+                        event.stopPropagation();
+                        source.open?.();
+                    })
+                );
+            } else {
+                templateData.sourcePath.removeAttribute("href");
+                templateData.sourcePath.removeAttribute("aria-label");
+            }
+        } else {
+            templateData.secondaryLine.classList.remove("has-source");
+            templateData.sourcePathLabel.set("");
+            templateData.sourcePath.style.display = "none";
+            templateData.sourcePathHover.update("");
+            templateData.sourcePath.classList.remove("source-link");
+            templateData.sourcePath.removeAttribute("href");
+            templateData.sourcePath.removeAttribute("aria-label");
+        }
+        templateData.sourcePath.tabIndex = source?.open && rowKey === this._focusedRowKey ? 0 : -1;
+        this.renderDescription(templateData, element, !!source);
+        if (element.type === "provider-item") {
+            templateData.container.classList.remove("builtin");
+            templateData.container.classList.add("has-detail");
+            templateData.name.textContent = formatDisplayName(element.label);
+            this.updateStatus(templateData, element, element, undefined, undefined);
+            return;
+        }
+        if (element.type === "connector-item") {
+            templateData.container.classList.remove("builtin");
+            templateData.container.classList.add("has-detail");
+            templateData.name.textContent = formatDisplayName(element.label);
+            this.updateKnownServerStatus(templateData, element);
+            return;
+        }
         if (element.type === "builtin-item") {
             templateData.container.classList.add("builtin");
             templateData.container.classList.toggle("has-detail", false);
             templateData.name.textContent = formatDisplayName(element.label);
-            if (element.description) {
-                templateData.description.textContent = truncateToFirstLine(element.description);
-                templateData.description.style.display = "";
-            } else {
-                templateData.description.textContent = "";
-                templateData.description.style.display = "none";
-            }
             this.updateKnownServerStatus(templateData, element);
             const pluginUriStr = getPluginUriFromCollectionId(element.collectionId);
             if (pluginUriStr) {
@@ -278,7 +399,7 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
                     const plugin = this.agentPluginService.plugins.get().find(p => ( p.uri.toString()) === pluginUriStr);
                     if (plugin) {
                         return {
-                            content: `${element.label}\n${( localize(9102, "Plugin: {0}", plugin.label))}`,
+                            content: `${element.label}\n${( localize(11035, "Plugin: {0}", plugin.label))}`,
                             appearance: {
                                 compact: true,
                                 skipFadeInAnimation: true
@@ -299,9 +420,7 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
         if (element.type === "session-server-item") {
             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";
+            templateData.name.textContent = formatDisplayName(getMcpServerDisplayLabel(element.server));
             this.updateActiveSessionStatus(templateData, element);
             return;
         }
@@ -311,13 +430,6 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
         const isGallery = !element.server.local;
         const hasDetail = !!description || isGallery;
         templateData.container.classList.toggle("has-detail", hasDetail);
-        if (description) {
-            templateData.description.textContent = truncateToFirstLine(description);
-            templateData.description.style.display = "";
-        } else {
-            templateData.description.textContent = "";
-            templateData.description.style.display = "none";
-        }
         if (element.activeSessionServer !== undefined) {
             this.updateKnownServerStatus(templateData, element);
         } else if (this.workspaceService.isSessionsWindow) {
@@ -332,8 +444,7 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
                     element,
                     element,
                     disabled ? "disabled" : connectionState?.state,
-                    undefined,
-                    connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined
+                    this._getCompatibilityKind(element, reader)
                 );
             }));
         }
@@ -341,13 +452,14 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
     updateKnownServerStatus(templateData, element) {
         let localDisabled = false;
         let connectionState;
-        const update = () => {
+        const update = reader => {
             const currentEntry = resolveMcpEntry(
                 element,
                 this.agentHostCustomizationService,
                 this.customizationHarnessService.activeSessionResource.get()
             );
             const activeSessionServer = currentEntry && getActiveSessionServer(currentEntry);
+            const compatibilityKind = this._getCompatibilityKind(element, reader);
             if (element.activeSessionServer !== undefined) {
                 const presentation = activeSessionServer && getActiveSessionServerPresentation(activeSessionServer);
                 templateData.container.classList.toggle("disabled", presentation?.enabled === false);
@@ -356,32 +468,33 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
                     element,
                     currentEntry,
                     presentation?.status,
-                    presentation?.enabled ? undefined : activeSessionServer?.disabledReason,
-                    activeSessionServer?.state?.kind === McpServerStatus.Error ? activeSessionServer.state.error?.message : undefined
+                    compatibilityKind,
+                    presentation?.enabled ? undefined : activeSessionServer?.disabledReason
                 );
                 return;
             }
             templateData.container.classList.toggle("disabled", localDisabled);
-            const localError = !this.workspaceService.isSessionsWindow && connectionState?.state === McpConnectionState.Kind.Error ? connectionState : undefined;
+            const localState = !this.workspaceService.isSessionsWindow ? connectionState?.state : undefined;
             this.updateStatus(
                 templateData,
                 element,
                 currentEntry,
-                localDisabled ? "disabled" : localError?.state,
-                undefined,
-                localError?.message
+                localDisabled ? "disabled" : localState,
+                compatibilityKind
             );
         };
         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();
+            update(reader);
         }));
-        templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
+        templateData.elementDisposables.add(
+            this.agentHostCustomizationService.onDidChangeCustomizations(() => update())
+        );
     }
     updateActiveSessionStatus(templateData, element) {
-        const update = () => {
+        const update = reader => {
             const currentEntry = resolveMcpEntry(
                 element,
                 this.agentHostCustomizationService,
@@ -395,32 +508,43 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
                 element,
                 currentEntry,
                 presentation?.status,
-                server?.disabledReason,
-                server?.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined
+                this._getCompatibilityKind(element, reader),
+                server?.disabledReason
             );
         };
         templateData.elementDisposables.add(autorun(reader => {
             this.customizationHarnessService.activeSessionResource.read(reader);
-            update();
+            update(reader);
         }));
-        templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
+        templateData.elementDisposables.add(
+            this.agentHostCustomizationService.onDidChangeCustomizations(() => update())
+        );
     }
-    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";
+    updateStatus(
+        templateData,
+        element,
+        currentEntry,
+        state,
+        compatibilityKind,
+        disabledReason
+    ) {
+        const isError = state === McpServerStatus.Error || state === McpConnectionState.Kind.Error;
+        templateData.compatibilityLink = updateMcpCompatibilityMessage(
+            templateData.compatibilityMessage,
+            compatibilityKind,
+            templateData.compatibilityMessageDisposables,
+            this._openMigrations
+        );
+        this.updateActionsTabbability(templateData);
+        if (isError) {
+            templateData.compatibilityMessage.style.display = "none";
         }
+        const presentation = getMcpStatusPresentation(state, disabledReason);
         const activeSessionServer = currentEntry && getActiveSessionServer(currentEntry);
+        templateData.issue.textContent = "";
+        templateData.issue.style.display = "none";
+        templateData.issueHover.update("");
+        templateData.description.style.display = compatibilityKind && compatibilityKind !== "supported" ? "none" : templateData.description.textContent ? "" : "none";
         const label = getMcpEntryLabel(currentEntry ?? element);
         const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
         const localServer = element.type === "session-server-item" ? undefined : element.localServer;
@@ -431,6 +555,7 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
             statusLabel: presentation?.label,
             statusClassName: presentation?.className,
             statusIconId: presentation?.icon?.id,
+            compatibilityKind,
             activeSessionServerId: activeSessionServer?.id,
             logOutputChannelId: activeSessionServer?.logOutputChannelId,
             localServerId: localServer?.definition.id,
@@ -446,47 +571,23 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
             return;
         }
         const getEntry = () => resolveMcpEntry(currentEntry, this.agentHostCustomizationService, activeSessionResource);
-        if (!presentation) {
-            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;
+        renderMcpServerStatusActions(templateData.actions, templateData.actionDisposables, this.hoverService, {
+            label,
+            state,
+            signIn: activeSessionServer ? () => authenticateMcpServer(
+                this.agentHostCustomizationService,
+                activeSessionResource,
+                activeSessionServer.id
+            ) : undefined,
+            start: async () => {
+                const entry = getEntry();
+                if (entry) {
+                    await startMcpEntry(entry);
                 }
-            });
-        }
-        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)
-        );
+            },
+            statusHover: presentation?.label,
+            updateTabbability: () => this.updateActionsTabbability(templateData)
+        });
         this._renderManagementActions(
             getEntry,
             templateData.actions,
@@ -495,81 +596,37 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
         );
         this.updateActionsTabbability(templateData);
     }
-    setFocusedIndex(index) {
-        this._focusedIndex = index;
+    setFocusedRowKey(rowKey) {
+        this._focusedRowKey = rowKey;
         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
-            });
+        const focused = templateData.currentElement !== undefined && getMcpRowKey(templateData.currentElement) === this._focusedRowKey;
+        setVirtualizedRowActionsTabbable(templateData.actions, focused);
+        templateData.sourcePath.tabIndex = templateData.sourcePath.classList.contains("source-link") && focused ? 0 : -1;
+        if (templateData.compatibilityLink) {
+            templateData.compatibilityLink.tabIndex = focused ? 0 : -1;
         }
     }
-    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);
+    renderDescription(template, element, hasSource) {
+        const description = hasSource || element.type === "session-server-item" ? "" : element.type === "builtin-item" || element.type === "connector-item" || element.type === "provider-item" ? element.description : element.server.description?.trim() ?? "";
+        template.description.textContent = truncateToFirstLine(description);
         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;
-        }
-        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(9103, "Show Less")) : ( localize(9104, "Show More"));
-        template.expandButton.element.setAttribute("aria-expanded", String(template.isExpanded));
-        this.updateActionsTabbability(template);
+        template.descriptionHover.update(description);
     }
     disposeElement(_element, _index, templateData) {
         templateData.elementDisposables.clear();
+        templateData.sourcePathHover.hide();
+        templateData.sourcePathHover.update("");
+        templateData.sourcePathLabel.set("");
         templateData.descriptionHover.hide();
         templateData.descriptionHover.update("");
+        templateData.issueHover.hide();
+        templateData.issueHover.update("");
         templateData.description.textContent = "";
-        templateData.renderedDescription = undefined;
         templateData.currentElement = undefined;
-        templateData.currentError = undefined;
-        templateData.isClipped = false;
-        templateData.currentIndex = -1;
     }
     disposeTemplate(templateData) {
         this._templates.delete(templateData);
@@ -577,18 +634,13 @@ let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
         templateData.elementDisposables.dispose();
         templateData.actionDisposables.dispose();
     }
-    dispose() {
-        this.expandedErrors.clear();
-        super.dispose();
-    }
 };
-McpServerItemRenderer = ( __decorate([( __param(1, IAICustomizationWorkspaceService)), ( __param(2, IAgentPluginService)), ( __param(3, IHoverService)), ( __param(4, IAgentHostCustomizationService)), ( __param(5, ICustomizationHarnessService))], McpServerItemRenderer));
+McpServerItemRenderer = ( __decorate([( __param(4, IAICustomizationWorkspaceService)), ( __param(5, IAgentPluginService)), ( __param(6, IHoverService)), ( __param(7, IAgentHostCustomizationService)), ( __param(8, ICustomizationHarnessService)), ( __param(9, ILabelService)), ( __param(10, IExtensionsWorkbenchService)), ( __param(11, IThemeService))], 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");
@@ -599,7 +651,12 @@ class McpMarketplaceItemRenderer {
         );
         const description = append(details, $(".plugin-list-item-description"));
         const actionContainer = append(container, $(".plugin-list-item-action"));
-        const installButton = ( new Button(actionContainer, defaultButtonStyles));
+        const installButton = ( new Button(actionContainer, {
+            ...getButtonStyles({
+                buttonSecondaryHoverBackground: undefined
+            }),
+            secondary: true
+        }));
         installButton.element.classList.add("plugin-list-item-install-button");
         const templateDisposables = ( new DisposableStore());
         templateDisposables.add(installButton);
@@ -613,32 +670,33 @@ class McpMarketplaceItemRenderer {
             installButton,
             elementDisposables: ( new DisposableStore()),
             templateDisposables,
-            currentIndex: -1
+            currentServerId: undefined
         };
         this._templates.add(template);
         return template;
     }
-    renderElement(element, index, templateData) {
+    renderElement(element, _index, templateData) {
         templateData.elementDisposables.clear();
-        templateData.currentIndex = index;
+        templateData.currentServerId = element.server.id;
         templateData.name.textContent = element.server.label;
-        templateData.description.textContent = truncateToFirstLine(element.server.description || ( localize(9105, "No description provided.")));
-        templateData.installButton.label = ( localize(9106, "Install"));
+        templateData.description.textContent = truncateToFirstLine(element.server.description || ( localize(11036, "No description provided.")));
+        templateData.installButton.label = ( localize(11037, "Install"));
         templateData.installButton.enabled = true;
-        templateData.installButton.element.tabIndex = index === this._focusedIndex ? 0 : -1;
+        templateData.installButton.element.tabIndex = element.server.id === this._focusedServerId ? 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;
+    setFocusedServerId(serverId) {
+        this._focusedServerId = serverId;
         for (const template of this._templates) {
-            template.installButton.element.tabIndex = template.currentIndex === index ? 0 : -1;
+            template.installButton.element.tabIndex = template.currentServerId === serverId ? 0 : -1;
         }
     }
     disposeElement(_element, _index, templateData) {
         templateData.elementDisposables.clear();
+        templateData.currentServerId = undefined;
     }
     disposeTemplate(templateData) {
         this._templates.delete(templateData);
@@ -647,18 +705,102 @@ class McpMarketplaceItemRenderer {
     }
 }
 function createMcpSignInButton(parent, store, serverLabel) {
-    const signInLabel = ( localize(9107, "Sign in to {0}", serverLabel));
+    const signInLabel = ( localize(11038, "Sign in to {0}", serverLabel));
     const signInButton = store.add(( new Button(parent, {
-        ...defaultButtonStyles,
+        ...getButtonStyles({
+            buttonSecondaryHoverBackground: undefined
+        }),
         secondary: true,
         small: true,
         title: signInLabel,
-        ariaLabel: signInLabel
+        ariaLabel: signInLabel,
+        supportIcons: true
     })));
-    signInButton.label = ( localize(9108, "Sign In"));
+    signInButton.label = ( localize(11039, "Sign In"));
     signInButton.element.classList.add("mcp-server-sign-in");
     return signInButton;
 }
+function createMcpStartButton(parent, store, serverLabel) {
+    const startLabel = ( localize(11040, "Start {0}", serverLabel));
+    const startButton = store.add(( new Button(parent, {
+        ...getButtonStyles({
+            buttonSecondaryHoverBackground: undefined
+        }),
+        secondary: true,
+        small: true,
+        title: startLabel,
+        ariaLabel: startLabel
+    })));
+    startButton.label = ( localize(11041, "Start"));
+    startButton.element.classList.add("mcp-server-start");
+    return startButton;
+}
+function createMcpShowOutputButton(parent, store, serverLabel) {
+    const showOutputLabel = ( localize(11042, "Show output for {0}", serverLabel));
+    const showOutputButton = store.add(( new Button(parent, {
+        ...getButtonStyles({
+            buttonSecondaryHoverBackground: undefined
+        }),
+        secondary: true,
+        small: true,
+        title: showOutputLabel,
+        ariaLabel: showOutputLabel
+    })));
+    showOutputButton.label = ( localize(11043, "Show Output"));
+    showOutputButton.element.classList.add("mcp-server-show-output");
+    return showOutputButton;
+}
+async function startMcpEntry(entry) {
+    const activeSessionServer = getActiveSessionServer(entry);
+    if (activeSessionServer) {
+        await activeSessionServer.start();
+        return;
+    }
+    if (entry.type !== "session-server-item" && entry.localServer) {
+        await entry.localServer.start({
+            promptType: "all-untrusted"
+        });
+    }
+}
+function registerMcpSignInButtonAction(store, button, serverLabel, action, options) {
+    const signingInLabel = ( localize(11044, "Signing In..."));
+    const signingInAriaLabel = ( localize(11045, "Signing in to {0}", serverLabel));
+    let pending = false;
+    let disposed = false;
+    store.add(toDisposable(() => disposed = true));
+    registerMcpInlineButtonAction(store, button, async () => {
+        if (pending) {
+            return;
+        }
+        pending = true;
+        const wasEnabled = button.enabled;
+        button.label = `$(${Codicon.loading.id}) ${signingInLabel}`;
+        button.setTitle(signingInAriaLabel);
+        button.setAriaLabel(signingInAriaLabel);
+        button.element.setAttribute("aria-busy", "true");
+        button.enabled = false;
+        status(( localize(11046, "Signing in to {0}.", serverLabel)));
+        try {
+            await action();
+        } finally {
+            if (!disposed) {
+                pending = false;
+                const tabIndex = button.element.tabIndex;
+                resetMcpSignInButton(button, serverLabel, wasEnabled);
+                button.element.tabIndex = tabIndex;
+                options?.updateTabbability?.();
+            }
+        }
+    });
+}
+function resetMcpSignInButton(button, serverLabel, enabled) {
+    const signInAriaLabel = ( localize(11038, "Sign in to {0}", serverLabel));
+    button.label = ( localize(11039, "Sign In"));
+    button.setTitle(signInAriaLabel);
+    button.setAriaLabel(signInAriaLabel);
+    button.element.removeAttribute("aria-busy");
+    button.enabled = enabled;
+}
 function registerMcpInlineButtonAction(store, button, action) {
     store.add(
         addDisposableGenericMouseDownListener(button.element, event => EventHelper.stop(event, true))
@@ -668,6 +810,70 @@ function registerMcpInlineButtonAction(store, button, action) {
         void action();
     }));
 }
+function renderMcpServerStatusActions(container, store, hoverService, options) {
+    const {
+        label,
+        state,
+        signIn,
+        start,
+        openStatus
+    } = options;
+    if (state === McpServerStatus.AuthRequired && signIn) {
+        const signInButton = createMcpSignInButton(container, store, label);
+        signInButton.element.tabIndex = -1;
+        registerMcpSignInButtonAction(store, signInButton, label, signIn, options);
+    }
+    if ((state === McpServerStatus.Stopped || state === McpConnectionState.Kind.Stopped) && start) {
+        const startButton = createMcpStartButton(container, store, label);
+        startButton.element.tabIndex = -1;
+        let disposed = false;
+        store.add(toDisposable(() => disposed = true));
+        registerMcpInlineButtonAction(store, startButton, async () => {
+            if (!startButton.enabled) {
+                return;
+            }
+            const tabIndex = startButton.element.tabIndex;
+            startButton.enabled = false;
+            try {
+                await start();
+            } finally {
+                if (!disposed) {
+                    startButton.enabled = true;
+                    startButton.element.tabIndex = tabIndex;
+                    options.updateTabbability?.();
+                }
+            }
+        });
+    }
+    const presentation = getMcpStatusPresentation(state);
+    if (presentation?.icon) {
+        const isError = state === McpServerStatus.Error || state === McpConnectionState.Kind.Error;
+        const statusContainer = isError ? append(container, $(".mcp-server-error-actions")) : container;
+        const statusElement = append(statusContainer, $(
+            openStatus ? "button.mcp-server-status.mcp-server-state-icon.mcp-server-status-action" : ".mcp-server-status.mcp-server-state-icon"
+        ));
+        statusElement.classList.add(presentation.className, ...ThemeIcon.asClassNameArray(presentation.icon));
+        if (openStatus) {
+            statusElement.setAttribute("type", "button");
+            statusElement.setAttribute("aria-label", ( localize(11047, "Show details for {0}", label)));
+            statusElement.tabIndex = -1;
+            store.add(
+                addDisposableGenericMouseDownListener(statusElement, event => EventHelper.stop(event, true))
+            );
+            store.add(addDisposableListener(statusElement, EventType.CLICK, event => {
+                EventHelper.stop(event, true);
+                openStatus();
+            }));
+        } else {
+            statusElement.setAttribute("aria-hidden", "true");
+        }
+        store.add(hoverService.setupManagedHover(
+            getDefaultHoverDelegate("element"),
+            statusElement,
+            options.statusHover ?? presentation.label
+        ));
+    }
+}
 function authenticateMcpServer(agentHostCustomizationService, sessionResource, serverId) {
     return agentHostCustomizationService.authenticateMcpServer(sessionResource, serverId);
 }
@@ -696,42 +902,103 @@ function getMcpServerOutputHandler(
     }
     return undefined;
 }
+function getMcpCompatibilityPresentation(kind) {
+    switch (kind) {
+    case "partiallySupported":
+        return {
+            label: ( localize(11048, "Partially supported")),
+            className: "partially-supported"
+        };
+    case "unsupported":
+        return {
+            label: ( localize(11049, "Unsupported")),
+            className: "unsupported"
+        };
+    case "unknown":
+        return {
+            label: ( localize(11050, "Support unknown")),
+            className: "support-unknown"
+        };
+    case "supported":
+    case undefined:
+        return undefined;
+    }
+}
+function updateMcpCompatibilityMessage(message, kind, disposables, openMigrations) {
+    const presentation = getMcpCompatibilityPresentation(kind);
+    disposables.clear();
+    message.className = "mcp-server-compatibility-message";
+    message.style.display = presentation ? "" : "none";
+    clearNode(message);
+    if (!presentation) {
+        return undefined;
+    }
+    message.classList.add(presentation.className);
+    renderFormattedText(( localize(11051, "{0}. See [[Migrations]] for details.", presentation.label)), {
+        actionHandler: {
+            callback: (_content, event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                openMigrations();
+            },
+            disposables
+        }
+    }, message);
+    const migrationLink = message.firstElementChild;
+    const iconTheme = kind === "unsupported" ? Codicon.error : Codicon.warning;
+    const icon = $("span.mcp-server-compatibility-icon");
+    icon.classList.add(...ThemeIcon.asClassNameArray(iconTheme));
+    icon.setAttribute("aria-hidden", "true");
+    message.insertBefore(icon, message.firstChild);
+    if (migrationLink) {
+        migrationLink.href = "#";
+        migrationLink.tabIndex = -1;
+        migrationLink.classList.add("mcp-server-compatibility-link");
+        disposables.add(
+            addDisposableListener(migrationLink, EventType.MOUSE_DOWN, event => event.stopPropagation())
+        );
+    }
+    return migrationLink ?? undefined;
+}
 function getMcpStatusPresentation(state, disabledReason) {
     if (state === undefined) {
         return undefined;
     }
     if (state === "disabled") {
         return {
-            label: getCustomizationDisabledLabel(disabledReason),
-            className: "disabled",
-            icon: Codicon.circleSlash
+            label: getMcpDisabledLabel(disabledReason),
+            className: "disabled"
         };
     }
     switch (state) {
     case McpConnectionState.Kind.Running:
     case McpServerStatus.Ready:
         return {
-            label: ( localize(9109, "Running")),
-            className: "running",
-            icon: Codicon.check
+            label: ( localize(11052, "Running")),
+            className: "running"
         };
     case McpConnectionState.Kind.Starting:
     case McpServerStatus.Starting:
         return {
-            label: ( localize(9110, "Starting")),
+            label: ( localize(11053, "Starting")),
+            className: "starting",
+            icon: ThemeIcon.modify(Codicon.loading, "spin")
+        };
+    case "authenticating":
+        return {
+            label: ( localize(11054, "Authenticating")),
             className: "starting",
             icon: ThemeIcon.modify(Codicon.loading, "spin")
         };
     case McpServerStatus.AuthRequired:
         return {
-            label: ( localize(9111, "Authentication required")),
-            className: "auth-required",
-            icon: Codicon.account
+            label: ( localize(11055, "Authentication required")),
+            className: "auth-required"
         };
     case McpConnectionState.Kind.Error:
     case McpServerStatus.Error:
         return {
-            label: ( localize(9112, "Error")),
+            label: ( localize(11056, "Error")),
             className: "error",
             icon: Codicon.error
         };
@@ -739,35 +1006,47 @@ function getMcpStatusPresentation(state, disabledReason) {
     case McpServerStatus.Stopped:
     default:
         return {
-            label: ( localize(9113, "Stopped")),
+            label: ( localize(11057, "Stopped")),
             className: "stopped"
         };
     }
 }
+function getMcpDisabledLabel(reason) {
+    if (reason?.source === "scope" && reason.scope !== CustomizationEnablementKind.Global) {
+        return getCustomizationDisabledLabel(reason);
+    }
+    if (reason?.source === "plugin") {
+        return getCustomizationDisabledLabel(reason);
+    }
+    return localize(11058, "Disabled (Globally)");
+}
+function getMcpEntryErrorMessage(entry) {
+    const activeSessionServer = getActiveSessionServer(entry);
+    if (activeSessionServer) {
+        return getMcpErrorMessage(
+            activeSessionServer.status,
+            activeSessionServer.state?.kind === McpServerStatus.Error ? activeSessionServer.state.error?.message : undefined
+        );
+    }
+    const connectionState = entry.type === "session-server-item" ? undefined : entry.localServer?.connectionState.get();
+    return getMcpErrorMessage(
+        connectionState?.state,
+        connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined
+    );
+}
 function getMcpErrorMessage(state, message) {
     if (state !== McpServerStatus.Error && state !== McpConnectionState.Kind.Error) {
         return undefined;
     }
-    return message && /\S/u.test(message) ? message : ( localize(9114, "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
-    };
+    return message && /\S/u.test(message) ? message : ( localize(11059, "The server reported an error without additional details."));
 }
 function getActiveSessionServer(entry) {
     return entry.type === "session-server-item" ? entry.server : entry.activeSessionServer;
 }
 function resolveMcpEntry(entry, customizations, sessionResource) {
+    if (entry.type === "provider-item") {
+        return entry;
+    }
     const activeSessionServer = getActiveSessionServer(entry);
     if (!activeSessionServer) {
         return entry;
@@ -789,8 +1068,49 @@ function getMcpRowKey(entry) {
         return `session:${entry.server.id}`;
     case "builtin-item":
         return `builtin:${entry.id}`;
+    case "connector-item":
+        return `connector:${entry.id}`;
+    case "provider-item":
+        return `provider:${entry.id}`;
     }
 }
+function getMcpEntryGroup(entry) {
+    if (entry.type === "provider-item") {
+        return "user";
+    }
+    if (entry.type === "server-item") {
+        return entry.server.local?.scope === LocalMcpServerScope.Workspace ? "workspace" : "user";
+    }
+    if (entry.type === "connector-item") {
+        return "plugins";
+    }
+    if (entry.type === "builtin-item") {
+        if (entry.collectionId?.startsWith(PLUGIN_COLLECTION_PREFIX)) {
+            return "plugins";
+        }
+        if (entry.extensionId) {
+            return isCopilotExtension(entry.extensionId) ? "builtin" : "extensions";
+        }
+        const collection = entry.localServer?.readDefinitions().get().collection;
+        if (collection?.provenance === McpCollectionProvenance.ExternalConfiguration) {
+            return McpCollectionDefinition.isWorkspaceDiscovered(collection) ? "workspace" : "user";
+        }
+    }
+    const activeSessionServer = getActiveSessionServer(entry);
+    switch (activeSessionServer?.source) {
+    case "user":
+        return "user";
+    case "workspace":
+        return "workspace";
+    case "plugin":
+        return "plugins";
+    case undefined:
+        if (activeSessionServer?.hostConfiguration) {
+            return "user";
+        }
+    }
+    return "builtin";
+}
 function getMcpStatusRenderSignature(input) {
     return JSON.stringify([
         input.rowKey,
@@ -799,14 +1119,208 @@ function getMcpStatusRenderSignature(input) {
         input.statusLabel ?? null,
         input.statusClassName ?? null,
         input.statusIconId ?? null,
+        input.compatibilityKind ?? 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 getMcpEntryLabel(element) {
+    switch (element.type) {
+    case "server-item":
+        return element.server.label;
+    case "session-server-item":
+        return getMcpServerDisplayLabel(element.server);
+    case "builtin-item":
+    case "connector-item":
+    case "provider-item":
+        return element.label;
+    }
+}
+function getMcpEntryName(element) {
+    return element.type === "session-server-item" ? element.server.name : element.type === "provider-item" ? element.name : getMcpEntryLabel(element);
+}
+function getMcpEntrySourceUri(element) {
+    switch (element.type) {
+    case "server-item":
+        return element.server.local?.mcpResource;
+    case "session-server-item":
+        return element.server.sourceUri;
+    case "connector-item":
+        return element.activeSessionServer?.sourceUri;
+    case "builtin-item":
+        return element.activeSessionServer?.sourceUri ?? element.localServer?.readDefinitions().get().server?.presentation?.origin?.uri ?? element.localServer?.collection?.presentation?.origin;
+    case "provider-item":
+        return undefined;
+    }
+}
+function getMcpEntrySource(
+    element,
+    labelService,
+    agentPluginService,
+    extensionsWorkbenchService,
+    openPlugin
+) {
+    const sourceUri = getMcpEntrySourceUri(element);
+    if (element.type === "builtin-item") {
+        const pluginUri = getPluginUriFromCollectionId(element.collectionId);
+        const plugin = pluginUri ? agentPluginService.plugins.get().find(plugin => ( plugin.uri.toString()) === pluginUri) : undefined;
+        if (plugin) {
+            return {
+                label: ( localize(11035, "Plugin: {0}", plugin.label)),
+                hover: ( localize(11060, "Open plugin details for {0}", plugin.label)),
+                ariaLabel: ( localize(11060, "Open plugin details for {0}", plugin.label)),
+                open: openPlugin ? () => openPlugin(plugin) : undefined
+            };
+        }
+        if (element.extensionId && extensionsWorkbenchService) {
+            const extensionId = element.extensionId;
+            const extension = extensionsWorkbenchService.local.find(
+                extension => ExtensionIdentifier.equals(extension.identifier.id, extensionId)
+            );
+            const extensionName = extension?.displayName || extensionId.value;
+            return {
+                label: isCopilotExtension(extensionId) ? ( localize(11061, "Built-in: {0}", extensionName)) : ( localize(11062, "Extension: {0}", extensionName)),
+                hover: ( localize(11063, "Open extension details for {0}", extensionName)),
+                ariaLabel: ( localize(11063, "Open extension details for {0}", extensionName)),
+                open: () => extensionsWorkbenchService.open(extensionId.value, {
+                    tab: ExtensionEditorTab.Features,
+                    feature: "mcp"
+                })
+            };
+        }
+    }
+    if (!sourceUri) {
+        return undefined;
+    }
+    return {
+        label: labelService.getUriLabel(sourceUri, {
+            relative: true
+        }),
+        hover: labelService.getUriLabel(sourceUri, {
+            noPrefix: true
+        })
+    };
+}
+function getAgentHostMcpServerSource(server, plugin, labelService, agentPluginService, openPlugin, openFile) {
+    const entry = {
+        type: "session-server-item",
+        server
+    };
+    const fileSource = createInstalledMcpServerDetailInput(entry).source;
+    const openFileSource = fileSource && openFile ? () => openFile(fileSource) : undefined;
+    if (plugin) {
+        const pluginUri = ( URI.parse(plugin.uri));
+        const clientPlugin = agentPluginService.plugins.get().find(candidate => isEqual(candidate.uri, pluginUri));
+        if (clientPlugin && openPlugin) {
+            return {
+                label: clientPlugin.label,
+                hover: ( localize(11060, "Open plugin details for {0}", clientPlugin.label)),
+                ariaLabel: ( localize(11060, "Open plugin details for {0}", clientPlugin.label)),
+                open: () => openPlugin(clientPlugin)
+            };
+        }
+        return {
+            label: plugin.name,
+            hover: fileSource ? labelService.getUriLabel(fileSource.uri, {
+                noPrefix: true
+            }) : plugin.name,
+            ariaLabel: openFileSource ? ( localize(11064, "Open {0}", plugin.name)) : undefined,
+            open: openFileSource
+        };
+    }
+    const source = getMcpEntrySource(entry, labelService, agentPluginService);
+    return source && openFileSource ? {
+        ...source,
+        ariaLabel: ( localize(11064, "Open {0}", source.label)),
+        open: openFileSource
+    } : source;
+}
+function getMcpEntryLabelWithSource(element, labelService, agentPluginService, extensionsWorkbenchService) {
+    const label = getMcpEntryLabel(element);
+    const source = getMcpEntrySource(element, labelService, agentPluginService, extensionsWorkbenchService);
+    return source ? ( localize(11065, "{0}, configured in {1}", label, source.label)) : label;
+}
+function getActiveSessionServerProvenance(server, agentLabel) {
+    if (server.hostConfiguration && server.source !== "builtin" && server.source !== "managed" && server.source !== "account") {
+        return {
+            label: ( localize(11066, "Agent host configuration"))
+        };
+    }
+    switch (server.source) {
+    case "builtin":
+        return {
+            label: server.sourcePluginName ? ( localize(11067, "Built-in plugin: {0}", server.sourcePluginName)) : ( localize(11061, "Built-in: {0}", agentLabel))
+        };
+    case "managed":
+        return {
+            label: ( localize(11068, "Managed by {0}", agentLabel))
+        };
+    case "account":
+        return {
+            label: ( localize(11069, "Signed-in account"))
+        };
+    case "plugin":
+        return server.sourcePluginName ? {
+            label: ( localize(11035, "Plugin: {0}", server.sourcePluginName))
+        } : undefined;
+    case "workspace":
+        return {
+            label: ( localize(11070, "Workspace configuration"))
+        };
+    case "user":
+        return {
+            label: ( localize(11071, "User configuration"))
+        };
+    default:
+        return undefined;
+    }
+}
+function getActiveSessionServerDefinitionUnavailable(server, agentLabel) {
+    const settingId = server.controllingSettingId;
+    switch (server.source) {
+    case "builtin":
+        return {
+            message: ( localize(
+                11072,
+                "{0} configures this server automatically, so its definition can't be viewed or edited.",
+                agentLabel
+            )),
+            ...(settingId ? {
+                settingId
+            } : {})
+        };
+    case "managed":
+        return {
+            message: ( localize(
+                11073,
+                "{0} manages this server, so its definition can't be viewed or edited.",
+                agentLabel
+            )),
+            ...(settingId ? {
+                settingId
+            } : {})
+        };
+    case "account":
+        return {
+            message: ( localize(
+                11074,
+                "Your signed-in account provides this server, so its definition can't be viewed or edited."
+            )),
+            ...(settingId ? {
+                settingId
+            } : {})
+        };
+    default:
+        return undefined;
+    }
+}
+function getMcpServerCompatibilityId(element) {
+    if (element.type === "session-server-item") {
+        return undefined;
+    }
+    return element.localServer?.definition.id ?? (element.type === "server-item" ? element.server.id : element.type === "connector-item" ? element.connector.serverName : undefined);
 }
 function getMcpStatusKind(entry, isSessionsWindow) {
     if (entry.type === "session-server-item") {
@@ -818,71 +1332,50 @@ function getMcpStatusKind(entry, isSessionsWindow) {
     if (entry.localServer && isContributionDisabled(entry.localServer.enablement.get())) {
         return "disabled";
     }
-    if (entry.type === "server-item" && !isSessionsWindow) {
-        return entry.localServer?.connectionState.get().state;
+    if (!isSessionsWindow) {
+        const state = entry.localServer?.connectionState.get().state;
+        return state;
     }
     return undefined;
 }
-function getMcpEntryAriaLabel(element, isSessionsWindow) {
-    const label = getMcpEntryLabel(element);
+function getMcpEntryAriaLabel(
+    element,
+    isSessionsWindow,
+    compatibilityKind,
+    labelService,
+    agentPluginService,
+    extensionsWorkbenchService
+) {
+    const label = getMcpEntryLabelWithSource(element, labelService, agentPluginService, extensionsWorkbenchService);
     const statusKind = getMcpStatusKind(element, isSessionsWindow);
     const disabledReason = statusKind === "disabled" ? getMcpDisabledReason(element) : undefined;
     const status = getMcpStatusPresentation(statusKind, disabledReason);
-    return status ? ( localize(9115, "{0}, {1}", label, status.label)) : label;
+    const compatibility = getMcpCompatibilityPresentation(compatibilityKind);
+    const errorMessage = statusKind === McpServerStatus.Error || statusKind === McpConnectionState.Kind.Error ? getMcpEntryErrorMessage(element) : undefined;
+    return [compatibility?.label, status?.label, errorMessage].reduce((result, detail) => detail ? ( localize(11075, "{0}, {1}", result, detail)) : result, label);
 }
 function getMcpDisabledReason(entry) {
     if (entry.type === "session-server-item") {
         return entry.server.disabledReason;
     }
     if (entry.activeSessionServer !== undefined) {
-        return entry.activeSessionServer.disabledReason;
-    }
-    return undefined;
-}
-function normalizeMcpMatchKey(value) {
-    return value || undefined;
-}
-function getUniqueMcpMatchKeys(values) {
-    const keys = ( new Set());
-    for (const value of values) {
-        const key = normalizeMcpMatchKey(value);
-        if (key) {
-            keys.add(key);
-        }
-    }
-    return [...keys];
-}
-class ActiveSessionMcpServerMatcher {
-    constructor(servers) {
-        this.servers = servers;
-        this.byKey = ( new Map());
-        this.matchedIds = ( new Set());
-        for (const server of servers) {
-            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 = [];
-                    this.byKey.set(key, bucket);
-                }
-                bucket.push(server);
-            }
-        }
-    }
-    take(keys) {
-        for (const key of getUniqueMcpMatchKeys(keys)) {
-            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 entry.activeSessionServer.disabledReason ?? getCustomizationDisabledReason(entry.activeSessionServer);
+    }
+    if (entry.localServer) {
+        switch (entry.localServer.enablement.get()) {
+        case ContributionEnablementState.DisabledWorkspace:
+            return {
+                source: "scope",
+                scope: CustomizationEnablementKind.Workspace
+            };
+        case ContributionEnablementState.DisabledProfile:
+            return {
+                source: "scope",
+                scope: CustomizationEnablementKind.Global
+            };
         }
-        return undefined;
-    }
-    unmatched(query) {
-        return this.servers.filter(server => !( this.matchedIds.has(server.id)) && matchesActiveSessionServerQuery(server, query));
     }
+    return undefined;
 }
 class LocalMcpServerMatcher {
     constructor(servers) {
@@ -908,26 +1401,49 @@ class LocalMcpServerMatcher {
         return undefined;
     }
 }
-function matchesActiveSessionServerQuery(server, query) {
-    if (!query) {
-        return true;
-    }
-    return server.name.toLowerCase().includes(query);
-}
 function getWorkbenchServerMatchKeys(server) {
     return getUniqueMcpMatchKeys([server.id, server.name, server.label]);
 }
-function getRuntimeServerMatchKeys(server) {
-    return getUniqueMcpMatchKeys([server.definition.id, server.definition.label]);
+function createProviderMcpEntries(installations, existingMatchKeys, query) {
+    const occupied = ( new Set(existingMatchKeys.map(key => key.toLowerCase())));
+    const normalizedQuery = query.toLowerCase().trim();
+    const result = [];
+    for (const installation of installations) {
+        const target = installation.state.target;
+        if (!installation.installationId || installation.state.kind !== "installed" || target.kind !== "mcp") {
+            continue;
+        }
+        const matchKeys = getUniqueMcpMatchKeys([target.id, target.name]);
+        if (matchKeys.length === 0 || ( matchKeys.some(key => ( occupied.has(key.toLowerCase()))))) {
+            continue;
+        }
+        const resource = installation.resource;
+        const name = target.name ?? target.id;
+        if (normalizedQuery && !( [name, resource.displayName, resource.description].some(value => value.toLowerCase().includes(normalizedQuery)))) {
+            continue;
+        }
+        for (const key of matchKeys) {
+            occupied.add(key.toLowerCase());
+        }
+        result.push({
+            type: "provider-item",
+            id: installation.installationId,
+            name,
+            label: resource.displayName,
+            description: resource.description,
+            marketplaceRecord: installation
+        });
+    }
+    return result;
 }
 function getActiveSessionServerPresentation(server) {
     return {
         enabled: server.enabled,
-        status: server.enabled ? server.status : "disabled"
+        status: server.enabled ? server.authenticating ? "authenticating" : server.status : "disabled"
     };
 }
 function updateMcpCardRuntimePresentation(
-    statusBadge,
+    statusIcon,
     primaryAction,
     description,
     statusKind,
@@ -936,11 +1452,16 @@ function updateMcpCardRuntimePresentation(
     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);
+    statusIcon.className = "mcp-server-state-icon";
+    statusIcon.style.display = statusPresentation?.icon ? "" : "none";
+    if (statusPresentation?.icon) {
+        statusIcon.classList.add(
+            statusPresentation.className,
+            ...ThemeIcon.asClassNameArray(statusPresentation.icon)
+        );
+        statusIcon.setAttribute("aria-label", statusPresentation.label);
+    } else {
+        statusIcon.removeAttribute("aria-label");
     }
     primaryAction.setAttribute("aria-label", ariaLabel);
     description.textContent = descriptionText;
@@ -948,6 +1469,9 @@ function updateMcpCardRuntimePresentation(
 function shouldLoadMcpGallerySnapshot(visible, query, itemCount, failed, loading, accessEnabled) {
     return accessEnabled && visible && !query.trim() && itemCount === 0 && !failed && !loading;
 }
+function shouldShowLegacyMcpGallery(configurationService) {
+    return configurationService.getValue(CustomizationMarketplaceConfiguration.MarketplaceEnabled) !== true;
+}
 function hasSameMcpMembership(previous, current) {
     return previous === current;
 }
@@ -955,7 +1479,7 @@ function getActiveSessionServerLifecycleAction(server) {
     if (!getActiveSessionServerPresentation(server).enabled) {
         return undefined;
     }
-    return server.status === McpServerStatus.Stopped || server.status === McpServerStatus.Error ? ( new Action("mcpServer.activeSession.start", ( localize(9116, "Start Server")), undefined, true, () => server.start())) : ( new Action("mcpServer.activeSession.stop", ( localize(9117, "Stop Server")), undefined, true, () => server.stop()));
+    return server.status === McpServerStatus.Stopped || server.status === McpServerStatus.Error ? ( new Action("mcpServer.activeSession.start", ( localize(11076, "Start Server")), undefined, true, () => server.start())) : ( new Action("mcpServer.activeSession.stop", ( localize(11077, "Stop Server")), undefined, true, () => server.stop()));
 }
 function isHostOwnedPluginMcpServer(server) {
     return server.isPluginProvided === true && !server.isClientBundled;
@@ -963,18 +1487,18 @@ function isHostOwnedPluginMcpServer(server) {
 const agentHostMcpServerEnablementActionInfo = {
     global: {
         kind: CustomizationEnablementKind.Global,
-        enableLabel: () => ( localize(9118, "Enable")),
-        disableLabel: () => ( localize(9119, "Disable"))
+        enableLabel: () => ( localize(11078, "Enable")),
+        disableLabel: () => ( localize(11079, "Disable (Globally)"))
     },
     workspace: {
         kind: CustomizationEnablementKind.Workspace,
-        enableLabel: () => ( localize(9120, "Enable (Workspace)")),
-        disableLabel: () => ( localize(9121, "Disable (Workspace)"))
+        enableLabel: () => ( localize(11080, "Enable (Workspace)")),
+        disableLabel: () => ( localize(11081, "Disable (Workspace)"))
     },
     session: {
         kind: CustomizationEnablementKind.Session,
-        enableLabel: () => ( localize(9122, "Enable (Session)")),
-        disableLabel: () => ( localize(9123, "Disable (Session)"))
+        enableLabel: () => ( localize(11082, "Enable (Session)")),
+        disableLabel: () => ( localize(11083, "Disable (Session)"))
     }
 };
 function getAgentHostMcpServerEnablementActions(
@@ -1047,6 +1571,17 @@ function setPrimaryMcpServerEnablement(
         );
         return;
     }
+    if (activeSessionServer && !activeSessionServer.enabled && enabled) {
+        const scope = activeSessionServer.disabledReason?.source === "scope" ? activeSessionServer.disabledReason.scope : getCustomizationEnablementDecision(activeSessionServer)?.kind ?? CustomizationEnablementKind.Global;
+        agentHostCustomizations.setCustomizationEnablement(
+            sessionResource,
+            activeSessionServer.id,
+            activeSessionServer.enablement,
+            scope,
+            true
+        );
+        return;
+    }
     if (localServerId) {
         const current = mcpService.enablementModel.readEnabled(localServerId);
         const next = getToggledMcpEnablementState(current);
@@ -1071,6 +1606,9 @@ function isPrimaryMcpServerEnabled(mcpService, localServerId, activeSessionServe
     if (activeSessionServer && isHostOwnedPluginMcpServer(activeSessionServer)) {
         return getCustomizationScopeEnablement(activeSessionServer).global;
     }
+    if (activeSessionServer && !activeSessionServer.enabled) {
+        return false;
+    }
     if (localServerId) {
         return isContributionEnabled(mcpService.enablementModel.readEnabled(localServerId));
     }
@@ -1094,20 +1632,20 @@ function getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkben
     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(9124, "Enable")), undefined, true, () => {
+        actions.push(( new Action("mcpServer.builtin.enable", ( localize(11084, "Enable")), undefined, true, () => {
             mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.EnabledProfile);
         })));
         if (includeWorkspace && !isEmptyWorkbench) {
-            actions.push(( new Action("mcpServer.builtin.enableWorkspace", ( localize(9125, "Enable (Workspace)")), undefined, true, () => {
+            actions.push(( new Action("mcpServer.builtin.enableWorkspace", ( localize(11085, "Enable (Workspace)")), undefined, true, () => {
                 mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.EnabledWorkspace);
             })));
         }
     } else {
-        actions.push(( new Action("mcpServer.builtin.disable", ( localize(9126, "Disable")), undefined, true, () => {
+        actions.push(( new Action("mcpServer.builtin.disable", ( localize(11086, "Disable (Globally)")), undefined, true, () => {
             mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.DisabledProfile);
         })));
         if (includeWorkspace && !isEmptyWorkbench) {
-            actions.push(( new Action("mcpServer.builtin.disableWorkspace", ( localize(9127, "Disable (Workspace)")), undefined, true, () => {
+            actions.push(( new Action("mcpServer.builtin.disableWorkspace", ( localize(11087, "Disable (Workspace)")), undefined, true, () => {
                 mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.DisabledWorkspace);
             })));
         }
@@ -1168,7 +1706,7 @@ function getActiveSessionServerOptionsActions(
         actions.push(...durableActions);
     }
     actions.push(( new Separator()));
-    actions.push(( new Action("mcpServer.activeSession.options", ( localize(9128, "Server Options")), undefined, true, async () => {
+    actions.push(( new Action("mcpServer.activeSession.options", ( localize(11088, "Server Options")), undefined, true, async () => {
         await commandService.executeCommand(McpCommandIds.AgentHostServerOptions, sessionResource, server.id);
     })));
     return actions;
@@ -1213,20 +1751,40 @@ function getServerItemContextMenuActions(
     }
     return actions;
 }
-function createBuiltinEntry(server, activeSessionServer) {
+function createBuiltinEntry(server, activeSessionServer, extensionId) {
     return {
         type: "builtin-item",
         id: `builtin-${server.definition.id}`,
         label: server.definition.label,
         description: "",
         collectionId: server.collection.id,
+        extensionId,
         activeSessionServer,
         localServer: server
     };
 }
-function createInstalledMcpServerDetailInput(entry) {
+function createConnectorMcpEntry(connector, activeSessionServer) {
+    return {
+        type: "connector-item",
+        id: `copilot-connector:${connector.id}`,
+        label: connector.serverName,
+        description: ( localize(11089, "Connector: {0}", connector.connector.displayName)),
+        activeSessionServer,
+        connector
+    };
+}
+function isConnectorMcpEntry(entry) {
+    return entry.type === "connector-item";
+}
+function createInstalledMcpServerDetailInput(entry, error, presentation) {
     if (entry.type === "server-item") {
-        return createWorkbenchMcpServerDetailInput(entry.server);
+        const input = createWorkbenchMcpServerDetailInput(entry.server);
+        return {
+            ...input,
+            icon: entry.marketplaceRecord?.resource.icon ?? input.icon,
+            compatibilityId: entry.localServer?.definition.id ?? entry.server.id,
+            error
+        };
     }
     const activeSessionServer = getActiveSessionServer(entry);
     const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
@@ -1247,13 +1805,46 @@ function createInstalledMcpServerDetailInput(entry) {
     } : undefined;
     return {
         id: getMcpRowKey(entry),
-        name: getMcpEntryLabel(entry),
+        name: getMcpEntryName(entry),
         label: getMcpEntryLabel(entry),
+        icon: entry.type === "provider-item" ? entry.marketplaceRecord.resource.icon : undefined,
         installState: McpServerInstallState.Installed,
-        config: localDefinition ? getMcpServerConfiguration(localDefinition) : undefined,
-        source: localSource ?? activeSessionSource
+        config: localDefinition ? getMcpServerConfiguration(localDefinition) : activeSessionServer?.hostConfiguration,
+        compatibilityId: localDefinition?.id,
+        error,
+        source: localSource ?? activeSessionSource,
+        ...(presentation?.provenance ? {
+            provenance: presentation.provenance
+        } : {}),
+        ...(presentation?.definitionUnavailable ? {
+            definitionUnavailable: presentation.definitionUnavailable
+        } : {})
     };
 }
+function createAgentHostMcpServerDetailInput(
+    server,
+    agentHostCustomizationService,
+    harnessService,
+    customizationsChanged
+) {
+    const agentLabel = harnessService.getActiveDescriptor().label;
+    return createInstalledMcpServerDetailInput({
+        type: "session-server-item",
+        server
+    }, derived(agentHostCustomizationService, reader => {
+        customizationsChanged.read(reader);
+        const sessionResource = harnessService.activeSessionResource.read(reader);
+        const currentServer = agentHostCustomizationService.getMcpServers(sessionResource).find(candidate => candidate.id === server.id);
+        if (!currentServer?.enabled) {
+            return undefined;
+        }
+        const errorMessage = currentServer.state?.kind === McpServerStatus.Error ? currentServer.state.error?.message : undefined;
+        return getMcpErrorMessage(getActiveSessionServerPresentation(currentServer).status, errorMessage);
+    }), {
+        provenance: getActiveSessionServerProvenance(server, agentLabel),
+        definitionUnavailable: getActiveSessionServerDefinitionUnavailable(server, agentLabel)
+    });
+}
 function getMcpServerConfiguration(definition) {
     const launch = definition.launch;
     if (launch.type === McpServerTransportType.HTTP) {
@@ -1280,53 +1871,80 @@ let McpListWidget = class McpListWidget extends Disposable {
     constructor(
         instantiationService,
         mcpWorkbenchService,
+        mcpGalleryManifestService,
+        marketplaceInstallService,
         mcpService,
         mcpRegistry,
+        connectorsService,
         commandService,
         openerService,
         contextViewService,
         contextMenuService,
+        hoverService,
         agentPluginService,
         dialogService,
         configurationService,
+        customizationMarketplaceService,
         customizationHarnessService,
         agentHostCustomizationService,
         workspaceService,
         notificationService,
         outputService,
-        mcpGalleryManifestService
+        labelService,
+        extensionsWorkbenchService,
+        logService,
+        telemetryService,
+        workspaceContextService
     ) {
         super();
         this.instantiationService = instantiationService;
         this.mcpWorkbenchService = mcpWorkbenchService;
+        this.mcpGalleryManifestService = mcpGalleryManifestService;
+        this.marketplaceInstallService = marketplaceInstallService;
         this.mcpService = mcpService;
         this.mcpRegistry = mcpRegistry;
+        this.connectorsService = connectorsService;
         this.commandService = commandService;
         this.openerService = openerService;
         this.contextViewService = contextViewService;
         this.contextMenuService = contextMenuService;
+        this.hoverService = hoverService;
         this.agentPluginService = agentPluginService;
         this.dialogService = dialogService;
         this.configurationService = configurationService;
+        this.customizationMarketplaceService = customizationMarketplaceService;
         this.customizationHarnessService = customizationHarnessService;
         this.agentHostCustomizationService = agentHostCustomizationService;
         this.workspaceService = workspaceService;
         this.notificationService = notificationService;
         this.outputService = outputService;
+        this.labelService = labelService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.logService = logService;
+        this.telemetryService = telemetryService;
+        this.workspaceContextService = workspaceContextService;
         this._onDidSelectServer = this._register(( new Emitter()));
         this.onDidSelectServer = this._onDidSelectServer.event;
+        this._onDidUpdateServerDetail = this._register(( new Emitter()));
+        this.onDidUpdateServerDetail = this._onDidUpdateServerDetail.event;
         this._onDidChangeItemCount = this._register(( new Emitter()));
         this.onDidChangeItemCount = this._onDidChangeItemCount.event;
         this._onDidRequestShowPlugin = this._register(( new Emitter()));
         this.onDidRequestShowPlugin = this._onDidRequestShowPlugin.event;
+        this._onDidSelectConnector = this._register(( new Emitter()));
+        this.onDidSelectConnector = this._onDidSelectConnector.event;
+        this._onDidRequestOpenMigrations = this._register(( new Emitter()));
+        this.onDidRequestOpenMigrations = this._onDidRequestOpenMigrations.event;
+        this._onDidRequestBrowse = this._register(( new Emitter()));
+        this.onDidRequestBrowse = this._onDidRequestBrowse.event;
         this.disabledLinkListener = this._register(( new MutableDisposable()));
         this.filteredServers = [];
-        this.filteredBuiltinCount = 0;
-        this.filteredActiveSessionCount = 0;
         this.installedEntries = [];
+        this.installedEntryOrder = ( new Map());
         this.gallerySnapshotServers = [];
         this.galleryServers = [];
         this.searchQuery = "";
+        this.currentTreeGroups = [];
         this.gallerySnapshotFailed = false;
         this.gallerySnapshotLoading = false;
         this.gallerySearchLoading = false;
@@ -1338,18 +1956,25 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.lastWidth = 0;
         this.lastHeaderHeight = 0;
         this._layoutDeferred = false;
-        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.connectorsCancellation = this._register(( new MutableDisposable()));
+        this.connectorActionCancellation = this._register(( new MutableDisposable()));
+        this.connectorChangeListener = this._register(( new MutableDisposable()));
         this.delayedFilter = ( new Delayer(200));
         this.delayedGallerySearch = ( new Delayer(400));
+        this._closeCustomizationEditor = () => Promise.resolve();
+        this.mcpServerCompatibility = observableValue(this, ( new Map()));
+        this.mcpServerCompatibilityScope = this._register(( new MutableDisposable()));
         this.agentHostCustomizationsChanged = observableSignalFromEvent(this, this.agentHostCustomizationService.onDidChangeCustomizations);
         this.element = $(".mcp-list-widget.plugin-list-widget");
         this.create();
+        this._register(autorun(reader => {
+            this.marketplaceInstallService.installations.read(reader);
+            this.filterServers();
+        }));
         const resizeObserver = this._register(new DisposableResizeObserver(
             "McpListWidget",
             () => this.updateResponsiveLayout(this.element.offsetWidth),
@@ -1358,6 +1983,9 @@ let McpListWidget = class McpListWidget extends Disposable {
         this._register(resizeObserver.observe(this.element));
         this.updateAccessState();
         this._register(mcpGalleryManifestService.onDidChangeMcpGalleryManifest(() => {
+            if (this.isGalleryDiscoveryEnabled()) {
+                return;
+            }
             this.galleryCts?.dispose(true);
             this.galleryCts = undefined;
             this.gallerySnapshotServers = [];
@@ -1370,35 +1998,76 @@ let McpListWidget = class McpListWidget extends Disposable {
                 void this.refresh();
             }
         }));
-        void mcpGalleryManifestService.getMcpGalleryManifest();
+        if (!this.isGalleryDiscoveryEnabled()) {
+            void mcpGalleryManifestService.getMcpGalleryManifest();
+        }
         void this.refresh();
+        this.updateConnectorChangeListener();
         this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (affectsCustomizationDiscoveryAvailability(e, this.customizationMarketplaceService)) {
+                this.galleryCts?.dispose(true);
+                this.galleryCts = undefined;
+                this.delayedGallerySearch.cancel();
+                this.gallerySnapshotServers = [];
+                this.galleryServers = [];
+                this.gallerySnapshotFailed = false;
+                this.gallerySnapshotLoading = false;
+                this.gallerySearchLoading = false;
+                void this.refresh();
+            }
             if (e.affectsConfiguration(mcpAccessConfig)) {
                 this.updateAccessState();
             }
+            if (e.affectsConfiguration(CustomizationMarketplaceConfiguration.CopilotConnectorsEnabled)) {
+                this.updateConnectorChangeListener();
+                this.connectorsCancellation.value?.cancel();
+                this.connectorsCancellation.clear();
+                this.connectorActionCancellation.value?.cancel();
+                this.connectorActionCancellation.clear();
+                if (this.visible && this.isConnectorsEnabled()) {
+                    void this.refreshConnectors();
+                } else {
+                    this.filterServers();
+                }
+            }
+            if (e.affectsConfiguration(ChatConfiguration.ChatCustomizationsMigrationEnabled)) {
+                this.updateMcpServerCompatibilityScope();
+            }
         }));
+        if (this.customizationMarketplaceService.onDidChangeSources) {
+            this._register(
+                this.customizationMarketplaceService.onDidChangeSources(() => void this.refresh())
+            );
+        }
+        this._register(
+            this.workspaceContextService.onDidChangeWorkspaceFolders(() => this.renderMcpTree())
+        );
         this._register({
             dispose: () => {
                 this.delayedFilter.cancel();
                 this.delayedGallerySearch.cancel();
                 this.galleryCts?.dispose(true);
+                this.connectorsCancellation.value?.cancel();
             }
         });
     }
+    setCloseCustomizationEditor(closeCustomizationEditor) {
+        this._closeCustomizationEditor = closeCustomizationEditor;
+    }
     create() {
         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(9129, "MCP Servers"));
+        sectionTitle.textContent = ( localize(11090, "MCP Servers"));
         const sectionTitleDescription = append(this.sectionTitleHeader, $("p.section-title-description"));
         const sectionTitleDescriptionText = append(sectionTitleDescription, $("span.section-title-description-text"));
         sectionTitleDescriptionText.textContent = ( localize(
-            9130,
+            11091,
             "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(9131, "Learn more about MCP servers"));
+        this.sectionLink.textContent = ( localize(11092, "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();
@@ -1424,7 +2093,7 @@ 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(9132, "Type to search...")),
+            placeholder: ( localize(11093, "Type to search...")),
             inputBoxStyles: defaultInputBoxStyles
         })));
         this._register(this.searchInput.onDidChange(() => {
@@ -1435,7 +2104,7 @@ let McpListWidget = class McpListWidget extends Disposable {
             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) {
+            if (!this.mcpAccessEnabled || this.isGalleryDiscoveryEnabled()) {
                 this.gallerySearchLoading = false;
                 this.delayedGallerySearch.cancel();
                 return;
@@ -1459,7 +2128,7 @@ let McpListWidget = class McpListWidget extends Disposable {
         const disabledHeader = append(this.disabledContainer, $(".empty-state-header"));
         this.disabledIcon = append(disabledHeader, $(".empty-icon"));
         const disabledText = append(disabledHeader, $(".empty-text"));
-        disabledText.textContent = ( localize(9133, "MCP servers are disabled"));
+        disabledText.textContent = ( localize(11094, "MCP servers are disabled"));
         this.disabledMessage = append(this.disabledContainer, $(".empty-subtext"));
         this.cardContainer = $(".plugin-card-container");
         this.cardScrollable = this._register(( new DomScrollableElement(this.cardContainer, {
@@ -1482,6 +2151,83 @@ let McpListWidget = class McpListWidget extends Disposable {
             new DisposableResizeObserver("McpListWidget.cardScrollable", () => this.cardScrollable.scanDomNode())
         );
         this._register(cardResizeObserver.observe(this.cardScrollableNode));
+        this.listContainer = append(this.element, $(".mcp-list-container.customization-tree-container"));
+        const delegate = ( new McpSectionDelegate(() => MCP_INSTALLED_ITEM_HEIGHT));
+        const groupRenderer = ( new CustomizationGroupHeaderRenderer(
+            "mcpGroupHeader",
+            this.hoverService,
+            (entry, container, disposables) => this.renderMcpTreeGroupActions(entry, container, disposables)
+        ));
+        const itemRenderer = this._register(this.instantiationService.createInstance(
+            McpServerItemRenderer,
+            (getEntry, actions, disposables, updateTabbability) => this.renderMcpListActions(getEntry, actions, disposables, updateTabbability),
+            (entry, reader) => this.getMcpServerCompatibilityKind(entry, reader),
+            plugin => this._onDidRequestShowPlugin.fire(createInstalledPluginItem(plugin)),
+            () => this._onDidRequestOpenMigrations.fire()
+        ));
+        const marketplaceRenderer = ( new McpMarketplaceItemRenderer((server, button) => this.installMarketplaceServer(server, button)));
+        this.list = this._register(
+            this.instantiationService.createInstance(WorkbenchObjectTree, "McpManagementTree", this.listContainer, delegate, [
+                asTreeRenderer(groupRenderer),
+                asTreeRenderer(itemRenderer),
+                asTreeRenderer(marketplaceRenderer)
+            ], {
+                indent: 8,
+                renderIndentGuides: RenderIndentGuides.None,
+                hideTwistiesOfChildlessElements: false,
+                overrideStyles: customizationTreeStyles,
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getAriaLabel: entry => {
+                        if (entry.type === "group-header") {
+                            return localize(11095, "{0}, {1} items", entry.label, entry.count);
+                        }
+                        return entry.type === "connector-item" ? ( localize(
+                            11096,
+                            "{0}. Connector: {1}.",
+                            entry.connector.serverName,
+                            entry.connector.connector.displayName
+                        )) : entry.type === "marketplace-item" ? ( localize(
+                            11097,
+                            "{0}. Available to install from the MCP marketplace.",
+                            entry.server.label
+                        )) : this.getMcpEntryAriaLabel(entry);
+                    },
+                    getWidgetAriaLabel: () => ( localize(11098, "MCP Servers"))
+                },
+                openOnSingleClick: true,
+                identityProvider: {
+                    getId: entry => this.getMcpTreeEntryId(entry)
+                }
+            })
+        );
+        this._register(this.list.onDidOpen(event => {
+            const entry = event.element;
+            if (!entry || entry.type === "group-header") {
+                return;
+            }
+            if (entry.type !== "marketplace-item" && isConnectorMcpEntry(entry)) {
+                this._onDidSelectConnector.fire(entry.connector.connector);
+                return;
+            }
+            this._onDidSelectServer.fire(
+                entry.type === "marketplace-item" ? createWorkbenchMcpServerDetailInput(entry.server) : this.createInstalledMcpServerDetailInput(entry)
+            );
+        }));
+        this._register(this.list.onContextMenu(event => {
+            if (event.element && event.element.type !== "group-header" && event.element.type !== "marketplace-item") {
+                this.showMcpServerActions(event.element, event.anchor);
+            }
+        }));
+        this._register(this.list.onDidChangeFocus(event => {
+            const entry = event.elements[0];
+            itemRenderer.setFocusedRowKey(
+                entry && entry.type !== "group-header" && entry.type !== "marketplace-item" ? getMcpRowKey(entry) : undefined
+            );
+            marketplaceRenderer.setFocusedServerId(entry?.type === "marketplace-item" ? entry.server.id : undefined);
+        }));
         this._register(this.mcpWorkbenchService.onChange(() => {
             this.refresh();
         }));
@@ -1494,6 +2240,8 @@ let McpListWidget = class McpListWidget extends Disposable {
         }));
         this._register(autorun(reader => {
             this.customizationHarnessService.activeSessionResource.read(reader);
+            this.customizationHarnessService.availableHarnesses.read(reader);
+            this.updateMcpServerCompatibilityScope();
             this.refresh();
         }));
         this._register(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
@@ -1502,11 +2250,12 @@ let McpListWidget = class McpListWidget extends Disposable {
             if (!hasSameMcpMembership(previousMembership, this.getInstalledEntryMembershipSignature())) {
                 this.renderFilteredServers();
             }
+            this._onDidUpdateServerDetail.fire();
         }));
     }
     async refresh() {
         this.filterServers();
-        if (shouldLoadMcpGallerySnapshot(
+        if (!this.isGalleryDiscoveryEnabled() && shouldLoadMcpGallerySnapshot(
             this.visible,
             this.searchQuery,
             this.gallerySnapshotServers.length,
@@ -1517,13 +2266,94 @@ let McpListWidget = class McpListWidget extends Disposable {
             await this.queryGallerySnapshot();
         }
     }
+    async refreshConnectors() {
+        if (!this.visible || !this.mcpAccessEnabled || !this.isConnectorsEnabled()) {
+            return;
+        }
+        this.connectorsCancellation.value?.cancel();
+        const cancellation = ( new CancellationTokenSource());
+        this.connectorsCancellation.value = cancellation;
+        try {
+            await this.connectorsService.getConnectors(cancellation.token);
+        } catch (error) {
+            if (!cancellation.token.isCancellationRequested && !isCancellationError(error)) {
+                this.logService.warn("[McpListWidget] Unable to refresh Copilot connectors", error);
+            }
+        } finally {
+            if (this.connectorsCancellation.value === cancellation) {
+                this.connectorsCancellation.clear();
+                this.filterServers();
+            }
+        }
+    }
+    isConnectorsEnabled() {
+        return this.configurationService.getValue(CustomizationMarketplaceConfiguration.CopilotConnectorsEnabled) === true;
+    }
+    updateConnectorChangeListener() {
+        if (!this.isConnectorsEnabled()) {
+            this.connectorChangeListener.clear();
+            return;
+        }
+        this.connectorChangeListener.value ??= this.connectorsService.onDidChange(() => {
+            if (this.visible) {
+                this.filterServers();
+                if (!this.connectorsService.connectionStateKnown) {
+                    void this.refreshConnectors();
+                }
+            }
+        });
+    }
+    isGalleryDiscoveryEnabled() {
+        return !shouldShowLegacyMcpGallery(this.configurationService);
+    }
     setVisible(visible) {
         if (this.visible === visible) {
             return;
         }
         this.visible = visible;
         if (visible) {
+            this.updateMcpServerCompatibilityScope();
             void this.refresh();
+            if (this.isConnectorsEnabled()) {
+                void this.refreshConnectors();
+            }
+        } else {
+            this.connectorsCancellation.value?.cancel();
+            this.connectorsCancellation.clear();
+            this.connectorActionCancellation.value?.cancel();
+            this.connectorActionCancellation.clear();
+            this.clearMcpServerCompatibilityScope();
+        }
+    }
+    dispose() {
+        this.connectorActionCancellation.value?.cancel();
+        super.dispose();
+    }
+    updateMcpServerCompatibilityScope() {
+        this.clearMcpServerCompatibilityScope();
+        if (!this.visible) {
+            return;
+        }
+        if (this.configurationService.getValue(ChatConfiguration.ChatCustomizationsMigrationEnabled) !== true) {
+            return;
+        }
+        const descriptor = this.customizationHarnessService.getActiveDescriptor();
+        const scope = descriptor.mcpServerCompatibilityProvider?.acquire(this.customizationHarnessService.activeSessionResource.get());
+        if (!scope) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        store.add(scope);
+        store.add(autorun(reader => {
+            const compatibility = ( new Map(scope.servers.read(reader).map(server => [server.id, server.kind])));
+            this.mcpServerCompatibility.set(compatibility, undefined);
+        }));
+        this.mcpServerCompatibilityScope.value = store;
+    }
+    clearMcpServerCompatibilityScope() {
+        this.mcpServerCompatibilityScope.clear();
+        if (this.mcpServerCompatibility.get().size > 0) {
+            this.mcpServerCompatibility.set(( new Map()), undefined);
         }
     }
     updateAccessState() {
@@ -1535,6 +2365,10 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.mcpAccessEnabled = !disabled;
         this.element.classList.toggle("access-disabled", disabled);
         if (disabled) {
+            this.connectorsCancellation.value?.cancel();
+            this.connectorsCancellation.clear();
+            this.connectorActionCancellation.value?.cancel();
+            this.connectorActionCancellation.clear();
             this.delayedGallerySearch.cancel();
             this.galleryCts?.dispose(true);
             this.galleryCts = undefined;
@@ -1549,13 +2383,13 @@ let McpListWidget = class McpListWidget extends Disposable {
             this.disabledLinkListener.clear();
             if (policyLocked) {
                 this.disabledMessage.textContent = ( localize(
-                    9134,
+                    11099,
                     "Access to MCP servers is disabled by your organization. Contact your organization administrator for more information."
                 ));
             } else {
-                this.disabledMessage.appendChild(createTextNode(( localize(9135, "MCP servers are disabled in settings. "))));
+                this.disabledMessage.appendChild(createTextNode(( localize(11100, "MCP servers are disabled in settings. "))));
                 const link = append(this.disabledMessage, $("a.mcp-disabled-settings-link"));
-                link.textContent = ( localize(9136, "Configure in settings."));
+                link.textContent = ( localize(11101, "Configure in settings."));
                 link.href = "#";
                 link.setAttribute("role", "button");
                 this.disabledLinkListener.value = addDisposableListener(link, "click", e => {
@@ -1564,14 +2398,20 @@ let McpListWidget = class McpListWidget extends Disposable {
                 });
             }
         } else if (accessChanged && this.visible) {
-            if (this.searchQuery.trim()) {
+            if (this.searchQuery.trim() && !this.isGalleryDiscoveryEnabled()) {
                 void this.queryMcpSearch();
             } else {
                 void this.refresh();
             }
+            if (this.isConnectorsEnabled()) {
+                void this.refreshConnectors();
+            }
         }
     }
     showBrowseMarketplace() {
+        if (this.isGalleryDiscoveryEnabled()) {
+            return;
+        }
         if (!this.mcpAccessEnabled) {
             return;
         }
@@ -1579,8 +2419,22 @@ let McpListWidget = class McpListWidget extends Disposable {
         this.searchQuery = "";
         void this.queryGallerySnapshot(true);
     }
+    async queryLegacyGallery(options, token) {
+        const [active, fallback] = await Promise.all([
+            this.mcpGalleryManifestService.getMcpGalleryManifest(),
+            this.mcpGalleryManifestService.getDefaultMcpGalleryManifest()
+        ]);
+        const manifests = active && fallback && active.url !== fallback.url ? [active, fallback] : [active ?? fallback ?? undefined];
+        const pages = await Promise.allSettled((manifests[0] ? manifests : [undefined]).map(
+            async manifest => (await this.mcpWorkbenchService.queryGallery(options, token, manifest)).firstPage.items
+        ));
+        if (pages.length && pages.every(page => page.status === "rejected")) {
+            throw pages[0].reason;
+        }
+        return pages.flatMap(page => page.status === "fulfilled" ? page.value : []);
+    }
     async queryGallerySnapshot(revealMarketplace = false) {
-        if (!this.mcpAccessEnabled) {
+        if (!this.mcpAccessEnabled || this.isGalleryDiscoveryEnabled()) {
             return;
         }
         this.galleryCts?.dispose(true);
@@ -1590,19 +2444,20 @@ let McpListWidget = class McpListWidget extends Disposable {
             this.renderMcpHome();
         }
         try {
-            const pager = await this.mcpWorkbenchService.queryGallery(undefined, cts.token);
+            const servers = await this.queryLegacyGallery(undefined, cts.token);
             if (this.galleryCts !== cts || cts.token.isCancellationRequested || !this.mcpAccessEnabled || this.searchQuery.trim()) {
                 return;
             }
-            this.gallerySnapshotServers = pager.firstPage.items;
+            this.gallerySnapshotServers = servers;
             this.galleryServers = [...this.gallerySnapshotServers];
             this.gallerySnapshotFailed = false;
             this.gallerySnapshotLoading = false;
             this.renderMcpHome();
             if (revealMarketplace) {
-                this.availableSection?.scrollIntoView({
-                    block: "start"
-                });
+                const group = this.currentTreeGroups.find(group => group.id === "available");
+                if (group) {
+                    this.list?.reveal(group.element);
+                }
             }
         } catch {
             if (this.galleryCts === cts && !cts.token.isCancellationRequested && this.mcpAccessEnabled) {
@@ -1620,27 +2475,27 @@ let McpListWidget = class McpListWidget extends Disposable {
     }
     async queryMcpSearch() {
         const query = this.searchQuery.trim();
-        if (!query || !this.mcpAccessEnabled) {
+        if (!query || !this.mcpAccessEnabled || this.isGalleryDiscoveryEnabled()) {
             return;
         }
         this.galleryCts?.dispose(true);
         const cts = this.galleryCts = ( new CancellationTokenSource());
         this.gallerySearchLoading = true;
         try {
-            const pager = await this.mcpWorkbenchService.queryGallery({
+            const servers = await this.queryLegacyGallery({
                 text: query
             }, cts.token);
             if (this.galleryCts !== cts || cts.token.isCancellationRequested || !this.mcpAccessEnabled || this.searchQuery.trim() !== query) {
                 return;
             }
-            this.galleryServers = pager.firstPage.items;
+            this.galleryServers = servers;
             this.searchInput.hideMessage();
         } catch {
             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(
-                        9137,
+                        11102,
                         "Marketplace results are unavailable. Showing installed MCP servers only."
                     )),
                     type: MessageType.WARNING
@@ -1653,208 +2508,106 @@ let McpListWidget = class McpListWidget extends Disposable {
             }
         }
     }
-    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);
+        trackCustomizationCardPrimaryActionFocus(
+            primaryAction,
+            surface.closest(".plugin-home-row") ?? surface,
+            this.cardDisposables
+        );
         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 {
-                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(
-                        9138,
-                        "{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;
+    getMcpServerCompatibilityKind(entry, reader) {
+        const id = getMcpServerCompatibilityId(entry);
+        return id ? (reader ? this.mcpServerCompatibility.read(reader) : this.mcpServerCompatibility.get()).get(id) : undefined;
+    }
+    getUpdatedServerDetail(id) {
+        for (const {
+            entry
+        } of this.installedEntries) {
+            if (entry.type === "server-item" ? entry.server.id === id : getMcpRowKey(entry) === id) {
+                return this.createInstalledMcpServerDetailInput(entry);
             }
-            this._onDidSelectServer.fire(
-                entry.type === "marketplace-item" ? createWorkbenchMcpServerDetailInput(entry.server) : createInstalledMcpServerDetailInput(entry)
+        }
+        return undefined;
+    }
+    createInstalledMcpServerDetailInput(entry) {
+        const activeSessionServer = getActiveSessionServer(entry);
+        if (activeSessionServer) {
+            const detail = createAgentHostMcpServerDetailInput(
+                activeSessionServer,
+                this.agentHostCustomizationService,
+                this.customizationHarnessService,
+                this.agentHostCustomizationsChanged
             );
-        }));
-        this.cardDisposables.add(list.onContextMenu(event => {
-            if (event.element && event.element.type !== "marketplace-item") {
-                this.showMcpServerActions(event.element, event.anchor);
+            return createInstalledMcpServerDetailInput(entry, detail.error, this.getMcpEntryDetailPresentation(entry));
+        }
+        return createInstalledMcpServerDetailInput(entry, derived(this, reader => {
+            if (entry.type === "session-server-item" || !entry.localServer) {
+                return undefined;
             }
-        }));
-        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]);
+            const runtimeServers = this.mcpService.servers.read(reader);
+            const matchKeys = entry.type === "server-item" ? getWorkbenchServerMatchKeys(entry.server) : getRuntimeServerMatchKeys(entry.localServer);
+            const localServer = ( new LocalMcpServerMatcher(runtimeServers)).find(matchKeys);
+            if (!localServer || isContributionDisabled(localServer.enablement.read(reader))) {
+                return undefined;
             }
-        }));
+            const connectionState = localServer.connectionState.read(reader);
+            return getMcpErrorMessage(
+                connectionState.state,
+                connectionState.state === McpConnectionState.Kind.Error ? connectionState.message : undefined
+            );
+        }), this.getMcpEntryDetailPresentation(entry));
     }
-    captureSectionScrollPositions() {
-        for (const section of this.sectionLists) {
-            this.sectionScrollPositions.set(section.key, section.list.scrollTop);
+    getMcpEntryDetailPresentation(entry) {
+        const activeSessionServer = getActiveSessionServer(entry);
+        const agentLabel = this.customizationHarnessService.getActiveDescriptor().label;
+        if (entry.type === "provider-item") {
+            const source = this.customizationMarketplaceService.sources.find(source => source.id === entry.marketplaceRecord.resource.sourceId);
+            return {
+                provenance: {
+                    label: source?.displayName ?? agentLabel
+                },
+                definitionUnavailable: {
+                    message: ( localize(
+                        11103,
+                        "{0} manages this server installation, so its definition can't be viewed or edited here.",
+                        agentLabel
+                    ))
+                }
+            };
         }
+        const definitionUnavailable = activeSessionServer && getActiveSessionServerDefinitionUnavailable(activeSessionServer, agentLabel);
+        const source = getMcpEntrySource(
+            entry,
+            this.labelService,
+            this.agentPluginService,
+            this.extensionsWorkbenchService,
+            plugin => this._onDidRequestShowPlugin.fire(createInstalledPluginItem(plugin))
+        );
+        const open = source?.open;
+        const provenance = source && open ? {
+            label: source.label,
+            ariaLabel: source.ariaLabel,
+            open
+        } : activeSessionServer && getActiveSessionServerProvenance(activeSessionServer, agentLabel);
+        return {
+            provenance,
+            definitionUnavailable
+        };
     }
-    getMcpEntryAriaLabel(entry, renderer) {
+    getMcpEntryAriaLabel(entry) {
         return derived(this, reader => {
-            renderer?.readErrorExpansion(reader);
             this.agentHostCustomizationsChanged.read(reader);
-            const label = getMcpEntryLabel(entry);
+            const label = getMcpEntryLabelWithSource(
+                entry,
+                this.labelService,
+                this.agentPluginService,
+                this.extensionsWorkbenchService
+            );
+            const compatibility = getMcpCompatibilityPresentation(this.getMcpServerCompatibilityKind(entry, reader));
             const activeSessionResource = this.customizationHarnessService.activeSessionResource.read(reader);
             let statusKind;
             let disabledReason;
@@ -1865,88 +2618,86 @@ let McpListWidget = class McpListWidget extends Disposable {
                 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;
+                const message = server?.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined;
+                errorMessage = getMcpErrorMessage(statusKind, message);
             } 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(
-                    9139,
-                    "{0}, {1}, {2}. Use Show More to read the full error.",
-                    label,
-                    status.label,
-                    text
-                )) : ( localize(9140, "{0}, {1}, {2}", label, status.label, text));
-            }
-            return status ? ( localize(9115, "{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(9141, "Disable {0}", label)) : ( localize(9142, "Enable {0}", label));
-            const accessibleLabel = blockedByPlugin ? ( localize(9143, "{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;
+                errorMessage = getMcpErrorMessage(
+                    statusKind,
+                    connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined
+                );
             }
-            enabled = checked;
-            this.setInstalledEntryEnabled(currentEntry, enabled);
+            const status = getMcpStatusPresentation(statusKind, disabledReason);
+            return [compatibility?.label, status?.label, errorMessage].reduce((result, detail) => detail ? ( localize(11075, "{0}, {1}", result, detail)) : result, label);
+        });
+    }
+    renderMcpListActions(getEntry, actions, disposables, updateTabbability) {
+        const entry = getEntry();
+        if (!entry) {
+            return;
+        }
+        const label = getMcpEntryLabel(entry);
+        if (!isConnectorMcpEntry(entry) && entry.type !== "provider-item") {
+            let enabled = this.isInstalledEntryEnabled(entry);
+            const disabledLabel = append(actions, $(".mcp-server-disabled-label"));
+            const toggle = disposables.add(this.instantiationService.createInstance(CustomizationToggle, {
+                ariaLabel: label,
+                checked: enabled
+            }));
+            append(actions, toggle.domNode);
+            const update = () => {
+                const currentEntry = getEntry();
+                enabled = currentEntry ? this.isInstalledEntryEnabled(currentEntry) : false;
+                const disabledReason = currentEntry && getMcpDisabledReason(currentEntry);
+                const blockedByPlugin = disabledReason?.source === "plugin";
+                const toggleLabel = enabled ? ( localize(11104, "Disable {0}", label)) : ( localize(11105, "Enable {0}", label));
+                const accessibleLabel = blockedByPlugin ? ( localize(11106, "{0} is disabled by its plugin", label)) : toggleLabel;
+                disabledLabel.textContent = enabled ? "" : getMcpDisabledLabel(disabledReason);
+                disabledLabel.style.display = enabled ? "none" : "";
+                toggle.disabled = !currentEntry || !!blockedByPlugin;
+                toggle.checked = enabled;
+                toggle.setAriaLabel(accessibleLabel);
+                updateTabbability();
+            };
             update();
-            status(enabled ? ( localize(9144, "{0} enabled.", label)) : ( localize(9145, "{0} disabled.", label)));
-        }));
-        if (entry.type !== "session-server-item" && entry.localServer) {
-            disposables.add(autorun(reader => {
-                entry.localServer?.enablement.read(reader);
+            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(11107, "{0} enabled.", label)) : ( localize(11108, "{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));
         }
-        disposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
         const more = disposables.add(( new Button(actions, {
             ...getButtonStyles({
                 buttonSecondaryBackground: undefined,
+                buttonSecondaryForeground: undefined,
+                buttonSecondaryHoverBackground: undefined,
                 buttonSecondaryBorder: undefined
             }),
             secondary: true,
-            supportIcons: true,
-            ariaLabel: ( localize(9146, "More actions for {0}", label))
+            ariaLabel: ( localize(11109, "More actions for {0}", label))
         })));
         more.element.classList.add("plugin-card-icon-button");
-        more.label = `$(${Codicon.ellipsis.id})`;
+        more.icon = Codicon.ellipsis;
         registerMcpInlineButtonAction(disposables, more, () => {
             const currentEntry = getEntry();
             if (currentEntry) {
@@ -1973,22 +2724,6 @@ let McpListWidget = class McpListWidget extends Disposable {
             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);
-                    }
-                }
             }
         }
     }
@@ -1998,63 +2733,269 @@ let McpListWidget = class McpListWidget extends Disposable {
             this.cardScrollable.scanDomNode();
         });
     }
+    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" || entry.type === "connector-item") {
+                installedKeys.add(entry.label.toLowerCase());
+                if (entry.localServer) {
+                    for (const key of getRuntimeServerMatchKeys(entry.localServer)) {
+                        installedKeys.add(key.toLowerCase());
+                    }
+                }
+            } else if (entry.type === "session-server-item") {
+                installedKeys.add(entry.server.name.toLowerCase());
+            } else {
+                installedKeys.add(entry.name.toLowerCase());
+                installedKeys.add(entry.label.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;
+    }
+    renderMcpTree() {
+        if (!this.list) {
+            return;
+        }
+        const showGallery = !this.isGalleryDiscoveryEnabled();
+        const allInstalledEntries = this.installedEntries.map(presentation => presentation.entry);
+        const workspaceGroups = getAICustomizationWorkspaceGroups(this.workspaceContextService);
+        const grouped = ( new Map([
+            ["user", []],
+            ...(workspaceGroups.length > 0 ? workspaceGroups.map(group => [group.key, []]) : [["workspace", []]]),
+            ["plugins", []],
+            ["extensions", []],
+            ["builtin", []],
+            [
+                "available",
+                showGallery ? this.getAvailableGalleryServers().map(server => ({
+                    type: "marketplace-item",
+                    server
+                })) : []
+            ]
+        ]));
+        for (const entry of allInstalledEntries) {
+            const group = getMcpEntryGroup(entry);
+            const sourceUri = getMcpEntrySourceUri(entry);
+            const groupKey = group === "workspace" && workspaceGroups.length > 0 ? (sourceUri ? getAICustomizationWorkspaceGroupForResource(sourceUri, this.workspaceContextService)?.key : undefined) ?? workspaceGroups[0].key : group;
+            grouped.get(groupKey).push(entry);
+        }
+        const definitions = [{
+            id: "user",
+            label: ( localize(11110, "User")),
+            description: ( localize(
+                11111,
+                "MCP servers configured for your profile and available across workspaces."
+            )),
+            icon: Codicon.account
+        }, ...(workspaceGroups.length > 0 ? workspaceGroups.map(group => ({
+            id: group.key,
+            label: group.label,
+            description: ( localize(11112, "MCP servers configured by this workspace.")),
+            icon: Codicon.folder,
+            workspaceFolder: group.uri
+        })) : [{
+            id: "workspace",
+            label: ( localize(11113, "Workspace")),
+            description: ( localize(11112, "MCP servers configured by this workspace.")),
+            icon: Codicon.folder,
+            workspaceFolder: undefined
+        }]), {
+            id: "plugins",
+            label: ( localize(11114, "Plugins")),
+            description: ( localize(
+                11115,
+                "MCP servers provided by installed plugins or connected connectors."
+            )),
+            icon: Codicon.plug
+        }, {
+            id: "extensions",
+            label: ( localize(11116, "Extensions")),
+            description: ( localize(11117, "MCP servers provided by installed extensions.")),
+            icon: Codicon.extensions
+        }, {
+            id: "builtin",
+            label: ( localize(11118, "Built-In")),
+            description: ( localize(11119, "MCP servers built into the application or active agent host.")),
+            icon: mcpServerIcon
+        }, {
+            id: "available",
+            label: ( localize(11120, "Available")),
+            description: ( localize(11121, "Browse and install MCP servers from the marketplace.")),
+            icon: Codicon.globe
+        }].filter(
+            group => group.id === "available" ? showGallery : group.id === "user" || group.id === "workspace" || isAICustomizationWorkspaceGroupKey(group.id) || grouped.get(group.id).length > 0
+        );
+        this.currentTreeGroups = definitions.map((group, index) => {
+            const entries = grouped.get(group.id);
+            const element = {
+                type: "group-header",
+                id: `mcp-group-${group.id}`,
+                group: group.id,
+                label: group.label,
+                icon: group.icon,
+                count: entries.length,
+                isFirst: index === 0,
+                description: group.description,
+                collapsed: false,
+                workspaceFolder: group.workspaceFolder
+            };
+            return {
+                id: group.id,
+                label: group.label,
+                description: group.description,
+                count: entries.length,
+                element,
+                children: entries
+            };
+        });
+        this.cardScrollableNode.style.display = "none";
+        this.cardDisposables.clear();
+        const children = this.currentTreeGroups.map(group => ({
+            element: group.element,
+            collapsible: true,
+            collapsed: ObjectTreeElementCollapseState.PreserveOrExpanded,
+            children: group.children.map(element => ({
+                element
+            }))
+        }));
+        this.list.setChildren(null);
+        this.list.setChildren(null, children);
+        this.updateMcpTreeEmptyState(
+            this.currentTreeGroups.reduce((count, group) => count + group.children.length, 0)
+        );
+    }
+    updateMcpTreeEmptyState(itemCount) {
+        const empty = itemCount === 0;
+        this.listContainer.style.display = empty ? "none" : "";
+        this.emptyContainer.style.display = empty ? "flex" : "none";
+        if (empty) {
+            this.emptyText.textContent = this.gallerySearchLoading ? ( localize(11122, "Searching the MCP marketplace...")) : this.searchQuery.trim() ? ( localize(11123, "No servers match '{0}'", this.searchQuery)) : ( localize(11124, "No MCP servers in this group"));
+            this.emptySubtext.textContent = this.gallerySearchLoading || !this.searchQuery.trim() ? "" : ( localize(11125, "Try a different search term"));
+        }
+    }
+    getMcpTreeEntryId(entry) {
+        if (entry.type === "group-header") {
+            return entry.id;
+        }
+        return entry.type === "marketplace-item" ? `marketplace:${entry.server.id}` : getMcpRowKey(entry);
+    }
+    getVisibleMcpEntries() {
+        return this.currentTreeGroups.flatMap(group => [group.element, ...group.children]);
+    }
     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(9147, "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(9148, "No MCP servers are installed."));
-        } else {
-            this.createMcpSectionList(installedList, ( localize(9147, "Installed")), this.installedEntries.map(presentation => presentation.entry));
+        this.renderMcpTree();
+    }
+    renderMcpTreeGroupActions(entry, container, disposables) {
+        if (entry.group !== "user" && entry.group !== "workspace" && !isAICustomizationWorkspaceGroupKey(entry.group)) {
+            return;
         }
-        this.renderAvailableServers(content, this.getAvailableGalleryServers(), true);
-        this.scheduleMcpSectionLayout();
+        this.renderInstalledSectionActionsWithDisposables(container, disposables, entry.group === "user", entry.workspaceFolder);
     }
-    renderInstalledSectionActions(header) {
+    renderInstalledSectionActionsWithDisposables(header, disposables, showBrowse, workspaceFolder) {
         const actions = append(header, $(".plugin-card-section-actions"));
-        const addLabel = ( localize(9149, "Add Server"));
-        const add = this.installedAddButton = this.cardDisposables.add(( new Button(actions, {
-            ...defaultButtonStyles,
+        const addLabel = ( localize(11126, "Add Server"));
+        const add = disposables.add(( new Button(actions, {
+            ...getButtonStyles({
+                buttonSecondaryBackground: undefined,
+                buttonSecondaryForeground: undefined,
+                buttonSecondaryHoverBackground: undefined,
+                buttonSecondaryBorder: undefined
+            }),
             secondary: true,
+            supportIcons: true,
+            title: addLabel,
             ariaLabel: addLabel
         })));
-        add.element.classList.add("plugin-installed-action");
-        add.label = this.narrowLayout ? ( localize(9150, "Add")) : addLabel;
-        this.firstCardFocusElement ??= add.element;
-        this.cardDisposables.add(
-            add.onDidClick(() => this.commandService.executeCommand(McpCommandIds.AddConfiguration))
+        add.element.classList.add(
+            "plugin-installed-action",
+            "plugin-card-ghost-button",
+            "plugin-card-icon-button"
         );
+        add.icon = Codicon.add;
+        this.firstCardFocusElement ??= add.element;
+        disposables.add(add.onDidClick(
+            () => this.commandService.executeCommand(McpCommandIds.AddConfiguration, workspaceFolder)
+        ));
+        if (showBrowse && isCustomizationDiscoveryAvailable(this.configurationService, this.customizationMarketplaceService)) {
+            const browseLabel = ( localize(11127, "Browse MCPs"));
+            const browse = disposables.add(( new Button(actions, {
+                ...getButtonStyles({
+                    buttonSecondaryBackground: undefined,
+                    buttonSecondaryForeground: undefined,
+                    buttonSecondaryHoverBackground: undefined,
+                    buttonSecondaryBorder: undefined
+                }),
+                secondary: true,
+                title: browseLabel,
+                ariaLabel: browseLabel
+            })));
+            browse.element.classList.add("plugin-installed-action", "plugin-card-ghost-button");
+            browse.label = browseLabel;
+            disposables.add(browse.onDidClick(() => this._onDidRequestBrowse.fire()));
+        }
     }
-    renderAvailableServers(parent, servers, showDescription) {
-        const availableList = this.renderCardSection(parent, ( localize(9151, "Available")), showDescription ? ( localize(9152, "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(9153, "Loading marketplace MCP servers...")), MCP_SECTION_ITEM_HEIGHT);
-            } else {
-                const empty = append(availableList, $(".plugin-inventory-empty"));
-                empty.textContent = ( localize(9154, "No marketplace MCP servers are available."));
+    startConnectorAction() {
+        this.connectorActionCancellation.value?.cancel();
+        const cancellation = ( new CancellationTokenSource());
+        this.connectorActionCancellation.value = cancellation;
+        return cancellation;
+    }
+    showConnectorActions(connector, anchor) {
+        const disposables = ( new DisposableStore());
+        const disconnect = disposables.add(( new Action(
+            "connectors.disconnect",
+            getConnectorActionLabel("disconnect"),
+            undefined,
+            true,
+            async () => {
+                const cancellation = this.startConnectorAction();
+                try {
+                    await this.connectorsService.disconnect(connector.name, cancellation.token);
+                    if (!cancellation.token.isCancellationRequested) {
+                        await this.refreshConnectors();
+                        if (!cancellation.token.isCancellationRequested) {
+                            status(( localize(
+                                11128,
+                                "{0}: {1}",
+                                connector.displayName,
+                                getConnectorActionLabel("disconnect")
+                            )));
+                        }
+                    }
+                } catch (error) {
+                    if (!cancellation.token.isCancellationRequested && !isCancellationError(error)) {
+                        this.notificationService.error(( localize(
+                            11129,
+                            "Unable to update {0}: {1}",
+                            connector.displayName,
+                            getErrorMessage(error)
+                        )));
+                    }
+                } finally {
+                    if (this.connectorActionCancellation.value === cancellation) {
+                        this.connectorActionCancellation.clear();
+                    }
+                }
             }
-            this.cardListControllers.get(availableList)?.finalize();
-            return;
-        }
-        this.createMcpSectionList(availableList, ( localize(9151, "Available")), servers.map(server => ({
-            type: "marketplace-item",
-            server
-        })));
+        )));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => [disconnect],
+            onHide: () => disposables.dispose()
+        });
     }
     appendInstalledServerRow(parent, presentation) {
         let entry = presentation.entry;
@@ -2063,54 +3004,87 @@ let McpListWidget = class McpListWidget extends Disposable {
         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 content = append(row, $(".mcp-installed-card-content"));
+        const primaryAction = this.addSurfaceActivation(content, getMcpEntryAriaLabel(
+            entry,
+            this.workspaceService.isSessionsWindow,
+            this.getMcpServerCompatibilityKind(entry),
+            this.labelService,
+            this.agentPluginService,
+            this.extensionsWorkbenchService
+        ), () => this._onDidSelectServer.fire(this.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 compatibilityMessage = append(content, $(".mcp-server-compatibility-message"));
+        const compatibilityMessageDisposables = this.cardDisposables.add(( new DisposableStore()));
         const actions = append(row, $(".plugin-list-item-action"));
         const getEntry = () => entry;
         const signIn = this.appendInstalledServerSignIn(actions, getEntry);
-        const toggle = this.appendInstalledServerToggle(actions, getEntry);
+        const start = this.appendInstalledServerStart(actions, getEntry);
+        const errorActions = append(actions, $(".mcp-server-error-actions"));
+        const statusIcon = append(errorActions, $("span.mcp-server-state-icon"));
+        const showOutput = this.appendInstalledServerShowOutput(errorActions, getEntry);
+        const toggle = entry.type === "provider-item" ? undefined : this.appendInstalledServerToggle(actions, getEntry);
         const more = this.cardDisposables.add(( new Button(actions, {
             ...getButtonStyles({
                 buttonSecondaryBackground: undefined,
+                buttonSecondaryForeground: undefined,
+                buttonSecondaryHoverBackground: undefined,
                 buttonSecondaryBorder: undefined
             }),
             secondary: true,
-            supportIcons: true,
-            ariaLabel: ( localize(9146, "More actions for {0}", label))
+            ariaLabel: ( localize(11109, "More actions for {0}", label))
         })));
         more.element.classList.add("plugin-card-icon-button");
-        more.label = `$(${Codicon.ellipsis.id})`;
+        more.icon = Codicon.ellipsis;
         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),
+            actions: [
+                compatibilityMessage,
+                signIn?.element,
+                start.element,
+                showOutput.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);
             }
+            const compatibilityKind = this.getMcpServerCompatibilityKind(entry, reader);
+            updateMcpCompatibilityMessage(
+                compatibilityMessage,
+                compatibilityKind,
+                compatibilityMessageDisposables,
+                () => this._onDidRequestOpenMigrations.fire()
+            );
             updateMcpCardRuntimePresentation(
-                statusBadge,
+                statusIcon,
                 primaryAction,
                 description,
                 getMcpStatusKind(entry, this.workspaceService.isSessionsWindow),
                 getMcpDisabledReason(entry),
-                getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+                getMcpEntryAriaLabel(
+                    entry,
+                    this.workspaceService.isSessionsWindow,
+                    compatibilityKind,
+                    this.labelService,
+                    this.agentPluginService,
+                    this.extensionsWorkbenchService
+                ),
                 this.getInstalledEntryDescription(entry)
             );
+            start.update();
+            showOutput.update();
         }));
         this.cardDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
             const updated = this.installedEntries.find(candidate => getMcpRowKey(candidate.entry) === rowKey)?.entry;
@@ -2118,17 +3092,33 @@ let McpListWidget = class McpListWidget extends Disposable {
                 return;
             }
             entry = updated;
+            const compatibilityKind = this.getMcpServerCompatibilityKind(entry);
+            updateMcpCompatibilityMessage(
+                compatibilityMessage,
+                compatibilityKind,
+                compatibilityMessageDisposables,
+                () => this._onDidRequestOpenMigrations.fire()
+            );
             updateMcpCardRuntimePresentation(
-                statusBadge,
+                statusIcon,
                 primaryAction,
                 description,
                 getMcpStatusKind(entry, this.workspaceService.isSessionsWindow),
                 getMcpDisabledReason(entry),
-                getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+                getMcpEntryAriaLabel(
+                    entry,
+                    this.workspaceService.isSessionsWindow,
+                    compatibilityKind,
+                    this.labelService,
+                    this.agentPluginService,
+                    this.extensionsWorkbenchService
+                ),
                 this.getInstalledEntryDescription(entry)
             );
             signIn?.update();
-            toggle.update();
+            start.update();
+            showOutput.update();
+            toggle?.update();
             row.classList.toggle("disabled", !this.isInstalledEntryEnabled(entry));
         }));
     }
@@ -2138,46 +3128,92 @@ let McpListWidget = class McpListWidget extends Disposable {
         }
         const label = getMcpEntryLabel(getEntry());
         const signInButton = createMcpSignInButton(parent, this.cardDisposables, label);
-        registerMcpInlineButtonAction(this.cardDisposables, signInButton, async () => {
-            const activeSessionServer = getActiveSessionServer(getEntry());
-            if (!activeSessionServer) {
-                return;
+        const actionDisposables = this.cardDisposables.add(( new DisposableStore()));
+        let hasAuthRequiredAction = false;
+        const update = () => {
+            const isAuthRequired = getMcpStatusKind(getEntry(), this.workspaceService.isSessionsWindow) === McpServerStatus.AuthRequired;
+            if (hasAuthRequiredAction !== isAuthRequired) {
+                actionDisposables.clear();
+                resetMcpSignInButton(signInButton, label, true);
+                hasAuthRequiredAction = isAuthRequired;
+                if (isAuthRequired) {
+                    registerMcpSignInButtonAction(actionDisposables, signInButton, label, async () => {
+                        const activeSessionServer = getActiveSessionServer(getEntry());
+                        if (!activeSessionServer) {
+                            return;
+                        }
+                        try {
+                            return await authenticateMcpServer(
+                                this.agentHostCustomizationService,
+                                this.customizationHarnessService.activeSessionResource.get(),
+                                activeSessionServer.id
+                            );
+                        } catch (error) {
+                            this.notificationService.error(( localize(11130, "Unable to sign in to {0}: {1}", label, getErrorMessage(error))));
+                            return false;
+                        }
+                    });
+                }
             }
-            signInButton.enabled = false;
+            signInButton.element.style.display = isAuthRequired ? "" : "none";
+        };
+        update();
+        return {
+            element: signInButton.element,
+            update
+        };
+    }
+    appendInstalledServerStart(parent, getEntry) {
+        const startButton = createMcpStartButton(parent, this.cardDisposables, getMcpEntryLabel(getEntry()));
+        registerMcpInlineButtonAction(this.cardDisposables, startButton, async () => {
+            startButton.enabled = false;
             try {
-                await authenticateMcpServer(
-                    this.agentHostCustomizationService,
-                    this.customizationHarnessService.activeSessionResource.get(),
-                    activeSessionServer.id
-                );
-            } catch (error) {
-                this.notificationService.error(( localize(9155, "Unable to sign in to {0}: {1}", label, getErrorMessage(error))));
+                await startMcpEntry(getEntry());
             } finally {
-                signInButton.enabled = true;
+                startButton.enabled = true;
             }
         });
         const update = () => {
-            signInButton.element.style.display = getMcpStatusKind(getEntry(), this.workspaceService.isSessionsWindow) === McpServerStatus.AuthRequired ? "" : "none";
+            const state = getMcpStatusKind(getEntry(), this.workspaceService.isSessionsWindow);
+            startButton.element.style.display = state === McpServerStatus.Stopped || state === McpConnectionState.Kind.Stopped ? "" : "none";
         };
         update();
         return {
-            element: signInButton.element,
+            element: startButton.element,
+            update
+        };
+    }
+    appendInstalledServerShowOutput(parent, getEntry) {
+        const showOutputButton = createMcpShowOutputButton(parent, this.cardDisposables, getMcpEntryLabel(getEntry()));
+        registerMcpInlineButtonAction(
+            this.cardDisposables,
+            showOutputButton,
+            () => this.showMcpServerOutput(getEntry())
+        );
+        const update = () => {
+            const state = getMcpStatusKind(getEntry(), this.workspaceService.isSessionsWindow);
+            showOutputButton.element.style.display = state === McpServerStatus.Error || state === McpConnectionState.Kind.Error ? "" : "none";
+        };
+        update();
+        return {
+            element: showOutputButton.element,
             update
         };
     }
     appendInstalledServerToggle(parent, getEntry) {
         const label = getMcpEntryLabel(getEntry());
         let enabled = this.isInstalledEntryEnabled(getEntry());
-        const toggle = this.cardDisposables.add(( new Switch({
+        const disabledLabel = append(parent, $(".mcp-server-disabled-label"));
+        const toggle = this.cardDisposables.add(this.instantiationService.createInstance(CustomizationToggle, {
             ariaLabel: label,
             checked: enabled
-        })));
+        }));
         const switchElement = toggle.domNode;
         append(parent, switchElement);
         const updateLabel = () => {
             const blockedByPlugin = getMcpDisabledReason(getEntry())?.source === "plugin";
-            const toggleLabel = enabled ? ( localize(9141, "Disable {0}", label)) : ( localize(9142, "Enable {0}", label));
-            const accessibleLabel = blockedByPlugin ? ( localize(9143, "{0} is disabled by its plugin", label)) : toggleLabel;
+            const toggleLabel = enabled ? ( localize(11104, "Disable {0}", label)) : ( localize(11105, "Enable {0}", label));
+            const accessibleLabel = blockedByPlugin ? ( localize(11106, "{0} is disabled by its plugin", label)) : toggleLabel;
             toggle.setAriaLabel(accessibleLabel);
         };
         updateLabel();
@@ -2185,11 +3221,14 @@ let McpListWidget = class McpListWidget extends Disposable {
             enabled = checked;
             updateLabel();
             this.setInstalledEntryEnabled(getEntry(), enabled);
-            status(enabled ? ( localize(9144, "{0} enabled.", label)) : ( localize(9145, "{0} disabled.", label)));
+            status(enabled ? ( localize(11107, "{0} enabled.", label)) : ( localize(11108, "{0} disabled.", label)));
         }));
         const update = () => {
             enabled = this.isInstalledEntryEnabled(getEntry());
-            toggle.disabled = getMcpDisabledReason(getEntry())?.source === "plugin";
+            const disabledReason = getMcpDisabledReason(getEntry());
+            disabledLabel.textContent = enabled ? "" : getMcpDisabledLabel(disabledReason);
+            disabledLabel.style.display = enabled ? "none" : "";
+            toggle.disabled = disabledReason?.source === "plugin";
             toggle.checked = enabled;
             updateLabel();
         };
@@ -2201,21 +3240,24 @@ let McpListWidget = class McpListWidget extends Disposable {
     }
     appendMarketplaceServerRow(parent, server) {
         const row = append(parent, $(".plugin-list-item.plugin-home-row.plugin-marketplace-home-row"));
-        const primaryAction = this.addSurfaceActivation(row, ( localize(9138, "{0}. Available to install from the MCP marketplace.", server.label)), () => this._onDidSelectServer.fire(createWorkbenchMcpServerDetailInput(server)));
+        const primaryAction = this.addSurfaceActivation(row, ( localize(11097, "{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(9105, "No description provided.")));
+        description.textContent = truncateToFirstLine(server.description || ( localize(11036, "No description provided.")));
         const actions = append(row, $(".plugin-list-item-action"));
         const install = this.cardDisposables.add(( new Button(actions, {
-            ...defaultButtonStyles,
-            ariaLabel: ( localize(9156, "Install {0}", server.label))
+            ...getButtonStyles({
+                buttonSecondaryHoverBackground: undefined
+            }),
+            secondary: true,
+            ariaLabel: ( localize(11131, "Install {0}", server.label))
         })));
         install.element.classList.add("plugin-list-item-install-button");
-        install.label = ( localize(9106, "Install"));
+        install.label = ( localize(11037, "Install"));
         this.cardDisposables.add(install.onDidClick(() => this.installMarketplaceServer(server, install)));
         this.cardListControllers.get(parent)?.addItem({
             row,
@@ -2225,55 +3267,44 @@ let McpListWidget = class McpListWidget extends Disposable {
         });
     }
     async installMarketplaceServer(server, button) {
-        button.label = ( localize(9157, "Installing..."));
+        button.label = ( localize(11132, "Installing..."));
         button.enabled = false;
         try {
-            await this.mcpWorkbenchService.install(server);
-            status(( localize(9158, "{0} installed.", server.label)));
+            await runCustomizationMarketplaceInstallWithTelemetry(
+                this.telemetryService,
+                getAvailableCustomizationMarketplaceInstallTelemetryContext("mcpServer"),
+                async () => {
+                    await this.mcpWorkbenchService.install(server);
+                }
+            );
+            status(( localize(11133, "{0} installed.", server.label)));
             await this.refresh();
         } catch (error) {
-            button.label = ( localize(9106, "Install"));
+            button.label = ( localize(11037, "Install"));
             button.enabled = true;
-            this.notificationService.error(( localize(9159, "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());
-            }
+            this.notificationService.error(( localize(11134, "Unable to install MCP server: {0}", getErrorMessage(error))));
         }
-        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(9105, "No description provided.")));
+        const description = entry.type === "server-item" ? entry.server.description : entry.type === "builtin-item" || entry.type === "connector-item" || entry.type === "provider-item" ? entry.description : "";
+        return truncateToFirstLine(description || ( localize(11036, "No description provided.")));
     }
     isInstalledEntryEnabled(entry) {
+        if (entry.type === "provider-item") {
+            return true;
+        }
         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);
     }
+    isInstalledEntryInUse(entry) {
+        return isMcpServerInUse(this.isInstalledEntryEnabled(entry), getActiveSessionServer(entry));
+    }
     setInstalledEntryEnabled(entry, enabled) {
+        if (entry.type === "provider-item") {
+            return;
+        }
         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);
@@ -2287,35 +3318,23 @@ let McpListWidget = class McpListWidget extends Disposable {
         );
     }
     updateSearchResults() {
-        const available = this.getAvailableGalleryServers();
-        if (this.installedEntries.length === 0 && available.length === 0) {
-            this.showEmptySurface(this.gallerySearchLoading ? ( localize(9160, "Searching the MCP marketplace...")) : ( localize(9161, "No servers match '{0}'", this.searchQuery)), this.gallerySearchLoading ? "" : ( localize(9162, "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(9163, "Installed")), undefined, "installed-mcp-servers-section", this.installedEntries.length);
-            installedList.classList.add("plugin-inventory-list");
-            this.createMcpSectionList(installedList, ( localize(9163, "Installed")), this.installedEntries.map(presentation => presentation.entry));
-        }
-        if (available.length > 0) {
-            this.renderAvailableServers(content, available, false);
-        }
-        this.scheduleMcpSectionLayout();
+        this.renderMcpTree();
     }
     filterServers(render = true) {
         const query = this.searchQuery.toLowerCase().trim();
         const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
-        const activeSessionMatcher = ( new ActiveSessionMcpServerMatcher(this.agentHostCustomizationService.getMcpServers(activeSessionResource)));
-        const localServerMatcher = ( new LocalMcpServerMatcher(this.mcpService.servers.get()));
+        const activeSessionServers = this.agentHostCustomizationService.getMcpServers(activeSessionResource);
+        const runtimeServers = this.mcpService.servers.get();
+        const activeSessionMatcher = ( new ActiveSessionMcpServerMatcher(activeSessionServers));
+        const localServerMatcher = ( new LocalMcpServerMatcher(runtimeServers));
+        const marketplaceInstallations = this.marketplaceInstallService.installations.get();
+        const providerEntries = createProviderMcpEntries(marketplaceInstallations.installations, [
+            ...this.mcpWorkbenchService.local.flatMap(getWorkbenchServerMatchKeys),
+            ...runtimeServers.flatMap(getRuntimeServerMatchKeys),
+            ...activeSessionServers.flatMap(
+                server => getUniqueMcpMatchKeys([server.id, server.name, server.displayName])
+            )
+        ], query);
         if (query) {
             this.filteredServers = this.mcpWorkbenchService.local.filter(
                 server => server.label.toLowerCase().includes(query) || (server.description?.toLowerCase().includes(query))
@@ -2325,7 +3344,7 @@ let McpListWidget = class McpListWidget extends Disposable {
         }
         const localIds = ( new Set(this.filteredServers.map(s => s.id)));
         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 builtinServers = runtimeServers.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 = [{
             entries: []
         }, {
@@ -2335,6 +3354,10 @@ let McpListWidget = class McpListWidget extends Disposable {
             const entry = {
                 type: "server-item",
                 server,
+                marketplaceRecord: marketplaceInstallations.findByTarget({
+                    kind: "mcp",
+                    id: server.id
+                }),
                 activeSessionServer: activeSessionMatcher.take(getWorkbenchServerMatchKeys(server)),
                 localServer: localServerMatcher.find(getWorkbenchServerMatchKeys(server))
             };
@@ -2358,11 +3381,29 @@ let McpListWidget = class McpListWidget extends Disposable {
             if (server.collection.id.startsWith(PLUGIN_COLLECTION_PREFIX)) {
                 pluginServers.push(entry);
             } else if (source instanceof ExtensionIdentifier && !isCopilotExtension(source)) {
-                extensionServers.push(entry);
+                extensionServers.push({
+                    ...entry,
+                    extensionId: source
+                });
             } else {
-                otherBuiltinServers.push(entry);
+                otherBuiltinServers.push({
+                    ...entry,
+                    extensionId: source instanceof ExtensionIdentifier ? source : undefined
+                });
             }
         }
+        const regularMatchKeys = ( new Set([
+            ...this.filteredServers.flatMap(getWorkbenchServerMatchKeys),
+            ...builtinServers.flatMap(getRuntimeServerMatchKeys)
+        ].map(key => key.toLowerCase())));
+        const connectorMcpEntries = this.isConnectorsEnabled() ? this.connectorsService.connectedMcpServers.filter(server => !( regularMatchKeys.has(server.serverName.toLowerCase()))).filter(server => !query || ( [
+            server.connector.displayName,
+            server.connector.description,
+            server.serverName
+        ].some(value => value.toLowerCase().includes(query)))).map(server => createConnectorMcpEntry(
+            server,
+            activeSessionMatcher.takeConnector([server.serverName], [server.connector.name, server.connector.displayName])
+        )) : [];
         const activeSessionOnlyServers = activeSessionMatcher.unmatched(query);
         const activeSessionBuiltinEntries = createBuiltinActiveSessionMcpEntries(activeSessionOnlyServers);
         this.installedEntries = [...groups.flatMap(group => group.entries.map(entry => ({
@@ -2377,22 +3418,32 @@ let McpListWidget = class McpListWidget extends Disposable {
         })), ...extensionServers.map((
             {
                 server,
-                activeSessionServer
+                activeSessionServer,
+                extensionId
             }
         ) => ({
-            entry: createBuiltinEntry(server, activeSessionServer)
+            entry: createBuiltinEntry(server, activeSessionServer, extensionId)
         })), ...otherBuiltinServers.map((
             {
                 server,
-                activeSessionServer
+                activeSessionServer,
+                extensionId
             }
         ) => ({
-            entry: createBuiltinEntry(server, activeSessionServer)
+            entry: createBuiltinEntry(server, activeSessionServer, extensionId)
+        })), ...connectorMcpEntries.map(entry => ({
+            entry
         })), ...activeSessionBuiltinEntries.map(entry => ({
             entry
+        })), ...providerEntries.map(entry => ({
+            entry
         }))];
-        this.filteredBuiltinCount = builtinServers.length;
-        this.filteredActiveSessionCount = activeSessionOnlyServers.length;
+        this.installedEntries = preserveMcpEntryOrder(this.installedEntries, this.installedEntryOrder);
+        this.element.classList.toggle("show-mcp-item-icons", ( this.installedEntries.some((
+            {
+                entry
+            }
+        ) => hasMcpInstalledEntryIcon(entry))));
         this._onDidChangeItemCount.fire(this.itemCount);
         if (render) {
             this.renderFilteredServers();
@@ -2412,12 +3463,19 @@ let McpListWidget = class McpListWidget extends Disposable {
             }
         ) => [
             getMcpRowKey(entry),
+            getMcpEntryGroup(entry),
             getActiveSessionServer(entry) ? "session" : "",
-            entry.type !== "session-server-item" && entry.localServer ? "local" : ""
+            entry.type !== "session-server-item" && entry.localServer ? "local" : "",
+            getMcpEntrySourceUri(entry)?.toString() ?? "",
+            getMcpEntryLabel(entry)
         ].join(":")).join("|");
     }
     get itemCount() {
-        return this.filteredServers.length + this.filteredBuiltinCount + this.filteredActiveSessionCount;
+        return this.installedEntries.filter((
+            {
+                entry
+            }
+        ) => this.isInstalledEntryInUse(entry)).length;
     }
     fireItemCount() {
         this._onDidChangeItemCount.fire(this.itemCount);
@@ -2449,38 +3507,81 @@ let McpListWidget = class McpListWidget extends Disposable {
         }
         const headerHeight = this.sectionTitleHeader.offsetHeight;
         this.lastHeaderHeight = headerHeight;
-        const listHeight = Math.max(0, availableHeight - searchBarHeight - headerHeight);
+        const listHeight = getCustomizationTreeContentHeight(this.element, this.listContainer, availableHeight);
         this.cardScrollableNode.style.height = `${listHeight}px`;
+        this.listContainer.style.height = `${listHeight}px`;
+        this.list.layout(listHeight, width);
         this.scheduleMcpSectionLayout();
     }
     focusSearch() {
         this.searchInput.focus();
     }
+    setSearchQuery(query) {
+        this.searchInput.value = query;
+    }
     revealLastItem() {
-        const reveal = () => {
-            const section = this.sectionLists.at(-1);
-            if (section?.entries.length) {
-                section.list.reveal(section.entries.length - 1);
+        const entries = this.getVisibleMcpEntries();
+        if (entries.length > 0) {
+            this.list.reveal(entries[entries.length - 1]);
+        }
+    }
+    revealAndSelectServer(serverId, serverName, connectorName) {
+        if (this.searchQuery) {
+            this.searchInput.value = "";
+            this.searchQuery = "";
+            this.delayedFilter.cancel();
+            void this.filterServers();
+            return false;
+        }
+        const entry = this.getVisibleMcpEntries().find(entry => {
+            if (connectorName) {
+                return entry.type === "connector-item" && entry.connector.connector.name === connectorName;
             }
-            this.cardScrollable.scanDomNode();
-            this.cardScrollable.setScrollPosition({
-                scrollTop: this.cardContainer.scrollHeight
-            });
-        };
-        reveal();
-        this.revealLastItemScheduler.value = scheduleAtNextAnimationFrame(getWindow(this.element), reveal);
-    }
-    focus() {
-        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();
+            if (serverId) {
+                switch (entry.type) {
+                case "server-item":
+                case "session-server-item":
+                    return entry.server.id === serverId;
+                case "builtin-item":
+                case "connector-item":
+                    return entry.id === serverId || entry.activeSessionServer?.id === serverId;
+                case "provider-item":
+                    return entry.id === serverId || entry.name === serverId;
+                case "group-header":
+                case "marketplace-item":
+                    return false;
                 }
             }
+            switch (entry.type) {
+            case "server-item":
+                return entry.server.label === serverName;
+            case "session-server-item":
+                return entry.server.name === serverName || entry.server.displayName === serverName;
+            case "builtin-item":
+                return entry.label === serverName;
+            case "connector-item":
+                return entry.label === serverName || entry.connector.connector.displayName === serverName;
+            case "provider-item":
+                return entry.name === serverName || entry.label === serverName;
+            case "group-header":
+            case "marketplace-item":
+                return false;
+            }
+        });
+        if (!entry) {
+            return false;
+        }
+        this.list.reveal(entry);
+        this.list.setFocus([entry]);
+        this.list.setSelection([entry]);
+        this.list.domFocus();
+        return true;
+    }
+    focus() {
+        const firstItem = this.getVisibleMcpEntries().find(entry => entry.type !== "group-header");
+        if (firstItem) {
+            this.list.setFocus([firstItem]);
+            this.list.domFocus();
         }
     }
     updateResponsiveLayout(width) {
@@ -2493,11 +3594,12 @@ let McpListWidget = class McpListWidget extends Disposable {
         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(9150, "Add")) : ( localize(9149, "Add Server"));
-        }
     }
     showMcpServerActions(entry, anchor) {
+        if (isConnectorMcpEntry(entry)) {
+            this.showConnectorActions(entry.connector.connector, anchor);
+            return;
+        }
         const disposables = ( new DisposableStore());
         const actions = this.getMcpServerActions(entry, disposables);
         if (actions.length === 0) {
@@ -2510,35 +3612,46 @@ let McpListWidget = class McpListWidget extends Disposable {
             onHide: () => disposables.dispose()
         });
     }
-    getMcpServerActions(entry, disposables) {
+    getMcpServerOutputHandler(entry) {
         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(
+        return activeSessionServer ? getMcpServerOutputHandler(
             this.outputService,
             undefined,
             activeSessionServer,
-            undefined,
-            () => this.agentHostCustomizationService.showMcpServerLog(sessionResource, activeSessionServer.id)
+            this._closeCustomizationEditor,
+            beforeShow => this.agentHostCustomizationService.showMcpServerLog(sessionResource, activeSessionServer.id, beforeShow)
         ) : getMcpServerOutputHandler(
             this.outputService,
             entry.type === "session-server-item" ? undefined : entry.localServer,
-            undefined
+            undefined,
+            this._closeCustomizationEditor
+        );
+    }
+    async showMcpServerOutput(entry) {
+        const currentEntry = resolveMcpEntry(
+            entry,
+            this.agentHostCustomizationService,
+            this.customizationHarnessService.activeSessionResource.get()
         );
+        const showOutput = currentEntry && this.getMcpServerOutputHandler(currentEntry);
+        await showOutput?.();
+    }
+    getMcpServerActions(entry, disposables) {
+        const sessionResource = this.customizationHarnessService.activeSessionResource.get();
+        const currentEntry = resolveMcpEntry(entry, this.agentHostCustomizationService, sessionResource);
+        if (!currentEntry) {
+            return [];
+        }
+        entry = currentEntry;
+        const actions = this.getMcpServerManagementActions(entry, disposables);
+        const showOutput = this.getMcpServerOutputHandler(entry);
         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(9164, "Show Output")), undefined, true, showOutput)));
+            const outputAction = disposables.add(( new Action("mcpServer.showOutput", ( localize(11043, "Show Output")), undefined, true, showOutput)));
             if (outputIndex !== -1) {
                 actions.splice(outputIndex, 0, outputAction);
             } else {
@@ -2551,6 +3664,9 @@ let McpListWidget = class McpListWidget extends Disposable {
         return actions;
     }
     getMcpServerManagementActions(entry, disposables) {
+        if (entry.type === "provider-item") {
+            return [disposables.add(( new Action(MCP_UNINSTALL_ACTION_ID, ( localize(11135, "Uninstall")), undefined, true, () => this.marketplaceInstallService.uninstall(entry.marketplaceRecord.resource))))];
+        }
         if (entry.type === "session-server-item") {
             const actions = getActiveSessionServerOptionsActions(
                 this.commandService,
@@ -2562,6 +3678,9 @@ let McpListWidget = class McpListWidget extends Disposable {
             actions.forEach(action => isDisposable(action) && disposables.add(action));
             return actions;
         }
+        if (entry.type === "connector-item") {
+            return [];
+        }
         if (entry.type === "builtin-item") {
             const collectionId = entry.collectionId;
             const pluginUriStr = getPluginUriFromCollectionId(collectionId);
@@ -2594,32 +3713,32 @@ let McpListWidget = class McpListWidget extends Disposable {
                     }
                 }
             }
+            const sourceAction = plugin ? undefined : this.getBuiltinMcpServerSourceAction(entry);
+            if (sourceAction) {
+                if (actions.length > 0) {
+                    actions.push(( new Separator()));
+                }
+                actions.push(disposables.add(sourceAction));
+            }
             if (plugin) {
                 if (actions.length > 0) {
                     actions.push(( new Separator()));
                 }
-                actions.push(disposables.add(( new Action("mcpServer.showPlugin", ( localize(9165, "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.showPlugin", ( localize(11136, "Show Plugin")), undefined, true, async () => {
+                    this._onDidRequestShowPlugin.fire(createInstalledPluginItem(plugin));
                 }))));
-                actions.push(disposables.add(( new Action("mcpServer.uninstallPlugin", ( localize(9166, "Uninstall Plugin")), undefined, true, async () => {
+                actions.push(disposables.add(( new Action("mcpServer.uninstallPlugin", ( localize(11137, "Uninstall Plugin")), undefined, true, async () => {
                     const result = await this.dialogService.confirm({
-                        message: ( localize(9167, "This MCP server is provided by the plugin '{0}'", plugin.label)),
+                        message: ( localize(11138, "This MCP server is provided by the plugin '{0}'", plugin.label)),
                         detail: ( localize(
-                            9168,
+                            11139,
                             "Individual MCP servers from a plugin cannot be removed separately. Would you like to uninstall the entire plugin?"
                         )),
-                        primaryButton: ( localize(9169, "Uninstall Plugin")),
+                        primaryButton: ( localize(11140, "Uninstall Plugin")),
                         type: "question"
                     });
                     if (result.confirmed) {
-                        await plugin.remove?.();
+                        await removePluginWithMarketplaceOwnership(plugin, this.marketplaceInstallService);
                     }
                 }))));
             }
@@ -2637,8 +3756,14 @@ let McpListWidget = class McpListWidget extends Disposable {
             ["workspace", "session"]
         ) : [];
         for (const menuActions of groups) {
-            for (const menuAction of menuActions) {
-                if (isDisposable(menuAction)) {
+            for (let index = 0; index < menuActions.length; index++) {
+                const originalMenuAction = menuActions[index];
+                if (isDisposable(originalMenuAction)) {
+                    disposables.add(originalMenuAction);
+                }
+                const menuAction = getMarketplaceMcpManagementAction(originalMenuAction, mcpServer.id, this.marketplaceInstallService);
+                menuActions[index] = menuAction;
+                if (menuAction !== originalMenuAction && isDisposable(menuAction)) {
                     disposables.add(menuAction);
                 }
             }
@@ -2655,7 +3780,42 @@ let McpListWidget = class McpListWidget extends Disposable {
             agentHostEnablementActions
         );
     }
+    getBuiltinMcpServerSourceAction(entry) {
+        const extensionId = entry.extensionId;
+        if (extensionId) {
+            return (new Action(
+                "mcpServer.showExtension",
+                localize(11141, "Show Extension"),
+                undefined,
+                true,
+                async () => {
+                    await this.extensionsWorkbenchService.open(extensionId.value, {
+                        tab: ExtensionEditorTab.Features,
+                        feature: "mcp"
+                    });
+                }
+            ));
+        }
+        const localServer = entry.localServer;
+        const definitions = localServer?.readDefinitions().get();
+        if (!localServer || !(definitions?.server?.presentation?.origin ?? definitions?.collection?.presentation?.origin)) {
+            return undefined;
+        }
+        return (new Action(
+            "mcpServer.showConfiguration",
+            localize(11142, "Show Configuration"),
+            undefined,
+            true,
+            async () => {
+                await this.commandService.executeCommand(
+                    McpCommandIds.ShowConfiguration,
+                    localServer.collection.id,
+                    localServer.definition.id
+                );
+            }
+        ));
+    }
 };
-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));
+McpListWidget = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IMcpWorkbenchService)), ( __param(2, IMcpGalleryManifestService)), ( __param(3, ICustomizationMarketplaceInstallService)), ( __param(4, IMcpService)), ( __param(5, IMcpRegistry)), ( __param(6, ICopilotConnectorsService)), ( __param(7, ICommandService)), ( __param(8, IOpenerService)), ( __param(9, IContextViewService)), ( __param(10, IContextMenuService)), ( __param(11, IHoverService)), ( __param(12, IAgentPluginService)), ( __param(13, IDialogService)), ( __param(14, IConfigurationService)), ( __param(15, ICustomizationMarketplaceService)), ( __param(16, ICustomizationHarnessService)), ( __param(17, IAgentHostCustomizationService)), ( __param(18, IAICustomizationWorkspaceService)), ( __param(19, INotificationService)), ( __param(20, IOutputService)), ( __param(21, ILabelService)), ( __param(22, IExtensionsWorkbenchService)), ( __param(23, ILogService)), ( __param(24, ITelemetryService)), ( __param(25, IWorkspaceContextService))], 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 };
+export { McpListWidget, McpServerItemRenderer, authenticateMcpServer, createAgentHostMcpServerDetailInput, createBuiltinActiveSessionMcpEntries, createInstalledMcpServerDetailInput, createInstalledPluginItem, createMcpSignInButton, createProviderMcpEntries, getActiveSessionServerDefinitionUnavailable, getActiveSessionServerLifecycleAction, getActiveSessionServerOptionsActions, getActiveSessionServerPresentation, getActiveSessionServerProvenance, getAgentHostMcpServerEnablementActions, getAgentHostMcpServerSource, getBuiltinMcpServerEnablementActions, getLocalMcpServerEnablementActions, getMarketplaceMcpManagementAction, getMcpCompatibilityPresentation, getMcpEntryGroup, getMcpErrorMessage, getMcpRowKey, getMcpServerOutputHandler, getMcpStatusPresentation, getMcpStatusRenderSignature, getServerItemContextMenuActions, getToggledMcpEnablementState, hasSameMcpMembership, isMcpServerCollectionVisible, isPrimaryMcpServerEnabled, preserveMcpEntryOrder, registerMcpInlineButtonAction, registerMcpSignInButtonAction, renderMcpServerStatusActions, setPrimaryMcpServerEnablement, shouldLoadMcpGallerySnapshot, shouldShowLegacyMcpGallery, updateMcpCardRuntimePresentation, updateMcpCompatibilityMessage };