@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -1,74 +1,123 @@
 
 import { registerCss } from '../../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { $ as $$1, addDisposableGenericMouseDownListener, EventHelper, append, addDisposableListener, EventType, createTextNode, clearNode, isAncestor, getActiveElement, addStandardDisposableListener, scheduleAtNextAnimationFrame, getWindow } from '../../../../../base/browser/dom.js';
+import { $ as $$1, append, addDisposableGenericMouseDownListener, EventHelper, addDisposableListener, clearNode, reset, EventType, createTextNode, addStandardDisposableListener } from '../../../../../base/browser/dom.js';
 import { Button } from '../../../../../base/browser/ui/button/button.js';
 import { HighlightedLabel } from '../../../../../base/browser/ui/highlightedlabel/highlightedLabel.js';
 import { InputBox } from '../../../../../base/browser/ui/inputbox/inputBox.js';
-import { DomScrollableElement } from '../../../../../base/browser/ui/scrollbar/scrollableElement.js';
-import { TriStateCheckbox, Checkbox } from '../../../../../base/browser/ui/toggle/toggle.js';
+import { RenderIndentGuides } from '../../../../../base/browser/ui/tree/abstractTree.js';
+import { ObjectTreeElementCollapseState } from '../../../../../base/browser/ui/tree/tree.js';
 import { Action } from '../../../../../base/common/actions.js';
 import { Delayer } from '../../../../../base/common/async.js';
-import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
 import { Emitter } from '../../../../../base/common/event.js';
+import { getErrorMessage } from '../../../../../base/common/errors.js';
 import { matchesContiguousSubString } from '../../../../../base/common/filters.js';
 import { KeyCode } from '../../../../../base/common/keyCodes.js';
-import { DisposableStore, Disposable, MutableDisposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { DisposableStore, Disposable } from '../../../../../base/common/lifecycle.js';
 import '../../../../../base/common/observableInternal/index.js';
-import { ScrollbarVisibility } from '../../../../../base/common/scrollable.js';
+import { isEqual } from '../../../../../base/common/resources.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { localize } from '../../../../../nls.js';
+import '../../../../../platform/agentHost/common/state/protocol/channels-root/state.js';
+import { CustomizationType, McpServerStatus } 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 { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
 import { IContextViewService, IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
 import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.service.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
-import { WorkbenchList } from '../../../../../platform/list/browser/listService.js';
-import { setupCollapsibleSection, layoutVirtualizedSections, getVirtualizedSectionMinimumHeight, layoutVirtualizedSectionList } from './customizationCardList.js';
+import { IHoverService } from '../../../../../platform/hover/browser/hover.service.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { WorkbenchObjectTree } from '../../../../../platform/list/browser/listService.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.service.js';
 import { IOpenerService } from '../../../../../platform/opener/common/opener.service.js';
-import { defaultCheckboxStyles, defaultInputBoxStyles, defaultButtonStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
-import { IExtensionManifestPropertiesService } from '../../../../services/extensions/common/extensionManifestPropertiesService.service.js';
+import { defaultInputBoxStyles, getButtonStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
 import { IWorkbenchEnvironmentService } from '../../../../services/environment/common/environmentService.service.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.service.js';
 import { ExtensionState } from '../../../extensions/common/extensions.js';
 import { IExtensionsWorkbenchService } from '../../../extensions/common/extensions.service.js';
-import { GalleryItemInstallState, GalleryItemRenderer } from './galleryItemRenderer.js';
 import { ToolDataSource } from '../../common/tools/languageModelToolsService.js';
 import { ILanguageModelToolsService } from '../../common/tools/languageModelToolsService.service.js';
+import { ICustomizationHarnessService } from '../../common/customizationHarnessService.service.js';
+import { IAgentPluginService } from '../../common/plugins/agentPluginService.service.js';
+import { IAgentHostCustomizationService } from '../agentSessions/agentHost/agentHostCustomizationService.service.js';
 import { getToolSetTriState, isToolEnabledInSet, countEnabledCustomizationTools } from '../agentSessions/agentHost/agentHostToolSetEnablementService.js';
 import { IAgentHostToolSetEnablementService } from '../agentSessions/agentHost/agentHostToolSetEnablementService.service.js';
+import { IMcpService } from '../../../mcp/common/mcpTypes.service.js';
+import { getActiveSessionServerPresentation, isPrimaryMcpServerEnabled, getAgentHostMcpServerSource, createInstalledPluginItem, setPrimaryMcpServerEnablement, renderMcpServerStatusActions, getMcpErrorMessage, authenticateMcpServer, createAgentHostMcpServerDetailInput, getMcpStatusPresentation } from './mcpListWidget.js';
+import { CUSTOMIZATION_GROUP_HEADER_HEIGHT, CustomizationGroupHeaderRenderer } from './customizationGroupHeaderRenderer.js';
+import { asTreeRenderer, customizationTreeStyles, getCustomizationTreeContentHeight } from './customizationTree.js';
+import { CustomizationToggle } from './customizationToggle.js';
 import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
 import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
-import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableSignal } from '../../../../../base/common/observableInternal/observables/observableSignal.js';
 import { observableSignalFromEvent } from '../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 
 registerCss(aiCustomizationManagement, 1);
 const $ = $$1;
 const TOOLS_SET_ROW_TEMPLATE_ID = "toolsSetRow";
 const TOOLS_TOOL_ROW_TEMPLATE_ID = "toolsToolRow";
+const TOOLS_CONNECTED_ROW_TEMPLATE_ID = "toolsConnectedRow";
 const TOOLS_SET_ROW_PADDING = 16;
 const TOOLS_TOOL_ROW_PADDING = 12;
 const TOOLS_ROW_LABEL_HEIGHT = 18;
 const TOOLS_ROW_SUBTEXT_HEIGHT = 14;
-const TOOLS_SECTION_MAX_HEIGHT = 320;
 function computeToolsRowHeight(entry) {
-    if (entry.kind === "set") {
+    if (entry.type === "set") {
         return TOOLS_SET_ROW_PADDING + TOOLS_ROW_LABEL_HEIGHT + (entry.vm.detail ? TOOLS_ROW_SUBTEXT_HEIGHT : 0);
     }
+    if (entry.type === "connected") {
+        return (entry.server || entry.expandable ? TOOLS_SET_ROW_PADDING : TOOLS_TOOL_ROW_PADDING) + TOOLS_ROW_LABEL_HEIGHT + (entry.description ? TOOLS_ROW_SUBTEXT_HEIGHT : 0);
+    }
     const description = entry.toolVm.tool.userDescription ?? entry.toolVm.tool.modelDescription;
     return TOOLS_TOOL_ROW_PADDING + TOOLS_ROW_LABEL_HEIGHT + (description ? TOOLS_ROW_SUBTEXT_HEIGHT : 0);
 }
-class ToolsRowDelegate {
+class ToolsTreeDelegate {
     getHeight(entry) {
+        if (entry.type === "group-header") {
+            return CUSTOMIZATION_GROUP_HEADER_HEIGHT;
+        }
+        if (entry.type === "empty") {
+            return 54;
+        }
         return computeToolsRowHeight(entry);
     }
     getTemplateId(entry) {
-        return entry.kind === "set" ? TOOLS_SET_ROW_TEMPLATE_ID : TOOLS_TOOL_ROW_TEMPLATE_ID;
+        if (entry.type === "group-header") {
+            return "toolsGroupHeader";
+        }
+        if (entry.type === "empty") {
+            return "toolsEmptyRow";
+        }
+        if (entry.type === "connected") {
+            return TOOLS_CONNECTED_ROW_TEMPLATE_ID;
+        }
+        return entry.type === "set" ? TOOLS_SET_ROW_TEMPLATE_ID : TOOLS_TOOL_ROW_TEMPLATE_ID;
+    }
+}
+class ToolsEmptyRowRenderer {
+    constructor() {
+        this.templateId = "toolsEmptyRow";
     }
+    renderTemplate(container) {
+        return append(container, $(".plugin-inventory-empty.tools-tree-empty-row"));
+    }
+    renderElement(entry, _index, templateData) {
+        templateData.textContent = entry.label;
+    }
+    disposeTemplate() {}
 }
 class ToolsSetRowRenderer {
     constructor(
+        _instantiationService,
         _sessionType,
         _enablementService,
         _isExpanded,
@@ -76,6 +125,7 @@ class ToolsSetRowRenderer {
         _resolveExtension,
         _showExtensionMenu
     ) {
+        this._instantiationService = _instantiationService;
         this._sessionType = _sessionType;
         this._enablementService = _enablementService;
         this._isExpanded = _isExpanded;
@@ -84,25 +134,27 @@ class ToolsSetRowRenderer {
         this._showExtensionMenu = _showExtensionMenu;
         this.templateId = TOOLS_SET_ROW_TEMPLATE_ID;
         this._templates = ( new Set());
-        this._focusedIndex = -1;
     }
     renderTemplate(container) {
         container.classList.add("tools-list-setrow");
         const templateDisposables = ( new DisposableStore());
-        const checkbox = templateDisposables.add(( new TriStateCheckbox("", false, defaultCheckboxStyles)));
-        checkbox.domNode.tabIndex = -1;
-        container.appendChild(checkbox.domNode);
+        const toggle = templateDisposables.add(this._instantiationService.createInstance(CustomizationToggle, {
+            ariaLabel: "",
+            checked: false
+        }));
+        toggle.setTabIndex(-1);
+        container.appendChild(toggle.domNode);
         templateDisposables.add(
-            addDisposableGenericMouseDownListener(checkbox.domNode, event => EventHelper.stop(event, true))
+            addDisposableGenericMouseDownListener(toggle.domNode, event => EventHelper.stop(event, true))
         );
         const main = append(container, $(".tools-list-row-main"));
         const text = append(main, $(".tools-list-row-text"));
         const labelEl = append(text, $("span.tools-list-row-label"));
         const label = templateDisposables.add(( new HighlightedLabel(labelEl)));
         const subtext = append(text, $("span.tools-list-row-subtext"));
-        const count = append(container, $("span.tools-list-row-count"));
         const alwaysAvailable = append(container, $("span.tools-list-always-available"));
-        alwaysAvailable.textContent = ( localize(9268, "Always Available"));
+        alwaysAvailable.textContent = ( localize(11230, "Always Available"));
+        const count = append(container, $("span.tools-list-row-count"));
         const moreButton = append(container, $("button.tools-list-more-action"));
         moreButton.type = "button";
         moreButton.tabIndex = -1;
@@ -114,7 +166,7 @@ class ToolsSetRowRenderer {
         chevron.setAttribute("aria-hidden", "true");
         const template = {
             container,
-            checkbox,
+            toggle,
             label,
             subtext,
             count,
@@ -123,14 +175,14 @@ class ToolsSetRowRenderer {
             chevron,
             templateDisposables,
             elementDisposables: templateDisposables.add(( new DisposableStore())),
-            currentIndex: -1
+            currentSetId: undefined
         };
         this._templates.add(template);
         return template;
     }
-    renderElement(entry, index, data) {
+    renderElement(entry, _index, data) {
         data.elementDisposables.clear();
-        data.currentIndex = index;
+        data.currentSetId = entry.vm.toolSet.id;
         data.container.removeAttribute("aria-selected");
         const vm = entry.vm;
         const ts = vm.toolSet;
@@ -138,26 +190,27 @@ class ToolsSetRowRenderer {
         data.label.set(setName, vm.nameMatches);
         data.subtext.style.display = vm.detail ? "" : "none";
         data.subtext.textContent = vm.detail ?? "";
-        data.alwaysAvailable.style.display = vm.readOnly ? "" : "none";
-        data.checkbox.domNode.style.display = vm.readOnly ? "none" : "";
+        data.alwaysAvailable.style.display = "none";
+        data.toggle.domNode.style.display = "";
+        data.toggle.domNode.style.visibility = vm.readOnly ? "hidden" : "";
         if (!vm.readOnly) {
-            data.checkbox.setTitle(( localize(9269, "Enable {0}", setName)));
-            data.elementDisposables.add(data.checkbox.onChange(() => {
-                this._enablementService.setToolSetEnabled(this._sessionType, ts.id, vm.allToolIds, data.checkbox.checked === true);
+            data.toggle.setAriaLabel(( localize(11231, "Enable {0}", setName)));
+            data.elementDisposables.add(data.toggle.onChange(() => {
+                this._enablementService.setToolSetEnabled(this._sessionType, ts.id, vm.allToolIds, data.toggle.checked === true);
             }));
         }
         data.elementDisposables.add(autorun(reader => {
             const state = this._enablementService.observe(this._sessionType).read(reader);
             const triState = getToolSetTriState(state, ts.id, vm.allToolIds);
             if (!vm.readOnly) {
-                data.checkbox.checked = triState;
+                data.toggle.checked = triState;
                 data.container.setAttribute("aria-checked", triState === "mixed" ? "mixed" : String(triState));
             } else {
                 data.container.removeAttribute("aria-checked");
             }
             const enabledCount = vm.allToolIds.reduce((n, id) => n + (isToolEnabledInSet(state, ts.id, id) ? 1 : 0), 0);
             data.count.textContent = `${enabledCount}/${vm.allToolIds.length}`;
-            data.count.setAttribute("aria-label", ( localize(9270, "{0} of {1} tools enabled", enabledCount, vm.allToolIds.length)));
+            data.count.setAttribute("aria-label", ( localize(11232, "{0} of {1} tools enabled", enabledCount, vm.allToolIds.length)));
         }));
         data.elementDisposables.add(autorun(reader => {
             const expanded = this._isExpanded(vm, reader);
@@ -167,9 +220,9 @@ class ToolsSetRowRenderer {
         }));
         const extension = this._resolveExtension(ts);
         data.moreButton.style.display = extension ? "" : "none";
-        data.moreButton.tabIndex = extension && index === this._focusedIndex ? 0 : -1;
+        data.moreButton.tabIndex = extension && entry.vm.toolSet.id === this._focusedSetId ? 0 : -1;
         if (extension) {
-            const moreLabel = ( localize(9271, "More actions for {0}", setName));
+            const moreLabel = ( localize(11233, "More actions for {0}", setName));
             data.moreButton.setAttribute("aria-label", moreLabel);
             data.moreButton.title = moreLabel;
             data.elementDisposables.add(addDisposableListener(data.moreButton, "click", e => {
@@ -178,16 +231,16 @@ class ToolsSetRowRenderer {
             }));
         }
         data.elementDisposables.add(addDisposableListener(data.container, "click", e => {
-            if (data.checkbox.domNode.contains(e.target) || data.moreButton.contains(e.target)) {
+            if (data.toggle.domNode.contains(e.target) || data.moreButton.contains(e.target)) {
                 return;
             }
             this._toggleExpand(ts.id);
         }));
     }
-    setFocusedIndex(index) {
-        this._focusedIndex = index;
+    setFocusedSetId(setId) {
+        this._focusedSetId = setId;
         for (const template of this._templates) {
-            template.moreButton.tabIndex = template.moreButton.style.display !== "none" && template.currentIndex === index ? 0 : -1;
+            template.moreButton.tabIndex = template.moreButton.style.display !== "none" && template.currentSetId === setId ? 0 : -1;
         }
     }
     disposeTemplate(data) {
@@ -196,7 +249,8 @@ class ToolsSetRowRenderer {
     }
 }
 class ToolsToolRowRenderer {
-    constructor(_sessionType, _enablementService) {
+    constructor(_instantiationService, _sessionType, _enablementService) {
+        this._instantiationService = _instantiationService;
         this._sessionType = _sessionType;
         this._enablementService = _enablementService;
         this.templateId = TOOLS_TOOL_ROW_TEMPLATE_ID;
@@ -204,21 +258,24 @@ class ToolsToolRowRenderer {
     renderTemplate(container) {
         container.classList.add("tools-list-toolrow");
         const templateDisposables = ( new DisposableStore());
-        const checkbox = templateDisposables.add(( new Checkbox("", false, defaultCheckboxStyles)));
-        checkbox.domNode.tabIndex = -1;
-        container.appendChild(checkbox.domNode);
+        const toggle = templateDisposables.add(this._instantiationService.createInstance(CustomizationToggle, {
+            ariaLabel: "",
+            checked: false
+        }));
+        toggle.setTabIndex(-1);
+        container.appendChild(toggle.domNode);
         templateDisposables.add(
-            addDisposableGenericMouseDownListener(checkbox.domNode, event => EventHelper.stop(event, true))
+            addDisposableGenericMouseDownListener(toggle.domNode, event => EventHelper.stop(event, true))
         );
         const text = append(container, $(".tools-list-row-text"));
         const labelEl = append(text, $("span.tools-list-row-label"));
         const label = templateDisposables.add(( new HighlightedLabel(labelEl)));
         const subtext = append(text, $("span.tools-list-row-subtext"));
         const alwaysAvailable = append(container, $("span.tools-list-always-available"));
-        alwaysAvailable.textContent = ( localize(9268, "Always Available"));
+        alwaysAvailable.textContent = ( localize(11230, "Always Available"));
         return {
             container,
-            checkbox,
+            toggle,
             label,
             subtext,
             alwaysAvailable,
@@ -241,11 +298,11 @@ class ToolsToolRowRenderer {
         data.subtext.style.display = description ? "" : "none";
         data.subtext.textContent = description ?? "";
         data.alwaysAvailable.style.display = setVm.readOnly ? "" : "none";
-        data.checkbox.domNode.style.display = setVm.readOnly ? "none" : "";
+        data.toggle.domNode.style.display = setVm.readOnly ? "none" : "";
         if (!setVm.readOnly) {
-            data.checkbox.setTitle(( localize(9272, "Enable {0}", toolName)));
-            data.elementDisposables.add(data.checkbox.onChange(() => {
-                this._enablementService.setToolEnabled(this._sessionType, setVm.toolSet.id, tool.id, data.checkbox.checked);
+            data.toggle.setAriaLabel(( localize(11234, "Enable {0}", toolName)));
+            data.elementDisposables.add(data.toggle.onChange(() => {
+                this._enablementService.setToolEnabled(this._sessionType, setVm.toolSet.id, tool.id, data.toggle.checked === true);
             }));
             data.elementDisposables.add(autorun(reader => {
                 const enabled = isToolEnabledInSet(
@@ -253,14 +310,14 @@ class ToolsToolRowRenderer {
                     setVm.toolSet.id,
                     tool.id
                 );
-                data.checkbox.checked = enabled;
+                data.toggle.checked = enabled;
                 data.container.setAttribute("aria-checked", String(enabled));
             }));
             data.elementDisposables.add(addDisposableListener(data.container, "click", e => {
-                if (data.checkbox.domNode.contains(e.target)) {
+                if (data.toggle.domNode.contains(e.target)) {
                     return;
                 }
-                this._enablementService.setToolEnabled(this._sessionType, setVm.toolSet.id, tool.id, !data.checkbox.checked);
+                this._enablementService.setToolEnabled(this._sessionType, setVm.toolSet.id, tool.id, !data.toggle.checked);
             }));
         } else {
             data.container.removeAttribute("aria-checked");
@@ -270,51 +327,130 @@ class ToolsToolRowRenderer {
         data.templateDisposables.dispose();
     }
 }
-const TOOLS_MARKETPLACE_QUERY = "language model tools";
-const TOOLS_GALLERY_ITEM_HEIGHT = 62;
-const TOOLS_GALLERY_ITEM_TEMPLATE_ID = "toolsGalleryItem";
-class ToolsGalleryItemDelegate {
-    getHeight() {
-        return TOOLS_GALLERY_ITEM_HEIGHT;
-    }
-    getTemplateId() {
-        return TOOLS_GALLERY_ITEM_TEMPLATE_ID;
-    }
-}
-class ToolsGalleryItemProvider {
-    constructor(_extensionsWorkbenchService) {
-        this._extensionsWorkbenchService = _extensionsWorkbenchService;
-    }
-    getLabel(extension) {
-        return extension.displayName;
-    }
-    getPublisherDisplayName(extension) {
-        return extension.publisherDisplayName;
+class ToolsConnectedRowRenderer {
+    constructor(
+        _instantiationService,
+        _hoverService,
+        _isEnabled,
+        _setEnabled,
+        _isExpanded,
+        _toggleExpand,
+        _renderActions
+    ) {
+        this._instantiationService = _instantiationService;
+        this._hoverService = _hoverService;
+        this._isEnabled = _isEnabled;
+        this._setEnabled = _setEnabled;
+        this._isExpanded = _isExpanded;
+        this._toggleExpand = _toggleExpand;
+        this._renderActions = _renderActions;
+        this.templateId = TOOLS_CONNECTED_ROW_TEMPLATE_ID;
     }
-    getDescription(extension) {
-        return extension.description;
+    renderTemplate(container) {
+        container.classList.add("tools-list-connected-row");
+        const templateDisposables = ( new DisposableStore());
+        const toggle = templateDisposables.add(this._instantiationService.createInstance(CustomizationToggle, {
+            ariaLabel: "",
+            checked: false
+        }));
+        toggle.setTabIndex(-1);
+        container.appendChild(toggle.domNode);
+        templateDisposables.add(
+            addDisposableGenericMouseDownListener(toggle.domNode, event => EventHelper.stop(event, true))
+        );
+        const text = append(container, $(".tools-list-row-text"));
+        const label = templateDisposables.add(( new HighlightedLabel(append(text, $("span.tools-list-row-label")))));
+        const subtext = append(text, $("span.tools-list-row-subtext"));
+        const actions = append(container, $(".tools-list-connected-actions"));
+        const chevron = append(container, $("a.tools-list-chevron.codicon"));
+        chevron.setAttribute("aria-hidden", "true");
+        return {
+            container,
+            actions,
+            toggle,
+            label,
+            subtext,
+            chevron,
+            templateDisposables,
+            elementDisposables: templateDisposables.add(( new DisposableStore()))
+        };
     }
-    getInstallState(extension) {
-        switch (extension.state) {
-        case ExtensionState.Installed:
-            return GalleryItemInstallState.Installed;
-        case ExtensionState.Installing:
-            return GalleryItemInstallState.Installing;
-        default:
-            return GalleryItemInstallState.Uninstalled;
+    renderElement(entry, _index, data) {
+        data.elementDisposables.clear();
+        clearNode(data.actions);
+        data.container.removeAttribute("aria-selected");
+        data.container.classList.toggle("tools-list-setrow", !!entry.server || entry.expandable);
+        data.container.classList.toggle("tools-list-toolrow", !entry.server && !entry.expandable);
+        data.container.classList.toggle("readonly", !entry.expandable);
+        data.container.classList.toggle("message", entry.message === true);
+        data.container.style.setProperty("--tools-connected-depth", String(entry.depth));
+        data.label.set(entry.label, entry.nameMatches);
+        data.subtext.textContent = entry.description ?? "";
+        data.subtext.style.display = entry.description ? "" : "none";
+        if (entry.source) {
+            const source = entry.source;
+            if (source.open) {
+                const link = $("a.source-link", {
+                    href: "#",
+                    tabIndex: -1,
+                    "aria-label": source.ariaLabel ?? source.label
+                }, source.label);
+                const [before, after = ""] = ( localize(11235, "MCP server from {0}", "\u0000")).split("\u0000");
+                reset(data.subtext, before, link, after);
+                data.elementDisposables.add(
+                    addDisposableGenericMouseDownListener(link, event => EventHelper.stop(event, true))
+                );
+                data.elementDisposables.add(addDisposableListener(link, EventType.CLICK, event => {
+                    EventHelper.stop(event, true);
+                    source.open?.();
+                }));
+                data.elementDisposables.add(this._hoverService.setupDelayedHover(link, {
+                    content: source.hover
+                }));
+            } else {
+                data.elementDisposables.add(this._hoverService.setupDelayedHover(data.subtext, {
+                    content: source.hover
+                }));
+            }
         }
-    }
-    async install(extension) {
-        await this._extensionsWorkbenchService.install(extension);
-    }
-    onDidChangeInstallState(extension, listener) {
-        return this._extensionsWorkbenchService.onChange(changed => {
-            if (!changed || changed.identifier.id === extension.identifier.id) {
-                listener();
+        data.toggle.domNode.style.display = entry.server ? "" : "none";
+        data.chevron.style.display = entry.expandable || entry.server ? "" : "none";
+        data.chevron.style.visibility = entry.expandable ? "" : "hidden";
+        if (entry.server) {
+            const server = entry.server;
+            const enabled = this._isEnabled(server);
+            data.toggle.checked = enabled;
+            data.toggle.setAriaLabel(( localize(11236, "Enable {0}", entry.label)));
+            data.container.setAttribute("aria-checked", String(enabled));
+            data.elementDisposables.add(data.toggle.onChange(enabled => this._setEnabled(server, enabled)));
+            if (server.enabled && enabled) {
+                this._renderActions(server, data.actions, data.elementDisposables);
             }
-        });
+        } else {
+            data.container.removeAttribute("aria-checked");
+        }
+        data.actions.style.display = data.actions.childElementCount > 0 ? "" : "none";
+        if (entry.expandable) {
+            data.elementDisposables.add(autorun(reader => {
+                const expanded = this._isExpanded(entry, reader);
+                data.chevron.classList.toggle("codicon-chevron-down-compact", expanded);
+                data.chevron.classList.toggle("codicon-chevron-right-compact", !expanded);
+                data.container.setAttribute("aria-expanded", String(expanded));
+            }));
+            data.elementDisposables.add(addDisposableListener(data.container, "click", event => {
+                if (!data.toggle.domNode.contains(event.target)) {
+                    this._toggleExpand(entry.id);
+                }
+            }));
+        } else {
+            data.container.removeAttribute("aria-expanded");
+        }
+    }
+    disposeTemplate(data) {
+        data.templateDisposables.dispose();
     }
 }
+const TOOLS_MARKETPLACE_QUERY = "@tag:language-model-tools";
 let ToolsListWidget = class ToolsListWidget extends Disposable {
     constructor(
         _sessionType,
@@ -326,8 +462,15 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         _openerService,
         _instantiationService,
         _extensionsWorkbenchService,
-        _extensionManifestPropertiesService,
-        _environmentService
+        _environmentService,
+        _hoverService,
+        _agentHostCustomizationService,
+        _harnessService,
+        _mcpService,
+        _agentPluginService,
+        _labelService,
+        _notificationService,
+        _editorService
     ) {
         super();
         this._sessionType = _sessionType;
@@ -339,55 +482,117 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         this._openerService = _openerService;
         this._instantiationService = _instantiationService;
         this._extensionsWorkbenchService = _extensionsWorkbenchService;
-        this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
         this._environmentService = _environmentService;
+        this._hoverService = _hoverService;
+        this._agentHostCustomizationService = _agentHostCustomizationService;
+        this._harnessService = _harnessService;
+        this._mcpService = _mcpService;
+        this._agentPluginService = _agentPluginService;
+        this._labelService = _labelService;
+        this._notificationService = _notificationService;
+        this._editorService = _editorService;
         this._onDidChangeItemCount = this._register(( new Emitter()));
         this.onDidChangeItemCount = this._onDidChangeItemCount.event;
-        this._onDidSelectExtension = this._register(( new Emitter()));
-        this.onDidSelectExtension = this._onDidSelectExtension.event;
-        this._rowStore = this._register(( new DisposableStore()));
-        this._pendingSectionLayout = this._register(( new MutableDisposable()));
+        this._onDidSelectServer = this._register(( new Emitter()));
+        this.onDidSelectServer = this._onDidSelectServer.event;
+        this._onDidRequestShowPlugin = this._register(( new Emitter()));
+        this.onDidRequestShowPlugin = this._onDidRequestShowPlugin.event;
         this._searchQuery = observableValue("toolsSearchQuery", "");
         this._expanded = observableValue("toolsExpanded", ( new Set()));
         this._delayedSearch = this._register(( new Delayer(200)));
         this._lastCount = -1;
-        this._browseMode = false;
         this._lastHeight = 0;
         this._lastWidth = 0;
-        this._sectionLists = [];
-        this._collapsedSections = ( new Set());
-        this._sectionScrollPositions = ( new Map());
+        this._closeCustomizationEditor = () => Promise.resolve(true);
+        this._collapsedGroups = ( new Set());
+        this._currentModel = [];
+        this._connectedServers = [];
+        this._connectedPlugins = [];
+        this._connectedTools = ( new Map());
+        this._connectedToolsChanged = observableSignal(this);
+        this._pendingAutoExpand = ( new Set());
+        this._agentHostCustomizationsChanged = observableSignalFromEvent(this, this._agentHostCustomizationService.onDidChangeCustomizations);
         this._staticReadOnlySets = this._createStaticReadOnlySets();
         this.element = $(".tools-list-widget");
         this._createHeader();
         this._createSearchRow();
-        const treeScrollContainer = $(".tools-list-scroll-container");
-        this._treeContainer = append(treeScrollContainer, $(".tools-list-tree.distributed-section-layout"));
-        const treeScrollable = this._register(( new DomScrollableElement(treeScrollContainer, {
-            horizontal: ScrollbarVisibility.Hidden,
-            vertical: ScrollbarVisibility.Auto,
-            useShadows: false
-        })));
-        this._treeScrollable = treeScrollable;
-        this._register(
-            addDisposableListener(treeScrollContainer, EventType.SCROLL, () => {
-                treeScrollable.setScrollPosition({
-                    scrollTop: treeScrollContainer.scrollTop
-                });
-            })
-        );
-        const treeScrollableNode = treeScrollable.getDomNode();
-        treeScrollableNode.classList.add("tools-list-tree-scrollable");
-        this.element.appendChild(treeScrollableNode);
-        this._createGallery();
-        this._register(toDisposable(() => this._galleryCts?.dispose(true)));
+        this._treeContainer = append(this.element, $(".tools-list-tree.customization-tree-container"));
+        this._createTree();
+        this._emptyState = append(this.element, $(".list-empty-state"));
+        this._emptyState.style.display = "none";
         const viewModel = this._createViewModel();
+        const connectedModel = derived(this, reader => {
+            this._agentHostCustomizationsChanged.read(reader);
+            const sessionResource = this._harnessService.activeSessionResource.read(reader);
+            return {
+                sessionResource,
+                servers: this._agentHostCustomizationService.getMcpServers(sessionResource),
+                plugins: this._agentHostCustomizationService.getCustomizations(sessionResource).filter(customization => customization.type === CustomizationType.Plugin)
+            };
+        });
         this._register(autorun(reader => {
-            this._render(viewModel.read(reader));
+            const {
+                sessionResource,
+                servers,
+                plugins
+            } = connectedModel.read(reader);
+            const expanded = this._expanded.read(reader);
+            this._connectedToolsChanged.read(reader);
+            const sessionChanged = !isEqual(this._connectedSessionResource, sessionResource);
+            if (sessionChanged) {
+                this._connectedTools.clear();
+                this._pendingAutoExpand.clear();
+                this._connectedSessionResource = sessionResource;
+            }
+            const nextExpanded = ( new Set(expanded));
+            for (const id of expanded) {
+                if (id.startsWith("connected-server:")) {
+                    const server = servers.find(server => id === `connected-server:${server.id}`);
+                    if (sessionChanged || !server || !this._isConnectedServerReady(server)) {
+                        nextExpanded.delete(id);
+                    }
+                } else if (sessionChanged && id.startsWith("connected-plugin:")) {
+                    nextExpanded.delete(id);
+                }
+            }
+            for (const id of this._pendingAutoExpand) {
+                const server = servers.find(server => server.id === id);
+                const state = server && getActiveSessionServerPresentation(server).status;
+                const previousServer = this._connectedServers.find(server => server.id === id);
+                const previousState = previousServer && getActiveSessionServerPresentation(previousServer).status;
+                if (!server || state === McpServerStatus.Error || (state === McpServerStatus.AuthRequired && previousState !== McpServerStatus.AuthRequired)) {
+                    this._pendingAutoExpand.delete(id);
+                } else if (this._isConnectedServerReady(server)) {
+                    this._pendingAutoExpand.delete(id);
+                    if (this.element.isConnected && this.element.offsetParent !== null) {
+                        nextExpanded.add(`connected-server:${id}`);
+                    }
+                }
+            }
+            this._connectedServers = servers;
+            this._connectedPlugins = plugins;
+            for (const id of ( this._connectedTools.keys())) {
+                const server = this._connectedServers.find(server => server.id === id);
+                if (!server?.listTools || !this._isConnectedServerReady(server)) {
+                    this._connectedTools.delete(id);
+                }
+            }
+            if (nextExpanded.size !== expanded.size || ( [...nextExpanded].some(id => !( expanded.has(id))))) {
+                this._expanded.set(nextExpanded, undefined);
+            }
+            for (const server of servers) {
+                if (( nextExpanded.has(`connected-server:${server.id}`)) && this._isConnectedServerReady(server) && server.listTools && !( this._connectedTools.has(server.id))) {
+                    void this._loadConnectedTools(server);
+                }
+            }
         }));
         this._register(autorun(reader => {
+            this._currentModel = viewModel.read(reader);
+            connectedModel.read(reader);
+            this._agentPluginService.plugins.read(reader);
             this._expanded.read(reader);
-            this._refreshAllSectionEntries();
+            this._connectedToolsChanged.read(reader);
+            this._renderTreeGroups();
         }));
         this._register(autorun(reader => {
             const count = countEnabledCustomizationTools(this._toolsService.toolSets.read(reader), this._readState(reader), reader);
@@ -397,17 +602,20 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
             }
         }));
     }
+    setCloseCustomizationEditor(closeCustomizationEditor) {
+        this._closeCustomizationEditor = closeCustomizationEditor;
+    }
     _createHeader() {
         this._header = append(this.element, $(".section-title-header"));
-        append(append(this._header, $(".section-title-row")), $("h2.section-title")).textContent = ( localize(9273, "Tools"));
+        append(append(this._header, $(".section-title-row")), $("h2.section-title")).textContent = ( localize(11237, "Tools"));
         const description = append(this._header, $("p.section-title-description"));
         append(description, $("span.section-title-description-text")).textContent = ( localize(
-            9274,
+            11238,
             "Enable or disable the tools available to chat. Disabled tools are not advertised to the agent. Tools other than Copilot's built-in tools run on the client and require it to be connected."
         ));
         description.appendChild(createTextNode(" "));
         const learnMore = append(description, $("a.section-title-link"));
-        learnMore.textContent = ( localize(9275, "Learn more about tools"));
+        learnMore.textContent = ( localize(11239, "Learn more about tools"));
         learnMore.href = "https://code.visualstudio.com/docs/agent-customization/tools?referrer=in-product";
         this._register(addDisposableListener(learnMore, "click", e => {
             e.preventDefault();
@@ -418,65 +626,108 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         this._searchRow = append(this.element, $(".tools-list-search-and-button-container"));
         const searchContainer = append(this._searchRow, $(".tools-list-search-container"));
         this._searchInput = this._register(( new InputBox(searchContainer, this._contextViewService, {
-            placeholder: ( localize(9276, "Type to search...")),
+            placeholder: ( localize(11240, "Type to search...")),
             inputBoxStyles: defaultInputBoxStyles,
-            ariaLabel: ( localize(9277, "Search tools"))
+            ariaLabel: ( localize(11241, "Search tools"))
         })));
         this._register(this._searchInput.onDidChange(() => {
             this._delayedSearch.trigger(() => {
-                if (this._browseMode) {
-                    void this._queryGallery();
-                } else {
-                    this._searchQuery.set(this._searchInput.value, undefined);
-                }
+                this._searchQuery.set(this._searchInput.value, undefined);
             }).catch(() => {});
         }));
-        const backLabel = ( localize(9278, "Back"));
-        this._backButtonContainer = append(this._searchRow, $(".tools-list-browse-button-container"));
-        this._backButtonContainer.style.display = "none";
-        const backButton = this._register(( new Button(this._backButtonContainer, {
-            ...defaultButtonStyles,
-            secondary: true,
-            supportIcons: true,
-            title: backLabel,
-            ariaLabel: backLabel
-        })));
-        backButton.label = `$(${Codicon.arrowLeft.id}) ${backLabel}`;
-        this._register(backButton.onDidClick(() => this._setBrowseMode(false)));
     }
-    _createGallery() {
-        this._galleryContainer = append(this.element, $(".tools-gallery-container"));
-        this._galleryContainer.style.display = "none";
-        const header = append(this._galleryContainer, $(".tools-marketplace-header"));
-        append(header, $("h3.tools-marketplace-title")).textContent = ( localize(9279, "Marketplace Tools"));
-        append(header, $("p.tools-marketplace-description")).textContent = ( localize(9280, "Install extensions that contribute additional tools."));
-        this._galleryEmpty = append(this._galleryContainer, $(".list-empty-state"));
-        this._galleryEmpty.style.display = "none";
-        this._galleryListContainer = append(this._galleryContainer, $(".tools-gallery-list"));
-        this._galleryList = this._register(this._instantiationService.createInstance(
-            WorkbenchList,
-            "ToolsMarketplaceList",
-            this._galleryListContainer,
-            ( new ToolsGalleryItemDelegate()),
-            [( new GalleryItemRenderer(TOOLS_GALLERY_ITEM_TEMPLATE_ID, ( new ToolsGalleryItemProvider(this._extensionsWorkbenchService))))],
+    _createTree() {
+        this._setRenderer = ( new ToolsSetRowRenderer(
+            this._instantiationService,
+            this._sessionType,
+            this._enablementService,
+            (vm, reader) => vm.forceExpanded || ( this._expanded.read(reader).has(vm.toolSet.id)),
+            setId => this._toggleCollapsed(setId),
+            ts => this._resolveExtensionForToolSet(ts),
+            (anchor, extension) => this._showExtensionContextMenu(anchor, extension)
+        ));
+        const groupRenderer = ( new CustomizationGroupHeaderRenderer(
+            "toolsGroupHeader",
+            this._hoverService,
+            (entry, container, disposables) => this._renderTreeGroupActions(entry, container, disposables)
+        ));
+        this._tree = this._register(this._instantiationService.createInstance(
+            WorkbenchObjectTree,
+            "ToolsManagementTree",
+            this._treeContainer,
+            ( new ToolsTreeDelegate()),
+            [
+                asTreeRenderer(groupRenderer),
+                asTreeRenderer(this._setRenderer),
+                asTreeRenderer(( new ToolsToolRowRenderer(this._instantiationService, this._sessionType, this._enablementService))),
+                asTreeRenderer(( new ToolsConnectedRowRenderer(
+                    this._instantiationService,
+                    this._hoverService,
+                    server => isPrimaryMcpServerEnabled(this._mcpService, undefined, server),
+                    (server, enabled) => this._setConnectedServerEnabled(server, enabled),
+                    (entry, reader) => ( this._expanded.read(reader).has(entry.id)) || (!entry.server && !!this._searchQuery.read(reader).trim()),
+                    id => this._toggleCollapsed(id),
+                    (server, container, disposables) => this._renderConnectedServerActions(server, container, disposables)
+                ))),
+                asTreeRenderer(( new ToolsEmptyRowRenderer()))
+            ],
             {
+                indent: 8,
+                renderIndentGuides: RenderIndentGuides.None,
+                hideTwistiesOfChildlessElements: false,
+                overrideStyles: customizationTreeStyles,
                 multipleSelectionSupport: false,
                 horizontalScrolling: false,
+                openOnSingleClick: true,
+                identityProvider: {
+                    getId: entry => this._treeEntryId(entry)
+                },
                 accessibilityProvider: {
-                    getAriaLabel: extension => extension.displayName,
-                    getWidgetAriaLabel: () => ( localize(9281, "Tool extensions"))
+                    getWidgetAriaLabel: () => ( localize(11242, "Tools")),
+                    getAriaLabel: entry => this._getTreeEntryLabel(entry)
                 },
-                identityProvider: {
-                    getId: extension => extension.identifier.id
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: entry => this._getTreeEntryLabel(entry)
                 }
             }
         ));
-        this._register(this._galleryList.onDidOpen(e => {
-            if (e.element) {
-                this._onDidSelectExtension.fire(e.element);
+        this._register(this._tree.onDidChangeSelection(() => this._tree.setSelection([])));
+        this._register(this._tree.onDidChangeFocus(event => {
+            const entry = event.elements[0];
+            this._setRenderer.setFocusedSetId(entry?.type === "set" ? entry.vm.toolSet.id : undefined);
+        }));
+        this._register(this._tree.onDidChangeCollapseState(event => {
+            const entry = event.node.element;
+            if (!entry || entry.type !== "group-header") {
+                return;
+            }
+            if (event.node.collapsed) {
+                this._collapsedGroups.add(entry.groupKey);
+            } else {
+                this._collapsedGroups.delete(entry.groupKey);
             }
         }));
-        this._register(this._galleryList.onContextMenu(e => this._onGalleryContextMenu(e)));
+        this._register(
+            addStandardDisposableListener(this._tree.getHTMLElement(), EventType.KEY_DOWN, event => {
+                const entry = this._tree.getFocus()[0];
+                if (entry?.type === "connected" && entry.expandable && (event.keyCode === KeyCode.LeftArrow || event.keyCode === KeyCode.RightArrow)) {
+                    if (( this._expanded.get().has(entry.id)) !== (event.keyCode === KeyCode.RightArrow)) {
+                        this._toggleCollapsed(entry.id);
+                    }
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+                if (event.keyCode !== KeyCode.Space && event.keyCode !== KeyCode.Enter) {
+                    return;
+                }
+                if (entry && entry.type !== "group-header" && entry.type !== "empty") {
+                    this._activateToolEntry(entry, event.keyCode === KeyCode.Enter);
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+            })
+        );
     }
     _readState(reader) {
         return this._enablementService.observe(this._sessionType).read(reader);
@@ -494,8 +745,8 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
             referenceName: "copilotCli",
             icon: Codicon.copilot,
             source: ToolDataSource.Internal,
-            description: ( localize(9282, "Copilot")),
-            detail: ( localize(9283, "Built-in tools the Copilot agent runs inside its own runtime.")),
+            description: ( localize(11243, "Copilot")),
+            detail: ( localize(11244, "Built-in tools the Copilot agent runs inside its own runtime.")),
             getTools: () => tools
         };
         return [copilotCliSet];
@@ -577,267 +828,354 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         }
         this.element.classList.toggle("narrow-layout", width < 500);
         this._searchInput.layout();
-        this._scheduleSectionListLayout();
-        const galleryOffset = this._galleryContainer.getBoundingClientRect().top - this.element.getBoundingClientRect().top;
-        this._galleryList.layout(Math.max(0, height - galleryOffset), width);
+        const treeHeight = getCustomizationTreeContentHeight(this.element, this._treeContainer, height);
+        this._treeContainer.style.height = `${treeHeight}px`;
+        this._tree.layout(treeHeight, width);
     }
-    _setBrowseMode(browse) {
-        if (browse && this._environmentService.isSessionsWindow) {
+    focusSearch() {
+        this._searchInput.focus();
+        this._searchInput.select();
+    }
+    setSearchQuery(query) {
+        this._searchInput.value = query;
+    }
+    fireItemCount() {
+        this._onDidChangeItemCount.fire(this._lastCount === -1 ? 0 : this._lastCount);
+    }
+    _renderTreeGroups() {
+        if (!this._tree) {
             return;
         }
-        if (this._browseMode === browse) {
+        const query = this._searchQuery.get().trim();
+        const groups = [this._createTreeGroup("builtin", ( localize(11245, "Built-in Tools")), ( localize(11246, "Tools provided by the active agent and VS Code.")), ( localize(11247, "No built-in tool sets are available.")), this._currentModel.filter(
+            vm => vm.toolSet.source.type === "internal" || vm.toolSet.source.type === "external"
+        )), this._createConnectedTreeGroup(query), this._createTreeGroup("extensions", ( localize(11248, "Extension Tools")), ( localize(11249, "Tool sets contributed by installed extensions.")), ( localize(11250, "No extension tools are installed.")), this._currentModel.filter(vm => vm.toolSet.source.type === "extension"))].filter(group => !query || group.count > 0);
+        if (groups.length === 0 && query) {
+            this._tree.setChildren(null);
+            this._treeContainer.style.display = "none";
+            this._showTreeEmptyState(( localize(11251, "No tools match '{0}'", query)), ( localize(11252, "Try a different search term")));
             return;
         }
-        this._browseMode = browse;
-        this._treeScrollable.getDomNode().style.display = browse ? "none" : "";
-        this._galleryContainer.style.display = browse ? "" : "none";
-        this._backButtonContainer.style.display = browse ? "" : "none";
-        this._searchInput.setPlaceHolder(browse ? ( localize(9284, "Search the Marketplace...")) : ( localize(9276, "Type to search...")));
-        this._searchInput.value = "";
-        if (browse) {
-            void this._queryGallery();
-        } else {
-            this._galleryCts?.dispose(true);
-            this._galleryCts = undefined;
-            this._galleryList.splice(0, this._galleryList.length, []);
-            this._searchQuery.set("", undefined);
-        }
-        this._searchInput.focus();
+        this._emptyState.style.display = "none";
+        this._treeContainer.style.display = "";
+        const children = groups.map(group => ({
+            element: group.element,
+            collapsible: true,
+            collapsed: ( this._collapsedGroups.has(group.id)) ? ObjectTreeElementCollapseState.PreserveOrCollapsed : ObjectTreeElementCollapseState.PreserveOrExpanded,
+            children: group.children.map(element => ({
+                element
+            }))
+        }));
+        this._tree.setChildren(null);
+        this._tree.setChildren(null, children);
         if (this._lastHeight > 0) {
             this.layout(this._lastHeight, this._lastWidth);
         }
     }
-    async _queryGallery() {
-        this._galleryCts?.dispose(true);
-        const cts = this._galleryCts = ( new CancellationTokenSource());
-        const userText = this._searchInput.value.trim();
-        const text = userText ? `${TOOLS_MARKETPLACE_QUERY} ${userText}` : TOOLS_MARKETPLACE_QUERY;
-        this._setGalleryMessage(( localize(9285, "Loading marketplace...")));
-        try {
-            const pager = await this._extensionsWorkbenchService.queryGallery({
-                text
-            }, cts.token);
-            if (cts.token.isCancellationRequested) {
-                return;
+    _createTreeGroup(id, label, description, emptyMessage, setVms) {
+        return this._createTreeGroupFromEntries(
+            id,
+            label,
+            description,
+            emptyMessage,
+            this._computeSectionEntries(setVms),
+            setVms.length
+        );
+    }
+    _createTreeGroupFromEntries(id, label, description, emptyMessage, rows, count) {
+        const entries = rows.length > 0 ? rows : [{
+            type: "empty",
+            id: `empty:${id}`,
+            label: emptyMessage
+        }];
+        const element = {
+            type: "group-header",
+            id: `tools-group-${id}`,
+            groupKey: id,
+            label,
+            icon: Codicon.tools,
+            count,
+            isFirst: false,
+            description,
+            collapsed: ( this._collapsedGroups.has(id))
+        };
+        return {
+            id,
+            label,
+            description,
+            count,
+            element,
+            children: entries
+        };
+    }
+    _createConnectedTreeGroup(query) {
+        const entries = [];
+        for (const plugin of this._connectedPlugins) {
+            const servers = this._connectedServers.filter(server => server.pluginId === plugin.id);
+            if (servers.length === 0) {
+                continue;
             }
-            const items = pager.firstPage;
-            const filteredItems = await this._filterGalleryResults(items, cts.token);
-            if (cts.token.isCancellationRequested) {
-                return;
+            if (servers.length === 1) {
+                entries.push(...this._computeConnectedServerEntries(
+                    servers[0],
+                    0,
+                    query,
+                    !query || !!matchesContiguousSubString(query, plugin.name)
+                ));
+                continue;
             }
-            if (filteredItems.length === 0) {
-                this._setGalleryMessage(( localize(
-                    9286,
-                    "No tool extensions match '{0}'",
-                    userText || TOOLS_MARKETPLACE_QUERY
-                )), ( localize(9287, "Try a different search term")));
-                return;
+            const id = `connected-plugin:${plugin.id}`;
+            const nameMatches = matchesContiguousSubString(query, plugin.name) ?? undefined;
+            const expanded = ( this._expanded.get().has(id)) || !!query;
+            const serverEntries = expanded ? servers.flatMap(
+                server => this._computeConnectedServerEntries(server, 1, query, !query || !!nameMatches)
+            ) : [];
+            if (query && !nameMatches && serverEntries.length === 0) {
+                continue;
             }
-            this._galleryEmpty.style.display = "none";
-            this._galleryListContainer.style.display = "";
-            this._galleryList.splice(0, this._galleryList.length, filteredItems);
-        } catch {
-            if (!cts.token.isCancellationRequested) {
-                this._setGalleryMessage(( localize(9288, "Unable to load marketplace")), ( localize(9289, "Check your connection and try again")));
+            entries.push({
+                type: "connected",
+                id,
+                depth: 0,
+                label: plugin.name,
+                expandable: true,
+                nameMatches
+            }, ...serverEntries);
+        }
+        for (const server of this._connectedServers) {
+            if (server.pluginId === undefined || !( this._connectedPlugins.some(plugin => plugin.id === server.pluginId))) {
+                entries.push(...this._computeConnectedServerEntries(server, 0, query, !query));
             }
         }
-    }
-    async _filterGalleryResults(extensions, token) {
-        const requireAgentsWindowSupport = this._environmentService.isSessionsWindow;
-        const results = await Promise.all(extensions.map(async extension => {
-            if (requireAgentsWindowSupport && extension.gallery?.properties.executesCode) {
-                return undefined;
+        return this._createTreeGroupFromEntries("connected", ( localize(11253, "Connected Sources")), ( localize(11254, "Plugins and MCP servers available to the agent.")), ( localize(11255, "No plugins or MCP servers are available.")), entries, entries.filter(entry => entry.depth === 0).length);
+    }
+    _computeConnectedServerEntries(server, depth, query, includeAll) {
+        const id = `connected-server:${server.id}`;
+        const expandable = this._isConnectedServerReady(server);
+        const expanded = expandable && ( this._expanded.get().has(id));
+        const nameMatches = matchesContiguousSubString(query, server.name) ?? undefined;
+        const state = this._connectedTools.get(server.id);
+        const tools = expanded && state?.state === "loaded" ? state.tools : [];
+        const toolEntries = [];
+        for (const tool of tools) {
+            const label = tool.title ?? tool.name;
+            const toolMatches = matchesContiguousSubString(query, label) ?? undefined;
+            if (!query || includeAll || nameMatches || toolMatches || matchesContiguousSubString(query, tool.name)) {
+                toolEntries.push({
+                    type: "connected",
+                    id: `${id}:tool:${tool.name}`,
+                    depth: depth + 1,
+                    label,
+                    description: tool.description,
+                    expandable: false,
+                    nameMatches: toolMatches
+                });
             }
-            try {
-                const manifest = await extension.getManifest(token);
-                if (!manifest?.contributes?.languageModelTools?.length) {
-                    return undefined;
-                }
-                if (requireAgentsWindowSupport && !this._extensionManifestPropertiesService.canExecuteOnSessionsWindow(manifest)) {
-                    return undefined;
+        }
+        if (query && !includeAll && !nameMatches && toolEntries.length === 0) {
+            return [];
+        }
+        const source = getAgentHostMcpServerSource(
+            server,
+            this._connectedPlugins.find(plugin => plugin.id === server.pluginId),
+            this._labelService,
+            this._agentPluginService,
+            plugin => this._onDidRequestShowPlugin.fire(createInstalledPluginItem(plugin)),
+            file => void this._editorService.openEditor({
+                resource: file.uri,
+                options: {
+                    selection: file.range,
+                    pinned: true
                 }
-                return extension;
-            } catch {
-                return undefined;
+            })
+        );
+        const description = source ? ( localize(11235, "MCP server from {0}", source.label)) : undefined;
+        const entries = [{
+            type: "connected",
+            id,
+            depth,
+            label: server.name,
+            description,
+            source,
+            server,
+            expandable,
+            nameMatches
+        }];
+        if (expanded) {
+            if (toolEntries.length > 0) {
+                entries.push(...toolEntries);
+            } else if (state?.state !== "loaded" || tools.length === 0) {
+                const label = state?.state === "error" ? ( localize(11256, "Unable to list tools")) : state?.state === "loaded" || !server.listTools ? ( localize(11257, "No tools")) : ( localize(11258, "Loading tools..."));
+                entries.push({
+                    type: "connected",
+                    id: `${id}:message`,
+                    depth: depth + 1,
+                    label,
+                    expandable: false,
+                    message: true
+                });
             }
-        }));
-        return results.filter(extension => !!extension);
+        }
+        return entries;
     }
-    _setGalleryMessage(text, subtext) {
-        this._galleryList.splice(0, this._galleryList.length, []);
-        this._galleryListContainer.style.display = "none";
-        clearNode(this._galleryEmpty);
-        this._galleryEmpty.style.display = "flex";
-        const header = append(this._galleryEmpty, $(".empty-state-header"));
-        append(header, $(".empty-state-text")).textContent = text;
-        if (subtext) {
-            append(this._galleryEmpty, $(".empty-state-subtext")).textContent = subtext;
+    async _loadConnectedTools(server) {
+        if (!server.listTools) {
+            return;
+        }
+        const pending = {
+            state: "loading"
+        };
+        this._connectedTools.set(server.id, pending);
+        let result;
+        try {
+            result = {
+                state: "loaded",
+                tools: await server.listTools()
+            };
+        } catch {
+            result = {
+                state: "error"
+            };
+        }
+        if (!this._store.isDisposed && this._connectedTools.get(server.id) === pending) {
+            this._connectedTools.set(server.id, result);
+            this._connectedToolsChanged.trigger(undefined);
         }
     }
-    focusSearch() {
-        this._searchInput.focus();
-        this._searchInput.select();
+    _setConnectedServerEnabled(server, enabled) {
+        setPrimaryMcpServerEnablement(
+            this._mcpService,
+            this._agentHostCustomizationService,
+            this._harnessService.activeSessionResource.get(),
+            undefined,
+            server,
+            enabled
+        );
     }
-    fireItemCount() {
-        this._onDidChangeItemCount.fire(this._lastCount === -1 ? 0 : this._lastCount);
+    _isConnectedServerReady(server) {
+        return getActiveSessionServerPresentation(server).status === McpServerStatus.Ready && isPrimaryMcpServerEnabled(this._mcpService, undefined, server);
+    }
+    _renderConnectedServerActions(server, container, disposables) {
+        const state = getActiveSessionServerPresentation(server).status;
+        renderMcpServerStatusActions(container, disposables, this._hoverService, {
+            label: server.name,
+            state,
+            start: () => this._startConnectedServer(server),
+            signIn: () => this._signInConnectedServer(server),
+            statusHover: getMcpErrorMessage(
+                state,
+                server.state.kind === McpServerStatus.Error ? server.state.error?.message : undefined
+            ),
+            openStatus: state === McpServerStatus.Error ? () => this._showConnectedServerDetails(server) : undefined
+        });
     }
-    _render(model) {
-        const focusedSection = this._sectionLists.find(
-            s => isAncestor(getActiveElement(this._treeContainer.ownerDocument), s.container)
-        );
-        const focusedRowId = focusedSection ? this._currentFocusedRowId(focusedSection) : undefined;
-        for (const section of this._sectionLists) {
-            this._sectionScrollPositions.set(section.label, section.list.scrollTop);
+    async _startConnectedServer(server) {
+        this._pendingAutoExpand.add(server.id);
+        await server.start();
+    }
+    async _signInConnectedServer(server) {
+        const sessionResource = this._harnessService.activeSessionResource.get();
+        try {
+            const authenticated = await authenticateMcpServer(this._agentHostCustomizationService, sessionResource, server.id);
+            if (authenticated && !this._store.isDisposed && isEqual(sessionResource, this._connectedSessionResource)) {
+                this._pendingAutoExpand.add(server.id);
+                this._connectedToolsChanged.trigger(undefined);
+            }
+            return authenticated;
+        } catch (error) {
+            this._notificationService.error(( localize(
+                11259,
+                "Unable to sign in to {0}: {1}",
+                server.name,
+                getErrorMessage(error)
+            )));
+            return false;
         }
-        this._rowStore.clear();
-        this._sectionLists = [];
-        clearNode(this._treeContainer);
-        const query = this._searchQuery.get().trim();
-        if (model.length === 0 && query) {
-            const emptyState = append(this._treeContainer, $(".list-empty-state"));
-            const header = append(emptyState, $(".empty-state-header"));
-            const text = append(header, $(".empty-state-text"));
-            const subtext = append(emptyState, $(".empty-state-subtext"));
-            text.textContent = ( localize(9290, "No tools match '{0}'", query));
-            subtext.textContent = ( localize(9287, "Try a different search term"));
-            this._treeScrollable.scanDomNode();
-            return;
+    }
+    _showConnectedServerDetails(server) {
+        this._onDidSelectServer.fire(createAgentHostMcpServerDetailInput(
+            server,
+            this._agentHostCustomizationService,
+            this._harnessService,
+            this._agentHostCustomizationsChanged
+        ));
+    }
+    _renderTreeGroupActions(entry, container, disposables) {
+        if (entry.groupKey === "extensions") {
+            this._renderBrowseToolsAction(container, disposables);
         }
-        const builtIn = model.filter(
-            vm => vm.toolSet.source.type === "internal" || vm.toolSet.source.type === "external"
-        );
-        const connected = model.filter(
-            vm => vm.toolSet.source.type === "mcp" || vm.toolSet.source.type === "user"
-        );
-        const installed = model.filter(vm => vm.toolSet.source.type === "extension");
-        this._renderToolSection(( localize(9291, "Built-in Tools")), ( localize(9292, "Tools provided by the active agent and VS Code.")), ( localize(9293, "No built-in tool sets are available.")), builtIn, query);
-        this._renderToolSection(( localize(9294, "Connected Sources")), ( localize(9295, "Tool sets provided by MCP servers and user configuration.")), ( localize(9296, "No connected tool sources are available.")), connected, query, undefined, false);
-        this._renderToolSection(( localize(9297, "Extension Tools")), ( localize(9298, "Tool sets contributed by installed extensions.")), ( localize(9299, "No extension tools are installed.")), installed, query, !this._environmentService.isSessionsWindow ? sectionHeader => {
-            const actions = append(sectionHeader, $(".tools-inventory-section-actions"));
-            const browseLabel = ( localize(9300, "Browse Marketplace"));
-            const browseButton = this._rowStore.add(( new Button(actions, {
-                ...defaultButtonStyles,
-                secondary: true,
-                supportIcons: true,
-                title: browseLabel,
-                ariaLabel: browseLabel
-            })));
-            browseButton.label = `$(${Codicon.library.id}) ${browseLabel}`;
-            this._rowStore.add(browseButton.onDidClick(() => this._setBrowseMode(true)));
-        } : undefined);
-        this._scheduleSectionListLayout();
-        if (focusedRowId) {
-            this._restoreFocus(focusedRowId);
+    }
+    _renderBrowseToolsAction(container, disposables) {
+        if (this._environmentService.isSessionsWindow) {
+            return;
         }
+        const browseLabel = ( localize(11260, "Browse Extensions"));
+        const actions = append(container, $(".tools-inventory-section-actions"));
+        const browseButton = disposables.add(( new Button(actions, {
+            ...getButtonStyles({
+                buttonSecondaryBackground: undefined,
+                buttonSecondaryForeground: undefined,
+                buttonSecondaryHoverBackground: undefined,
+                buttonSecondaryBorder: undefined
+            }),
+            secondary: true,
+            title: browseLabel,
+            ariaLabel: browseLabel
+        })));
+        browseButton.element.classList.add("plugin-installed-action", "plugin-card-ghost-button");
+        browseButton.label = browseLabel;
+        disposables.add(browseButton.onDidClick(() => void this._browseMarketplace()));
     }
-    _renderToolSection(
-        title,
-        description,
-        emptyMessage,
-        model,
-        query,
-        renderActions,
-        showWhenEmpty = true
-    ) {
-        if (model.length === 0 && (query || !showWhenEmpty)) {
+    async _browseMarketplace() {
+        if (this._environmentService.isSessionsWindow || !(await this._closeCustomizationEditor())) {
             return;
         }
-        const section = append(this._treeContainer, $(".tools-inventory-section"));
-        const header = append(section, $(".tools-inventory-section-header"));
-        const text = append(header, $(".tools-inventory-section-text"));
-        const headingRow = append(text, $(".tools-inventory-section-heading-row"));
-        append(headingRow, $("h3.tools-inventory-section-title")).textContent = title;
-        append(headingRow, $("span.tools-inventory-section-count")).textContent = String(model.length);
-        append(text, $("p.tools-inventory-section-description")).textContent = description;
-        renderActions?.(header);
-        let inventory;
-        if (model.length === 0) {
-            inventory = append(section, $(".tools-inventory-list"));
-            append(inventory, $(".plugin-inventory-empty")).textContent = emptyMessage;
-        } else {
-            inventory = this._createToolsSectionList(section, title, model).container;
+        await this._extensionsWorkbenchService.openSearch(TOOLS_MARKETPLACE_QUERY);
+    }
+    _showTreeEmptyState(text, subtext) {
+        clearNode(this._emptyState);
+        this._emptyState.style.display = "flex";
+        const header = append(this._emptyState, $(".empty-state-header"));
+        append(header, $(".empty-state-text")).textContent = text;
+        append(this._emptyState, $(".empty-state-subtext")).textContent = subtext;
+    }
+    _treeEntryId(entry) {
+        if (entry.type === "group-header") {
+            return entry.id;
         }
-        const collapsedSections = this._collapsedSections ??= ( new Set());
-        setupCollapsibleSection(headingRow, inventory, title, this._rowStore, ( collapsedSections.has(title)), collapsed => {
-            if (collapsed) {
-                collapsedSections.add(title);
-            } else {
-                collapsedSections.delete(title);
-            }
-            this._scheduleSectionListLayout();
-        });
+        if (entry.type === "empty") {
+            return entry.id;
+        }
+        return this._entryRowId(entry);
     }
-    _createToolsSectionList(sectionEl, label, setVms) {
-        const listContainer = append(sectionEl, $(".tools-inventory-list"));
-        const setRenderer = ( new ToolsSetRowRenderer(
-            this._sessionType,
-            this._enablementService,
-            (vm, reader) => vm.forceExpanded || ( this._expanded.read(reader).has(vm.toolSet.id)),
-            setId => this._toggleCollapsed(setId),
-            ts => this._resolveExtensionForToolSet(ts),
-            (anchor, extension) => this._showExtensionContextMenu(anchor, extension)
-        ));
-        const list = this._rowStore.add(
-            this._instantiationService.createInstance(WorkbenchList, "ToolsSectionList", listContainer, ( new ToolsRowDelegate()), [setRenderer, ( new ToolsToolRowRenderer(this._sessionType, this._enablementService))], {
-                multipleSelectionSupport: false,
-                horizontalScrolling: false,
-                accessibilityProvider: {
-                    getWidgetAriaLabel: () => label,
-                    getWidgetRole: () => "tree",
-                    getRole: () => "treeitem",
-                    getAriaLevel: entry => entry.kind === "set" ? 1 : 2,
-                    getAriaLabel: () => null
-                },
-                identityProvider: {
-                    getId: entry => this._entryRowId(entry)
-                }
-            })
-        );
-        const section = {
-            list,
-            entries: this._computeSectionEntries(setVms),
-            setVms,
-            container: listContainer,
-            label
-        };
-        if (section.entries.length > 0) {
-            listContainer.style.height = `${computeToolsRowHeight(section.entries[0])}px`;
+    _getTreeEntryLabel(entry) {
+        if (entry.type === "group-header") {
+            return entry.label;
         }
-        list.splice(0, list.length, section.entries);
-        list.scrollTop = this._sectionScrollPositions.get(label) ?? 0;
-        this._rowStore.add(list.onDidChangeSelection(event => {
-            if (event.indexes.length > 0) {
-                list.setSelection([]);
+        if (entry.type === "empty" || entry.type === "connected") {
+            if (entry.type === "connected" && entry.server) {
+                return localize(
+                    11261,
+                    "{0}, {1}",
+                    entry.label,
+                    getMcpStatusPresentation(getActiveSessionServerPresentation(entry.server).status)?.label ?? ""
+                );
             }
-        }));
-        this._rowStore.add(
-            list.onDidChangeFocus(event => setRenderer.setFocusedIndex(event.indexes[0] ?? -1))
-        );
-        let focusBeforeKeyDown;
-        this._rowStore.add(
-            addStandardDisposableListener(listContainer, EventType.KEY_DOWN, () => {
-                focusBeforeKeyDown = list.getFocus()[0];
-            }, true)
-        );
-        this._rowStore.add(
-            addStandardDisposableListener(list.getHTMLElement(), EventType.KEY_DOWN, e => {
-                this._onSectionKeyDown(section, e, () => focusBeforeKeyDown);
-            })
-        );
-        this._sectionLists.push(section);
-        return section;
+            return entry.label;
+        }
+        return entry.type === "set" ? entry.vm.toolSet.description ?? entry.vm.toolSet.referenceName : entry.toolVm.tool.displayName ?? entry.toolVm.tool.id;
     }
     _computeSectionEntries(setVms) {
         const entries = [];
         for (const vm of setVms) {
             entries.push({
-                kind: "set",
+                type: "set",
                 vm
             });
             if (this._isRowExpanded(vm)) {
                 for (const toolVm of vm.visibleTools) {
                     entries.push({
-                        kind: "tool",
+                        type: "tool",
                         setVm: vm,
                         toolVm
                     });
@@ -850,135 +1188,43 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         return vm.forceExpanded || ( this._expanded.get().has(vm.toolSet.id));
     }
     _entryRowId(entry) {
-        return entry.kind === "set" ? `set:${entry.vm.toolSet.id}` : `tool:${entry.setVm.toolSet.id}:${entry.toolVm.tool.id}`;
-    }
-    _currentFocusedRowId(section) {
-        const index = section.list.getFocus()[0];
-        const entry = index !== undefined ? section.entries[index] : undefined;
-        return entry ? this._entryRowId(entry) : undefined;
-    }
-    _refreshAllSectionEntries() {
-        for (const section of this._sectionLists) {
-            this._refreshSectionEntries(section);
-        }
-    }
-    _refreshSectionEntries(section) {
-        const focusedRowId = this._currentFocusedRowId(section);
-        const nextEntries = this._computeSectionEntries(section.setVms);
-        section.entries = nextEntries;
-        section.list.splice(0, section.list.length, nextEntries);
-        if (focusedRowId) {
-            const index = nextEntries.findIndex(e => this._entryRowId(e) === focusedRowId);
-            if (index !== -1) {
-                section.list.setFocus([index]);
-                section.list.domFocus();
-            }
-        }
-        this._scheduleSectionListLayout();
-    }
-    _restoreFocus(rowId) {
-        for (const section of this._sectionLists) {
-            if (section.container.hidden) {
-                continue;
-            }
-            const index = section.entries.findIndex(e => this._entryRowId(e) === rowId);
-            if (index !== -1) {
-                section.list.setFocus([index]);
-                section.list.reveal(index);
-                section.list.domFocus();
-                return;
-            }
+        if (entry.type === "connected") {
+            return entry.id;
         }
-        this._focusFirstOverall();
-    }
-    _layoutSectionLists() {
-        const heights = layoutVirtualizedSections(this._treeContainer, this._sectionLists.map(section => ({
-            container: section.container,
-            contentHeight: section.entries.reduce((sum, entry) => sum + computeToolsRowHeight(entry), 0),
-            minimumHeight: getVirtualizedSectionMinimumHeight(section.entries, computeToolsRowHeight)
-        })));
-        for (let index = 0; index < this._sectionLists.length; index++) {
-            this._layoutSection(this._sectionLists[index], heights[index]);
-        }
-    }
-    _scheduleSectionListLayout() {
-        this._pendingSectionLayout.value = scheduleAtNextAnimationFrame(getWindow(this.element), () => {
-            this._layoutSectionLists();
-            this._treeScrollable.scanDomNode();
-        });
-    }
-    _layoutSection(section, allocatedHeight) {
-        const contentHeight = section.entries.reduce((sum, e) => sum + computeToolsRowHeight(e), 0);
-        const height = allocatedHeight ?? Math.min(contentHeight, TOOLS_SECTION_MAX_HEIGHT);
-        layoutVirtualizedSectionList(
-            section.list,
-            section.container,
-            height,
-            section.container.clientWidth || this._lastWidth || undefined
-        );
-    }
-    _onSectionKeyDown(section, e, getFocusBeforeKeyDown) {
-        const entries = section.entries;
-        if (entries.length === 0) {
-            return;
-        }
-        const focusIndex = section.list.getFocus()[0];
-        const entry = entries[focusIndex ?? 0];
-        let handled = true;
-        switch (e.keyCode) {
-        case KeyCode.DownArrow:
-            {
-                const before = getFocusBeforeKeyDown();
-                handled = before !== undefined && before === entries.length - 1;
-                if (handled) {
-                    this._focusAdjacentSection(section, 1);
-                }
-                break;
-            }
-        case KeyCode.UpArrow:
-            {
-                const before = getFocusBeforeKeyDown();
-                handled = before !== undefined && before === 0;
-                if (handled) {
-                    this._focusAdjacentSection(section, -1);
+        return entry.type === "set" ? `set:${entry.vm.toolSet.id}` : `tool:${entry.setVm.toolSet.id}:${entry.toolVm.tool.id}`;
+    }
+    _activateToolEntry(entry, viaEnter) {
+        if (entry.type === "connected") {
+            if (entry.server) {
+                const server = entry.server;
+                const enabled = isPrimaryMcpServerEnabled(this._mcpService, undefined, server);
+                if (!viaEnter) {
+                    this._setConnectedServerEnabled(server, !enabled);
+                } else if (entry.expandable) {
+                    this._toggleCollapsed(entry.id);
+                } else if (server.enabled && enabled) {
+                    const state = getActiveSessionServerPresentation(server).status;
+                    if (state === McpServerStatus.Stopped) {
+                        void this._startConnectedServer(server);
+                    } else if (state === McpServerStatus.AuthRequired) {
+                        void this._signInConnectedServer(server);
+                    } else if (state === McpServerStatus.Error) {
+                        this._showConnectedServerDetails(server);
+                    }
                 }
-                break;
+            } else if (viaEnter && entry.expandable) {
+                this._toggleCollapsed(entry.id);
             }
-        case KeyCode.RightArrow:
-            handled = this._onExpandKey(section, entry);
-            break;
-        case KeyCode.LeftArrow:
-            handled = this._onCollapseKey(section, entry);
-            break;
-        case KeyCode.Home:
-            this._focusFirstOverall();
-            break;
-        case KeyCode.End:
-            this._focusLastOverall();
-            break;
-        case KeyCode.Space:
-            this._onActivateKey(entry, false);
-            break;
-        case KeyCode.Enter:
-            this._onActivateKey(entry, true);
-            break;
-        default:
-            handled = false;
-        }
-        if (handled) {
-            e.preventDefault();
-            e.stopPropagation();
+            return;
         }
-    }
-    _onActivateKey(entry, viaEnter) {
-        const readOnly = entry.kind === "set" ? entry.vm.readOnly : entry.setVm.readOnly;
+        const readOnly = entry.type === "set" ? entry.vm.readOnly : entry.setVm.readOnly;
         if (readOnly) {
-            if (viaEnter && entry.kind === "set") {
+            if (viaEnter && entry.type === "set") {
                 this._toggleCollapsed(entry.vm.toolSet.id);
             }
             return;
         }
-        if (entry.kind === "set") {
+        if (entry.type === "set") {
             const vm = entry.vm;
             const current = getToolSetTriState(this._currentState(), vm.toolSet.id, vm.allToolIds);
             this._enablementService.setToolSetEnabled(this._sessionType, vm.toolSet.id, vm.allToolIds, current !== true);
@@ -991,76 +1237,6 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
             this._enablementService.setToolEnabled(this._sessionType, setVm.toolSet.id, toolVm.tool.id, !current);
         }
     }
-    _onExpandKey(section, entry) {
-        if (entry.kind !== "set") {
-            return false;
-        }
-        const vm = entry.vm;
-        if (!this._isRowExpanded(vm)) {
-            this._setExpanded(vm.toolSet.id, true);
-        } else if (vm.visibleTools.length) {
-            this._focusEntryInSection(section, `tool:${vm.toolSet.id}:${vm.visibleTools[0].tool.id}`);
-        }
-        return true;
-    }
-    _onCollapseKey(section, entry) {
-        if (entry.kind === "set") {
-            if (this._isRowExpanded(entry.vm)) {
-                this._setExpanded(entry.vm.toolSet.id, false);
-                return true;
-            }
-            return false;
-        }
-        this._focusEntryInSection(section, `set:${entry.setVm.toolSet.id}`);
-        return true;
-    }
-    _focusEntryInSection(section, rowId) {
-        const index = section.entries.findIndex(e => this._entryRowId(e) === rowId);
-        if (index === -1) {
-            return;
-        }
-        section.list.setFocus([index]);
-        section.list.reveal(index);
-        section.list.domFocus();
-    }
-    _focusAdjacentSection(from, delta) {
-        let targetIndex = this._sectionLists.indexOf(from) + delta;
-        while (this._sectionLists[targetIndex]?.container.hidden) {
-            targetIndex += delta;
-        }
-        const target = this._sectionLists[targetIndex];
-        if (!target) {
-            return;
-        }
-        if (target.entries.length === 0) {
-            this._focusAdjacentSection(target, delta);
-            return;
-        }
-        const index = delta === 1 ? 0 : target.entries.length - 1;
-        target.list.setFocus([index]);
-        target.list.reveal(index);
-        target.list.domFocus();
-    }
-    _focusFirstOverall() {
-        const section = this._sectionLists.find(s => !s.container.hidden && s.entries.length > 0);
-        if (section) {
-            section.list.setFocus([0]);
-            section.list.reveal(0);
-            section.list.domFocus();
-        }
-    }
-    _focusLastOverall() {
-        for (let i = this._sectionLists.length - 1; i >= 0; i--) {
-            const section = this._sectionLists[i];
-            if (!section.container.hidden && section.entries.length > 0) {
-                const index = section.entries.length - 1;
-                section.list.setFocus([index]);
-                section.list.reveal(index);
-                section.list.domFocus();
-                return;
-            }
-        }
-    }
     _resolveSetDetail(ts) {
         if (ts.detail) {
             return ts.detail;
@@ -1070,7 +1246,7 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         }
         const source = ts.source;
         const extension = this._extensionsWorkbenchService.local.find(e => ExtensionIdentifier.equals(e.identifier.id, source.extensionId));
-        return extension?.description || ( localize(9301, "Tools contributed by {0}", source.label));
+        return extension?.description || ( localize(11262, "Tools contributed by {0}", source.label));
     }
     _toggleCollapsed(toolSetId) {
         const next = ( new Set(this._expanded.get()));
@@ -1081,18 +1257,6 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         }
         this._expanded.set(next, undefined);
     }
-    _setExpanded(toolSetId, expanded) {
-        const next = ( new Set(this._expanded.get()));
-        if (expanded === ( next.has(toolSetId))) {
-            return;
-        }
-        if (expanded) {
-            next.add(toolSetId);
-        } else {
-            next.delete(toolSetId);
-        }
-        this._expanded.set(next, undefined);
-    }
     _currentState() {
         return this._enablementService.getState(this._sessionType);
     }
@@ -1107,16 +1271,9 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         }
         return extension;
     }
-    _onGalleryContextMenu(e) {
-        const extension = e.element;
-        if (!extension || extension.state !== ExtensionState.Installed || extension.local?.isBuiltin) {
-            return;
-        }
-        this._showExtensionContextMenu(e.anchor, extension);
-    }
     _showExtensionContextMenu(anchor, extension) {
         const disposables = ( new DisposableStore());
-        const uninstallAction = disposables.add(( new Action("toolsList.uninstallExtension", ( localize(9302, "Uninstall Extension")), undefined, true, () => this._uninstallExtension(extension))));
+        const uninstallAction = disposables.add(( new Action("toolsList.uninstallExtension", ( localize(11263, "Uninstall Extension")), undefined, true, () => this._uninstallExtension(extension))));
         this._contextMenuService.showContextMenu({
             getAnchor: () => anchor,
             getActions: () => [uninstallAction],
@@ -1126,15 +1283,15 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
     async _uninstallExtension(extension) {
         const result = await this._dialogService.confirm({
             message: ( localize(
-                9303,
+                11264,
                 "Do you want to uninstall the extension '{0}'?",
                 extension.displayName
             )),
             detail: ( localize(
-                9304,
+                11265,
                 "This extension may contribute more than tools. Uninstalling it removes all of its contributions."
             )),
-            primaryButton: ( localize(9305, "Uninstall Extension")),
+            primaryButton: ( localize(11266, "Uninstall Extension")),
             type: "question"
         });
         if (result.confirmed) {
@@ -1142,62 +1299,62 @@ let ToolsListWidget = class ToolsListWidget extends Disposable {
         }
     }
 };
-ToolsListWidget = ( __decorate([( __param(1, ILanguageModelToolsService)), ( __param(2, IAgentHostToolSetEnablementService)), ( __param(3, IContextViewService)), ( __param(4, IContextMenuService)), ( __param(5, IDialogService)), ( __param(6, IOpenerService)), ( __param(7, IInstantiationService)), ( __param(8, IExtensionsWorkbenchService)), ( __param(9, IExtensionManifestPropertiesService)), ( __param(10, IWorkbenchEnvironmentService))], ToolsListWidget));
+ToolsListWidget = ( __decorate([( __param(1, ILanguageModelToolsService)), ( __param(2, IAgentHostToolSetEnablementService)), ( __param(3, IContextViewService)), ( __param(4, IContextMenuService)), ( __param(5, IDialogService)), ( __param(6, IOpenerService)), ( __param(7, IInstantiationService)), ( __param(8, IExtensionsWorkbenchService)), ( __param(9, IWorkbenchEnvironmentService)), ( __param(10, IHoverService)), ( __param(11, IAgentHostCustomizationService)), ( __param(12, ICustomizationHarnessService)), ( __param(13, IMcpService)), ( __param(14, IAgentPluginService)), ( __param(15, ILabelService)), ( __param(16, INotificationService)), ( __param(17, IEditorService))], ToolsListWidget));
 const COPILOT_CLI_TOOLS = [
 {
     name: "bash / powershell",
-    description: ( localize(9306, "Execute commands"))
+    description: ( localize(11267, "Execute commands"))
 }, {
     name: "list_bash / list_powershell",
-    description: ( localize(9307, "List active shell sessions"))
+    description: ( localize(11268, "List active shell sessions"))
 }, {
     name: "read_bash / read_powershell",
-    description: ( localize(9308, "Read output from a shell session"))
+    description: ( localize(11269, "Read output from a shell session"))
 }, {
     name: "stop_bash / stop_powershell",
-    description: ( localize(9309, "Terminate a shell session"))
+    description: ( localize(11270, "Terminate a shell session"))
 }, {
     name: "write_bash / write_powershell",
-    description: ( localize(9310, "Send input to a shell session"))
+    description: ( localize(11271, "Send input to a shell session"))
 },
 {
     name: "apply_patch",
-    description: ( localize(9311, "Apply patches (used by some models instead of edit/create)"))
+    description: ( localize(11272, "Apply patches (used by some models instead of edit/create)"))
 }, {
     name: "create",
-    description: ( localize(9312, "Create new files"))
+    description: ( localize(11273, "Create new files"))
 }, {
     name: "edit",
-    description: ( localize(9313, "Edit files via string replacement"))
+    description: ( localize(11274, "Edit files via string replacement"))
 }, {
     name: "view",
-    description: ( localize(9314, "Read files or directories"))
+    description: ( localize(11275, "Read files or directories"))
 },
 {
     name: "list_agents",
-    description: ( localize(9315, "List available agents"))
+    description: ( localize(11276, "List available agents"))
 }, {
     name: "read_agent",
-    description: ( localize(9316, "Check background agent status"))
+    description: ( localize(11277, "Check background agent status"))
 }, {
     name: "task",
-    description: ( localize(9317, "Run subagents"))
+    description: ( localize(11278, "Run subagents"))
 },
 {
     name: "ask_user",
-    description: ( localize(9318, "Ask the user a question"))
+    description: ( localize(11279, "Ask the user a question"))
 }, {
     name: "glob",
-    description: ( localize(9319, "Find files matching patterns"))
+    description: ( localize(11280, "Find files matching patterns"))
 }, {
     name: "grep (or rg)",
-    description: ( localize(9320, "Search for text in files"))
+    description: ( localize(11281, "Search for text in files"))
 }, {
     name: "skill",
-    description: ( localize(9321, "Invoke custom skills"))
+    description: ( localize(11282, "Invoke custom skills"))
 }, {
     name: "web_fetch",
-    description: ( localize(9322, "Fetch and parse web content"))
+    description: ( localize(11283, "Fetch and parse web content"))
 }];
 const CUSTOM_TOOL_SET_ORDER = {
     "copilot-cli": 0,