@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.0

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

@@ -0,0 +1,898 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, addStandardDisposableListener, EventType, addDisposableListener, append, createTextNode, clearNode, isAncestor, EventHelper, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { HighlightedLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/highlightedlabel/highlightedLabel';
+import { InputBox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/inputbox/inputBox';
+import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { TriStateCheckbox, Checkbox } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/toggle/toggle';
+import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { matchesContiguousSubString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { IContextViewService, IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkbenchList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { defaultInputBoxStyles, defaultButtonStyles, defaultCheckboxStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IExtensionManifestPropertiesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionManifestPropertiesService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { ExtensionState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { GalleryItemInstallState, GalleryItemRenderer } from './galleryItemRenderer.js';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { countEnabledCustomizationTools, getToolSetTriState, isToolEnabledInSet } from '../agentSessions/agentHost/agentHostToolSetEnablementService.js';
+import { IAgentHostToolSetEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service';
+import * as aiCustomizationManagement from './media/aiCustomizationManagement.css';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+registerCss(aiCustomizationManagement);
+const $ = $$1;
+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;
+    }
+    getDescription(extension) {
+        return extension.description;
+    }
+    getInstallState(extension) {
+        switch (extension.state) {
+        case ExtensionState.Installed:
+            return GalleryItemInstallState.Installed;
+        case ExtensionState.Installing:
+            return GalleryItemInstallState.Installing;
+        default:
+            return GalleryItemInstallState.Uninstalled;
+        }
+    }
+    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();
+            }
+        });
+    }
+}
+let ToolsListWidget = class ToolsListWidget extends Disposable {
+    constructor(
+        _sessionType,
+        _toolsService,
+        _enablementService,
+        _contextViewService,
+        _contextMenuService,
+        _dialogService,
+        _openerService,
+        _instantiationService,
+        _extensionsWorkbenchService,
+        _extensionManifestPropertiesService,
+        _environmentService
+    ) {
+        super();
+        this._sessionType = _sessionType;
+        this._toolsService = _toolsService;
+        this._enablementService = _enablementService;
+        this._contextViewService = _contextViewService;
+        this._contextMenuService = _contextMenuService;
+        this._dialogService = _dialogService;
+        this._openerService = _openerService;
+        this._instantiationService = _instantiationService;
+        this._extensionsWorkbenchService = _extensionsWorkbenchService;
+        this._extensionManifestPropertiesService = _extensionManifestPropertiesService;
+        this._environmentService = _environmentService;
+        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._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._rows = [];
+        this._rowByElement = ( new Map());
+        this._staticReadOnlySets = this._createStaticReadOnlySets();
+        this.element = $(".tools-list-widget");
+        this._createHeader();
+        this._createSearchRow();
+        this._treeContainer = $(".tools-list-tree");
+        this._treeContainer.setAttribute("role", "tree");
+        this._treeContainer.setAttribute("aria-label", ( localize(6129, "Tool groups")));
+        this._register(
+            addStandardDisposableListener(this._treeContainer, EventType.KEY_DOWN, e => this._onTreeKeyDown(e))
+        );
+        this._register(
+            addDisposableListener(this._treeContainer, EventType.FOCUS_IN, e => {
+                const row = this._rowFromTarget(e.target);
+                if (row) {
+                    this._setRovingRow(row);
+                }
+            })
+        );
+        this._treeScrollable = this._register(( new DomScrollableElement(this._treeContainer, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: false
+        })));
+        const treeScrollableNode = this._treeScrollable.getDomNode();
+        treeScrollableNode.classList.add("tools-list-tree-scrollable");
+        this.element.appendChild(treeScrollableNode);
+        this._createGallery();
+        this._register(toDisposable(() => this._galleryCts?.dispose(true)));
+        const viewModel = this._createViewModel();
+        this._register(autorun(reader => {
+            this._render(viewModel.read(reader));
+        }));
+        this._register(autorun(reader => {
+            const count = countEnabledCustomizationTools(this._toolsService.toolSets.read(reader), this._readState(reader), reader);
+            if (count !== this._lastCount) {
+                this._lastCount = count;
+                this._onDidChangeItemCount.fire(count);
+            }
+        }));
+    }
+    _createHeader() {
+        this._header = append(this.element, $(".section-title-header"));
+        append(append(this._header, $(".section-title-row")), $("h2.section-title")).textContent = ( localize(6130, "Tools"));
+        const description = append(this._header, $("p.section-title-description"));
+        append(description, $("span.section-title-description-text")).textContent = ( localize(
+            6131,
+            "Enable or disable the tools available to chat. Disabled tools are not advertised to the agent. Tools other than Copilot CLI run on the client and require it to be connected."
+        ));
+        description.appendChild(createTextNode(" "));
+        const learnMore = append(description, $("a.section-title-link"));
+        learnMore.textContent = ( localize(6132, "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();
+            void this._openerService.open(( URI.parse(learnMore.href)));
+        }));
+    }
+    _createSearchRow() {
+        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(6133, "Type to search...")),
+            inputBoxStyles: defaultInputBoxStyles,
+            ariaLabel: ( localize(6134, "Search tools"))
+        })));
+        this._register(this._searchInput.onDidChange(() => {
+            this._delayedSearch.trigger(() => {
+                if (this._browseMode) {
+                    void this._queryGallery();
+                } else {
+                    this._searchQuery.set(this._searchInput.value, undefined);
+                }
+            }).catch(() => {});
+        }));
+        if (!this._environmentService.isSessionsWindow) {
+            const browseLabel = ( localize(6135, "Browse Marketplace"));
+            this._browseButtonContainer = append(this._searchRow, $(".tools-list-browse-button-container"));
+            const browseButton = this._register(( new Button(this._browseButtonContainer, {
+                ...defaultButtonStyles,
+                secondary: true,
+                supportIcons: true,
+                title: browseLabel,
+                ariaLabel: browseLabel
+            })));
+            browseButton.label = `$(${Codicon.library.id}) ${browseLabel}`;
+            this._register(browseButton.onDidClick(() => this._setBrowseMode(true)));
+        }
+        const backLabel = ( localize(6136, "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";
+        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))))],
+            {
+                multipleSelectionSupport: false,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getAriaLabel: extension => extension.displayName,
+                    getWidgetAriaLabel: () => ( localize(6137, "Tool extensions"))
+                },
+                identityProvider: {
+                    getId: extension => extension.identifier.id
+                }
+            }
+        ));
+        this._register(this._galleryList.onDidOpen(e => {
+            if (e.element) {
+                this._onDidSelectExtension.fire(e.element);
+            }
+        }));
+        this._register(this._galleryList.onContextMenu(e => this._onGalleryContextMenu(e)));
+    }
+    _readState(reader) {
+        return this._enablementService.observe(this._sessionType).read(reader);
+    }
+    _createStaticReadOnlySets() {
+        const tools = ( COPILOT_CLI_TOOLS.map(t => ({
+            id: `copilot-cli:${t.name}`,
+            displayName: t.name,
+            modelDescription: t.description,
+            source: ToolDataSource.Internal,
+            canBeReferencedInPrompt: false
+        })));
+        const copilotCliSet = {
+            id: "copilot-cli",
+            referenceName: "copilotCli",
+            icon: Codicon.copilot,
+            source: ToolDataSource.Internal,
+            description: ( localize(6138, "Copilot CLI")),
+            detail: ( localize(6139, "Built-in tools the Copilot CLI agent runs inside its own runtime.")),
+            getTools: () => tools
+        };
+        return [copilotCliSet];
+    }
+    _createViewModel() {
+        const extensionsChanged = observableSignalFromEvent(this, this._extensionsWorkbenchService.onChange);
+        return derived(reader => {
+            extensionsChanged.read(reader);
+            const query = this._searchQuery.read(reader).trim();
+            const result = [];
+            for (const ts of [...this._toolsService.toolSets.read(reader), ...this._staticReadOnlySets]) {
+                const vm = this._toViewModel(reader, ts, query);
+                if (vm) {
+                    result.push(vm);
+                }
+            }
+            result.sort((a, b) => sortKey(a.toolSet).localeCompare(sortKey(b.toolSet)));
+            return result;
+        });
+    }
+    _toViewModel(reader, ts, query) {
+        if (ts.deprecated) {
+            return undefined;
+        }
+        if (ts.source.type === "extension") {
+            const extensionId = ts.source.extensionId;
+            const installed = this._extensionsWorkbenchService.local.find(e => ExtensionIdentifier.equals(e.identifier.id, extensionId));
+            if (!installed || installed.state === ExtensionState.Uninstalling || installed.state === ExtensionState.Uninstalled) {
+                return undefined;
+            }
+        }
+        const memberTools = Array.from(ts.getTools(reader));
+        if (memberTools.length === 0) {
+            return undefined;
+        }
+        const allToolIds = ( memberTools.map(t => t.id));
+        let visibleTools = ( memberTools.map(tool => ({
+            tool
+        })));
+        let nameMatches;
+        if (query) {
+            nameMatches = matchesContiguousSubString(query, ts.description ?? ts.referenceName) ?? undefined;
+            if (nameMatches) {
+                visibleTools = ( memberTools.map(tool => ({
+                    tool,
+                    nameMatches: matchesContiguousSubString(query, tool.displayName ?? tool.id) ?? undefined
+                })));
+            } else {
+                visibleTools = [];
+                for (const tool of memberTools) {
+                    const toolMatches = matchesContiguousSubString(query, tool.displayName ?? tool.id);
+                    if (toolMatches) {
+                        visibleTools.push({
+                            tool,
+                            nameMatches: toolMatches
+                        });
+                    }
+                }
+                if (visibleTools.length === 0) {
+                    return undefined;
+                }
+            }
+        }
+        return {
+            toolSet: ts,
+            allToolIds,
+            visibleTools,
+            nameMatches,
+            forceExpanded: query !== "",
+            readOnly: ts.id === "copilot-cli"
+        };
+    }
+    layout(height, width) {
+        this._lastHeight = height;
+        this._lastWidth = width;
+        this._searchInput.layout();
+        this._treeScrollable.scanDomNode();
+        const galleryOffset = this._galleryContainer.getBoundingClientRect().top - this.element.getBoundingClientRect().top;
+        this._galleryList.layout(Math.max(0, height - galleryOffset), width);
+    }
+    _setBrowseMode(browse) {
+        if (browse && this._environmentService.isSessionsWindow) {
+            return;
+        }
+        if (this._browseMode === browse) {
+            return;
+        }
+        this._browseMode = browse;
+        this._treeScrollable.getDomNode().style.display = browse ? "none" : "";
+        this._galleryContainer.style.display = browse ? "" : "none";
+        if (this._browseButtonContainer) {
+            this._browseButtonContainer.style.display = browse ? "none" : "";
+        }
+        this._backButtonContainer.style.display = browse ? "" : "none";
+        this._searchInput.setPlaceHolder(browse ? ( localize(6140, "Search the Marketplace...")) : ( localize(6133, "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();
+        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(6141, "Loading marketplace...")));
+        try {
+            const pager = await this._extensionsWorkbenchService.queryGallery({
+                text
+            }, cts.token);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            const items = pager.firstPage;
+            const filteredItems = await this._filterGalleryResults(items, cts.token);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            if (filteredItems.length === 0) {
+                this._setGalleryMessage(( localize(
+                    6142,
+                    "No tool extensions match '{0}'",
+                    userText || TOOLS_MARKETPLACE_QUERY
+                )), ( localize(6143, "Try a different search term")));
+                return;
+            }
+            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(6144, "Unable to load marketplace")), ( localize(6145, "Check your connection and try again")));
+            }
+        }
+    }
+    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;
+            }
+            try {
+                const manifest = await extension.getManifest(token);
+                if (!manifest?.contributes?.languageModelTools?.length) {
+                    return undefined;
+                }
+                if (requireAgentsWindowSupport && !this._extensionManifestPropertiesService.canExecuteOnSessionsWindow(manifest)) {
+                    return undefined;
+                }
+                return extension;
+            } catch {
+                return undefined;
+            }
+        })));
+        return results.filter(extension => !!extension);
+    }
+    _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;
+        }
+    }
+    focusSearch() {
+        this._searchInput.focus();
+        this._searchInput.select();
+    }
+    fireItemCount() {
+        this._onDidChangeItemCount.fire(this._lastCount === -1 ? 0 : this._lastCount);
+    }
+    _render(model) {
+        const hadFocus = isAncestor(this._treeContainer.ownerDocument.activeElement, this._treeContainer);
+        this._rowStore.clear();
+        this._rows = [];
+        this._rowByElement.clear();
+        clearNode(this._treeContainer);
+        if (model.length === 0) {
+            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"));
+            const query = this._searchQuery.get().trim();
+            if (query) {
+                text.textContent = ( localize(6146, "No tools match '{0}'", query));
+                subtext.textContent = ( localize(6143, "Try a different search term"));
+            } else {
+                text.textContent = ( localize(6147, "No tools available."));
+            }
+            this._treeScrollable.scanDomNode();
+            return;
+        }
+        for (const vm of model) {
+            const setRow = this._renderToolSet(vm);
+            this._addRow(setRow);
+            for (const child of setRow.children) {
+                this._addRow(child);
+            }
+        }
+        this._initRovingTabIndex(hadFocus);
+        this._treeScrollable.scanDomNode();
+    }
+    _addRow(row) {
+        this._rows.push(row);
+        this._rowByElement.set(row.element, row);
+    }
+    _renderToolSet(vm) {
+        const ts = vm.toolSet;
+        const row = append(this._treeContainer, $(".tools-list-setrow"));
+        row.setAttribute("role", "treeitem");
+        row.setAttribute("aria-level", "1");
+        row.tabIndex = -1;
+        const setName = ts.description ?? ts.referenceName;
+        const toggleExpand = () => this._toggleCollapsed(ts.id);
+        const checkbox = this._rowStore.add(( new TriStateCheckbox(( localize(6148, "Enable {0}", setName)), getToolSetTriState(this._currentState(), ts.id, vm.allToolIds), defaultCheckboxStyles)));
+        checkbox.domNode.tabIndex = -1;
+        row.appendChild(checkbox.domNode);
+        if (vm.readOnly) {
+            checkbox.disable();
+            checkbox.setTitle(( localize(6149, "These are the agent's built-in tools and cannot be changed.")));
+        } else {
+            this._rowStore.add(checkbox.onChange(() => {
+                const enabled = checkbox.checked === true;
+                this._enablementService.setToolSetEnabled(this._sessionType, ts.id, vm.allToolIds, enabled);
+            }));
+        }
+        const main = append(row, $(".tools-list-row-main"));
+        const text = append(main, $(".tools-list-row-text"));
+        const label = append(text, $("span.tools-list-row-label"));
+        const labelHighlight = this._rowStore.add(( new HighlightedLabel(label)));
+        labelHighlight.set(setName, vm.nameMatches);
+        const detail = this._resolveSetDetail(ts);
+        if (detail) {
+            append(text, $("span.tools-list-row-subtext")).textContent = detail;
+        }
+        const count = append(row, $("span.tools-list-row-count"));
+        const chevron = append(row, $("a.tools-list-chevron.codicon"));
+        chevron.setAttribute("aria-hidden", "true");
+        this._rowStore.add(addDisposableListener(row, "click", e => {
+            if (checkbox.domNode.contains(e.target)) {
+                return;
+            }
+            row.focus();
+            toggleExpand();
+        }));
+        this._rowStore.add(addDisposableListener(row, "contextmenu", e => {
+            const extension = this._resolveExtensionForToolSet(ts);
+            if (!extension) {
+                return;
+            }
+            EventHelper.stop(e, true);
+            const anchor = e.button === 2 ? ( new StandardMouseEvent(getWindow(row), e)) : row;
+            this._showExtensionContextMenu(anchor, extension);
+        }));
+        const group = append(this._treeContainer, $(".tools-list-children"));
+        group.id = `tools-group-${ts.id}`;
+        group.setAttribute("role", "group");
+        group.setAttribute("aria-label", setName);
+        row.setAttribute("aria-owns", group.id);
+        const setRow = {
+            kind: "set",
+            rowId: `set:${ts.id}`,
+            toolSetId: ts.id,
+            element: row,
+            toggleNode: checkbox.domNode,
+            group,
+            children: []
+        };
+        for (const tool of vm.visibleTools) {
+            setRow.children.push(this._renderTool(group, setRow, vm, tool));
+        }
+        this._rowStore.add(autorun(reader => {
+            const state = this._readState(reader);
+            const triState = getToolSetTriState(state, ts.id, vm.allToolIds);
+            checkbox.checked = triState;
+            this._updateRowAriaChecked(row, triState);
+            const enabledCount = vm.allToolIds.reduce((n, id) => n + (isToolEnabledInSet(state, ts.id, id) ? 1 : 0), 0);
+            count.textContent = `${enabledCount}/${vm.allToolIds.length}`;
+            count.setAttribute("aria-label", ( localize(6150, "{0} of {1} tools enabled", enabledCount, vm.allToolIds.length)));
+        }));
+        this._rowStore.add(autorun(reader => {
+            const expanded = vm.forceExpanded || ( this._expanded.read(reader).has(ts.id));
+            group.style.display = expanded ? "" : "none";
+            chevron.classList.toggle("codicon-chevron-down", expanded);
+            chevron.classList.toggle("codicon-chevron-right", !expanded);
+            row.setAttribute("aria-expanded", String(expanded));
+            this._treeScrollable.scanDomNode();
+        }));
+        return setRow;
+    }
+    _renderTool(group, parent, vm, toolVm) {
+        const tool = toolVm.tool;
+        const enabled = isToolEnabledInSet(this._currentState(), vm.toolSet.id, tool.id);
+        const toolName = tool.displayName ?? tool.id;
+        const row = append(group, $(".tools-list-toolrow"));
+        row.classList.toggle("readonly", vm.readOnly);
+        row.setAttribute("role", "treeitem");
+        row.setAttribute("aria-level", "2");
+        row.tabIndex = -1;
+        const checkbox = this._rowStore.add(( new Checkbox(( localize(6151, "Enable {0}", toolName)), enabled, defaultCheckboxStyles)));
+        checkbox.domNode.tabIndex = -1;
+        row.appendChild(checkbox.domNode);
+        this._updateRowAriaChecked(row, enabled);
+        if (vm.readOnly) {
+            checkbox.disable();
+            checkbox.setTitle(( localize(6149, "These are the agent's built-in tools and cannot be changed.")));
+        } else {
+            this._rowStore.add(checkbox.onChange(() => {
+                this._enablementService.setToolEnabled(this._sessionType, vm.toolSet.id, tool.id, checkbox.checked);
+            }));
+            this._rowStore.add(addDisposableListener(row, "click", e => {
+                if (checkbox.domNode.contains(e.target)) {
+                    return;
+                }
+                row.focus();
+                this._enablementService.setToolEnabled(this._sessionType, vm.toolSet.id, tool.id, !checkbox.checked);
+            }));
+            this._rowStore.add(autorun(reader => {
+                const toolEnabled = isToolEnabledInSet(this._readState(reader), vm.toolSet.id, tool.id);
+                checkbox.checked = toolEnabled;
+                this._updateRowAriaChecked(row, toolEnabled);
+            }));
+        }
+        const text = append(row, $(".tools-list-row-text"));
+        const label = append(text, $("span.tools-list-row-label"));
+        const labelHighlight = this._rowStore.add(( new HighlightedLabel(label)));
+        labelHighlight.set(toolName, toolVm.nameMatches);
+        const description = tool.userDescription ?? tool.modelDescription;
+        if (description) {
+            const subtext = append(text, $("span.tools-list-row-subtext"));
+            subtext.textContent = description;
+        }
+        return {
+            kind: "tool",
+            rowId: `tool:${vm.toolSet.id}:${tool.id}`,
+            toolSetId: vm.toolSet.id,
+            element: row,
+            toggleNode: checkbox.domNode,
+            parent
+        };
+    }
+    _resolveSetDetail(ts) {
+        if (ts.detail) {
+            return ts.detail;
+        }
+        if (ts.source.type !== "extension") {
+            return undefined;
+        }
+        const source = ts.source;
+        const extension = this._extensionsWorkbenchService.local.find(e => ExtensionIdentifier.equals(e.identifier.id, source.extensionId));
+        return extension?.description || ( localize(6152, "Tools contributed by {0}", source.label));
+    }
+    _updateRowAriaChecked(element, state) {
+        element.setAttribute("aria-checked", state === "mixed" ? "mixed" : String(state));
+    }
+    _toggleCollapsed(toolSetId) {
+        const next = ( new Set(this._expanded.get()));
+        if (( next.has(toolSetId))) {
+            next.delete(toolSetId);
+        } else {
+            next.add(toolSetId);
+        }
+        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);
+    }
+    _isExpanded(setRow) {
+        return setRow.group.style.display !== "none";
+    }
+    _visibleRows() {
+        return this._rows.filter(r => r.kind === "set" || this._isExpanded(r.parent));
+    }
+    _setRovingRow(row) {
+        for (const r of this._rows) {
+            r.element.tabIndex = r === row ? 0 : -1;
+        }
+        this._activeRowId = row.rowId;
+    }
+    _focusRow(row) {
+        this._setRovingRow(row);
+        row.element.focus();
+    }
+    _rowFromTarget(target) {
+        for (let el = target; el && el !== this._treeContainer; el = el.parentElement) {
+            const row = this._rowByElement.get(el);
+            if (row) {
+                return row;
+            }
+        }
+        return undefined;
+    }
+    _initRovingTabIndex(refocus = false) {
+        let active = this._activeRowId ? this._rows.find(r => r.rowId === this._activeRowId) : undefined;
+        if (!active || (active.kind === "tool" && !this._isExpanded(active.parent))) {
+            active = this._visibleRows()[0];
+        }
+        for (const r of this._rows) {
+            r.element.tabIndex = r === active ? 0 : -1;
+        }
+        this._activeRowId = active?.rowId;
+        if (refocus && active) {
+            active.element.focus();
+        }
+    }
+    _onTreeKeyDown(e) {
+        const row = this._rowFromTarget(e.target);
+        if (!row) {
+            return;
+        }
+        let handled = true;
+        switch (e.keyCode) {
+        case KeyCode.DownArrow:
+            this._focusRelative(row, 1);
+            break;
+        case KeyCode.UpArrow:
+            this._focusRelative(row, -1);
+            break;
+        case KeyCode.RightArrow:
+            handled = this._onExpandKey(row);
+            break;
+        case KeyCode.LeftArrow:
+            handled = this._onCollapseKey(row);
+            break;
+        case KeyCode.Home:
+            this._focusEdge(true);
+            break;
+        case KeyCode.End:
+            this._focusEdge(false);
+            break;
+        case KeyCode.Space:
+        case KeyCode.Enter:
+            row.toggleNode.click();
+            break;
+        default:
+            handled = false;
+        }
+        if (handled) {
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    }
+    _focusRelative(row, delta) {
+        const rows = this._visibleRows();
+        const index = rows.indexOf(row);
+        const next = index === -1 ? undefined : rows[index + delta];
+        if (next) {
+            this._focusRow(next);
+        }
+    }
+    _focusEdge(first) {
+        const rows = this._visibleRows();
+        this._focusRow(first ? rows[0] : rows[rows.length - 1]);
+    }
+    _onExpandKey(row) {
+        if (row.kind !== "set") {
+            return false;
+        }
+        if (!this._isExpanded(row)) {
+            this._setExpanded(row.toolSetId, true);
+        } else if (row.children.length) {
+            this._focusRow(row.children[0]);
+        }
+        return true;
+    }
+    _onCollapseKey(row) {
+        if (row.kind === "set") {
+            if (this._isExpanded(row)) {
+                this._setExpanded(row.toolSetId, false);
+                return true;
+            }
+            return false;
+        }
+        this._focusRow(row.parent);
+        return true;
+    }
+    _currentState() {
+        return this._enablementService.getState(this._sessionType);
+    }
+    _resolveExtensionForToolSet(ts) {
+        if (ts.source.type !== "extension") {
+            return undefined;
+        }
+        const source = ts.source;
+        const extension = this._extensionsWorkbenchService.local.find(e => ExtensionIdentifier.equals(e.identifier.id, source.extensionId));
+        if (!extension || extension.local?.isBuiltin) {
+            return undefined;
+        }
+        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(6153, "Uninstall Extension")), undefined, true, () => this._uninstallExtension(extension))));
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => anchor,
+            getActions: () => [uninstallAction],
+            onHide: () => disposables.dispose()
+        });
+    }
+    async _uninstallExtension(extension) {
+        const result = await this._dialogService.confirm({
+            message: ( localize(
+                6154,
+                "Do you want to uninstall the extension '{0}'?",
+                extension.displayName
+            )),
+            detail: ( localize(
+                6155,
+                "This extension may contribute more than tools. Uninstalling it removes all of its contributions."
+            )),
+            primaryButton: ( localize(6156, "Uninstall Extension")),
+            type: "question"
+        });
+        if (result.confirmed) {
+            await this._extensionsWorkbenchService.uninstall(extension);
+        }
+    }
+};
+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));
+const COPILOT_CLI_TOOLS = [
+{
+    name: "bash / powershell",
+    description: ( localize(6157, "Execute commands"))
+}, {
+    name: "list_bash / list_powershell",
+    description: ( localize(6158, "List active shell sessions"))
+}, {
+    name: "read_bash / read_powershell",
+    description: ( localize(6159, "Read output from a shell session"))
+}, {
+    name: "stop_bash / stop_powershell",
+    description: ( localize(6160, "Terminate a shell session"))
+}, {
+    name: "write_bash / write_powershell",
+    description: ( localize(6161, "Send input to a shell session"))
+},
+{
+    name: "apply_patch",
+    description: ( localize(6162, "Apply patches (used by some models instead of edit/create)"))
+}, {
+    name: "create",
+    description: ( localize(6163, "Create new files"))
+}, {
+    name: "edit",
+    description: ( localize(6164, "Edit files via string replacement"))
+}, {
+    name: "view",
+    description: ( localize(6165, "Read files or directories"))
+},
+{
+    name: "list_agents",
+    description: ( localize(6166, "List available agents"))
+}, {
+    name: "read_agent",
+    description: ( localize(6167, "Check background agent status"))
+}, {
+    name: "task",
+    description: ( localize(6168, "Run subagents"))
+},
+{
+    name: "ask_user",
+    description: ( localize(6169, "Ask the user a question"))
+}, {
+    name: "glob",
+    description: ( localize(6170, "Find files matching patterns"))
+}, {
+    name: "grep (or rg)",
+    description: ( localize(6171, "Search for text in files"))
+}, {
+    name: "skill",
+    description: ( localize(6172, "Invoke custom skills"))
+}, {
+    name: "web_fetch",
+    description: ( localize(6173, "Fetch and parse web content"))
+}];
+const CUSTOM_TOOL_SET_ORDER = {
+    "copilot-cli": 0,
+    "vscode-general": 1,
+    "vscode-tasks": 2,
+    "vscode-browser": 3,
+    "vscode-notebooks": 4
+};
+function sortKey(toolSet) {
+    const sourcePriority = toolSet.source.type === "internal" ? "0" : "1";
+    const order = CUSTOM_TOOL_SET_ORDER[toolSet.id];
+    const orderKey = order !== undefined ? String(order) : `9-${toolSet.description ?? toolSet.referenceName}`;
+    return `${sourcePriority}-${orderKey}`;
+}
+
+export { ToolsListWidget };