@codingame/monaco-vscode-api 37.2.0 → 37.3.0

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

@@ -0,0 +1,2661 @@
+
+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 { Emitter } from '../../../../../base/common/event.js';
+import { localize } from '../../../../../nls.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.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 { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.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 { 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 { 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';
+import { InputBox, MessageType } from '../../../../../base/browser/ui/inputbox/inputBox.js';
+import { IContextViewService, IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
+import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
+import { Delayer } from '../../../../../base/common/async.js';
+import { Action, Separator } from '../../../../../base/common/actions.js';
+import { StartServerAction, StopServerAction, RestartServerAction, ConfigureModelAccessAction, ShowSamplingRequestsAction, EnableMcpServerGloballyAction, EnableMcpServerForWorkspaceAction, DisableMcpServerGloballyAction, DisableMcpServerForWorkspaceAction, ShowServerOutputAction, getContextMenuActions } from '../../../mcp/browser/mcpServerActions.js';
+import { LocalMcpServerScope } from '../../../../services/mcp/common/mcpWorkbenchManagementService.js';
+import { IAgentPluginService } from '../../common/plugins/agentPluginService.service.js';
+import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
+import { mcpServerIcon } from './aiCustomizationIcons.js';
+import { formatDisplayName } from './aiCustomizationListWidget.js';
+import { getDefaultHoverDelegate } from '../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { IHoverService } from '../../../../../platform/hover/browser/hover.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 { 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';
+import '../../../../../platform/agentHost/common/state/protocol/channels-chat/state.js';
+import '../../../../../platform/agentHost/common/state/protocol/channels-terminal/state.js';
+import '../../../../../platform/agentHost/common/state/protocol/channels-changeset/state.js';
+import '../../../../../platform/agentHost/common/state/protocol/channels-resource-watch/state.js';
+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 { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
+import { 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 { DomScrollableElement } from '../../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { ScrollbarVisibility } from '../../../../../base/common/scrollable.js';
+import { WorkbenchList } from '../../../../../platform/list/browser/listService.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 COPILOT_EXTENSION_IDS = ["github.copilot", "github.copilot-chat"];
+function isCopilotExtension(id) {
+    return ( COPILOT_EXTENSION_IDS.some(copilotId => ExtensionIdentifier.equals(id, copilotId)));
+}
+function getPluginUriFromCollectionId(collectionId) {
+    return collectionId?.startsWith(PLUGIN_COLLECTION_PREFIX) ? collectionId.slice(PLUGIN_COLLECTION_PREFIX.length) : undefined;
+}
+function createBuiltinActiveSessionMcpEntries(servers) {
+    return servers.map(server => ({
+        type: "session-server-item",
+        server
+    }));
+}
+function isMcpServerCollectionVisible(collectionId, hiddenCollectionIds) {
+    return !hiddenCollectionIds?.includes(collectionId);
+}
+class McpSectionDelegate {
+    getHeight() {
+        return MCP_SECTION_ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        return element.type === "marketplace-item" ? "mcpMarketplaceItem" : "mcpServerItem";
+    }
+    hasDynamicHeight(element) {
+        return element.type !== "marketplace-item";
+    }
+}
+function getToggledMcpEnablementState(state) {
+    switch (state) {
+    case ContributionEnablementState.EnabledWorkspace:
+        return ContributionEnablementState.DisabledWorkspace;
+    case ContributionEnablementState.DisabledWorkspace:
+        return ContributionEnablementState.EnabledWorkspace;
+    case ContributionEnablementState.EnabledProfile:
+        return ContributionEnablementState.DisabledProfile;
+    case ContributionEnablementState.DisabledProfile:
+        return ContributionEnablementState.EnabledProfile;
+    }
+}
+let McpServerItemRenderer = class McpServerItemRenderer extends Disposable {
+    constructor(
+        _renderManagementActions,
+        workspaceService,
+        agentPluginService,
+        hoverService,
+        agentHostCustomizationService,
+        customizationHarnessService
+    ) {
+        super();
+        this._renderManagementActions = _renderManagementActions;
+        this.workspaceService = workspaceService;
+        this.agentPluginService = agentPluginService;
+        this.hoverService = hoverService;
+        this.agentHostCustomizationService = agentHostCustomizationService;
+        this.customizationHarnessService = customizationHarnessService;
+        this.templateId = "mcpServerItem";
+        this._templates = ( new Set());
+        this._focusedIndex = -1;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this.errorExpansionChanged = observableSignal(this);
+        this.expandedErrors = ( new Map());
+    }
+    readErrorExpansion(reader) {
+        this.errorExpansionChanged.read(reader);
+    }
+    syncError(element, error) {
+        const session = this.customizationHarnessService.activeSessionResource.get();
+        if (!isEqual(session, this.expansionSession)) {
+            this.expansionSession = session;
+            if (this.expandedErrors.size) {
+                this.expandedErrors.clear();
+                this.errorExpansionChanged.trigger(undefined);
+            }
+        }
+        const key = getMcpRowKey(element);
+        if (( this.expandedErrors.has(key)) && this.expandedErrors.get(key) !== error) {
+            this.expandedErrors.delete(key);
+            this.errorExpansionChanged.trigger(undefined);
+        }
+    }
+    isErrorExpanded(element, error) {
+        return error !== undefined && isEqual(
+            this.expansionSession,
+            this.customizationHarnessService.activeSessionResource.get()
+        ) && this.expandedErrors.get(getMcpRowKey(element)) === error;
+    }
+    isErrorClipped(element) {
+        return ( [...this._templates].some(
+            template => template.currentIndex >= 0 && template.renderedRowKey === getMcpRowKey(element) && template.isClipped
+        ));
+    }
+    renderTemplate(container) {
+        const templateDisposables = ( new DisposableStore());
+        container.classList.add("mcp-server-item");
+        container.style.minHeight = `${MCP_SECTION_ITEM_HEIGHT}px`;
+        const typeIcon = append(container, $(".mcp-server-icon"));
+        typeIcon.classList.add(...ThemeIcon.asClassNameArray(mcpServerIcon));
+        const details = append(container, $(".mcp-server-details"));
+        const nameRow = append(details, $(".mcp-server-name-row"));
+        const name = append(nameRow, $(".mcp-server-name"));
+        const statusBadge = append(nameRow, $(".plugin-list-item-status.mcp-runtime-status-badge"));
+        statusBadge.setAttribute("aria-hidden", "true");
+        const description = append(details, $(".mcp-server-description"));
+        description.id = defaultGenerator.nextId();
+        const descriptionHover = templateDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), description, "")
+        );
+        const expandButton = templateDisposables.add(( new Button(details, {
+            ...getButtonStyles({
+                buttonBackground: undefined,
+                buttonHoverBackground: undefined,
+                buttonForeground: undefined,
+                buttonBorder: undefined
+            })
+        })));
+        expandButton.element.classList.add("mcp-server-error-toggle");
+        expandButton.element.style.display = "none";
+        expandButton.element.setAttribute("aria-controls", description.id);
+        const actions = append(container, $(".mcp-server-actions"));
+        const template = {
+            container,
+            typeIcon,
+            name,
+            statusBadge,
+            description,
+            descriptionHover,
+            expandButton,
+            actions,
+            templateDisposables,
+            elementDisposables: ( new DisposableStore()),
+            actionDisposables: ( new DisposableStore()),
+            currentIndex: -1,
+            isRendering: false,
+            isExpanded: false,
+            isClipped: false
+        };
+        registerMcpInlineButtonAction(templateDisposables, expandButton, () => {
+            if (!template.currentElement || !template.currentError) {
+                return;
+            }
+            const key = getMcpRowKey(template.currentElement);
+            if (template.isExpanded) {
+                this.expandedErrors.delete(key);
+            } else {
+                this.expandedErrors.set(key, template.currentError);
+            }
+            this.renderDescription(template);
+            this.errorExpansionChanged.trigger(undefined);
+        });
+        const resizeObserver = templateDisposables.add(new DisposableResizeObserver(
+            "McpServerItemRenderer.description",
+            () => this.updateExpandButton(template)
+        ));
+        templateDisposables.add(resizeObserver.observe(description));
+        templateDisposables.add(addDisposableListener(
+            expandButton.element,
+            EventType.BLUR,
+            () => this.updateExpandButton(template)
+        ));
+        this._templates.add(template);
+        return template;
+    }
+    renderElement(element, index, templateData) {
+        templateData.isRendering = true;
+        try {
+            this.renderEntry(element, index, templateData);
+        } finally {
+            templateData.isRendering = false;
+        }
+    }
+    renderEntry(element, index, templateData) {
+        templateData.currentIndex = index;
+        templateData.currentElement = element;
+        const rowKey = getMcpRowKey(element);
+        if (templateData.renderedRowKey !== rowKey) {
+            templateData.renderedRowKey = rowKey;
+            templateData.renderedStatusSignature = undefined;
+            templateData.actionDisposables.clear();
+            clearNode(templateData.actions);
+        }
+        templateData.elementDisposables.clear();
+        if (element.type === "builtin-item") {
+            templateData.container.classList.add("builtin");
+            templateData.container.classList.toggle("has-detail", false);
+            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) {
+                templateData.elementDisposables.add(this.hoverService.setupDelayedHover(templateData.container, () => {
+                    const plugin = this.agentPluginService.plugins.get().find(p => ( p.uri.toString()) === pluginUriStr);
+                    if (plugin) {
+                        return {
+                            content: `${element.label}\n${( localize(8981, "Plugin: {0}", plugin.label))}`,
+                            appearance: {
+                                compact: true,
+                                skipFadeInAnimation: true
+                            }
+                        };
+                    }
+                    return {
+                        content: element.label,
+                        appearance: {
+                            compact: true,
+                            skipFadeInAnimation: true
+                        }
+                    };
+                }));
+            }
+            return;
+        }
+        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";
+            this.updateActiveSessionStatus(templateData, element);
+            return;
+        }
+        templateData.container.classList.remove("builtin");
+        templateData.name.textContent = formatDisplayName(element.server.label);
+        const description = element.server.description?.trim();
+        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) {
+            this.updateKnownServerStatus(templateData, element);
+        } else {
+            templateData.elementDisposables.add(autorun(reader => {
+                const disabled = element.localServer ? isContributionDisabled(element.localServer.enablement.read(reader)) : false;
+                const connectionState = element.localServer?.connectionState.read(reader);
+                templateData.container.classList.toggle("disabled", disabled);
+                this.updateStatus(
+                    templateData,
+                    element,
+                    element,
+                    disabled ? "disabled" : connectionState?.state,
+                    undefined,
+                    connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined
+                );
+            }));
+        }
+    }
+    updateKnownServerStatus(templateData, element) {
+        let localDisabled = false;
+        let connectionState;
+        const update = () => {
+            const currentEntry = resolveMcpEntry(
+                element,
+                this.agentHostCustomizationService,
+                this.customizationHarnessService.activeSessionResource.get()
+            );
+            const activeSessionServer = currentEntry && getActiveSessionServer(currentEntry);
+            if (element.activeSessionServer !== undefined) {
+                const presentation = activeSessionServer && getActiveSessionServerPresentation(activeSessionServer);
+                templateData.container.classList.toggle("disabled", presentation?.enabled === false);
+                this.updateStatus(
+                    templateData,
+                    element,
+                    currentEntry,
+                    presentation?.status,
+                    presentation?.enabled ? undefined : activeSessionServer?.disabledReason,
+                    activeSessionServer?.state?.kind === McpServerStatus.Error ? activeSessionServer.state.error?.message : undefined
+                );
+                return;
+            }
+            templateData.container.classList.toggle("disabled", localDisabled);
+            const localError = !this.workspaceService.isSessionsWindow && connectionState?.state === McpConnectionState.Kind.Error ? connectionState : undefined;
+            this.updateStatus(
+                templateData,
+                element,
+                currentEntry,
+                localDisabled ? "disabled" : localError?.state,
+                undefined,
+                localError?.message
+            );
+        };
+        templateData.elementDisposables.add(autorun(reader => {
+            this.customizationHarnessService.activeSessionResource.read(reader);
+            localDisabled = element.localServer ? isContributionDisabled(element.localServer.enablement.read(reader)) : false;
+            connectionState = element.localServer?.connectionState.read(reader);
+            update();
+        }));
+        templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
+    }
+    updateActiveSessionStatus(templateData, element) {
+        const update = () => {
+            const currentEntry = resolveMcpEntry(
+                element,
+                this.agentHostCustomizationService,
+                this.customizationHarnessService.activeSessionResource.get()
+            );
+            const server = currentEntry && getActiveSessionServer(currentEntry);
+            const presentation = server && getActiveSessionServerPresentation(server);
+            templateData.container.classList.toggle("disabled", presentation?.enabled === false);
+            this.updateStatus(
+                templateData,
+                element,
+                currentEntry,
+                presentation?.status,
+                server?.disabledReason,
+                server?.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined
+            );
+        };
+        templateData.elementDisposables.add(autorun(reader => {
+            this.customizationHarnessService.activeSessionResource.read(reader);
+            update();
+        }));
+        templateData.elementDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
+    }
+    updateStatus(templateData, element, currentEntry, state, disabledReason, errorMessage) {
+        const error = getMcpErrorMessage(state, errorMessage);
+        this.syncError(element, error);
+        templateData.currentError = error;
+        this.renderDescription(templateData);
+        const presentation = getMcpStatusPresentation(state, disabledReason);
+        templateData.statusBadge.className = "plugin-list-item-status mcp-runtime-status-badge";
+        if (presentation) {
+            templateData.statusBadge.textContent = presentation.label;
+            templateData.statusBadge.classList.add(presentation.className);
+            templateData.statusBadge.style.display = "";
+        } else {
+            templateData.statusBadge.textContent = "";
+            templateData.statusBadge.style.display = "none";
+        }
+        const activeSessionServer = currentEntry && getActiveSessionServer(currentEntry);
+        const label = getMcpEntryLabel(currentEntry ?? element);
+        const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
+        const localServer = element.type === "session-server-item" ? undefined : element.localServer;
+        const signature = getMcpStatusRenderSignature({
+            rowKey: getMcpRowKey(element),
+            label,
+            state,
+            statusLabel: presentation?.label,
+            statusClassName: presentation?.className,
+            statusIconId: presentation?.icon?.id,
+            activeSessionServerId: activeSessionServer?.id,
+            logOutputChannelId: activeSessionServer?.logOutputChannelId,
+            localServerId: localServer?.definition.id,
+            activeSessionResource: ( activeSessionResource.toString())
+        });
+        if (templateData.renderedStatusSignature === signature) {
+            return;
+        }
+        templateData.renderedStatusSignature = signature;
+        templateData.actionDisposables.clear();
+        clearNode(templateData.actions);
+        if (!currentEntry) {
+            return;
+        }
+        const getEntry = () => resolveMcpEntry(currentEntry, this.agentHostCustomizationService, activeSessionResource);
+        if (!presentation) {
+            this._renderManagementActions(
+                getEntry,
+                templateData.actions,
+                templateData.actionDisposables,
+                () => this.updateActionsTabbability(templateData)
+            );
+            this.updateActionsTabbability(templateData);
+            return;
+        }
+        if (state === McpServerStatus.AuthRequired && activeSessionServer !== undefined) {
+            const signInButton = createMcpSignInButton(templateData.actions, templateData.actionDisposables, label);
+            registerMcpInlineButtonAction(templateData.actionDisposables, signInButton, async () => {
+                signInButton.enabled = false;
+                try {
+                    await authenticateMcpServer(
+                        this.agentHostCustomizationService,
+                        activeSessionResource,
+                        activeSessionServer.id
+                    );
+                } finally {
+                    signInButton.enabled = true;
+                }
+            });
+        }
+        if (!presentation.icon || error !== undefined) {
+            this._renderManagementActions(
+                getEntry,
+                templateData.actions,
+                templateData.actionDisposables,
+                () => this.updateActionsTabbability(templateData)
+            );
+            this.updateActionsTabbability(templateData);
+            return;
+        }
+        const statusElement = append(templateData.actions, $(".mcp-server-status"));
+        statusElement.classList.add(presentation.className, ...ThemeIcon.asClassNameArray(presentation.icon));
+        statusElement.setAttribute("aria-hidden", "true");
+        templateData.actionDisposables.add(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("element"), statusElement, presentation.label)
+        );
+        this._renderManagementActions(
+            getEntry,
+            templateData.actions,
+            templateData.actionDisposables,
+            () => this.updateActionsTabbability(templateData)
+        );
+        this.updateActionsTabbability(templateData);
+    }
+    setFocusedIndex(index) {
+        this._focusedIndex = index;
+        for (const template of this._templates) {
+            this.updateActionsTabbability(template);
+        }
+    }
+    updateActionsTabbability(templateData) {
+        setVirtualizedRowActionsTabbable(templateData.actions, templateData.currentIndex === this._focusedIndex);
+        templateData.expandButton.element.tabIndex = templateData.currentIndex === this._focusedIndex ? 0 : -1;
+    }
+    notifyHeightChange(template) {
+        if (!template.isRendering && template.currentIndex >= 0) {
+            this._onDidChangeHeight.fire({
+                index: template.currentIndex,
+                text: template.currentError === undefined ? undefined : template.renderedDescription,
+                expanded: template.isExpanded
+            });
+        }
+    }
+    renderDescription(template) {
+        const element = template.currentElement;
+        if (!element) {
+            return;
+        }
+        const error = template.currentError;
+        const expanded = this.isErrorExpanded(element, error);
+        const description = error === undefined ? element.type === "session-server-item" ? "" : element.type === "builtin-item" ? element.description : element.server.description?.trim() ?? "" : expanded ? error : getMcpErrorPreview(error).text;
+        const text = error === undefined ? truncateToFirstLine(description) : description;
+        const changed = template.renderedDescription !== description || template.isExpanded !== expanded || template.description.classList.contains("error") !== (error !== undefined);
+        if (template.description.textContent !== text) {
+            template.description.textContent = text;
+        }
+        template.isExpanded = expanded;
+        template.description.classList.toggle("expanded", expanded);
+        template.description.classList.toggle("error", error !== undefined);
+        template.container.classList.toggle("has-error", error !== undefined);
+        template.description.style.display = description ? "" : "none";
+        if (template.renderedDescription !== description) {
+            template.renderedDescription = description;
+            template.descriptionHover.update(description);
+        }
+        if (changed) {
+            this.updateExpandButton(template);
+            this.notifyHeightChange(template);
+        }
+    }
+    updateExpandButton(template) {
+        if (!template.currentElement) {
+            return;
+        }
+        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(8982, "Show Less")) : ( localize(8983, "Show More"));
+        template.expandButton.element.setAttribute("aria-expanded", String(template.isExpanded));
+        this.updateActionsTabbability(template);
+    }
+    disposeElement(_element, _index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.descriptionHover.hide();
+        templateData.descriptionHover.update("");
+        templateData.description.textContent = "";
+        templateData.renderedDescription = undefined;
+        templateData.currentElement = undefined;
+        templateData.currentError = undefined;
+        templateData.isClipped = false;
+        templateData.currentIndex = -1;
+    }
+    disposeTemplate(templateData) {
+        this._templates.delete(templateData);
+        templateData.templateDisposables.dispose();
+        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));
+class McpMarketplaceItemRenderer {
+    constructor(_install) {
+        this._install = _install;
+        this.templateId = "mcpMarketplaceItem";
+        this._templates = ( new Set());
+        this._focusedIndex = -1;
+    }
+    renderTemplate(container) {
+        container.classList.add("plugin-list-item", "plugin-marketplace-home-row");
+        const details = append(container, $(".plugin-list-item-details"));
+        const name = append(
+            append(details, $(".plugin-list-item-name-row")),
+            $(".plugin-list-item-name")
+        );
+        const description = append(details, $(".plugin-list-item-description"));
+        const actionContainer = append(container, $(".plugin-list-item-action"));
+        const installButton = ( new Button(actionContainer, defaultButtonStyles));
+        installButton.element.classList.add("plugin-list-item-install-button");
+        const templateDisposables = ( new DisposableStore());
+        templateDisposables.add(installButton);
+        templateDisposables.add(
+            addDisposableGenericMouseDownListener(installButton.element, event => EventHelper.stop(event, true))
+        );
+        const template = {
+            container,
+            name,
+            description,
+            installButton,
+            elementDisposables: ( new DisposableStore()),
+            templateDisposables,
+            currentIndex: -1
+        };
+        this._templates.add(template);
+        return template;
+    }
+    renderElement(element, index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.currentIndex = index;
+        templateData.name.textContent = element.server.label;
+        templateData.description.textContent = truncateToFirstLine(element.server.description || ( localize(8984, "No description provided.")));
+        templateData.installButton.label = ( localize(8985, "Install"));
+        templateData.installButton.enabled = true;
+        templateData.installButton.element.tabIndex = index === this._focusedIndex ? 0 : -1;
+        templateData.elementDisposables.add(templateData.installButton.onDidClick(event => {
+            EventHelper.stop(event, true);
+            void this._install(element.server, templateData.installButton);
+        }));
+    }
+    setFocusedIndex(index) {
+        this._focusedIndex = index;
+        for (const template of this._templates) {
+            template.installButton.element.tabIndex = template.currentIndex === index ? 0 : -1;
+        }
+    }
+    disposeElement(_element, _index, templateData) {
+        templateData.elementDisposables.clear();
+    }
+    disposeTemplate(templateData) {
+        this._templates.delete(templateData);
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposables.dispose();
+    }
+}
+function createMcpSignInButton(parent, store, serverLabel) {
+    const signInLabel = ( localize(8986, "Sign in to {0}", serverLabel));
+    const signInButton = store.add(( new Button(parent, {
+        ...defaultButtonStyles,
+        secondary: true,
+        small: true,
+        title: signInLabel,
+        ariaLabel: signInLabel
+    })));
+    signInButton.label = ( localize(8987, "Sign In"));
+    signInButton.element.classList.add("mcp-server-sign-in");
+    return signInButton;
+}
+function registerMcpInlineButtonAction(store, button, action) {
+    store.add(
+        addDisposableGenericMouseDownListener(button.element, event => EventHelper.stop(event, true))
+    );
+    store.add(button.onDidClick(event => {
+        EventHelper.stop(event, true);
+        void action();
+    }));
+}
+function authenticateMcpServer(agentHostCustomizationService, sessionResource, serverId) {
+    return agentHostCustomizationService.authenticateMcpServer(sessionResource, serverId);
+}
+function getMcpServerOutputHandler(
+    outputService,
+    localServer,
+    activeSessionServer,
+    closeCustomizationEditor,
+    showActiveSessionOutput
+) {
+    const outputChannelId = activeSessionServer?.logOutputChannelId;
+    if (showActiveSessionOutput) {
+        return () => showActiveSessionOutput(closeCustomizationEditor);
+    }
+    if (outputChannelId) {
+        return async () => {
+            await closeCustomizationEditor?.();
+            await outputService.showChannel(outputChannelId);
+        };
+    }
+    if (localServer) {
+        return async () => {
+            await closeCustomizationEditor?.();
+            await localServer.showOutput();
+        };
+    }
+    return undefined;
+}
+function getMcpStatusPresentation(state, disabledReason) {
+    if (state === undefined) {
+        return undefined;
+    }
+    if (state === "disabled") {
+        return {
+            label: getCustomizationDisabledLabel(disabledReason),
+            className: "disabled",
+            icon: Codicon.circleSlash
+        };
+    }
+    switch (state) {
+    case McpConnectionState.Kind.Running:
+    case McpServerStatus.Ready:
+        return {
+            label: ( localize(8988, "Running")),
+            className: "running",
+            icon: Codicon.check
+        };
+    case McpConnectionState.Kind.Starting:
+    case McpServerStatus.Starting:
+        return {
+            label: ( localize(8989, "Starting")),
+            className: "starting",
+            icon: ThemeIcon.modify(Codicon.loading, "spin")
+        };
+    case McpServerStatus.AuthRequired:
+        return {
+            label: ( localize(8990, "Authentication required")),
+            className: "auth-required",
+            icon: Codicon.account
+        };
+    case McpConnectionState.Kind.Error:
+    case McpServerStatus.Error:
+        return {
+            label: ( localize(8991, "Error")),
+            className: "error",
+            icon: Codicon.error
+        };
+    case McpConnectionState.Kind.Stopped:
+    case McpServerStatus.Stopped:
+    default:
+        return {
+            label: ( localize(8992, "Stopped")),
+            className: "stopped"
+        };
+    }
+}
+function getMcpErrorMessage(state, message) {
+    if (state !== McpServerStatus.Error && state !== McpConnectionState.Kind.Error) {
+        return undefined;
+    }
+    return message && /\S/u.test(message) ? message : ( localize(8993, "The server reported an error without additional details."));
+}
+function getMcpErrorPreview(message) {
+    let end = 0;
+    const characters = [];
+    for (let count = 0; count < MCP_ERROR_PREVIEW_LENGTH && end < message.length; count++) {
+        const codePoint = message.codePointAt(end);
+        characters.push(String.fromCodePoint(codePoint));
+        end += codePoint > 0xFFFF ? 2 : 1;
+    }
+    const truncated = end < message.length;
+    return {
+        text: characters.join("") + (truncated ? "…" : ""),
+        truncated
+    };
+}
+function getActiveSessionServer(entry) {
+    return entry.type === "session-server-item" ? entry.server : entry.activeSessionServer;
+}
+function resolveMcpEntry(entry, customizations, sessionResource) {
+    const activeSessionServer = getActiveSessionServer(entry);
+    if (!activeSessionServer) {
+        return entry;
+    }
+    const server = customizations.getMcpServers(sessionResource).find(server => server.id === activeSessionServer.id);
+    return server ? entry.type === "session-server-item" ? {
+        ...entry,
+        server
+    } : {
+        ...entry,
+        activeSessionServer: server
+    } : undefined;
+}
+function getMcpRowKey(entry) {
+    switch (entry.type) {
+    case "server-item":
+        return `server:${entry.server.id}:${entry.marketplace ? 1 : 0}`;
+    case "session-server-item":
+        return `session:${entry.server.id}`;
+    case "builtin-item":
+        return `builtin:${entry.id}`;
+    }
+}
+function getMcpStatusRenderSignature(input) {
+    return JSON.stringify([
+        input.rowKey,
+        input.label,
+        input.state ?? null,
+        input.statusLabel ?? null,
+        input.statusClassName ?? null,
+        input.statusIconId ?? null,
+        input.activeSessionServerId ?? null,
+        input.logOutputChannelId ?? null,
+        input.localServerId ?? null,
+        input.activeSessionResource ?? null
+    ]);
+}
+function getMcpEntryLabel(element) {
+    return element.type === "session-server-item" ? element.server.name : element.type === "builtin-item" ? element.label : element.server.label;
+}
+function getMcpStatusKind(entry, isSessionsWindow) {
+    if (entry.type === "session-server-item") {
+        return getActiveSessionServerPresentation(entry.server).status;
+    }
+    if (entry.activeSessionServer !== undefined) {
+        return getActiveSessionServerPresentation(entry.activeSessionServer).status;
+    }
+    if (entry.localServer && isContributionDisabled(entry.localServer.enablement.get())) {
+        return "disabled";
+    }
+    if (entry.type === "server-item" && !isSessionsWindow) {
+        return entry.localServer?.connectionState.get().state;
+    }
+    return undefined;
+}
+function getMcpEntryAriaLabel(element, isSessionsWindow) {
+    const label = getMcpEntryLabel(element);
+    const statusKind = getMcpStatusKind(element, isSessionsWindow);
+    const disabledReason = statusKind === "disabled" ? getMcpDisabledReason(element) : undefined;
+    const status = getMcpStatusPresentation(statusKind, disabledReason);
+    return status ? ( localize(8994, "{0}, {1}", label, status.label)) : label;
+}
+function getMcpDisabledReason(entry) {
+    if (entry.type === "session-server-item") {
+        return entry.server.disabledReason;
+    }
+    if (entry.activeSessionServer !== undefined) {
+        return entry.activeSessionServer.disabledReason;
+    }
+    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 undefined;
+    }
+    unmatched(query) {
+        return this.servers.filter(server => !( this.matchedIds.has(server.id)) && matchesActiveSessionServerQuery(server, query));
+    }
+}
+class LocalMcpServerMatcher {
+    constructor(servers) {
+        this.byKey = ( new Map());
+        for (const server of servers) {
+            for (const key of getRuntimeServerMatchKeys(server)) {
+                let matches = this.byKey.get(key);
+                if (!matches) {
+                    matches = [];
+                    this.byKey.set(key, matches);
+                }
+                matches.push(server);
+            }
+        }
+    }
+    find(keys) {
+        for (const key of getUniqueMcpMatchKeys(keys)) {
+            const matches = this.byKey.get(key);
+            if (matches?.length === 1) {
+                return matches[0];
+            }
+        }
+        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 getActiveSessionServerPresentation(server) {
+    return {
+        enabled: server.enabled,
+        status: server.enabled ? server.status : "disabled"
+    };
+}
+function updateMcpCardRuntimePresentation(
+    statusBadge,
+    primaryAction,
+    description,
+    statusKind,
+    disabledReason,
+    ariaLabel,
+    descriptionText
+) {
+    const statusPresentation = getMcpStatusPresentation(statusKind, disabledReason);
+    statusBadge.className = "plugin-list-item-status mcp-runtime-status-badge";
+    statusBadge.style.display = statusPresentation ? "" : "none";
+    statusBadge.textContent = statusPresentation?.label ?? "";
+    if (statusPresentation) {
+        statusBadge.classList.add(statusPresentation.className);
+    }
+    primaryAction.setAttribute("aria-label", ariaLabel);
+    description.textContent = descriptionText;
+}
+function shouldLoadMcpGallerySnapshot(visible, query, itemCount, failed, loading, accessEnabled) {
+    return accessEnabled && visible && !query.trim() && itemCount === 0 && !failed && !loading;
+}
+function hasSameMcpMembership(previous, current) {
+    return previous === current;
+}
+function getActiveSessionServerLifecycleAction(server) {
+    if (!getActiveSessionServerPresentation(server).enabled) {
+        return undefined;
+    }
+    return server.status === McpServerStatus.Stopped || server.status === McpServerStatus.Error ? ( new Action("mcpServer.activeSession.start", ( localize(8995, "Start Server")), undefined, true, () => server.start())) : ( new Action("mcpServer.activeSession.stop", ( localize(8996, "Stop Server")), undefined, true, () => server.stop()));
+}
+function isHostOwnedPluginMcpServer(server) {
+    return server.isPluginProvided === true && !server.isClientBundled;
+}
+const agentHostMcpServerEnablementActionInfo = {
+    global: {
+        kind: CustomizationEnablementKind.Global,
+        enableLabel: () => ( localize(8997, "Enable")),
+        disableLabel: () => ( localize(8998, "Disable"))
+    },
+    workspace: {
+        kind: CustomizationEnablementKind.Workspace,
+        enableLabel: () => ( localize(8999, "Enable (Workspace)")),
+        disableLabel: () => ( localize(9000, "Disable (Workspace)"))
+    },
+    session: {
+        kind: CustomizationEnablementKind.Session,
+        enableLabel: () => ( localize(9001, "Enable (Session)")),
+        disableLabel: () => ( localize(9002, "Disable (Session)"))
+    }
+};
+function getAgentHostMcpServerEnablementActions(
+    agentHostCustomizations,
+    agentPluginService,
+    sessionResource,
+    server,
+    scopes = ["global", "workspace", "session"]
+) {
+    if (server.disabledReason?.source === "plugin") {
+        const decision = server.disabledReason.plugin.enablement?.[0];
+        if (!decision) {
+            return [];
+        }
+        const action = createAgentHostEnablePluginAction(
+            agentHostCustomizations,
+            agentPluginService,
+            sessionResource,
+            server.disabledReason.plugin,
+            decision.kind
+        );
+        return [( new Action(action.id, action.label, undefined, true, action.run))];
+    }
+    const enablement = getCustomizationScopeEnablement(server);
+    const actions = [];
+    if (scopes.includes("global")) {
+        actions.push(createAgentHostMcpServerEnablementAction(
+            agentHostCustomizations,
+            sessionResource,
+            server,
+            !enablement.global,
+            "global"
+        ));
+    }
+    if (scopes.includes("workspace") && agentHostCustomizations.getWorkingDirectories(sessionResource).length > 0) {
+        actions.push(createAgentHostMcpServerEnablementAction(
+            agentHostCustomizations,
+            sessionResource,
+            server,
+            !enablement.workspace,
+            "workspace"
+        ));
+    }
+    if (scopes.includes("session")) {
+        actions.push(createAgentHostMcpServerEnablementAction(
+            agentHostCustomizations,
+            sessionResource,
+            server,
+            !enablement.session,
+            "session"
+        ));
+    }
+    return actions;
+}
+function setPrimaryMcpServerEnablement(
+    mcpService,
+    agentHostCustomizations,
+    sessionResource,
+    localServerId,
+    activeSessionServer,
+    enabled
+) {
+    if (activeSessionServer && isHostOwnedPluginMcpServer(activeSessionServer)) {
+        agentHostCustomizations.setCustomizationEnablement(
+            sessionResource,
+            activeSessionServer.id,
+            activeSessionServer.enablement,
+            CustomizationEnablementKind.Global,
+            enabled
+        );
+        return;
+    }
+    if (localServerId) {
+        const current = mcpService.enablementModel.readEnabled(localServerId);
+        const next = getToggledMcpEnablementState(current);
+        if (isContributionEnabled(next) !== enabled) {
+            throw ( new Error(`Unexpected MCP enablement transition for ${localServerId}.`));
+        }
+        mcpService.enablementModel.setEnabled(localServerId, next);
+        return;
+    }
+    if (!activeSessionServer) {
+        throw ( new Error("Cannot update MCP enablement without a durable server target."));
+    }
+    agentHostCustomizations.setCustomizationEnablement(
+        sessionResource,
+        activeSessionServer.id,
+        activeSessionServer.enablement,
+        CustomizationEnablementKind.Global,
+        enabled
+    );
+}
+function isPrimaryMcpServerEnabled(mcpService, localServerId, activeSessionServer) {
+    if (activeSessionServer && isHostOwnedPluginMcpServer(activeSessionServer)) {
+        return getCustomizationScopeEnablement(activeSessionServer).global;
+    }
+    if (localServerId) {
+        return isContributionEnabled(mcpService.enablementModel.readEnabled(localServerId));
+    }
+    if (activeSessionServer) {
+        return getCustomizationScopeEnablement(activeSessionServer).global;
+    }
+    return true;
+}
+function createAgentHostMcpServerEnablementAction(agentHostCustomizations, sessionResource, server, enabled, scope) {
+    const actionInfo = agentHostMcpServerEnablementActionInfo[scope];
+    return ( new Action(
+        `mcpServer.agentHost.${enabled ? "enable" : "disable"}.${scope}`,
+        enabled ? actionInfo.enableLabel() : actionInfo.disableLabel(),
+        undefined,
+        true,
+        () => agentHostCustomizations.setCustomizationEnablement(sessionResource, server.id, server.enablement, actionInfo.kind, enabled)
+    ));
+}
+function getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkbench, options = {}) {
+    const includeWorkspace = options.includeWorkspace ?? true;
+    const disabled = options.activeSessionServer ? !getActiveSessionServerPresentation(options.activeSessionServer).enabled : isContributionDisabled(mcpService.enablementModel.readEnabled(serverId));
+    const actions = [];
+    if (disabled) {
+        actions.push(( new Action("mcpServer.builtin.enable", ( localize(9003, "Enable")), undefined, true, () => {
+            mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.EnabledProfile);
+        })));
+        if (includeWorkspace && !isEmptyWorkbench) {
+            actions.push(( new Action("mcpServer.builtin.enableWorkspace", ( localize(9004, "Enable (Workspace)")), undefined, true, () => {
+                mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.EnabledWorkspace);
+            })));
+        }
+    } else {
+        actions.push(( new Action("mcpServer.builtin.disable", ( localize(9005, "Disable")), undefined, true, () => {
+            mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.DisabledProfile);
+        })));
+        if (includeWorkspace && !isEmptyWorkbench) {
+            actions.push(( new Action("mcpServer.builtin.disableWorkspace", ( localize(9006, "Disable (Workspace)")), undefined, true, () => {
+                mcpService.enablementModel.setEnabled(serverId, ContributionEnablementState.DisabledWorkspace);
+            })));
+        }
+    }
+    return actions;
+}
+function getBuiltinMcpServerEnablementActions(
+    mcpService,
+    serverId,
+    isEmptyWorkbench,
+    agentHostCustomizations,
+    agentPluginService,
+    sessionResource,
+    activeSessionServer
+) {
+    if (activeSessionServer === undefined) {
+        return getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkbench);
+    }
+    if (isHostOwnedPluginMcpServer(activeSessionServer)) {
+        return getAgentHostMcpServerEnablementActions(
+            agentHostCustomizations,
+            agentPluginService,
+            sessionResource,
+            activeSessionServer
+        );
+    }
+    return [
+        ...getLocalMcpServerEnablementActions(mcpService, serverId, isEmptyWorkbench, {
+            includeWorkspace: false,
+            activeSessionServer
+        }),
+        ...getAgentHostMcpServerEnablementActions(
+            agentHostCustomizations,
+            agentPluginService,
+            sessionResource,
+            activeSessionServer,
+            ["workspace", "session"]
+        )
+    ];
+}
+function getActiveSessionServerOptionsActions(
+    commandService,
+    agentHostCustomizations,
+    agentPluginService,
+    sessionResource,
+    server
+) {
+    const actions = [];
+    const lifecycleAction = getActiveSessionServerLifecycleAction(server);
+    if (lifecycleAction) {
+        actions.push(lifecycleAction);
+    }
+    const durableActions = getAgentHostMcpServerEnablementActions(agentHostCustomizations, agentPluginService, sessionResource, server);
+    if (durableActions.length > 0) {
+        if (actions.length > 0) {
+            actions.push(( new Separator()));
+        }
+        actions.push(...durableActions);
+    }
+    actions.push(( new Separator()));
+    actions.push(( new Action("mcpServer.activeSession.options", ( localize(9007, "Server Options")), undefined, true, async () => {
+        await commandService.executeCommand(McpCommandIds.AgentHostServerOptions, sessionResource, server.id);
+    })));
+    return actions;
+}
+function shouldHideLocalActionForActiveSessionServer(action) {
+    return action instanceof StartServerAction || action instanceof StopServerAction || action instanceof RestartServerAction || action instanceof ConfigureModelAccessAction || action instanceof ShowSamplingRequestsAction || isLocalMcpServerWorkspaceEnablementAction(action);
+}
+function isLocalMcpServerEnablementAction(action) {
+    return action.id === EnableMcpServerGloballyAction.ID || action.id === EnableMcpServerForWorkspaceAction.ID || action.id === DisableMcpServerGloballyAction.ID || action.id === DisableMcpServerForWorkspaceAction.ID;
+}
+function isLocalMcpServerWorkspaceEnablementAction(action) {
+    return action.id === EnableMcpServerForWorkspaceAction.ID || action.id === DisableMcpServerForWorkspaceAction.ID;
+}
+function getServerItemContextMenuActions(
+    menuActionGroups,
+    activeSessionServer,
+    activeSessionLifecycleAction,
+    agentHostEnablementActions
+) {
+    const actions = [];
+    const hasActiveSession = activeSessionServer !== undefined;
+    let agentHostEnablementAdded = false;
+    if (activeSessionLifecycleAction) {
+        actions.push(activeSessionLifecycleAction, ( new Separator()));
+    }
+    for (const menuActions of menuActionGroups) {
+        const visibleMenuActions = hasActiveSession ? menuActions.filter(action => !shouldHideLocalActionForActiveSessionServer(action)) : menuActions;
+        actions.push(...visibleMenuActions);
+        if (hasActiveSession && ( menuActions.some(isLocalMcpServerEnablementAction))) {
+            actions.push(...agentHostEnablementActions);
+            agentHostEnablementAdded = true;
+        }
+        if (visibleMenuActions.length > 0) {
+            actions.push(( new Separator()));
+        }
+    }
+    if (hasActiveSession && !agentHostEnablementAdded) {
+        actions.push(...agentHostEnablementActions);
+    }
+    if (actions[actions.length - 1] instanceof Separator) {
+        actions.pop();
+    }
+    return actions;
+}
+function createBuiltinEntry(server, activeSessionServer) {
+    return {
+        type: "builtin-item",
+        id: `builtin-${server.definition.id}`,
+        label: server.definition.label,
+        description: "",
+        collectionId: server.collection.id,
+        activeSessionServer,
+        localServer: server
+    };
+}
+function createInstalledMcpServerDetailInput(entry) {
+    if (entry.type === "server-item") {
+        return createWorkbenchMcpServerDetailInput(entry.server);
+    }
+    const activeSessionServer = getActiveSessionServer(entry);
+    const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
+    const localDefinitions = localServer?.readDefinitions().get();
+    const localDefinition = localDefinitions?.server;
+    const collectionOrigin = localDefinitions?.collection?.presentation?.origin;
+    const localSource = localDefinition?.presentation?.origin ?? (collectionOrigin ? {
+        uri: collectionOrigin
+    } : undefined);
+    const activeSessionSource = activeSessionServer?.sourceUri ? {
+        uri: activeSessionServer.sourceUri,
+        range: activeSessionServer.sourceRange ? ( new Range(
+            activeSessionServer.sourceRange.start.line + 1,
+            activeSessionServer.sourceRange.start.character + 1,
+            activeSessionServer.sourceRange.end.line + 1,
+            activeSessionServer.sourceRange.end.character + 1
+        )) : undefined
+    } : undefined;
+    return {
+        id: getMcpRowKey(entry),
+        name: getMcpEntryLabel(entry),
+        label: getMcpEntryLabel(entry),
+        installState: McpServerInstallState.Installed,
+        config: localDefinition ? getMcpServerConfiguration(localDefinition) : undefined,
+        source: localSource ?? activeSessionSource
+    };
+}
+function getMcpServerConfiguration(definition) {
+    const launch = definition.launch;
+    if (launch.type === McpServerTransportType.HTTP) {
+        return {
+            type: McpServerType.REMOTE,
+            url: ( launch.uri.toString(true)),
+            headers: launch.headers.length > 0 ? Object.fromEntries(launch.headers) : undefined,
+            oauth: launch.oauth,
+            dev: definition.devMode
+        };
+    }
+    return {
+        type: McpServerType.LOCAL,
+        command: launch.command,
+        args: launch.args,
+        env: launch.env,
+        envFile: launch.envFile,
+        cwd: launch.cwd,
+        sandboxEnabled: definition.sandboxEnabled,
+        dev: definition.devMode
+    };
+}
+let McpListWidget = class McpListWidget extends Disposable {
+    constructor(
+        instantiationService,
+        mcpWorkbenchService,
+        mcpService,
+        mcpRegistry,
+        commandService,
+        openerService,
+        contextViewService,
+        contextMenuService,
+        agentPluginService,
+        dialogService,
+        configurationService,
+        customizationHarnessService,
+        agentHostCustomizationService,
+        workspaceService,
+        notificationService,
+        outputService,
+        mcpGalleryManifestService
+    ) {
+        super();
+        this.instantiationService = instantiationService;
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.mcpService = mcpService;
+        this.mcpRegistry = mcpRegistry;
+        this.commandService = commandService;
+        this.openerService = openerService;
+        this.contextViewService = contextViewService;
+        this.contextMenuService = contextMenuService;
+        this.agentPluginService = agentPluginService;
+        this.dialogService = dialogService;
+        this.configurationService = configurationService;
+        this.customizationHarnessService = customizationHarnessService;
+        this.agentHostCustomizationService = agentHostCustomizationService;
+        this.workspaceService = workspaceService;
+        this.notificationService = notificationService;
+        this.outputService = outputService;
+        this._onDidSelectServer = this._register(( new Emitter()));
+        this.onDidSelectServer = this._onDidSelectServer.event;
+        this._onDidChangeItemCount = this._register(( new Emitter()));
+        this.onDidChangeItemCount = this._onDidChangeItemCount.event;
+        this._onDidRequestShowPlugin = this._register(( new Emitter()));
+        this.onDidRequestShowPlugin = this._onDidRequestShowPlugin.event;
+        this.disabledLinkListener = this._register(( new MutableDisposable()));
+        this.filteredServers = [];
+        this.filteredBuiltinCount = 0;
+        this.filteredActiveSessionCount = 0;
+        this.installedEntries = [];
+        this.gallerySnapshotServers = [];
+        this.galleryServers = [];
+        this.searchQuery = "";
+        this.gallerySnapshotFailed = false;
+        this.gallerySnapshotLoading = false;
+        this.gallerySearchLoading = false;
+        this.visible = false;
+        this.mcpAccessEnabled = false;
+        this.narrowLayout = false;
+        this.wideLayout = false;
+        this.lastHeight = 0;
+        this.lastWidth = 0;
+        this.lastHeaderHeight = 0;
+        this._layoutDeferred = false;
+        this.revealLastItemScheduler = this._register(( new MutableDisposable()));
+        this.sectionScrollPositions = ( new Map());
+        this.cardDisposables = this._register(( new DisposableStore()));
+        this.pendingSectionLayout = this._register(( new MutableDisposable()));
+        this.cardListControllers = ( new WeakMap());
+        this.sectionLists = [];
+        this.collapsedSections = ( new Set());
+        this.delayedFilter = ( new Delayer(200));
+        this.delayedGallerySearch = ( new Delayer(400));
+        this.agentHostCustomizationsChanged = observableSignalFromEvent(this, this.agentHostCustomizationService.onDidChangeCustomizations);
+        this.element = $(".mcp-list-widget.plugin-list-widget");
+        this.create();
+        const resizeObserver = this._register(new DisposableResizeObserver(
+            "McpListWidget",
+            () => this.updateResponsiveLayout(this.element.offsetWidth),
+            getWindow(this.element)
+        ));
+        this._register(resizeObserver.observe(this.element));
+        this.updateAccessState();
+        this._register(mcpGalleryManifestService.onDidChangeMcpGalleryManifest(() => {
+            this.galleryCts?.dispose(true);
+            this.galleryCts = undefined;
+            this.gallerySnapshotServers = [];
+            this.galleryServers = [];
+            this.gallerySnapshotFailed = false;
+            this.gallerySnapshotLoading = false;
+            if (this.searchQuery.trim()) {
+                void this.queryMcpSearch();
+            } else {
+                void this.refresh();
+            }
+        }));
+        void mcpGalleryManifestService.getMcpGalleryManifest();
+        void this.refresh();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(mcpAccessConfig)) {
+                this.updateAccessState();
+            }
+        }));
+        this._register({
+            dispose: () => {
+                this.delayedFilter.cancel();
+                this.delayedGallerySearch.cancel();
+                this.galleryCts?.dispose(true);
+            }
+        });
+    }
+    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(9008, "MCP Servers"));
+        const sectionTitleDescription = append(this.sectionTitleHeader, $("p.section-title-description"));
+        const sectionTitleDescriptionText = append(sectionTitleDescription, $("span.section-title-description-text"));
+        sectionTitleDescriptionText.textContent = ( localize(
+            9009,
+            "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(9010, "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();
+            const href = this.sectionLink.href;
+            if (href) {
+                this.openerService.open(( URI.parse(href)));
+            }
+        }));
+        const targetWindow = getWindow(this.element);
+        const headerObserver = this._register(
+            new DisposableResizeObserver("McpListWidget.sectionTitleHeader", () => {
+                if (this.lastWidth <= 0 || this.lastHeight <= 0) {
+                    return;
+                }
+                const headerHeight = this.sectionTitleHeader.offsetHeight;
+                if (headerHeight === this.lastHeaderHeight) {
+                    return;
+                }
+                this.layout(this.lastHeight, this.lastWidth);
+            }, targetWindow)
+        );
+        this._register(headerObserver.observe(this.sectionTitleHeader));
+        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(9011, "Type to search...")),
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        this._register(this.searchInput.onDidChange(() => {
+            this.searchQuery = this.searchInput.value;
+            this.galleryCts?.dispose(true);
+            this.galleryCts = undefined;
+            this.searchInput.hideMessage();
+            const query = this.searchQuery.toLowerCase().trim();
+            this.galleryServers = query ? this.gallerySnapshotServers.filter(server => this.matchesGalleryServerQuery(server, query)) : [...this.gallerySnapshotServers];
+            this.delayedFilter.trigger(() => this.filterServers());
+            if (!this.mcpAccessEnabled) {
+                this.gallerySearchLoading = false;
+                this.delayedGallerySearch.cancel();
+                return;
+            }
+            if (query) {
+                this.gallerySearchLoading = true;
+                this.delayedGallerySearch.trigger(() => this.queryMcpSearch());
+            } else {
+                this.gallerySearchLoading = false;
+                this.delayedGallerySearch.cancel();
+                if (this.visible && this.gallerySnapshotServers.length === 0) {
+                    this.delayedGallerySearch.trigger(() => this.queryGallerySnapshot());
+                }
+            }
+        }));
+        this.emptyContainer = append(this.element, $(".mcp-empty-state"));
+        const emptyHeader = append(this.emptyContainer, $(".empty-state-header"));
+        this.emptyText = append(emptyHeader, $(".empty-text"));
+        this.emptySubtext = append(this.emptyContainer, $(".empty-subtext"));
+        this.disabledContainer = append(this.element, $(".mcp-disabled-state"));
+        const disabledHeader = append(this.disabledContainer, $(".empty-state-header"));
+        this.disabledIcon = append(disabledHeader, $(".empty-icon"));
+        const disabledText = append(disabledHeader, $(".empty-text"));
+        disabledText.textContent = ( localize(9012, "MCP servers are disabled"));
+        this.disabledMessage = append(this.disabledContainer, $(".empty-subtext"));
+        this.cardContainer = $(".plugin-card-container");
+        this.cardScrollable = this._register(( new DomScrollableElement(this.cardContainer, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
+        })));
+        this._register(
+            addDisposableListener(this.cardContainer, EventType.SCROLL, () => {
+                this.cardScrollable.setScrollPosition({
+                    scrollTop: this.cardContainer.scrollTop
+                });
+            })
+        );
+        this.cardScrollableNode = this.cardScrollable.getDomNode();
+        this.cardScrollableNode.classList.add("plugin-card-scrollable");
+        this.cardScrollableNode.style.display = "none";
+        this.element.appendChild(this.cardScrollableNode);
+        const cardResizeObserver = this._register(
+            new DisposableResizeObserver("McpListWidget.cardScrollable", () => this.cardScrollable.scanDomNode())
+        );
+        this._register(cardResizeObserver.observe(this.cardScrollableNode));
+        this._register(this.mcpWorkbenchService.onChange(() => {
+            this.refresh();
+        }));
+        this._register(autorun(reader => {
+            const servers = this.mcpService.servers.read(reader);
+            for (const server of servers) {
+                server.enablement.read(reader);
+            }
+            this.refresh();
+        }));
+        this._register(autorun(reader => {
+            this.customizationHarnessService.activeSessionResource.read(reader);
+            this.refresh();
+        }));
+        this._register(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
+            const previousMembership = this.getInstalledEntryMembershipSignature();
+            this.filterServers(false);
+            if (!hasSameMcpMembership(previousMembership, this.getInstalledEntryMembershipSignature())) {
+                this.renderFilteredServers();
+            }
+        }));
+    }
+    async refresh() {
+        this.filterServers();
+        if (shouldLoadMcpGallerySnapshot(
+            this.visible,
+            this.searchQuery,
+            this.gallerySnapshotServers.length,
+            this.gallerySnapshotFailed,
+            this.gallerySnapshotLoading,
+            this.mcpAccessEnabled
+        )) {
+            await this.queryGallerySnapshot();
+        }
+    }
+    setVisible(visible) {
+        if (this.visible === visible) {
+            return;
+        }
+        this.visible = visible;
+        if (visible) {
+            void this.refresh();
+        }
+    }
+    updateAccessState() {
+        const inspect = this.configurationService.inspect(mcpAccessConfig);
+        const value = inspect.value ?? inspect.defaultValue;
+        const disabled = value === McpAccessValue.None;
+        const policyLocked = inspect.policyValue === McpAccessValue.None;
+        const accessChanged = this.mcpAccessEnabled === disabled;
+        this.mcpAccessEnabled = !disabled;
+        this.element.classList.toggle("access-disabled", disabled);
+        if (disabled) {
+            this.delayedGallerySearch.cancel();
+            this.galleryCts?.dispose(true);
+            this.galleryCts = undefined;
+            this.gallerySnapshotLoading = false;
+            this.gallerySearchLoading = false;
+            this.searchInput.hideMessage();
+            this.disabledIcon.className = "empty-icon";
+            this.disabledIcon.classList.add(
+                ...ThemeIcon.asClassNameArray(policyLocked ? Codicon.shield : mcpServerIcon)
+            );
+            clearNode(this.disabledMessage);
+            this.disabledLinkListener.clear();
+            if (policyLocked) {
+                this.disabledMessage.textContent = ( localize(
+                    9013,
+                    "Access to MCP servers is disabled by your organization. Contact your organization administrator for more information."
+                ));
+            } else {
+                this.disabledMessage.appendChild(createTextNode(( localize(9014, "MCP servers are disabled in settings. "))));
+                const link = append(this.disabledMessage, $("a.mcp-disabled-settings-link"));
+                link.textContent = ( localize(9015, "Configure in settings."));
+                link.href = "#";
+                link.setAttribute("role", "button");
+                this.disabledLinkListener.value = addDisposableListener(link, "click", e => {
+                    e.preventDefault();
+                    this.commandService.executeCommand("workbench.action.openSettings", `@id:${mcpAccessConfig}`);
+                });
+            }
+        } else if (accessChanged && this.visible) {
+            if (this.searchQuery.trim()) {
+                void this.queryMcpSearch();
+            } else {
+                void this.refresh();
+            }
+        }
+    }
+    showBrowseMarketplace() {
+        if (!this.mcpAccessEnabled) {
+            return;
+        }
+        this.searchInput.value = "";
+        this.searchQuery = "";
+        void this.queryGallerySnapshot(true);
+    }
+    async queryGallerySnapshot(revealMarketplace = false) {
+        if (!this.mcpAccessEnabled) {
+            return;
+        }
+        this.galleryCts?.dispose(true);
+        const cts = this.galleryCts = ( new CancellationTokenSource());
+        this.gallerySnapshotLoading = true;
+        if (!revealMarketplace && !this.searchQuery.trim()) {
+            this.renderMcpHome();
+        }
+        try {
+            const pager = await this.mcpWorkbenchService.queryGallery(undefined, cts.token);
+            if (this.galleryCts !== cts || cts.token.isCancellationRequested || !this.mcpAccessEnabled || this.searchQuery.trim()) {
+                return;
+            }
+            this.gallerySnapshotServers = pager.firstPage.items;
+            this.galleryServers = [...this.gallerySnapshotServers];
+            this.gallerySnapshotFailed = false;
+            this.gallerySnapshotLoading = false;
+            this.renderMcpHome();
+            if (revealMarketplace) {
+                this.availableSection?.scrollIntoView({
+                    block: "start"
+                });
+            }
+        } catch {
+            if (this.galleryCts === cts && !cts.token.isCancellationRequested && this.mcpAccessEnabled) {
+                this.gallerySnapshotServers = [];
+                this.galleryServers = [];
+                this.gallerySnapshotFailed = true;
+                this.gallerySnapshotLoading = false;
+                this.renderMcpHome();
+            }
+        } finally {
+            if (this.galleryCts === cts) {
+                this.gallerySnapshotLoading = false;
+            }
+        }
+    }
+    async queryMcpSearch() {
+        const query = this.searchQuery.trim();
+        if (!query || !this.mcpAccessEnabled) {
+            return;
+        }
+        this.galleryCts?.dispose(true);
+        const cts = this.galleryCts = ( new CancellationTokenSource());
+        this.gallerySearchLoading = true;
+        try {
+            const pager = await this.mcpWorkbenchService.queryGallery({
+                text: query
+            }, cts.token);
+            if (this.galleryCts !== cts || cts.token.isCancellationRequested || !this.mcpAccessEnabled || this.searchQuery.trim() !== query) {
+                return;
+            }
+            this.galleryServers = pager.firstPage.items;
+            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(
+                        9016,
+                        "Marketplace results are unavailable. Showing installed MCP servers only."
+                    )),
+                    type: MessageType.WARNING
+                });
+            }
+        } finally {
+            if (this.galleryCts === cts && this.mcpAccessEnabled && this.searchQuery.trim() === query) {
+                this.gallerySearchLoading = false;
+                this.filterServers();
+            }
+        }
+    }
+    showCardSurface() {
+        this.emptyContainer.style.display = "none";
+        this.cardScrollableNode.style.display = "";
+    }
+    showEmptySurface(message, detail) {
+        this.cardScrollableNode.style.display = "none";
+        this.emptyContainer.style.display = "flex";
+        this.emptyText.textContent = message;
+        this.emptySubtext.textContent = detail;
+    }
+    createCardScrollContent(...classNames) {
+        const content = append(this.cardContainer, $(".plugin-card-scroll.plugin-card-scroll-content"));
+        content.classList.add(...classNames);
+        this.sectionLayoutContainer = classNames.includes("distributed-section-layout") ? content : undefined;
+        const resizeObserver = this.cardDisposables.add(
+            new DisposableResizeObserver("McpListWidget.cardScrollContent", () => this.scheduleMcpSectionLayout())
+        );
+        this.cardDisposables.add(resizeObserver.observe(content));
+        return content;
+    }
+    addSurfaceActivation(surface, label, callback, ...classNames) {
+        const primaryAction = createCustomizationCardPrimaryAction(surface, label, ...classNames);
+        this.firstCardFocusElement ??= primaryAction;
+        this.cardDisposables.add(addDisposableListener(primaryAction, "click", callback));
+        return primaryAction;
+    }
+    renderCardSection(parent, title, description, className, count, renderActions) {
+        const section = append(parent, $(".plugin-card-section"));
+        section.classList.add(className);
+        const header = append(section, $(".plugin-card-section-header"));
+        const text = append(header, $(".plugin-card-section-text"));
+        const headingRow = append(text, $(".plugin-card-section-heading-row"));
+        const heading = append(headingRow, $("h3.plugin-card-section-title"));
+        heading.textContent = title;
+        if (count !== undefined) {
+            const countElement = append(headingRow, $(".plugin-card-section-count"));
+            countElement.textContent = String(count);
+        }
+        if (description) {
+            const descriptionElement = append(text, $(".plugin-card-section-description"));
+            descriptionElement.textContent = description;
+        }
+        renderActions?.(header);
+        const list = append(section, $(".plugin-card-grid"));
+        list.dataset.virtualizedSectionKey = className;
+        const collapsedSections = this.collapsedSections ??= ( new Set());
+        setupCollapsibleSection(headingRow, list, title, this.cardDisposables, ( collapsedSections.has(className)), collapsed => {
+            if (collapsed) {
+                collapsedSections.add(className);
+            } else {
+                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(
+                        9017,
+                        "{0}. Available to install from the MCP marketplace.",
+                        entry.server.label
+                    )) : this.getMcpEntryAriaLabel(entry, itemRenderer),
+                    getWidgetAriaLabel: () => label,
+                    getSetSize: (_entry, _index, listLength) => listLength,
+                    getPosInSet: (_entry, index) => index + 1
+                },
+                openOnSingleClick: true,
+                identityProvider: {
+                    getId: entry => entry.type === "marketplace-item" ? `marketplace:${entry.server.id}` : getMcpRowKey(entry)
+                }
+            })
+        );
+        this.cardDisposables.add(list.onDidChangeContentHeight(() => this.scheduleMcpSectionLayout()));
+        list.splice(0, 0, entries);
+        const section = {
+            list,
+            entries,
+            container,
+            key,
+            pendingMeasurements: ( new Set()),
+            deferredMeasurements: ( new Set())
+        };
+        this.sectionLists.push(section);
+        this.cardDisposables.add(list.onDidScroll(() => {
+            if (( [...section.deferredMeasurements].some(index => index >= list.firstVisibleIndex && index <= list.lastVisibleIndex))) {
+                this.scheduleMcpSectionLayout();
+            }
+        }));
+        const heightInputs = ( new Map());
+        this.cardDisposables.add(itemRenderer.onDidChangeHeight((
+            {
+                index,
+                text,
+                expanded
+            }
+        ) => {
+            const entry = entries[index];
+            if (entry && entry.type !== "marketplace-item") {
+                heightInputs.set(entry, {
+                    text,
+                    expanded
+                });
+            }
+            section.pendingMeasurements.add(index);
+            this.scheduleMcpSectionLayout();
+        }));
+        this.cardDisposables.add(autorun(reader => {
+            this.agentHostCustomizationsChanged.read(reader);
+            const sessionResource = this.customizationHarnessService.activeSessionResource.read(reader);
+            const servers = ( new Map(
+                this.agentHostCustomizationService.getMcpServers(sessionResource).map(server => [server.id, server])
+            ));
+            for (let index = 0; index < entries.length; index++) {
+                const entry = entries[index];
+                if (entry.type === "marketplace-item") {
+                    continue;
+                }
+                const host = getActiveSessionServer(entry);
+                let error;
+                if (host) {
+                    const server = servers.get(host.id);
+                    error = server?.enabled && server.status === McpServerStatus.Error ? getMcpErrorMessage(
+                        server.status,
+                        server.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined
+                    ) : undefined;
+                } else if (!this.workspaceService.isSessionsWindow && entry.type !== "session-server-item") {
+                    const state = entry.localServer?.connectionState.read(reader);
+                    const enabled = !entry.localServer || isContributionEnabled(entry.localServer.enablement.read(reader));
+                    error = enabled && state?.state === McpConnectionState.Kind.Error ? getMcpErrorMessage(state.state, state.message) : undefined;
+                }
+                itemRenderer.syncError(entry, error);
+                const expanded = itemRenderer.isErrorExpanded(entry, error);
+                const text = error === undefined ? undefined : expanded ? error : getMcpErrorPreview(error).text;
+                const previous = heightInputs.get(entry);
+                heightInputs.set(entry, {
+                    text,
+                    expanded
+                });
+                if (previous && (previous.text !== text || previous.expanded !== expanded)) {
+                    section.pendingMeasurements.add(index);
+                }
+            }
+            if (section.pendingMeasurements.size) {
+                this.scheduleMcpSectionLayout();
+            }
+        }));
+        list.scrollTop = this.sectionScrollPositions.get(key) ?? 0;
+        this.cardDisposables.add(list.onDidOpen(event => {
+            const entry = event.element;
+            if (!entry) {
+                return;
+            }
+            this._onDidSelectServer.fire(
+                entry.type === "marketplace-item" ? createWorkbenchMcpServerDetailInput(entry.server) : createInstalledMcpServerDetailInput(entry)
+            );
+        }));
+        this.cardDisposables.add(list.onContextMenu(event => {
+            if (event.element && event.element.type !== "marketplace-item") {
+                this.showMcpServerActions(event.element, event.anchor);
+            }
+        }));
+        this.cardDisposables.add(list.onDidChangeFocus(event => {
+            const index = event.indexes[0] ?? -1;
+            itemRenderer.setFocusedIndex(index);
+            marketplaceRenderer.setFocusedIndex(index);
+        }));
+        this.cardDisposables.add(list.onDidFocus(() => {
+            if (list.getFocus().length === 0 && entries.length > 0) {
+                list.setFocus([0]);
+            }
+        }));
+    }
+    captureSectionScrollPositions() {
+        for (const section of this.sectionLists) {
+            this.sectionScrollPositions.set(section.key, section.list.scrollTop);
+        }
+    }
+    getMcpEntryAriaLabel(entry, renderer) {
+        return derived(this, reader => {
+            renderer?.readErrorExpansion(reader);
+            this.agentHostCustomizationsChanged.read(reader);
+            const label = getMcpEntryLabel(entry);
+            const activeSessionResource = this.customizationHarnessService.activeSessionResource.read(reader);
+            let statusKind;
+            let disabledReason;
+            let errorMessage;
+            const activeSessionServer = getActiveSessionServer(entry);
+            if (activeSessionServer !== undefined) {
+                const server = this.agentHostCustomizationService.getMcpServers(activeSessionResource).find(server => server.id === activeSessionServer.id);
+                const presentation = server && getActiveSessionServerPresentation(server);
+                statusKind = presentation?.status;
+                disabledReason = presentation?.enabled ? undefined : server?.disabledReason;
+                errorMessage = server?.state?.kind === McpServerStatus.Error ? server.state.error?.message : undefined;
+            } else if (entry.type !== "session-server-item" && entry.localServer && isContributionDisabled(entry.localServer.enablement.read(reader))) {
+                statusKind = "disabled";
+                disabledReason = getMcpDisabledReason(entry);
+            } else if (entry.type !== "session-server-item" && !this.workspaceService.isSessionsWindow) {
+                const connectionState = entry.localServer?.connectionState.read(reader);
+                statusKind = entry.type === "server-item" || connectionState?.state === McpConnectionState.Kind.Error ? connectionState?.state : undefined;
+                errorMessage = connectionState?.state === McpConnectionState.Kind.Error ? connectionState.message : undefined;
+            }
+            const status = getMcpStatusPresentation(statusKind, disabledReason);
+            const error = getMcpErrorMessage(statusKind, errorMessage);
+            if (status && error) {
+                const preview = getMcpErrorPreview(error);
+                const expanded = renderer?.isErrorExpanded(entry, error);
+                const text = expanded ? error : preview.text;
+                return !expanded && (preview.truncated || renderer?.isErrorClipped(entry)) ? ( localize(
+                    9018,
+                    "{0}, {1}, {2}. Use Show More to read the full error.",
+                    label,
+                    status.label,
+                    text
+                )) : ( localize(9019, "{0}, {1}, {2}", label, status.label, text));
+            }
+            return status ? ( localize(8994, "{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(9020, "Disable {0}", label)) : ( localize(9021, "Enable {0}", label));
+            const accessibleLabel = blockedByPlugin ? ( localize(9022, "{0} is disabled by its plugin", label)) : toggleLabel;
+            toggle.disabled = !currentEntry || !!blockedByPlugin;
+            toggle.checked = enabled;
+            toggle.setAriaLabel(accessibleLabel);
+            updateTabbability();
+        };
+        update();
+        disposables.add(
+            addDisposableGenericMouseDownListener(toggle.domNode, event => EventHelper.stop(event, true))
+        );
+        disposables.add(toggle.onChange(checked => {
+            const currentEntry = getEntry();
+            if (!currentEntry) {
+                update();
+                return;
+            }
+            enabled = checked;
+            this.setInstalledEntryEnabled(currentEntry, enabled);
+            update();
+            status(enabled ? ( localize(9023, "{0} enabled.", label)) : ( localize(9024, "{0} disabled.", label)));
+        }));
+        if (entry.type !== "session-server-item" && entry.localServer) {
+            disposables.add(autorun(reader => {
+                entry.localServer?.enablement.read(reader);
+                update();
+            }));
+        }
+        disposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(update));
+        const more = disposables.add(( new Button(actions, {
+            ...getButtonStyles({
+                buttonSecondaryBackground: undefined,
+                buttonSecondaryBorder: undefined
+            }),
+            secondary: true,
+            supportIcons: true,
+            ariaLabel: ( localize(9025, "More actions for {0}", label))
+        })));
+        more.element.classList.add("plugin-card-icon-button");
+        more.label = `$(${Codicon.ellipsis.id})`;
+        registerMcpInlineButtonAction(disposables, more, () => {
+            const currentEntry = getEntry();
+            if (currentEntry) {
+                this.showMcpServerActions(currentEntry, more.element);
+            }
+        });
+    }
+    layoutMcpSectionLists() {
+        const content = this.sectionLayoutContainer;
+        if (!content || content.clientWidth === 0) {
+            return;
+        }
+        const heights = layoutVirtualizedSections(content, this.sectionLists.map(section => ({
+            container: section.container,
+            contentHeight: section.list.contentHeight,
+            minimumHeight: getVirtualizedSectionMinimumHeight(
+                section.entries.map((_entry, index) => index),
+                index => section.list.getElementHeight(index)
+            )
+        })));
+        for (let index = 0; index < this.sectionLists.length; index++) {
+            const section = this.sectionLists[index];
+            const height = heights[index];
+            section.container.style.height = `${height}px`;
+            if (height > 0) {
+                section.list.layout(height, section.container.clientWidth || undefined);
+                for (const index of section.deferredMeasurements) {
+                    if (index >= section.list.firstVisibleIndex && index <= section.list.lastVisibleIndex) {
+                        section.deferredMeasurements.delete(index);
+                        section.pendingMeasurements.add(index);
+                    }
+                }
+                const pending = [...section.pendingMeasurements];
+                section.pendingMeasurements.clear();
+                for (const index of pending) {
+                    if (index >= section.list.firstVisibleIndex && index <= section.list.lastVisibleIndex) {
+                        section.list.updateElementHeight(index, undefined);
+                    } else {
+                        section.list.updateElementHeight(index, MCP_SECTION_ITEM_HEIGHT);
+                        section.deferredMeasurements.add(index);
+                    }
+                }
+            }
+        }
+    }
+    scheduleMcpSectionLayout() {
+        this.pendingSectionLayout.value = scheduleAtNextAnimationFrame(getWindow(this.element), () => {
+            this.layoutMcpSectionLists();
+            this.cardScrollable.scanDomNode();
+        });
+    }
+    renderMcpHome() {
+        if (this.searchQuery.trim()) {
+            return;
+        }
+        this.captureSectionScrollPositions();
+        this.cardDisposables.clear();
+        this.sectionLists = [];
+        this.installedAddButton = undefined;
+        this.firstCardFocusElement = undefined;
+        this.availableSection = undefined;
+        clearNode(this.cardContainer);
+        this.showCardSurface();
+        const content = this.createCardScrollContent("distributed-section-layout");
+        const installedList = this.renderCardSection(content, ( localize(9026, "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(9027, "No MCP servers are installed."));
+        } else {
+            this.createMcpSectionList(installedList, ( localize(9026, "Installed")), this.installedEntries.map(presentation => presentation.entry));
+        }
+        this.renderAvailableServers(content, this.getAvailableGalleryServers(), true);
+        this.scheduleMcpSectionLayout();
+    }
+    renderInstalledSectionActions(header) {
+        const actions = append(header, $(".plugin-card-section-actions"));
+        const addLabel = ( localize(9028, "Add Server"));
+        const add = this.installedAddButton = this.cardDisposables.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            secondary: true,
+            ariaLabel: addLabel
+        })));
+        add.element.classList.add("plugin-installed-action");
+        add.label = this.narrowLayout ? ( localize(9029, "Add")) : addLabel;
+        this.firstCardFocusElement ??= add.element;
+        this.cardDisposables.add(
+            add.onDidClick(() => this.commandService.executeCommand(McpCommandIds.AddConfiguration))
+        );
+    }
+    renderAvailableServers(parent, servers, showDescription) {
+        const availableList = this.renderCardSection(parent, ( localize(9030, "Available")), showDescription ? ( localize(9031, "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(9032, "Loading marketplace MCP servers...")), MCP_SECTION_ITEM_HEIGHT);
+            } else {
+                const empty = append(availableList, $(".plugin-inventory-empty"));
+                empty.textContent = ( localize(9033, "No marketplace MCP servers are available."));
+            }
+            this.cardListControllers.get(availableList)?.finalize();
+            return;
+        }
+        this.createMcpSectionList(availableList, ( localize(9030, "Available")), servers.map(server => ({
+            type: "marketplace-item",
+            server
+        })));
+    }
+    appendInstalledServerRow(parent, presentation) {
+        let entry = presentation.entry;
+        const rowKey = getMcpRowKey(entry);
+        const label = getMcpEntryLabel(entry);
+        const row = append(parent, $(".plugin-list-item.plugin-home-row.mcp-installed-home-row"));
+        const enabled = this.isInstalledEntryEnabled(entry);
+        row.classList.toggle("disabled", !enabled);
+        const primaryAction = this.addSurfaceActivation(
+            row,
+            getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+            () => this._onDidSelectServer.fire(createInstalledMcpServerDetailInput(entry))
+        );
+        const details = append(primaryAction, $(".plugin-list-item-details"));
+        const nameRow = append(details, $(".plugin-list-item-name-row"));
+        const name = append(nameRow, $(".plugin-list-item-name"));
+        name.textContent = formatDisplayName(label);
+        name.title = label;
+        const statusBadge = append(nameRow, $(".plugin-list-item-status.mcp-runtime-status-badge"));
+        const description = append(details, $(".plugin-list-item-description"));
+        const actions = append(row, $(".plugin-list-item-action"));
+        const getEntry = () => entry;
+        const signIn = this.appendInstalledServerSignIn(actions, getEntry);
+        const toggle = this.appendInstalledServerToggle(actions, getEntry);
+        const more = this.cardDisposables.add(( new Button(actions, {
+            ...getButtonStyles({
+                buttonSecondaryBackground: undefined,
+                buttonSecondaryBorder: undefined
+            }),
+            secondary: true,
+            supportIcons: true,
+            ariaLabel: ( localize(9025, "More actions for {0}", label))
+        })));
+        more.element.classList.add("plugin-card-icon-button");
+        more.label = `$(${Codicon.ellipsis.id})`;
+        this.cardDisposables.add(more.onDidClick(() => this.showMcpServerActions(entry, more.element)));
+        this.cardListControllers.get(parent)?.addItem({
+            row,
+            primaryAction,
+            label,
+            actions: [signIn?.element, toggle.element, more.element].filter(action => action !== undefined),
+            contextMenuAction: more.element
+        });
+        this.cardDisposables.add(autorun(reader => {
+            if (entry.type !== "session-server-item") {
+                entry.localServer?.connectionState.read(reader);
+            }
+            updateMcpCardRuntimePresentation(
+                statusBadge,
+                primaryAction,
+                description,
+                getMcpStatusKind(entry, this.workspaceService.isSessionsWindow),
+                getMcpDisabledReason(entry),
+                getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+                this.getInstalledEntryDescription(entry)
+            );
+        }));
+        this.cardDisposables.add(this.agentHostCustomizationService.onDidChangeCustomizations(() => {
+            const updated = this.installedEntries.find(candidate => getMcpRowKey(candidate.entry) === rowKey)?.entry;
+            if (!updated) {
+                return;
+            }
+            entry = updated;
+            updateMcpCardRuntimePresentation(
+                statusBadge,
+                primaryAction,
+                description,
+                getMcpStatusKind(entry, this.workspaceService.isSessionsWindow),
+                getMcpDisabledReason(entry),
+                getMcpEntryAriaLabel(entry, this.workspaceService.isSessionsWindow),
+                this.getInstalledEntryDescription(entry)
+            );
+            signIn?.update();
+            toggle.update();
+            row.classList.toggle("disabled", !this.isInstalledEntryEnabled(entry));
+        }));
+    }
+    appendInstalledServerSignIn(parent, getEntry) {
+        if (getActiveSessionServer(getEntry()) === undefined) {
+            return undefined;
+        }
+        const label = getMcpEntryLabel(getEntry());
+        const signInButton = createMcpSignInButton(parent, this.cardDisposables, label);
+        registerMcpInlineButtonAction(this.cardDisposables, signInButton, async () => {
+            const activeSessionServer = getActiveSessionServer(getEntry());
+            if (!activeSessionServer) {
+                return;
+            }
+            signInButton.enabled = false;
+            try {
+                await authenticateMcpServer(
+                    this.agentHostCustomizationService,
+                    this.customizationHarnessService.activeSessionResource.get(),
+                    activeSessionServer.id
+                );
+            } catch (error) {
+                this.notificationService.error(( localize(9034, "Unable to sign in to {0}: {1}", label, getErrorMessage(error))));
+            } finally {
+                signInButton.enabled = true;
+            }
+        });
+        const update = () => {
+            signInButton.element.style.display = getMcpStatusKind(getEntry(), this.workspaceService.isSessionsWindow) === McpServerStatus.AuthRequired ? "" : "none";
+        };
+        update();
+        return {
+            element: signInButton.element,
+            update
+        };
+    }
+    appendInstalledServerToggle(parent, getEntry) {
+        const label = getMcpEntryLabel(getEntry());
+        let enabled = this.isInstalledEntryEnabled(getEntry());
+        const toggle = this.cardDisposables.add(( new Switch({
+            ariaLabel: label,
+            checked: enabled
+        })));
+        const switchElement = toggle.domNode;
+        append(parent, switchElement);
+        const updateLabel = () => {
+            const blockedByPlugin = getMcpDisabledReason(getEntry())?.source === "plugin";
+            const toggleLabel = enabled ? ( localize(9020, "Disable {0}", label)) : ( localize(9021, "Enable {0}", label));
+            const accessibleLabel = blockedByPlugin ? ( localize(9022, "{0} is disabled by its plugin", label)) : toggleLabel;
+            toggle.setAriaLabel(accessibleLabel);
+        };
+        updateLabel();
+        this.cardDisposables.add(toggle.onChange(checked => {
+            enabled = checked;
+            updateLabel();
+            this.setInstalledEntryEnabled(getEntry(), enabled);
+            status(enabled ? ( localize(9023, "{0} enabled.", label)) : ( localize(9024, "{0} disabled.", label)));
+        }));
+        const update = () => {
+            enabled = this.isInstalledEntryEnabled(getEntry());
+            toggle.disabled = getMcpDisabledReason(getEntry())?.source === "plugin";
+            toggle.checked = enabled;
+            updateLabel();
+        };
+        update();
+        return {
+            element: switchElement,
+            update
+        };
+    }
+    appendMarketplaceServerRow(parent, server) {
+        const row = append(parent, $(".plugin-list-item.plugin-home-row.plugin-marketplace-home-row"));
+        const primaryAction = this.addSurfaceActivation(row, ( localize(9017, "{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(8984, "No description provided.")));
+        const actions = append(row, $(".plugin-list-item-action"));
+        const install = this.cardDisposables.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            ariaLabel: ( localize(9035, "Install {0}", server.label))
+        })));
+        install.element.classList.add("plugin-list-item-install-button");
+        install.label = ( localize(8985, "Install"));
+        this.cardDisposables.add(install.onDidClick(() => this.installMarketplaceServer(server, install)));
+        this.cardListControllers.get(parent)?.addItem({
+            row,
+            primaryAction,
+            label: server.label,
+            actions: [install.element]
+        });
+    }
+    async installMarketplaceServer(server, button) {
+        button.label = ( localize(9036, "Installing..."));
+        button.enabled = false;
+        try {
+            await this.mcpWorkbenchService.install(server);
+            status(( localize(9037, "{0} installed.", server.label)));
+            await this.refresh();
+        } catch (error) {
+            button.label = ( localize(8985, "Install"));
+            button.enabled = true;
+            this.notificationService.error(( localize(9038, "Unable to install MCP server: {0}", getErrorMessage(error))));
+        }
+    }
+    getAvailableGalleryServers() {
+        const installedKeys = ( new Set());
+        for (const presentation of this.installedEntries) {
+            const entry = presentation.entry;
+            if (entry.type === "server-item") {
+                for (const key of getWorkbenchServerMatchKeys(entry.server)) {
+                    installedKeys.add(key.toLowerCase());
+                }
+            } else if (entry.type === "builtin-item") {
+                installedKeys.add(entry.label.toLowerCase());
+                if (entry.localServer) {
+                    for (const key of getRuntimeServerMatchKeys(entry.localServer)) {
+                        installedKeys.add(key.toLowerCase());
+                    }
+                }
+            } else {
+                installedKeys.add(entry.server.name.toLowerCase());
+            }
+        }
+        return this.galleryServers.filter(
+            server => server.installState === McpServerInstallState.Uninstalled && !( getWorkbenchServerMatchKeys(server).some(key => ( installedKeys.has(key.toLowerCase()))))
+        );
+    }
+    matchesGalleryServerQuery(server, query) {
+        return server.label.toLowerCase().includes(query) || server.description.toLowerCase().includes(query) || server.publisherDisplayName?.toLowerCase().includes(query) === true;
+    }
+    getInstalledEntryDescription(entry) {
+        const description = entry.type === "server-item" ? entry.server.description : entry.type === "builtin-item" ? entry.description : "";
+        return truncateToFirstLine(description || ( localize(8984, "No description provided.")));
+    }
+    isInstalledEntryEnabled(entry) {
+        const activeSessionServer = getActiveSessionServer(entry);
+        const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
+        const serverId = localServer?.definition.id ?? (entry.type === "server-item" ? entry.server.id : undefined);
+        return isPrimaryMcpServerEnabled(this.mcpService, serverId, activeSessionServer);
+    }
+    setInstalledEntryEnabled(entry, enabled) {
+        const activeSessionServer = getActiveSessionServer(entry);
+        const localServer = entry.type === "session-server-item" ? undefined : entry.localServer;
+        const serverId = localServer?.definition.id ?? (entry.type === "server-item" ? entry.server.id : undefined);
+        setPrimaryMcpServerEnablement(
+            this.mcpService,
+            this.agentHostCustomizationService,
+            this.customizationHarnessService.activeSessionResource.get(),
+            serverId,
+            activeSessionServer,
+            enabled
+        );
+    }
+    updateSearchResults() {
+        const available = this.getAvailableGalleryServers();
+        if (this.installedEntries.length === 0 && available.length === 0) {
+            this.showEmptySurface(this.gallerySearchLoading ? ( localize(9039, "Searching the MCP marketplace...")) : ( localize(9040, "No servers match '{0}'", this.searchQuery)), this.gallerySearchLoading ? "" : ( localize(9041, "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(9042, "Installed")), undefined, "installed-mcp-servers-section", this.installedEntries.length);
+            installedList.classList.add("plugin-inventory-list");
+            this.createMcpSectionList(installedList, ( localize(9042, "Installed")), this.installedEntries.map(presentation => presentation.entry));
+        }
+        if (available.length > 0) {
+            this.renderAvailableServers(content, available, false);
+        }
+        this.scheduleMcpSectionLayout();
+    }
+    filterServers(render = true) {
+        const query = this.searchQuery.toLowerCase().trim();
+        const activeSessionResource = this.customizationHarnessService.activeSessionResource.get();
+        const activeSessionMatcher = ( new ActiveSessionMcpServerMatcher(this.agentHostCustomizationService.getMcpServers(activeSessionResource)));
+        const localServerMatcher = ( new LocalMcpServerMatcher(this.mcpService.servers.get()));
+        if (query) {
+            this.filteredServers = this.mcpWorkbenchService.local.filter(
+                server => server.label.toLowerCase().includes(query) || (server.description?.toLowerCase().includes(query))
+            );
+        } else {
+            this.filteredServers = [...this.mcpWorkbenchService.local];
+        }
+        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 groups = [{
+            entries: []
+        }, {
+            entries: []
+        }];
+        for (const server of this.filteredServers) {
+            const entry = {
+                type: "server-item",
+                server,
+                activeSessionServer: activeSessionMatcher.take(getWorkbenchServerMatchKeys(server)),
+                localServer: localServerMatcher.find(getWorkbenchServerMatchKeys(server))
+            };
+            const scope = server.local?.scope;
+            if (scope === LocalMcpServerScope.Workspace) {
+                groups[0].entries.push(entry);
+            } else {
+                groups[1].entries.push(entry);
+            }
+        }
+        const collectionSources = ( new Map(this.mcpRegistry.collections.get().map(c => [c.id, c.source])));
+        const pluginServers = [];
+        const extensionServers = [];
+        const otherBuiltinServers = [];
+        for (const server of builtinServers) {
+            const entry = {
+                server,
+                activeSessionServer: activeSessionMatcher.take(getRuntimeServerMatchKeys(server))
+            };
+            const source = collectionSources.get(server.collection.id);
+            if (server.collection.id.startsWith(PLUGIN_COLLECTION_PREFIX)) {
+                pluginServers.push(entry);
+            } else if (source instanceof ExtensionIdentifier && !isCopilotExtension(source)) {
+                extensionServers.push(entry);
+            } else {
+                otherBuiltinServers.push(entry);
+            }
+        }
+        const activeSessionOnlyServers = activeSessionMatcher.unmatched(query);
+        const activeSessionBuiltinEntries = createBuiltinActiveSessionMcpEntries(activeSessionOnlyServers);
+        this.installedEntries = [...groups.flatMap(group => group.entries.map(entry => ({
+            entry
+        }))), ...pluginServers.map((
+            {
+                server,
+                activeSessionServer
+            }
+        ) => ({
+            entry: createBuiltinEntry(server, activeSessionServer)
+        })), ...extensionServers.map((
+            {
+                server,
+                activeSessionServer
+            }
+        ) => ({
+            entry: createBuiltinEntry(server, activeSessionServer)
+        })), ...otherBuiltinServers.map((
+            {
+                server,
+                activeSessionServer
+            }
+        ) => ({
+            entry: createBuiltinEntry(server, activeSessionServer)
+        })), ...activeSessionBuiltinEntries.map(entry => ({
+            entry
+        }))];
+        this.filteredBuiltinCount = builtinServers.length;
+        this.filteredActiveSessionCount = activeSessionOnlyServers.length;
+        this._onDidChangeItemCount.fire(this.itemCount);
+        if (render) {
+            this.renderFilteredServers();
+        }
+    }
+    renderFilteredServers() {
+        if (this.searchQuery.trim()) {
+            this.updateSearchResults();
+        } else {
+            this.renderMcpHome();
+        }
+    }
+    getInstalledEntryMembershipSignature() {
+        return this.installedEntries.map((
+            {
+                entry
+            }
+        ) => [
+            getMcpRowKey(entry),
+            getActiveSessionServer(entry) ? "session" : "",
+            entry.type !== "session-server-item" && entry.localServer ? "local" : ""
+        ].join(":")).join("|");
+    }
+    get itemCount() {
+        return this.filteredServers.length + this.filteredBuiltinCount + this.filteredActiveSessionCount;
+    }
+    fireItemCount() {
+        this._onDidChangeItemCount.fire(this.itemCount);
+    }
+    isInBrowseMode() {
+        return false;
+    }
+    exitBrowseMode() {}
+    layout(height, width) {
+        this.lastHeight = height;
+        this.lastWidth = width;
+        if (!this.visible || this.element.parentElement?.style.display === "none") {
+            return;
+        }
+        this.element.style.height = `${height}px`;
+        this.updateResponsiveLayout(width);
+        const availableHeight = this.element.clientHeight || height;
+        const searchBarHeight = this.searchAndButtonContainer.offsetHeight;
+        if (searchBarHeight === 0 && !this._layoutDeferred) {
+            this._layoutDeferred = true;
+            getWindow(this.element).requestAnimationFrame(() => {
+                try {
+                    this.layout(this.lastHeight, this.lastWidth);
+                } finally {
+                    this._layoutDeferred = false;
+                }
+            });
+            return;
+        }
+        const headerHeight = this.sectionTitleHeader.offsetHeight;
+        this.lastHeaderHeight = headerHeight;
+        const listHeight = Math.max(0, availableHeight - searchBarHeight - headerHeight);
+        this.cardScrollableNode.style.height = `${listHeight}px`;
+        this.scheduleMcpSectionLayout();
+    }
+    focusSearch() {
+        this.searchInput.focus();
+    }
+    revealLastItem() {
+        const reveal = () => {
+            const section = this.sectionLists.at(-1);
+            if (section?.entries.length) {
+                section.list.reveal(section.entries.length - 1);
+            }
+            this.cardScrollable.scanDomNode();
+            this.cardScrollable.setScrollPosition({
+                scrollTop: this.cardContainer.scrollHeight
+            });
+        };
+        reveal();
+        this.revealLastItemScheduler.value = scheduleAtNextAnimationFrame(getWindow(this.element), reveal);
+    }
+    focus() {
+        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();
+                }
+            }
+        }
+    }
+    updateResponsiveLayout(width) {
+        const narrow = width < 500;
+        const wide = width >= 600;
+        if (this.narrowLayout === narrow && this.wideLayout === wide) {
+            return;
+        }
+        this.narrowLayout = narrow;
+        this.wideLayout = wide;
+        this.element.classList.toggle("narrow-layout", narrow);
+        this.element.classList.toggle("wide-layout", wide);
+        if (this.installedAddButton) {
+            this.installedAddButton.label = narrow ? ( localize(9029, "Add")) : ( localize(9028, "Add Server"));
+        }
+    }
+    showMcpServerActions(entry, anchor) {
+        const disposables = ( new DisposableStore());
+        const actions = this.getMcpServerActions(entry, disposables);
+        if (actions.length === 0) {
+            disposables.dispose();
+            return;
+        }
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => actions,
+            onHide: () => disposables.dispose()
+        });
+    }
+    getMcpServerActions(entry, disposables) {
+        const sessionResource = this.customizationHarnessService.activeSessionResource.get();
+        const currentEntry = resolveMcpEntry(entry, this.agentHostCustomizationService, sessionResource);
+        if (!currentEntry) {
+            return [];
+        }
+        entry = currentEntry;
+        const activeSessionServer = getActiveSessionServer(entry);
+        const actions = this.getMcpServerManagementActions(entry, disposables);
+        if (!activeSessionServer && entry.type === "server-item") {
+            return actions;
+        }
+        const showOutput = activeSessionServer ? getMcpServerOutputHandler(
+            this.outputService,
+            undefined,
+            activeSessionServer,
+            undefined,
+            () => this.agentHostCustomizationService.showMcpServerLog(sessionResource, activeSessionServer.id)
+        ) : getMcpServerOutputHandler(
+            this.outputService,
+            entry.type === "session-server-item" ? undefined : entry.localServer,
+            undefined
+        );
+        const outputIndex = actions.findIndex(action => action instanceof ShowServerOutputAction);
+        if (outputIndex !== -1) {
+            actions.splice(outputIndex, 1);
+        }
+        if (showOutput) {
+            const outputAction = disposables.add(( new Action("mcpServer.showOutput", ( localize(9043, "Show Output")), undefined, true, showOutput)));
+            if (outputIndex !== -1) {
+                actions.splice(outputIndex, 0, outputAction);
+            } else {
+                if (actions.length > 0) {
+                    actions.push(( new Separator()));
+                }
+                actions.push(outputAction);
+            }
+        }
+        return actions;
+    }
+    getMcpServerManagementActions(entry, disposables) {
+        if (entry.type === "session-server-item") {
+            const actions = getActiveSessionServerOptionsActions(
+                this.commandService,
+                this.agentHostCustomizationService,
+                this.agentPluginService,
+                this.customizationHarnessService.activeSessionResource.get(),
+                entry.server
+            );
+            actions.forEach(action => isDisposable(action) && disposables.add(action));
+            return actions;
+        }
+        if (entry.type === "builtin-item") {
+            const collectionId = entry.collectionId;
+            const pluginUriStr = getPluginUriFromCollectionId(collectionId);
+            const plugin = pluginUriStr ? this.agentPluginService.plugins.get().find(p => ( p.uri.toString()) === pluginUriStr) : undefined;
+            const actions = [];
+            const lifecycleAction = entry.activeSessionServer !== undefined ? getActiveSessionServerLifecycleAction(entry.activeSessionServer) : undefined;
+            if (lifecycleAction) {
+                actions.push(disposables.add(lifecycleAction));
+            }
+            if (entry.localServer) {
+                const isEmptyWorkbench = this.workspaceService.getActiveProjectRoot() === undefined;
+                const enablementActions = getBuiltinMcpServerEnablementActions(
+                    this.mcpService,
+                    entry.localServer.definition.id,
+                    isEmptyWorkbench,
+                    this.agentHostCustomizationService,
+                    this.agentPluginService,
+                    this.customizationHarnessService.activeSessionResource.get(),
+                    entry.activeSessionServer
+                );
+                if (enablementActions.length > 0) {
+                    if (actions.length > 0) {
+                        actions.push(( new Separator()));
+                    }
+                    for (const enablementAction of enablementActions) {
+                        if (isDisposable(enablementAction)) {
+                            disposables.add(enablementAction);
+                        }
+                        actions.push(enablementAction);
+                    }
+                }
+            }
+            if (plugin) {
+                if (actions.length > 0) {
+                    actions.push(( new Separator()));
+                }
+                actions.push(disposables.add(( new Action("mcpServer.showPlugin", ( localize(9044, "Show Plugin")), undefined, true, async () => {
+                    const item = {
+                        kind: AgentPluginItemKind.Installed,
+                        name: plugin.label,
+                        description: plugin.fromMarketplace?.description ?? "",
+                        marketplace: plugin.fromMarketplace?.marketplace,
+                        plugin
+                    };
+                    this._onDidRequestShowPlugin.fire(item);
+                }))));
+                actions.push(disposables.add(( new Action("mcpServer.uninstallPlugin", ( localize(9045, "Uninstall Plugin")), undefined, true, async () => {
+                    const result = await this.dialogService.confirm({
+                        message: ( localize(9046, "This MCP server is provided by the plugin '{0}'", plugin.label)),
+                        detail: ( localize(
+                            9047,
+                            "Individual MCP servers from a plugin cannot be removed separately. Would you like to uninstall the entire plugin?"
+                        )),
+                        primaryButton: ( localize(9048, "Uninstall Plugin")),
+                        type: "question"
+                    });
+                    if (result.confirmed) {
+                        await plugin.remove?.();
+                    }
+                }))));
+            }
+            return actions;
+        }
+        const mcpServer = this.mcpWorkbenchService.local.find(local => local.id === entry.server.id) || entry.server;
+        const groups = getContextMenuActions(mcpServer, false, this.instantiationService);
+        const activeSessionServer = entry.activeSessionServer;
+        const activeSessionLifecycleAction = activeSessionServer !== undefined ? getActiveSessionServerLifecycleAction(activeSessionServer) : undefined;
+        const agentHostEnablementActions = activeSessionServer !== undefined ? getAgentHostMcpServerEnablementActions(
+            this.agentHostCustomizationService,
+            this.agentPluginService,
+            this.customizationHarnessService.activeSessionResource.get(),
+            activeSessionServer,
+            ["workspace", "session"]
+        ) : [];
+        for (const menuActions of groups) {
+            for (const menuAction of menuActions) {
+                if (isDisposable(menuAction)) {
+                    disposables.add(menuAction);
+                }
+            }
+        }
+        for (const action of [activeSessionLifecycleAction, ...agentHostEnablementActions]) {
+            if (action && isDisposable(action)) {
+                disposables.add(action);
+            }
+        }
+        return getServerItemContextMenuActions(
+            groups,
+            activeSessionServer,
+            activeSessionLifecycleAction,
+            agentHostEnablementActions
+        );
+    }
+};
+McpListWidget = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IMcpWorkbenchService)), ( __param(2, IMcpService)), ( __param(3, IMcpRegistry)), ( __param(4, ICommandService)), ( __param(5, IOpenerService)), ( __param(6, IContextViewService)), ( __param(7, IContextMenuService)), ( __param(8, IAgentPluginService)), ( __param(9, IDialogService)), ( __param(10, IConfigurationService)), ( __param(11, ICustomizationHarnessService)), ( __param(12, IAgentHostCustomizationService)), ( __param(13, IAICustomizationWorkspaceService)), ( __param(14, INotificationService)), ( __param(15, IOutputService)), ( __param(16, IMcpGalleryManifestService))], McpListWidget));
+
+export { 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 };