@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

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

@@ -0,0 +1,692 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
+import { $ as $$1, append, addDisposableListener, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { DisposableStore, Disposable, isDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { defaultButtonStyles, defaultInputBoxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { McpConnectionState, McpServerInstallState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpService, IMcpWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { McpCommandIds } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpCommandIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { InputBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { IContextViewService, IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { getContextMenuActions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/browser/mcpServerActions';
+import { LocalMcpServerScope } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/mcp/common/mcpWorkbenchManagementService';
+import { workspaceIcon, userIcon, extensionIcon } from './aiCustomizationIcons.js';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IAICustomizationWorkspaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(aiCustomizationManagement);
+const $ = $$1;
+const MCP_ITEM_HEIGHT = 36;
+const MCP_GROUP_HEADER_HEIGHT = 36;
+const MCP_GROUP_HEADER_HEIGHT_WITH_SEPARATOR = 40;
+class McpServerItemDelegate {
+    getHeight(element) {
+        if (element.type === "group-header") {
+            return element.isFirst ? MCP_GROUP_HEADER_HEIGHT : MCP_GROUP_HEADER_HEIGHT_WITH_SEPARATOR;
+        }
+        return MCP_ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        if (element.type === "group-header") {
+            return "mcpGroupHeader";
+        }
+        if (element.type === "builtin-item") {
+            return "mcpServerItem";
+        }
+        const server = element.server;
+        return server.gallery && !server.local ? "mcpGalleryItem" : "mcpServerItem";
+    }
+}
+class McpGroupHeaderRenderer {
+    constructor(hoverService) {
+        this.hoverService = hoverService;
+        this.templateId = "mcpGroupHeader";
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposables = ( new DisposableStore());
+        container.classList.add("ai-customization-group-header");
+        const chevron = append(container, $(".group-chevron"));
+        const icon = append(container, $(".group-icon"));
+        const labelGroup = append(container, $(".group-label-group"));
+        const label = append(labelGroup, $(".group-label"));
+        const infoIcon = append(labelGroup, $(".group-info"));
+        infoIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.info));
+        const count = append(container, $(".group-count"));
+        return {
+            container,
+            chevron,
+            icon,
+            label,
+            count,
+            infoIcon,
+            disposables,
+            elementDisposables
+        };
+    }
+    renderElement(element, _index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.chevron.className = "group-chevron";
+        templateData.chevron.classList.add(
+            ...ThemeIcon.asClassNameArray(element.collapsed ? Codicon.chevronRight : Codicon.chevronDown)
+        );
+        templateData.icon.className = "group-icon";
+        templateData.icon.classList.add(...ThemeIcon.asClassNameArray(element.icon));
+        templateData.label.textContent = element.label;
+        templateData.count.textContent = `${element.count}`;
+        templateData.elementDisposables.add(this.hoverService.setupDelayedHover(templateData.infoIcon, () => ({
+            content: element.description,
+            appearance: {
+                compact: true,
+                skipFadeInAnimation: true
+            }
+        })));
+        templateData.container.classList.toggle("collapsed", element.collapsed);
+        templateData.container.classList.toggle("has-previous-group", !element.isFirst);
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.disposables.dispose();
+    }
+}
+let McpServerItemRenderer = class McpServerItemRenderer {
+    constructor(mcpService, workspaceService) {
+        this.mcpService = mcpService;
+        this.workspaceService = workspaceService;
+        this.templateId = "mcpServerItem";
+    }
+    renderTemplate(container) {
+        container.classList.add("mcp-server-item");
+        const details = append(container, $(".mcp-server-details"));
+        const name = append(details, $(".mcp-server-name"));
+        const description = append(details, $(".mcp-server-description"));
+        const status = append(container, $(".mcp-server-status"));
+        return {
+            container,
+            name,
+            description,
+            status,
+            disposables: ( new DisposableStore())
+        };
+    }
+    renderElement(element, index, templateData) {
+        templateData.disposables.clear();
+        if (element.type === "builtin-item") {
+            templateData.container.classList.add("builtin");
+            templateData.name.textContent = element.label;
+            if (element.description) {
+                templateData.description.textContent = element.description;
+                templateData.description.style.display = "";
+            } else {
+                templateData.description.style.display = "none";
+            }
+            templateData.status.style.display = "none";
+            return;
+        }
+        templateData.container.classList.remove("builtin");
+        templateData.name.textContent = element.server.label;
+        if (element.server.description) {
+            templateData.description.textContent = element.server.description;
+            templateData.description.style.display = "";
+        } else {
+            templateData.description.style.display = "none";
+        }
+        const server = this.mcpService.servers.get().find(s => s.definition.id === element.server.id);
+        templateData.disposables.add(autorun(reader => {
+            const connectionState = server?.connectionState.read(reader);
+            this.updateStatus(templateData.status, connectionState?.state);
+        }));
+    }
+    updateStatus(statusElement, state) {
+        statusElement.className = "mcp-server-status";
+        if (this.workspaceService.isSessionsWindow) {
+            statusElement.style.display = "none";
+            return;
+        }
+        statusElement.style.display = "";
+        switch (state) {
+        case McpConnectionState.Kind.Running:
+            statusElement.textContent = ( localize(5320, "Running"));
+            statusElement.classList.add("running");
+            break;
+        case McpConnectionState.Kind.Starting:
+            statusElement.textContent = ( localize(5321, "Starting"));
+            statusElement.classList.add("starting");
+            break;
+        case McpConnectionState.Kind.Error:
+            statusElement.textContent = ( localize(5322, "Error"));
+            statusElement.classList.add("error");
+            break;
+        case McpConnectionState.Kind.Stopped:
+        default:
+            statusElement.textContent = ( localize(5323, "Stopped"));
+            statusElement.classList.add("stopped");
+            break;
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+McpServerItemRenderer = ( __decorate([( __param(0, IMcpService)), ( __param(1, IAICustomizationWorkspaceService))], McpServerItemRenderer));
+class McpGalleryItemRenderer {
+    constructor(mcpWorkbenchService) {
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.templateId = "mcpGalleryItem";
+    }
+    renderTemplate(container) {
+        container.classList.add("mcp-server-item", "mcp-gallery-item");
+        const details = append(container, $(".mcp-server-details"));
+        const nameRow = append(details, $(".mcp-gallery-name-row"));
+        const name = append(nameRow, $(".mcp-server-name"));
+        const publisher = append(nameRow, $(".mcp-gallery-publisher"));
+        const description = append(details, $(".mcp-server-description"));
+        const actionContainer = append(container, $(".mcp-gallery-action"));
+        const installButton = ( new Button(actionContainer, {
+            ...defaultButtonStyles,
+            supportIcons: true
+        }));
+        installButton.element.classList.add("mcp-gallery-install-button");
+        const templateDisposables = ( new DisposableStore());
+        templateDisposables.add(installButton);
+        return {
+            container,
+            name,
+            publisher,
+            description,
+            installButton,
+            elementDisposables: ( new DisposableStore()),
+            templateDisposables
+        };
+    }
+    renderElement(element, _index, templateData) {
+        templateData.elementDisposables.clear();
+        templateData.name.textContent = element.server.label;
+        templateData.publisher.textContent = element.server.publisherDisplayName ? `by ${element.server.publisherDisplayName}` : "";
+        templateData.description.textContent = element.server.description || "";
+        this.updateInstallButton(templateData.installButton, element.server);
+        templateData.elementDisposables.add(templateData.installButton.onDidClick(async () => {
+            const canInstall = this.mcpWorkbenchService.canInstall(element.server);
+            if (canInstall === true) {
+                templateData.installButton.label = ( localize(5324, "Installing..."));
+                templateData.installButton.enabled = false;
+                await this.mcpWorkbenchService.install(element.server);
+            }
+        }));
+        templateData.elementDisposables.add(this.mcpWorkbenchService.onChange(changed => {
+            if (!changed || changed.id === element.server.id) {
+                this.updateInstallButton(templateData.installButton, element.server);
+            }
+        }));
+    }
+    updateInstallButton(button, server) {
+        switch (server.installState) {
+        case McpServerInstallState.Installed:
+            button.label = ( localize(5325, "Installed"));
+            button.enabled = false;
+            break;
+        case McpServerInstallState.Installing:
+            button.label = ( localize(5324, "Installing..."));
+            button.enabled = false;
+            break;
+        default:
+            button.label = ( localize(5326, "Install"));
+            button.enabled = true;
+            break;
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposables.dispose();
+    }
+}
+let McpListWidget = class McpListWidget extends Disposable {
+    constructor(
+        instantiationService,
+        mcpWorkbenchService,
+        mcpService,
+        commandService,
+        openerService,
+        contextViewService,
+        contextMenuService,
+        hoverService
+    ) {
+        super();
+        this.instantiationService = instantiationService;
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.mcpService = mcpService;
+        this.commandService = commandService;
+        this.openerService = openerService;
+        this.contextViewService = contextViewService;
+        this.contextMenuService = contextMenuService;
+        this.hoverService = hoverService;
+        this._onDidSelectServer = this._register(( new Emitter()));
+        this.onDidSelectServer = this._onDidSelectServer.event;
+        this.filteredServers = [];
+        this.displayEntries = [];
+        this.galleryServers = [];
+        this.searchQuery = "";
+        this.browseMode = false;
+        this.collapsedGroups = ( new Set());
+        this.delayedFilter = ( new Delayer(200));
+        this.delayedGallerySearch = ( new Delayer(400));
+        this.element = $(".mcp-list-widget");
+        this.create();
+        this._register({
+            dispose: () => {
+                this.galleryCts?.dispose();
+            }
+        });
+    }
+    create() {
+        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(5327, "Type to search...")),
+            inputBoxStyles: defaultInputBoxStyles
+        })));
+        this._register(this.searchInput.onDidChange(() => {
+            this.searchQuery = this.searchInput.value;
+            if (this.browseMode) {
+                this.delayedGallerySearch.trigger(() => this.queryGallery());
+            } else {
+                this.delayedFilter.trigger(() => this.filterServers());
+            }
+        }));
+        const buttonContainer = append(this.searchAndButtonContainer, $(".list-button-group"));
+        const browseButtonContainer = append(buttonContainer, $(".list-add-button-container"));
+        this.browseButton = this._register(( new Button(browseButtonContainer, {
+            ...defaultButtonStyles,
+            secondary: true,
+            supportIcons: true
+        })));
+        this.browseButton.label = `$(${Codicon.library.id}) ${( localize(5328, "Browse Marketplace"))}`;
+        this.browseButton.element.classList.add("list-add-button");
+        this._register(this.browseButton.onDidClick(() => {
+            this.toggleBrowseMode(!this.browseMode);
+        }));
+        const addButtonContainer = append(buttonContainer, $(".list-add-button-container"));
+        this.addButton = this._register(( new Button(addButtonContainer, {
+            ...defaultButtonStyles,
+            supportIcons: true
+        })));
+        this.addButton.label = `$(${Codicon.add.id}) ${( localize(5329, "Add Server"))}`;
+        this.addButton.element.classList.add("list-add-button");
+        this._register(this.addButton.onDidClick(() => {
+            this.commandService.executeCommand(McpCommandIds.AddConfiguration);
+        }));
+        this.backLink = append(this.element, $(".mcp-back-link"));
+        this.backLink.setAttribute("role", "button");
+        this.backLink.tabIndex = 0;
+        this.backLink.setAttribute("aria-label", ( localize(5330, "Back to installed servers")));
+        const backIcon = append(this.backLink, $("span"));
+        backIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.arrowLeft));
+        const backText = append(this.backLink, $("span"));
+        backText.textContent = ( localize(5331, "Back to installed servers"));
+        this._register(addDisposableListener(this.backLink, "click", () => {
+            this.toggleBrowseMode(false);
+        }));
+        this._register(addDisposableListener(this.backLink, "keydown", e => {
+            if (e.key === "Enter" || e.key === " ") {
+                e.preventDefault();
+                this.toggleBrowseMode(false);
+            }
+        }));
+        this.backLink.style.display = "none";
+        this.emptyContainer = append(this.element, $(".mcp-empty-state"));
+        const emptyIcon = append(this.emptyContainer, $(".empty-icon"));
+        emptyIcon.classList.add(...ThemeIcon.asClassNameArray(Codicon.server));
+        this.emptyText = append(this.emptyContainer, $(".empty-text"));
+        this.emptySubtext = append(this.emptyContainer, $(".empty-subtext"));
+        this.listContainer = append(this.element, $(".mcp-list-container"));
+        this.sectionHeader = append(this.element, $(".section-footer"));
+        this.sectionDescription = append(this.sectionHeader, $("p.section-footer-description"));
+        this.sectionDescription.textContent = ( localize(
+            5332,
+            "An open standard that lets AI use external tools and services. MCP servers provide tools for file operations, databases, APIs, and more."
+        ));
+        this.sectionLink = append(this.sectionHeader, $("a.section-footer-link"));
+        this.sectionLink.textContent = ( localize(5333, "Learn more about MCP servers"));
+        this.sectionLink.href = "https://code.visualstudio.com/docs/copilot/chat/mcp-servers";
+        this._register(addDisposableListener(this.sectionLink, "click", e => {
+            e.preventDefault();
+            const href = this.sectionLink.href;
+            if (href) {
+                this.openerService.open(( URI.parse(href)));
+            }
+        }));
+        const delegate = ( new McpServerItemDelegate());
+        const groupHeaderRenderer = ( new McpGroupHeaderRenderer(this.hoverService));
+        const localRenderer = this.instantiationService.createInstance(McpServerItemRenderer);
+        const galleryRenderer = ( new McpGalleryItemRenderer(this.mcpWorkbenchService));
+        this.list = this._register(this.instantiationService.createInstance(
+            WorkbenchList,
+            "McpManagementList",
+            this.listContainer,
+            delegate,
+            [groupHeaderRenderer, localRenderer, galleryRenderer],
+            {
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getAriaLabel(element) {
+                        if (element.type === "group-header") {
+                            return localize(
+                                5334,
+                                "{0}, {1} items, {2}",
+                                element.label,
+                                element.count,
+                                element.collapsed ? ( localize(5335, "collapsed")) : ( localize(5336, "expanded"))
+                            );
+                        }
+                        if (element.type === "builtin-item") {
+                            return element.label;
+                        }
+                        return element.server.label;
+                    },
+                    getWidgetAriaLabel() {
+                        return localize(5337, "MCP Servers");
+                    }
+                },
+                openOnSingleClick: true,
+                identityProvider: {
+                    getId(element) {
+                        if (element.type === "group-header") {
+                            return element.id;
+                        }
+                        if (element.type === "builtin-item") {
+                            return element.id;
+                        }
+                        return element.server.id;
+                    }
+                }
+            }
+        ));
+        this._register(this.list.onDidOpen(e => {
+            if (e.element) {
+                if (e.element.type === "group-header") {
+                    this.toggleGroup(e.element);
+                } else if (e.element.type === "server-item") {
+                    this._onDidSelectServer.fire(e.element.server);
+                }
+            }
+        }));
+        this._register(this.list.onContextMenu(e => this.onContextMenu(e)));
+        this._register(this.mcpWorkbenchService.onChange(() => {
+            if (!this.browseMode) {
+                this.refresh();
+            }
+        }));
+        this._register(autorun(reader => {
+            this.mcpService.servers.read(reader);
+            if (!this.browseMode) {
+                this.refresh();
+            }
+        }));
+        void this.refresh();
+    }
+    async refresh() {
+        if (this.browseMode) {
+            await this.queryGallery();
+        } else {
+            this.filterServers();
+        }
+    }
+    toggleBrowseMode(browse) {
+        this.browseMode = browse;
+        this.searchInput.value = "";
+        this.searchQuery = "";
+        this.backLink.style.display = browse ? "" : "none";
+        this.addButton.element.parentElement.style.display = browse ? "none" : "";
+        this.browseButton.element.parentElement.style.display = browse ? "none" : "";
+        this.searchInput.setPlaceHolder(browse ? ( localize(5338, "Search MCP marketplace...")) : ( localize(5327, "Type to search...")));
+        if (browse) {
+            void this.queryGallery();
+        } else {
+            this.galleryCts?.dispose(true);
+            this.galleryServers = [];
+            this.filterServers();
+        }
+    }
+    async queryGallery() {
+        this.galleryCts?.dispose(true);
+        const cts = this.galleryCts = ( new CancellationTokenSource());
+        this.emptyContainer.style.display = "flex";
+        this.listContainer.style.display = "none";
+        this.emptyText.textContent = ( localize(5339, "Loading marketplace..."));
+        this.emptySubtext.textContent = "";
+        try {
+            const pager = await this.mcpWorkbenchService.queryGallery({
+                text: this.searchQuery.trim() || undefined
+            }, cts.token);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            this.galleryServers = pager.firstPage.items;
+            this.updateGalleryList();
+        } catch {
+            if (!cts.token.isCancellationRequested) {
+                this.galleryServers = [];
+                this.emptyContainer.style.display = "flex";
+                this.listContainer.style.display = "none";
+                this.emptyText.textContent = ( localize(5340, "Unable to load marketplace"));
+                this.emptySubtext.textContent = ( localize(5341, "Check your connection and try again"));
+            }
+        }
+    }
+    updateGalleryList() {
+        if (this.galleryServers.length === 0) {
+            this.emptyContainer.style.display = "flex";
+            this.listContainer.style.display = "none";
+            if (this.searchQuery.trim()) {
+                this.emptyText.textContent = ( localize(5342, "No servers match '{0}'", this.searchQuery));
+                this.emptySubtext.textContent = ( localize(5343, "Try a different search term"));
+            } else {
+                this.emptyText.textContent = ( localize(5344, "No MCP servers available"));
+                this.emptySubtext.textContent = "";
+            }
+        } else {
+            this.emptyContainer.style.display = "none";
+            this.listContainer.style.display = "";
+        }
+        const entries = ( this.galleryServers.map(server => ({
+            type: "server-item",
+            server
+        })));
+        this.list.splice(0, this.list.length, entries);
+    }
+    filterServers() {
+        const query = this.searchQuery.toLowerCase().trim();
+        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 builtinServers = this.mcpService.servers.get().filter(s => !( localIds.has(s.definition.id))).filter(s => !query || s.definition.label.toLowerCase().includes(query));
+        if (this.filteredServers.length === 0 && builtinServers.length === 0) {
+            this.emptyContainer.style.display = "flex";
+            this.listContainer.style.display = "none";
+            if (this.searchQuery.trim()) {
+                this.emptyText.textContent = ( localize(5345, "No servers match '{0}'", this.searchQuery));
+                this.emptySubtext.textContent = ( localize(5343, "Try a different search term"));
+            } else {
+                this.emptyText.textContent = ( localize(5346, "No MCP servers configured"));
+                this.emptySubtext.textContent = ( localize(5347, "Add an MCP server configuration to get started"));
+            }
+        } else {
+            this.emptyContainer.style.display = "none";
+            this.listContainer.style.display = "";
+        }
+        const groups = [{
+            scope: LocalMcpServerScope.Workspace,
+            label: ( localize(5348, "Workspace")),
+            icon: workspaceIcon,
+            description: ( localize(
+                5349,
+                "MCP servers configured in your workspace settings, shared with your team via version control."
+            )),
+            servers: []
+        }, {
+            scope: LocalMcpServerScope.User,
+            label: ( localize(5350, "User")),
+            icon: userIcon,
+            description: ( localize(
+                5351,
+                "MCP servers configured in your user settings. Private to you and available across all projects."
+            )),
+            servers: []
+        }];
+        for (const server of this.filteredServers) {
+            const scope = server.local?.scope;
+            if (scope === LocalMcpServerScope.Workspace) {
+                groups[0].servers.push(server);
+            } else {
+                groups[1].servers.push(server);
+            }
+        }
+        const entries = [];
+        let isFirst = true;
+        for (const group of groups) {
+            if (group.servers.length === 0) {
+                continue;
+            }
+            const collapsed = ( this.collapsedGroups.has(group.scope));
+            entries.push({
+                type: "group-header",
+                id: `mcp-group-${group.scope}`,
+                scope: group.scope,
+                label: group.label,
+                icon: group.icon,
+                count: group.servers.length,
+                isFirst,
+                description: group.description,
+                collapsed
+            });
+            if (!collapsed) {
+                for (const server of group.servers) {
+                    entries.push({
+                        type: "server-item",
+                        server
+                    });
+                }
+            }
+            isFirst = false;
+        }
+        if (builtinServers.length > 0) {
+            const collapsed = ( this.collapsedGroups.has("builtin"));
+            entries.push({
+                type: "group-header",
+                id: "mcp-group-builtin",
+                scope: "builtin",
+                label: ( localize(5352, "Built-in")),
+                icon: extensionIcon,
+                count: builtinServers.length,
+                isFirst,
+                description: ( localize(5353, "MCP servers built into VS Code. These are available automatically.")),
+                collapsed
+            });
+            if (!collapsed) {
+                for (const server of builtinServers) {
+                    entries.push({
+                        type: "builtin-item",
+                        id: `builtin-${server.definition.id}`,
+                        label: server.definition.label,
+                        description: ""
+                    });
+                }
+            }
+        }
+        this.displayEntries = entries;
+        this.list.splice(0, this.list.length, this.displayEntries);
+    }
+    toggleGroup(entry) {
+        if (( this.collapsedGroups.has(entry.scope))) {
+            this.collapsedGroups.delete(entry.scope);
+        } else {
+            this.collapsedGroups.add(entry.scope);
+        }
+        this.filterServers();
+    }
+    layout(height, width) {
+        const sectionFooterHeight = this.sectionHeader.offsetHeight || 0;
+        const searchBarHeight = this.searchAndButtonContainer.offsetHeight || 52;
+        const backLinkHeight = this.browseMode ? (this.backLink.offsetHeight || 28) : 0;
+        const listHeight = height - sectionFooterHeight - searchBarHeight - backLinkHeight;
+        this.listContainer.style.height = `${Math.max(0, listHeight)}px`;
+        this.list.layout(Math.max(0, listHeight), width);
+        if (sectionFooterHeight === 0) {
+            getWindow(this.listContainer).requestAnimationFrame(() => {
+                if (this._store.isDisposed) {
+                    return;
+                }
+                const actualFooterHeight = this.sectionHeader.offsetHeight;
+                if (actualFooterHeight > 0) {
+                    const correctedHeight = height - actualFooterHeight - searchBarHeight - backLinkHeight;
+                    this.listContainer.style.height = `${Math.max(0, correctedHeight)}px`;
+                    this.list.layout(Math.max(0, correctedHeight), width);
+                }
+            });
+        }
+    }
+    focusSearch() {
+        this.searchInput.focus();
+    }
+    focus() {
+        this.list.domFocus();
+        const servers = this.list.length;
+        if (servers > 0) {
+            this.list.setFocus([0]);
+        }
+    }
+    onContextMenu(e) {
+        if (!e.element || e.element.type !== "server-item") {
+            return;
+        }
+        const serverEntry = e.element;
+        const disposables = ( new DisposableStore());
+        const mcpServer = this.mcpWorkbenchService.local.find(local => local.id === serverEntry.server.id) || serverEntry.server;
+        const groups = getContextMenuActions(mcpServer, false, this.instantiationService);
+        const actions = [];
+        for (const menuActions of groups) {
+            for (const menuAction of menuActions) {
+                actions.push(menuAction);
+                if (isDisposable(menuAction)) {
+                    disposables.add(menuAction);
+                }
+            }
+            actions.push(( new Separator()));
+        }
+        if (actions.length > 0 && actions[actions.length - 1] instanceof Separator) {
+            actions.pop();
+        }
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => actions,
+            onHide: () => disposables.dispose()
+        });
+    }
+};
+McpListWidget = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IMcpWorkbenchService)), ( __param(2, IMcpService)), ( __param(3, ICommandService)), ( __param(4, IOpenerService)), ( __param(5, IContextViewService)), ( __param(6, IContextMenuService)), ( __param(7, IHoverService))], McpListWidget));
+
+export { McpListWidget };