@codingame/monaco-vscode-api 37.6.0 → 38.0.0

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

@@ -0,0 +1,2100 @@
+
+import { registerCss } from '../../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import * as aiCustomizationDiscovery from './media/aiCustomizationDiscovery.css';
+import { $ as $$1, addDisposableListener, EventType, append, clearNode, getWindow, Dimension } from '../../../../../base/browser/dom.js';
+import { renderFormattedText } from '../../../../../base/browser/formattedTextRenderer.js';
+import { status, alert } from '../../../../../base/browser/ui/aria/aria.js';
+import { Button } from '../../../../../base/browser/ui/button/button.js';
+import { createPixelSpinner } from '../../../../../base/browser/ui/pixelSpinner/pixelSpinner.js';
+import { ProgressBar } from '../../../../../base/browser/ui/progressbar/progressbar.js';
+import { DomScrollableElement } from '../../../../../base/browser/ui/scrollbar/scrollableElement.js';
+import { Action, Separator, SubmenuAction } from '../../../../../base/common/actions.js';
+import { equals } from '../../../../../base/common/arrays.js';
+import { RunOnceScheduler } from '../../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { structuralEquals } from '../../../../../base/common/equals.js';
+import { isCancellationError, getErrorMessage, onUnexpectedError } from '../../../../../base/common/errors.js';
+import { DisposableStore, Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { basename, isEqual } from '../../../../../base/common/resources.js';
+import { ScrollbarVisibility } from '../../../../../base/common/scrollable.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { localize } from '../../../../../nls.js';
+import { AccessibilitySignal } from '../../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IAccessibilitySignalService } from '../../../../../platform/accessibilitySignal/browser/accessibilitySignalService.service.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
+import { getCustomizationMarketplaceResourceKey, CustomizationMarketplaceMediaType } from '../../../../../platform/customizationMarketplace/common/customizationMarketplaceService.js';
+import { ICustomizationMarketplaceService } from '../../../../../platform/customizationMarketplace/common/customizationMarketplaceService.service.js';
+import { affectsCustomizationMarketplaceSources, getVisibleCustomizationMarketplaceSources } from '../../../../../platform/customizationMarketplace/common/customizationMarketplaceSources.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { IContextMenuService } from '../../../../../platform/contextview/browser/contextView.service.js';
+import { IHoverService } from '../../../../../platform/hover/browser/hover.service.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
+import { WorkbenchList } 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 { WorkbenchToolBar } from '../../../../../platform/actions/browser/toolbar.js';
+import { defaultButtonStyles, defaultProgressBarStyles } from '../../../../../platform/theme/browser/defaultStyles.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
+import { IChatEntitlementService } from '../../../../services/chat/common/chatEntitlementService.service.js';
+import { AccessibilityVerbositySettingId } from '../../../accessibility/browser/accessibilityConfiguration.js';
+import { SuggestEnabledInput } from '../../../codeEditor/browser/suggestEnabledInput/suggestEnabledInput.js';
+import { McpServerInstallState } from '../../../mcp/common/mcpTypes.js';
+import { IMcpWorkbenchService } from '../../../mcp/common/mcpTypes.service.js';
+import { ICustomizationMarketplaceInstallService } from '../../common/customizationMarketplaceInstallService.service.js';
+import { AICustomizationManagementSection } from '../../common/aiCustomizationWorkspaceService.js';
+import { IAICustomizationWorkspaceService } from '../../common/aiCustomizationWorkspaceService.service.js';
+import { isPluginCustomizationItem } from '../../common/customizationHarnessService.js';
+import { IAgentPluginService } from '../../common/plugins/agentPluginService.service.js';
+import { PromptsType } from '../../common/promptSyntax/promptTypes.js';
+import { AgentPluginItemKind } from '../agentPluginEditor/agentPluginItems.js';
+import { MANAGE_PLUGIN_MARKETPLACES_COMMAND_ID } from '../actions/chatPluginActions.js';
+import { ITEMS_MODEL_SECTIONS } from './aiCustomizationItemsModel.js';
+import { IAICustomizationItemsModel } from './aiCustomizationItemsModel.service.js';
+import { DELETE_AI_CUSTOMIZATION_ID } from './aiCustomizationManagement.js';
+import { CustomizationDiscoveryQuery, getCustomizationDiscoveryQuerySuggestions } from './aiCustomizationQuery.js';
+import { renderCustomizationMarketplaceIcon } from './aiCustomizationPresentation.js';
+import { CustomizationMarketplaceSourceWarnings } from './customizationMarketplaceSourceWarnings.js';
+import { createCustomizationCardPrimaryAction } from './customizationCardList.js';
+import { createWorkbenchMcpServerDetailInput } from './embeddedMcpServerDetail.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+
+registerCss(aiCustomizationDiscovery, 1);
+const $ = $$1;
+const searchDelay = 300;
+const catalogPageSize = 24;
+const browseCatalogPageSize = 100;
+const maxFilteredCatalogPagesPerLoad = 8;
+const leadingBrowseItemCount = 4;
+const resultRowHeight = 56;
+const searchInputHeight = 20;
+const firstPartyPublishers = ( new Set(["azure", "azure-samples", "github", "microsoft", "microsoftdocs"]));
+const firstPartyMcpNamespaces = ( new Set([
+    "azure",
+    "azure-ai-foundry",
+    "com.microsoft",
+    "io.github.azure",
+    "io.github.azure-samples",
+    "io.github.github",
+    "io.github.microsoft",
+    "io.github.microsoftdocs"
+]));
+function isFirstPartyBrowseItem(resource) {
+    if (resource.publisher && ( firstPartyPublishers.has(resource.publisher.toLowerCase()))) {
+        return true;
+    }
+    if (resource.installation?.kind !== "mcp") {
+        return false;
+    }
+    const separator = resource.installation.name.indexOf("/");
+    const namespace = (separator === -1 ? resource.installation.name : resource.installation.name.slice(0, separator)).toLowerCase();
+    return ( firstPartyMcpNamespaces.has(namespace));
+}
+function getLeadingBrowseItems(resources) {
+    const firstParty = resources.filter(isFirstPartyBrowseItem).slice(0, leadingBrowseItemCount);
+    if (firstParty.length === leadingBrowseItemCount) {
+        return firstParty;
+    }
+    const firstPartyKeys = ( new Set(firstParty.map(getCustomizationMarketplaceResourceKey)));
+    return [...firstParty, ...resources.filter(resource => !( firstPartyKeys.has(getCustomizationMarketplaceResourceKey(resource))))].slice(0, leadingBrowseItemCount);
+}
+function getSectionType(section) {
+    switch (section) {
+    case AICustomizationManagementSection.Agents:
+        return "agent";
+    case AICustomizationManagementSection.Skills:
+        return "skill";
+    case AICustomizationManagementSection.Instructions:
+        return "instructions";
+    case AICustomizationManagementSection.Hooks:
+        return "hook";
+    default:
+        return "prompt";
+    }
+}
+function getTypeLabel(type) {
+    switch (type) {
+    case "agent":
+        return localize(10121, "Agent");
+    case "skill":
+        return localize(10122, "Skill");
+    case "instructions":
+        return localize(10123, "Instructions");
+    case "prompt":
+        return localize(10124, "Prompt");
+    case "hook":
+        return localize(10125, "Hook");
+    case "mcp":
+        return localize(10126, "MCP server");
+    case "plugin":
+        return localize(10127, "Plugin");
+    }
+}
+function getCatalogType(resource) {
+    switch (resource.mediaType) {
+    case CustomizationMarketplaceMediaType.Skill:
+        return "skill";
+    case CustomizationMarketplaceMediaType.McpServer:
+        return "mcp";
+    case CustomizationMarketplaceMediaType.CopilotPlugin:
+    case CustomizationMarketplaceMediaType.ClaudePlugin:
+        return "plugin";
+    default:
+        return undefined;
+    }
+}
+function getSectionForCatalogType(type) {
+    switch (type) {
+    case "skill":
+        return AICustomizationManagementSection.Skills;
+    case "mcp":
+        return AICustomizationManagementSection.McpServers;
+    case "plugin":
+        return AICustomizationManagementSection.Plugins;
+    }
+}
+function getSourceLabel(item) {
+    if (item.isBuiltin) {
+        return localize(10128, "VS Code");
+    }
+    switch (item.source) {
+    case "extension":
+        return item.extensionId;
+    case "builtin":
+        return localize(10128, "VS Code");
+    default:
+        return undefined;
+    }
+}
+function normalizedName(value) {
+    return value.trim().toLowerCase();
+}
+function hasInstallationTarget(state) {
+    return "target" in state;
+}
+function getInstalledItemMarketplaceRecord(item, installations) {
+    switch (item.type) {
+    case "skill":
+    case "plugin":
+        return item.uri ? installations.findByTarget({
+            kind: item.type,
+            uri: item.uri
+        }) : undefined;
+    case "mcp":
+        return item.mcpServerId ? installations.findByTarget({
+            kind: "mcp",
+            id: item.mcpServerId
+        }) : undefined;
+    default:
+        return undefined;
+    }
+}
+function isCopilotConnectorResource(resource) {
+    return resource?.installation?.kind === "copilotConnector";
+}
+function getInstallationStateLabel(state, connector) {
+    if (connector) {
+        switch (state.kind) {
+        case "missing":
+            return localize(10129, "Disconnected");
+        case "checking":
+            return localize(10130, "Checking connection");
+        case "repairing":
+            return localize(10131, "Reconnecting");
+        case "uninstalling":
+            return localize(10132, "Disconnecting");
+        case "error":
+            return localize(10133, "Could not verify connection");
+        default:
+            return localize(10134, "Connected");
+        }
+    }
+    switch (state.kind) {
+    case "missing":
+        return localize(10135, "Missing files");
+    case "checking":
+        return localize(10136, "Checking installation");
+    case "repairing":
+        return localize(10137, "Repairing");
+    case "uninstalling":
+        return localize(10138, "Uninstalling");
+    case "error":
+        return localize(10139, "Could not verify installation");
+    default:
+        return localize(10140, "Installed");
+    }
+}
+function getInstallActionLabel(state, hasSetupUrl, operationError, connector) {
+    if (connector) {
+        switch (state.kind) {
+        case "installed":
+            return localize(10134, "Connected");
+        case "missing":
+            return operationError ? ( localize(10141, "Retry")) : ( localize(10142, "Reconnect"));
+        case "repairing":
+        case "installing":
+            return localize(10143, "Cancel");
+        case "checking":
+            return localize(10144, "Checking...");
+        case "uninstalling":
+            return localize(10145, "Disconnecting...");
+        case "error":
+            return localize(10146, "Unavailable");
+        default:
+            return localize(10147, "Connect");
+        }
+    }
+    switch (state.kind) {
+    case "installed":
+        return localize(10140, "Installed");
+    case "missing":
+        return operationError ? ( localize(10148, "Retry Repair")) : ( localize(10149, "Repair"));
+    case "repairing":
+        return localize(10150, "Repairing...");
+    case "checking":
+        return localize(10151, "Checking...");
+    case "uninstalling":
+        return localize(10152, "Uninstalling...");
+    case "installing":
+        return localize(10153, "Installing...");
+    case "error":
+        return localize(10146, "Unavailable");
+    default:
+        return hasSetupUrl ? ( localize(10154, "View Setup")) : operationError ? ( localize(10155, "Retry Install")) : ( localize(10156, "Install"));
+    }
+}
+function isCancellableConnectorOperation(resource, state) {
+    return isCopilotConnectorResource(resource) && (state.kind === "installing" || state.kind === "repairing");
+}
+function isInstallActionEnabled(resource, state, hasSetupUrl) {
+    return isCancellableConnectorOperation(resource, state) || state.kind === "available" || state.kind === "missing" && !state.repairUnavailableMessage || hasSetupUrl;
+}
+function isInstallActionBusy(state) {
+    return state.kind === "installing" || state.kind === "checking" || state.kind === "repairing";
+}
+function getInstallActionError(state, operationError) {
+    return state.kind === "unavailable" || state.kind === "error" ? state.message : state.kind === "missing" ? state.repairUnavailableMessage : operationError;
+}
+function renderRecordedCustomizationActions(
+    container,
+    resource,
+    name,
+    state,
+    operationError,
+    disposables,
+    hoverService,
+    onRepair,
+    onCancel,
+    onUninstall
+) {
+    const connector = isCopilotConnectorResource(resource);
+    if (state.kind === "missing") {
+        const repair = disposables.add(( new Button(container, {
+            ...defaultButtonStyles,
+            small: true
+        })));
+        repair.label = getInstallActionLabel(state, false, operationError, connector);
+        repair.enabled = !state.repairUnavailableMessage;
+        repair.setAriaLabel(state.repairUnavailableMessage ? ( localize(10157, "{0} {1}. {2}", repair.label, name, state.repairUnavailableMessage)) : ( localize(10158, "{0} {1}", repair.label, name)));
+        disposables.add(
+            addDisposableListener(repair.element, EventType.CLICK, event => event.stopPropagation())
+        );
+        disposables.add(repair.onDidClick(onRepair));
+        const repairError = state.repairUnavailableMessage ?? operationError;
+        if (repairError) {
+            disposables.add(hoverService.setupDelayedHover(repair.element, {
+                content: repairError
+            }));
+        }
+    }
+    const cancellable = isCancellableConnectorOperation(resource, state);
+    const button = disposables.add(( new Button(container, {
+        ...defaultButtonStyles,
+        secondary: true,
+        small: true
+    })));
+    button.label = cancellable ? ( localize(10143, "Cancel")) : state.kind === "repairing" ? ( localize(10150, "Repairing...")) : state.kind === "checking" ? ( localize(10151, "Checking...")) : state.kind === "uninstalling" ? ( localize(10152, "Uninstalling...")) : operationError && state.kind === "installed" ? ( localize(10159, "Retry Uninstall")) : connector ? ( localize(10160, "Disconnect")) : ( localize(10161, "Uninstall"));
+    button.enabled = cancellable || state.kind === "installed" || state.kind === "missing" || state.kind === "error";
+    button.setAriaLabel(cancellable ? ( localize(10162, "Cancel reconnecting {0}", name)) : connector ? ( localize(10163, "Disconnect {0}", name)) : ( localize(10164, "{0} {1}", button.label, name)));
+    button.element.setAttribute("aria-busy", String(
+        !cancellable && (state.kind === "uninstalling" || state.kind === "repairing" || state.kind === "checking")
+    ));
+    disposables.add(
+        addDisposableListener(button.element, EventType.CLICK, event => event.stopPropagation())
+    );
+    disposables.add(button.onDidClick(cancellable ? onCancel : onUninstall));
+    const uninstallError = state.kind === "error" ? state.message : state.kind === "installed" ? operationError : undefined;
+    if (uninstallError) {
+        disposables.add(hoverService.setupDelayedHover(button.element, {
+            content: uninstallError
+        }));
+    }
+}
+function getCatalogMediaType(types) {
+    if (types.size !== 1) {
+        return undefined;
+    }
+    if (( types.has("skill"))) {
+        return CustomizationMarketplaceMediaType.Skill;
+    }
+    if (( types.has("mcp"))) {
+        return CustomizationMarketplaceMediaType.McpServer;
+    }
+    return undefined;
+}
+class DiscoveryListDelegate {
+    getHeight(_element) {
+        return resultRowHeight;
+    }
+    getTemplateId(_element) {
+        return "discoveryResult";
+    }
+}
+class DiscoveryResultRenderer {
+    constructor(
+        hoverService,
+        getInstallState,
+        getInstallError,
+        getSourceLabel,
+        onInstall,
+        onRepair,
+        onCancel,
+        onUninstall,
+        onOpen,
+        onOpenDetails,
+        onOpenInstalled,
+        isDirectUninstalling,
+        themeService
+    ) {
+        this.hoverService = hoverService;
+        this.getInstallState = getInstallState;
+        this.getInstallError = getInstallError;
+        this.getSourceLabel = getSourceLabel;
+        this.onInstall = onInstall;
+        this.onRepair = onRepair;
+        this.onCancel = onCancel;
+        this.onUninstall = onUninstall;
+        this.onOpen = onOpen;
+        this.onOpenDetails = onOpenDetails;
+        this.onOpenInstalled = onOpenInstalled;
+        this.isDirectUninstalling = isDirectUninstalling;
+        this.themeService = themeService;
+        this.templateId = "discoveryResult";
+    }
+    renderTemplate(container) {
+        container.classList.add("customization-discovery-result-row");
+        const root = append(container, $(".customization-discovery-result-content"));
+        const primaryAction = createCustomizationCardPrimaryAction(root, "", "customization-discovery-result-primary");
+        const templateDisposables = ( new DisposableStore());
+        const loading = templateDisposables.add(createPixelSpinner(root, {
+            variant: "ring"
+        })).element;
+        loading.classList.add("customization-discovery-result-loading");
+        const icon = append(root, $(".customization-discovery-result-icon"));
+        const identity = append(root, $(".customization-discovery-result-identity"));
+        const heading = append(identity, $(".customization-discovery-result-heading"));
+        const name = append(heading, $(".customization-discovery-result-name"));
+        const detail = append(heading, $(".customization-discovery-result-detail"));
+        const description = append(identity, $(".customization-discovery-result-description"));
+        const aside = append(root, $(".customization-discovery-result-aside"));
+        const stats = append(aside, $(".customization-discovery-result-stats"));
+        const actions = append(aside, $(".customization-discovery-result-actions"));
+        return {
+            root,
+            primaryAction,
+            icon,
+            identity,
+            name,
+            detail,
+            description,
+            stats,
+            actions,
+            elementDisposables: ( new DisposableStore()),
+            templateDisposables
+        };
+    }
+    renderElement(element, _index, templateData) {
+        templateData.elementDisposables.clear();
+        clearNode(templateData.icon);
+        clearNode(templateData.stats);
+        clearNode(templateData.actions);
+        templateData.root.classList.toggle("loading", element.kind === "loading");
+        templateData.root.inert = element.kind === "loading";
+        templateData.primaryAction.disabled = element.kind === "loading";
+        if (element.kind === "loading") {
+            templateData.name.textContent = "";
+            templateData.detail.textContent = "";
+            templateData.description.textContent = "";
+            templateData.primaryAction.removeAttribute("aria-label");
+            return;
+        }
+        const installed = element.kind === "installed";
+        const name = installed ? element.name : element.resource.displayName;
+        const description = installed ? element.description : element.resource.description;
+        const type = installed ? element.type : getCatalogType(element.resource);
+        const resource = installed ? element.catalogResource : element.resource;
+        const marketplaceState = installed && element.catalogResource ? this.getInstallState(element.catalogResource) : undefined;
+        const opensInstalled = installed && (!marketplaceState || marketplaceState.kind === "installed");
+        const installationDetail = marketplaceState && marketplaceState.kind !== "installed" ? getInstallationStateLabel(marketplaceState, isCopilotConnectorResource(resource)) : undefined;
+        const detail = [
+            type ? getTypeLabel(type) : !installed ? element.resource.mediaType : undefined,
+            installed ? element.sourceLabel : this.getSourceLabel(element.resource),
+            installationDetail,
+            installed && element.disabled ? ( localize(10165, "Disabled")) : undefined
+        ].filter(Boolean).join(" · ");
+        renderCustomizationMarketplaceIcon(
+            templateData.icon,
+            type === "mcp" ? Codicon.server : type === "plugin" ? Codicon.extensions : type === "skill" ? Codicon.lightbulb : Codicon.file,
+            resource?.icon,
+            this.themeService.getColorTheme().type,
+            templateData.elementDisposables
+        );
+        templateData.name.textContent = name;
+        templateData.name.removeAttribute("href");
+        templateData.name.removeAttribute("rel");
+        templateData.detail.textContent = detail;
+        templateData.description.textContent = description;
+        templateData.primaryAction.setAttribute("aria-label", opensInstalled ? ( localize(10166, "Open installed customization {0}", name)) : ( localize(10167, "View details for {0}", name)));
+        templateData.elementDisposables.add(this.hoverService.setupDelayedHover(templateData.name, {
+            content: name
+        }));
+        templateData.elementDisposables.add(this.hoverService.setupDelayedHover(templateData.description, {
+            content: description
+        }));
+        const registerOpenListeners = open => {
+            templateData.elementDisposables.add(
+                addDisposableListener(templateData.primaryAction, EventType.CLICK, event => {
+                    event.stopPropagation();
+                    open();
+                })
+            );
+        };
+        if (element.kind === "installed" && opensInstalled) {
+            registerOpenListeners(() => this.onOpenInstalled(element));
+        } else {
+            registerOpenListeners(
+                () => this.onOpenDetails(element.kind === "installed" ? element.catalogResource : element.resource)
+            );
+        }
+        if (!installed) {
+            if (element.resource.stars !== undefined) {
+                const starsLabel = ( localize(10168, "{0} stars", element.resource.stars.toLocaleString()));
+                templateData.stats.setAttribute("aria-label", starsLabel);
+                const star = append(templateData.stats, $(".codicon"));
+                star.classList.add(...ThemeIcon.asClassNameArray(Codicon.starFull));
+                star.setAttribute("aria-hidden", "true");
+                append(templateData.stats, $("span")).textContent = element.resource.stars.toLocaleString();
+            } else {
+                templateData.stats.removeAttribute("aria-label");
+            }
+            const state = this.getInstallState(element.resource);
+            const setupUrl = state.kind === "unavailable" ? state.setupUrl : undefined;
+            const installError = this.getInstallError(element.resource);
+            const cancellable = isCancellableConnectorOperation(element.resource, state);
+            const button = templateData.elementDisposables.add(( new Button(templateData.actions, {
+                ...defaultButtonStyles,
+                secondary: true,
+                small: true
+            })));
+            button.label = getInstallActionLabel(
+                state,
+                !!setupUrl,
+                installError,
+                isCopilotConnectorResource(element.resource)
+            );
+            button.enabled = isInstallActionEnabled(element.resource, state, !!setupUrl);
+            button.setAriaLabel(cancellable ? ( localize(10169, "Cancel connecting {0}", element.resource.displayName)) : setupUrl ? ( localize(10170, "View setup instructions for {0}", element.resource.displayName)) : state.kind === "missing" ? state.repairUnavailableMessage ? ( localize(
+                10157,
+                "{0} {1}. {2}",
+                button.label,
+                element.resource.displayName,
+                state.repairUnavailableMessage
+            )) : ( localize(10158, "{0} {1}", button.label, element.resource.displayName)) : state.kind === "error" ? ( localize(10171, "{0}. {1}", element.resource.displayName, state.message)) : state.kind === "unavailable" ? ( localize(10172, "Install {0}. {1}", element.resource.displayName, state.message)) : ( localize(10173, "{0} {1}", button.label, element.resource.displayName)));
+            button.element.setAttribute("aria-busy", String(isInstallActionBusy(state) && !cancellable));
+            templateData.elementDisposables.add(
+                addDisposableListener(button.element, EventType.CLICK, event => event.stopPropagation())
+            );
+            templateData.elementDisposables.add(button.onDidClick(
+                () => cancellable ? this.onCancel(element.resource) : setupUrl ? this.onOpen(setupUrl) : state.kind === "missing" ? this.onRepair(element.resource) : this.onInstall(element.resource)
+            ));
+            const actionError = getInstallActionError(state, installError);
+            if (actionError) {
+                templateData.elementDisposables.add(this.hoverService.setupDelayedHover(button.element, {
+                    content: actionError
+                }));
+            }
+        } else if (element.catalogResource && marketplaceState && hasInstallationTarget(marketplaceState)) {
+            const state = marketplaceState;
+            const error = this.getInstallError(element.catalogResource);
+            renderRecordedCustomizationActions(
+                templateData.actions,
+                element.catalogResource,
+                element.name,
+                state,
+                error,
+                templateData.elementDisposables,
+                this.hoverService,
+                () => this.onRepair(element.catalogResource),
+                () => this.onCancel(element.catalogResource),
+                () => this.onUninstall(element)
+            );
+        } else if (element.removable) {
+            const uninstalling = this.isDirectUninstalling(element);
+            const button = templateData.elementDisposables.add(( new Button(templateData.actions, {
+                ...defaultButtonStyles,
+                secondary: true,
+                small: true
+            })));
+            button.label = uninstalling ? ( localize(10152, "Uninstalling...")) : ( localize(10161, "Uninstall"));
+            button.enabled = !uninstalling;
+            button.setAriaLabel(( localize(10164, "{0} {1}", button.label, element.name)));
+            button.element.setAttribute("aria-busy", String(uninstalling));
+            templateData.elementDisposables.add(
+                addDisposableListener(button.element, EventType.CLICK, event => event.stopPropagation())
+            );
+            templateData.elementDisposables.add(button.onDidClick(() => this.onUninstall(element)));
+        }
+    }
+    disposeTemplate(templateData) {
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposables.dispose();
+    }
+}
+let AICustomizationDiscoveryPage = class AICustomizationDiscoveryPage extends Disposable {
+    constructor(
+        parent,
+        _welcomePageFeatures,
+        callbacks,
+        _harnessLabel,
+        instantiationService,
+        contextMenuService,
+        hoverService,
+        openerService,
+        notificationService,
+        configurationService,
+        commandService,
+        keybindingService,
+        entitlementService,
+        marketplaceService,
+        installService,
+        itemsModel,
+        pluginService,
+        mcpWorkbenchService,
+        workspaceService,
+        accessibilitySignalService,
+        themeService
+    ) {
+        super();
+        this.callbacks = callbacks;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.hoverService = hoverService;
+        this.openerService = openerService;
+        this.notificationService = notificationService;
+        this.configurationService = configurationService;
+        this.commandService = commandService;
+        this.keybindingService = keybindingService;
+        this.entitlementService = entitlementService;
+        this.marketplaceService = marketplaceService;
+        this.installService = installService;
+        this.itemsModel = itemsModel;
+        this.pluginService = pluginService;
+        this.mcpWorkbenchService = mcpWorkbenchService;
+        this.workspaceService = workspaceService;
+        this.accessibilitySignalService = accessibilitySignalService;
+        this.themeService = themeService;
+        this.progressBarActive = false;
+        this.browseDisposables = this._register(( new DisposableStore()));
+        this.browsePrimaryActions = ( new Map());
+        this.resultStatusDisposables = this._register(( new DisposableStore()));
+        this.descriptionDisposables = this._register(( new DisposableStore()));
+        this.searchActionDisposables = this._register(( new DisposableStore()));
+        this.sourceHover = this._register(( new MutableDisposable()));
+        this.request = this._register(( new MutableDisposable()));
+        this.searchScheduler = this._register(( new RunOnceScheduler(() => void this.loadCatalog(false), searchDelay)));
+        this.continuationScheduler = this._register(( new RunOnceScheduler(() => void this.loadCatalog(true), 0)));
+        this.browseCatalogCache = ( new Map());
+        this.installErrors = ( new Map());
+        this.pendingInstalls = ( new Set());
+        this.pendingUninstalls = ( new Set());
+        this.pendingDirectUninstalls = ( new Set());
+        this.forceMarketplaceRefresh = false;
+        this.marketplaceRefreshScheduler = this._register(( new RunOnceScheduler(() => {
+            const force = this.forceMarketplaceRefresh;
+            this.forceMarketplaceRefresh = false;
+            this.updateSources();
+            this.handleAvailabilityChanged(force);
+        }, 0)));
+        this.query = CustomizationDiscoveryQuery.parse("");
+        this.installedItems = [];
+        this.providerPlugins = [];
+        this.catalogItems = [];
+        this.marketplaceSources = [];
+        this.visibleSectionIds = ( new Set());
+        this.visible = false;
+        this.pendingRecoveryReload = false;
+        this.filteredBackfillLimitReached = false;
+        this.loaded = false;
+        this.loading = false;
+        this.loadingMore = false;
+        this.requestSequence = 0;
+        this.providerPluginSequence = 0;
+        this.enabledSourceIds = this.getEnabledCatalogSourceIds();
+        this.container = append(parent, $(".customization-discovery"));
+        const content = append(this.container, $(".customization-discovery-content"));
+        const header = this.header = append(content, $(".customization-discovery-header"));
+        const titleRow = append(header, $(".customization-discovery-title-row"));
+        const title = append(titleRow, $("h2.customization-discovery-title"));
+        title.textContent = ( localize(10174, "Discover customizations"));
+        this.createAddButton(titleRow);
+        this.titleDescription = append(header, $("p.customization-discovery-description"));
+        this.updateDescription();
+        const progressContainer = append(header, $(".customization-discovery-progress"));
+        this.progressBar = this._register(( new ProgressBar(progressContainer, {
+            ...defaultProgressBarStyles,
+            ariaLabel: ( localize(10175, "Loading customizations"))
+        })));
+        this.progressBar.hide();
+        const searchRow = append(header, $(".customization-discovery-search-row"));
+        const searchContainer = append(searchRow, $(".customization-discovery-search"));
+        const placeholder = ( localize(10176, "Search customizations"));
+        this.searchWidget = this._register(
+            this.instantiationService.createInstance(SuggestEnabledInput, "aiCustomizationDiscovery.search", searchContainer, {
+                triggerCharacters: ["@", ":"],
+                sortKey: item => item.startsWith("@installed") ? "a" : "b",
+                provideResults: value => [...getCustomizationDiscoveryQuerySuggestions(value)]
+            }, ( localize(10177, "Search customizations")), "aiCustomizationDiscovery:search", {
+                placeholderText: placeholder
+            })
+        );
+        this.searchActionsContainer = append(searchContainer, $(".customization-discovery-search-actions"));
+        this.searchToolbar = this._register(
+            this.instantiationService.createInstance(WorkbenchToolBar, this.searchActionsContainer, {
+                ariaLabel: ( localize(10178, "Customization Search Actions")),
+                highlightToggledItems: true,
+                telemetrySource: "customizationDiscoverySearch"
+            })
+        );
+        this._register(this.searchWidget.onInputDidChange(() => this.onQueryChanged()));
+        this.updateSearchAriaLabel();
+        this._register(
+            this.keybindingService.onDidUpdateKeybindings(() => this.updateSearchAriaLabel())
+        );
+        const sourceContainer = append(searchRow, $(".customization-discovery-source"));
+        this.sourceButton = this._register(( new Button(sourceContainer, {
+            ...defaultButtonStyles,
+            secondary: true,
+            small: true,
+            supportIcons: true
+        })));
+        this.sourceButton.element.setAttribute("aria-haspopup", "menu");
+        this.updateSourceButton();
+        this._register(this.sourceButton.onDidClick(() => this.showSourceMenu()));
+        this.sourceWarnings = this._register(( new CustomizationMarketplaceSourceWarnings(
+            header,
+            () => this.marketplaceService.allSources ?? this.marketplaceService.sources,
+            () => {
+                this.browseCatalogCache.clear();
+                if (!this.visible) {
+                    this.pendingRecoveryReload = true;
+                    return;
+                }
+                this.focus();
+                void this.loadCatalog(false);
+            },
+            sourceId => this.marketplaceService.getSourceRecoveryAction?.(sourceId),
+            this.notificationService
+        )));
+        this.browseContent = append(content, $(".customization-discovery-browse"));
+        this.browseStatus = append(this.browseContent, $(".customization-discovery-state"));
+        this.browseSections = append(this.browseContent, $(".customization-discovery-sections"));
+        this.browseScrollable = this._register(( new DomScrollableElement(this.browseContent, {
+            horizontal: ScrollbarVisibility.Hidden,
+            vertical: ScrollbarVisibility.Auto,
+            useShadows: true
+        })));
+        const browseScrollableNode = this.browseScrollable.getDomNode();
+        browseScrollableNode.classList.add("customization-discovery-browse-scrollable");
+        content.appendChild(browseScrollableNode);
+        this.resultListContainer = append(content, $(".customization-discovery-results"));
+        this.resultStatus = append(this.resultListContainer, $(".customization-discovery-state"));
+        const listContainer = append(this.resultListContainer, $(".customization-discovery-list"));
+        const renderer = ( new DiscoveryResultRenderer(
+            this.hoverService,
+            resource => this.getInstallState(resource),
+            resource => this.installErrors.get(getCustomizationMarketplaceResourceKey(resource)),
+            resource => this.getMarketplaceResourceLabel(resource),
+            resource => void this.install(resource),
+            resource => void this.repair(resource),
+            resource => this.installService.cancelConnectorOperation(resource),
+            item => void this.uninstall(item),
+            resource => void this.openExternal(resource),
+            resource => this.openMarketplaceItem(resource, "search"),
+            item => this.openInstalledItem(item),
+            item => ( this.pendingDirectUninstalls.has(item.id)),
+            this.themeService
+        ));
+        this.resultList = this._register(this.instantiationService.createInstance(
+            WorkbenchList,
+            "AICustomizationDiscoveryResults",
+            listContainer,
+            ( new DiscoveryListDelegate()),
+            [renderer],
+            {
+                identityProvider: {
+                    getId: entry => entry.id
+                },
+                accessibilityProvider: {
+                    getAriaLabel: entry => this.getEntryAriaLabel(entry),
+                    getWidgetAriaLabel: () => ( localize(10179, "Customization search results"))
+                },
+                keyboardNavigationLabelProvider: {
+                    getKeyboardNavigationLabel: entry => entry.kind === "loading" ? undefined : entry.kind === "installed" ? entry.name : entry.resource.displayName
+                },
+                multipleSelectionSupport: false,
+                openOnSingleClick: true,
+                horizontalScrolling: false
+            }
+        ));
+        this._register(this.resultList.onDidOpen(event => {
+            if (event.element?.kind === "installed") {
+                const resource = event.element.catalogResource;
+                if (!resource || this.getInstallState(resource).kind === "installed") {
+                    this.openInstalledItem(event.element);
+                } else {
+                    this.openMarketplaceItem(resource, "search");
+                }
+            } else if (event.element?.kind === "available") {
+                this.openMarketplaceItem(event.element.resource, "search");
+            }
+        }));
+        this._register(this.searchWidget.onShouldFocusResults(() => this.resultList.domFocus()));
+        this._register(this.resultList.onDidScroll(event => {
+            if (!this.query.isEmpty() && !this.errorMessage && event.scrollHeight > event.height && event.scrollTop + event.height >= event.scrollHeight - resultRowHeight * 3) {
+                this.continuationScheduler.schedule();
+            }
+        }));
+        this._register(autorun(reader => {
+            for (const section of ITEMS_MODEL_SECTIONS) {
+                this.itemsModel.getItems(section).read(reader);
+            }
+            this.pluginService.plugins.read(reader);
+            this.refreshInstalledItems();
+        }));
+        this._register(this.mcpWorkbenchService.onChange(() => this.refreshInstalledItems()));
+        this._register(this.mcpWorkbenchService.onReset(() => this.refreshInstalledItems()));
+        void this.mcpWorkbenchService.whenInitialLocalMcpServersLoaded.then(() => {
+            if (!this._store.isDisposed) {
+                this.refreshInstalledItems();
+            }
+        });
+        this._register(this.installService.onDidChange(() => this.render()));
+        this._register(this.themeService.onDidColorThemeChange(() => this.render()));
+        if (this.marketplaceService.onDidChangeSources) {
+            this._register(
+                this.marketplaceService.onDidChangeSources(() => this.scheduleMarketplaceRefresh(true))
+            );
+        }
+        this._register(
+            this.entitlementService.onDidChangeSentiment(() => this.handleAvailabilityChanged())
+        );
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AccessibilityVerbositySettingId.CustomizationDiscovery)) {
+                this.updateSearchAriaLabel();
+            }
+        }));
+        this.updateSearchActions();
+        this.render();
+        this.updateSources();
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (affectsCustomizationMarketplaceSources(
+                event,
+                this.marketplaceService.allSources ?? this.marketplaceService.sources
+            )) {
+                this.scheduleMarketplaceRefresh(this.isCurrentQueryAffectedBySourceConfiguration(event));
+            }
+        }));
+    }
+    scheduleMarketplaceRefresh(force) {
+        this.forceMarketplaceRefresh ||= force;
+        this.marketplaceRefreshScheduler.schedule();
+    }
+    updateSources() {
+        this.marketplaceSources = getVisibleCustomizationMarketplaceSources(this.configurationService, this.marketplaceService.sources);
+        if (this.selectedSourceId && !( this.marketplaceSources.some(source => source.id === this.selectedSourceId))) {
+            this.selectedSourceId = undefined;
+        }
+        this.updateSourceButton();
+    }
+    updateSourceButton() {
+        const selectedSource = this.marketplaceSources.find(source => source.id === this.selectedSourceId);
+        const label = selectedSource ? selectedSource.displayName ?? selectedSource.id : ( localize(10180, "All Sources"));
+        this.sourceButton.label = `${label} $(chevron-down)`;
+        this.sourceButton.setAriaLabel(( localize(10181, "Customization source: {0}", label)));
+        this.sourceButton.element.removeAttribute("title");
+        this.sourceHover.value = this.hoverService.setupDelayedHover(this.sourceButton.element, {
+            content: label
+        });
+    }
+    showSourceMenu() {
+        const disposables = ( new DisposableStore());
+        const allSources = disposables.add(( new Action("customizationDiscovery.source.all", ( localize(10180, "All Sources")), undefined, true, () => this.selectSource(undefined))));
+        allSources.checked = this.selectedSourceId === undefined;
+        const sourceActions = this.marketplaceSources.map(source => {
+            const action = disposables.add(( new Action(
+                `customizationDiscovery.source.${source.id}`,
+                source.displayName ?? source.id,
+                undefined,
+                true,
+                () => this.selectSource(source.id)
+            )));
+            action.checked = source.id === this.selectedSourceId;
+            return action;
+        });
+        const configure = disposables.add(( new Action("customizationDiscovery.source.configure", ( localize(10182, "Configure Marketplaces")), ThemeIcon.asClassName(Codicon.settingsGear), true, () => this.commandService.executeCommand(MANAGE_PLUGIN_MARKETPLACES_COMMAND_ID))));
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => this.sourceButton.element,
+            getActions: () => [allSources, ...sourceActions, ( new Separator()), configure],
+            onHide: () => disposables.dispose()
+        });
+    }
+    selectSource(sourceId) {
+        if (this.selectedSourceId === sourceId) {
+            return;
+        }
+        this.selectedSourceId = sourceId;
+        this.updateSourceButton();
+        this.cancelCatalogRequest();
+        this.searchScheduler.cancel();
+        this.resetCatalogState();
+        this.errorMessage = undefined;
+        this.resultList.scrollTop = 0;
+        this.lastAnnouncement = undefined;
+        this.render();
+        if (this.shouldQueryCatalog() && !this.loaded) {
+            void this.loadCatalog(false);
+        }
+    }
+    createAddButton(parent) {
+        const addButton = this._register(( new Button(parent, {
+            ...defaultButtonStyles,
+            secondary: true,
+            small: true,
+            supportIcons: true
+        })));
+        addButton.element.setAttribute("aria-haspopup", "menu");
+        addButton.label = ( localize(10183, "Add Customization {0}", `$(${Codicon.chevronDown.id})`));
+        addButton.setAriaLabel(( localize(10184, "Add a customization")));
+        addButton.element.setAttribute("aria-expanded", "false");
+        this._register(addButton.onDidClick(() => {
+            const disposables = ( new DisposableStore());
+            const actions = [];
+            if (( this.visibleSectionIds.has(AICustomizationManagementSection.Agents))) {
+                actions.push(disposables.add(( new Action("customizationDiscovery.newAgent", ( localize(10185, "New Agent")), undefined, true, () => this.createCustomization(PromptsType.agent)))));
+            }
+            if (( this.visibleSectionIds.has(AICustomizationManagementSection.Skills))) {
+                actions.push(disposables.add(( new Action("customizationDiscovery.newSkill", ( localize(10186, "New Skill")), undefined, true, () => this.createCustomization(PromptsType.skill)))));
+            }
+            if (( this.visibleSectionIds.has(AICustomizationManagementSection.Instructions))) {
+                actions.push(disposables.add(( new Action("customizationDiscovery.newInstructions", ( localize(10187, "New Instructions")), undefined, true, () => this.createCustomization(PromptsType.instructions)))));
+            }
+            if (( this.visibleSectionIds.has(AICustomizationManagementSection.Prompts))) {
+                actions.push(disposables.add(( new Action("customizationDiscovery.newPrompt", ( localize(10188, "New Prompt")), undefined, true, () => this.createCustomization(PromptsType.prompt)))));
+            }
+            if (( this.visibleSectionIds.has(AICustomizationManagementSection.McpServers))) {
+                actions.push(disposables.add(( new Action("customizationDiscovery.addMcp", ( localize(10189, "Add MCP Server")), undefined, true, () => this.callbacks.selectSection(AICustomizationManagementSection.McpServers)))));
+            }
+            if (( this.visibleSectionIds.has(AICustomizationManagementSection.Plugins))) {
+                actions.push(disposables.add(( new Action("customizationDiscovery.addPlugin", ( localize(10190, "Add Plugin")), undefined, true, () => this.callbacks.selectSection(AICustomizationManagementSection.Plugins)))));
+            }
+            this.contextMenuService.showContextMenu({
+                getAnchor: () => addButton.element,
+                getActions: () => actions,
+                onHide: () => {
+                    addButton.element.setAttribute("aria-expanded", "false");
+                    disposables.dispose();
+                }
+            });
+            addButton.element.setAttribute("aria-expanded", "true");
+        }));
+    }
+    createCustomization(type) {
+        this.callbacks.closeEditor();
+        return this.workspaceService.generateCustomization(type);
+    }
+    updateDescription() {
+        this.descriptionDisposables.clear();
+        const sections = [
+            AICustomizationManagementSection.Plugins,
+            AICustomizationManagementSection.McpServers,
+            AICustomizationManagementSection.Skills,
+            AICustomizationManagementSection.Instructions,
+            AICustomizationManagementSection.Agents,
+            AICustomizationManagementSection.Hooks
+        ];
+        const description = ( localize(
+            10191,
+            "Find new ways to extend your agent with [[Plugins]], [[MCP Servers]], [[Skills]], [[Instructions]], [[Agents]], and [[Hooks]]."
+        ));
+        renderFormattedText(description, {
+            actionHandler: {
+                callback: (index, event) => {
+                    event.preventDefault();
+                    const section = sections[Number(index)];
+                    if (section) {
+                        this.callbacks.selectSection(section);
+                    }
+                },
+                disposables: this.descriptionDisposables
+            }
+        }, this.titleDescription);
+        for (const link of this.titleDescription.children) {
+            link.setAttribute("href", "#");
+        }
+    }
+    onQueryChanged() {
+        const next = CustomizationDiscoveryQuery.parse(this.searchWidget.getValue());
+        if (this.query.equals(next)) {
+            return;
+        }
+        this.query = next;
+        this.resetCatalogState();
+        this.errorMessage = undefined;
+        this.cancelCatalogRequest();
+        this.resultList.scrollTop = 0;
+        this.lastAnnouncement = undefined;
+        this.updateSearchActions();
+        this.render();
+        this.searchScheduler.cancel();
+        if (this.shouldQueryCatalog() && !this.loaded) {
+            this.searchScheduler.schedule();
+        }
+    }
+    setQuery(query) {
+        this.query = query;
+        this.resetCatalogState();
+        this.errorMessage = undefined;
+        this.cancelCatalogRequest();
+        this.searchScheduler.cancel();
+        this.resultList.scrollTop = 0;
+        this.lastAnnouncement = undefined;
+        this.searchWidget.setValue(( query.toString()));
+        this.updateSearchActions();
+        this.render();
+        if (this.shouldQueryCatalog() && !this.loaded) {
+            this.searchScheduler.schedule(0);
+        }
+        this.searchWidget.focus();
+    }
+    resetCatalogState() {
+        this.installErrors.clear();
+        const cached = this.query.isEmpty() ? this.browseCatalogCache.get(this.selectedSourceId ?? "") : undefined;
+        this.catalogPage = cached?.page;
+        if (cached) {
+            this.catalogItems = cached.items;
+            this.loaded = true;
+        } else {
+            this.catalogItems = [];
+            this.loaded = false;
+        }
+    }
+    updateSearchActions() {
+        this.searchActionDisposables.clear();
+        const actions = [];
+        if (!this.query.isEmpty()) {
+            actions.push(this.searchActionDisposables.add(( new Action("customizationDiscovery.clearSearch", ( localize(10192, "Clear Customization Search Results")), ThemeIcon.asClassName(Codicon.clearAll), true, () => this.setQuery(CustomizationDiscoveryQuery.parse(""))))));
+        }
+        const installed = this.searchActionDisposables.add(( new Action("customizationDiscovery.filter.installed", ( localize(10193, "Installed")), undefined, true, () => this.setQuery(this.query.withInstalled(!this.query.installed)))));
+        installed.checked = this.query.installed;
+        const mcp = this.searchActionDisposables.add(( new Action("customizationDiscovery.filter.mcp", ( localize(10194, "MCP Servers")), undefined, true, () => this.setQuery(this.query.withType("mcp", !( this.query.types.has("mcp")))))));
+        mcp.checked = ( this.query.types.has("mcp"));
+        const plugins = this.searchActionDisposables.add(( new Action("customizationDiscovery.filter.plugin", ( localize(10195, "Plugins")), undefined, true, () => this.setQuery(this.query.withType("plugin", !( this.query.types.has("plugin")))))));
+        plugins.checked = ( this.query.types.has("plugin"));
+        const skills = this.searchActionDisposables.add(( new Action("customizationDiscovery.filter.skill", ( localize(10196, "Skills")), undefined, true, () => this.setQuery(this.query.withType("skill", !( this.query.types.has("skill")))))));
+        skills.checked = ( this.query.types.has("skill"));
+        actions.push(( new SubmenuAction("customizationDiscovery.filter", ( localize(10197, "Filter Customizations...")), [installed, ( new Separator()), mcp, plugins, skills], ThemeIcon.asClassName(Codicon.filter))));
+        this.searchToolbar.setActions(actions);
+    }
+    handleAvailabilityChanged(force = false) {
+        const enabledSourceIds = this.getEnabledCatalogSourceIds();
+        if (!force && equals(this.enabledSourceIds, enabledSourceIds)) {
+            return;
+        }
+        this.enabledSourceIds = enabledSourceIds;
+        this.searchScheduler.cancel();
+        this.cancelCatalogRequest();
+        this.catalogPage = undefined;
+        this.browseCatalogCache.clear();
+        this.catalogItems = [];
+        this.loaded = false;
+        this.errorMessage = undefined;
+        this.render();
+        if (this.shouldQueryCatalog()) {
+            void this.loadCatalog(false);
+        }
+    }
+    refreshInstalledItems() {
+        const items = [];
+        for (const section of ITEMS_MODEL_SECTIONS) {
+            if (!( this.visibleSectionIds.has(section))) {
+                continue;
+            }
+            for (const item of this.itemsModel.getItems(section).get()) {
+                const type = getSectionType(section);
+                items.push({
+                    kind: "installed",
+                    id: `installed:${section}:${item.id}`,
+                    name: item.displayName ?? item.name,
+                    description: item.description ?? item.filename,
+                    sourceLabel: item.marketplace ? this.getMarketplaceResourceLabel(item.marketplace.resource) : getSourceLabel(item),
+                    type,
+                    section,
+                    uri: item.uri,
+                    source: item.source,
+                    promptType: item.promptType,
+                    itemId: item.id,
+                    promptDetail: item,
+                    catalogResource: item.marketplace?.resource,
+                    removable: !item.isBuiltin && item.source !== "extension" && item.source !== "builtin",
+                    disabled: item.disabled
+                });
+            }
+        }
+        if (( this.visibleSectionIds.has(AICustomizationManagementSection.Plugins))) {
+            for (const plugin of this.pluginService.plugins.get()) {
+                const name = plugin.label || basename(plugin.uri);
+                const source = plugin.fromMarketplace;
+                items.push({
+                    kind: "installed",
+                    id: `installed:plugin:${( plugin.uri.toString())}`,
+                    name,
+                    description: source?.description ?? ( localize(10198, "Installed agent plugin")),
+                    sourceLabel: source?.marketplace,
+                    type: "plugin",
+                    section: AICustomizationManagementSection.Plugins,
+                    uri: plugin.uri,
+                    removable: !!plugin.remove,
+                    pluginDetail: {
+                        kind: AgentPluginItemKind.Installed,
+                        name,
+                        description: source?.description ?? ( localize(10198, "Installed agent plugin")),
+                        marketplace: source?.marketplace,
+                        plugin
+                    }
+                });
+            }
+        }
+        if (( this.visibleSectionIds.has(AICustomizationManagementSection.McpServers))) {
+            for (const server of this.mcpWorkbenchService.local) {
+                if (server.installState !== McpServerInstallState.Installed || !server.local) {
+                    continue;
+                }
+                items.push({
+                    kind: "installed",
+                    id: `installed:mcp:${server.id}`,
+                    name: server.label,
+                    description: server.description,
+                    type: "mcp",
+                    section: AICustomizationManagementSection.McpServers,
+                    removable: true,
+                    mcpServerId: server.id,
+                    mcpDetail: createWorkbenchMcpServerDetailInput(server)
+                });
+            }
+        }
+        this.installedItems = items;
+        void this.refreshProviderPlugins();
+        this.render();
+    }
+    async refreshProviderPlugins() {
+        const sequence = ++this.providerPluginSequence;
+        if (!( this.visibleSectionIds.has(AICustomizationManagementSection.Plugins))) {
+            this.providerPlugins = [];
+            return;
+        }
+        try {
+            const provided = await this.itemsModel.getActiveItemSource().fetchProviderItems();
+            if (sequence !== this.providerPluginSequence || this._store.isDisposed) {
+                return;
+            }
+            this.providerPlugins = provided.filter(isPluginCustomizationItem).map(item => ({
+                kind: "installed",
+                id: `installed:provider-plugin:${( item.uri.toString())}`,
+                name: item.name,
+                description: item.description ?? ( localize(10198, "Installed agent plugin")),
+                sourceLabel: item.badge,
+                type: "plugin",
+                section: AICustomizationManagementSection.Plugins,
+                uri: item.uri,
+                disabled: item.enabled === false
+            }));
+            this.render();
+        } catch (error) {
+            if (sequence === this.providerPluginSequence && !isCancellationError(error)) {
+                this.notificationService.error(( localize(10199, "Could not load installed plugins. {0}", getErrorMessage(error))));
+            }
+        }
+    }
+    getFilteredInstalledItems() {
+        const text = normalizedName(this.query.text);
+        const items = [...this.installedItems, ...this.providerPlugins];
+        return items.filter(item => this.matchesType(item.type)).filter(item => !text || ( [item.name, item.description, item.sourceLabel, getTypeLabel(item.type)].some(value => value && normalizedName(value).includes(text)))).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    matchesType(type) {
+        if (this.query.types.size === 0) {
+            return true;
+        }
+        return type === "skill" && ( this.query.types.has("skill")) || type === "mcp" && ( this.query.types.has("mcp")) || type === "plugin" && ( this.query.types.has("plugin"));
+    }
+    shouldQueryCatalog() {
+        return this.visible && this.isCatalogEnabled() && !this.query.installed;
+    }
+    isCatalogEnabled() {
+        return this.getEnabledCatalogSourceIds().length > 0;
+    }
+    isCurrentQueryAffectedBySourceConfiguration(event) {
+        return ( this.getCurrentQuerySources().some(
+            source => source.configurationDependencies?.some(setting => event.affectsConfiguration(setting))
+        ));
+    }
+    getCurrentQuerySources() {
+        return this.selectedSourceId ? this.marketplaceSources.filter(source => source.id === this.selectedSourceId) : this.marketplaceSources;
+    }
+    getEnabledCatalogSourceIds() {
+        return this.entitlementService.sentiment.hidden ? [] : getVisibleCustomizationMarketplaceSources(this.configurationService, this.marketplaceService.sources).map(source => source.id);
+    }
+    hasNextCatalogPage() {
+        return !this.query.installed && this.catalogPage?.nextCursor !== undefined;
+    }
+    getMarketplaceSourceLabel(sourceId) {
+        const source = this.marketplaceSources.find(source => source.id === sourceId) ?? (this.marketplaceService.allSources ?? this.marketplaceService.sources).find(source => source.id === sourceId);
+        return source?.displayName ?? sourceId;
+    }
+    getMarketplaceResourceLabel(resource) {
+        const source = this.getMarketplaceSourceLabel(resource.sourceId);
+        return resource.originLabel && resource.originLabel !== source ? ( localize(10200, "{0} · {1}", source, resource.originLabel)) : resource.originLabel ?? source;
+    }
+    cancelCatalogRequest() {
+        this.continuationScheduler.cancel();
+        this.request.value?.cancel();
+        this.request.clear();
+        this.loading = false;
+        this.loadingMore = false;
+    }
+    async loadCatalog(append) {
+        if (!this.shouldQueryCatalog() || (append && (this.loading || !this.hasNextCatalogPage()))) {
+            return;
+        }
+        const sequence = ++this.requestSequence;
+        this.cancelCatalogRequest();
+        const request = ( new CancellationTokenSource());
+        this.request.value = request;
+        this.loading = true;
+        this.loadingMore = append;
+        this.filteredBackfillLimitReached = false;
+        this.errorMessage = undefined;
+        this.render(true);
+        try {
+            const backfill = !this.query.isEmpty() && this.query.types.size > 0 && getCatalogMediaType(this.query.types) === undefined;
+            let hasMatchingCatalogItem = false;
+            for (let pageCount = 0; pageCount < (backfill ? maxFilteredCatalogPagesPerLoad : 1); pageCount++) {
+                const page = await this.marketplaceService.query({
+                    query: this.query.text || undefined,
+                    mediaType: getCatalogMediaType(this.query.types),
+                    sourceIds: this.selectedSourceId ? [this.selectedSourceId] : undefined,
+                    pageSize: this.query.isEmpty() ? browseCatalogPageSize : catalogPageSize,
+                    cursor: append ? this.catalogPage?.nextCursor : undefined
+                }, request.token);
+                if (sequence !== this.requestSequence || request.token.isCancellationRequested) {
+                    return;
+                }
+                this.catalogPage = {
+                    items: append ? [...(this.catalogPage?.items ?? []), ...page.items] : page.items,
+                    nextCursor: page.nextCursor,
+                    sourceErrors: page.sourceErrors
+                };
+                const seen = ( new Set());
+                this.catalogItems = this.catalogPage.items.filter(item => {
+                    if (item.mediaType === CustomizationMarketplaceMediaType.CursorPlugin) {
+                        return false;
+                    }
+                    const key = getCustomizationMarketplaceResourceKey(item);
+                    if (( seen.has(key))) {
+                        return false;
+                    }
+                    seen.add(key);
+                    return true;
+                });
+                hasMatchingCatalogItem = ( this.catalogItems.some(item => {
+                    const type = getCatalogType(item);
+                    return type !== undefined && this.matchesType(type);
+                }));
+                append = true;
+                if (!backfill || !page.nextCursor || hasMatchingCatalogItem) {
+                    break;
+                }
+                if (pageCount === maxFilteredCatalogPagesPerLoad - 1) {
+                    this.filteredBackfillLimitReached = true;
+                }
+            }
+            this.loaded = true;
+            if (this.query.isEmpty() && this.catalogPage) {
+                this.browseCatalogCache.set(this.selectedSourceId ?? "", {
+                    items: this.catalogItems,
+                    page: this.catalogPage
+                });
+            }
+        } catch (error) {
+            if (sequence !== this.requestSequence || isCancellationError(error)) {
+                return;
+            }
+            this.filteredBackfillLimitReached = false;
+            this.loaded = true;
+            this.errorMessage = getErrorMessage(error);
+        } finally {
+            if (this.request.value === request) {
+                this.loading = false;
+                this.request.clear();
+                this.render(this.loadingMore);
+            }
+        }
+    }
+    isLoadingMore() {
+        return this.loading && this.loadingMore && this.hasMatchingCatalogItems();
+    }
+    hasMatchingCatalogItems() {
+        return ( this.catalogItems.some(item => {
+            const type = getCatalogType(item);
+            return type !== undefined && this.matchesType(type);
+        }));
+    }
+    isCatalogPending() {
+        return this.loading || this.shouldQueryCatalog() && (!this.loaded || this.filteredBackfillLimitReached && this.hasNextCatalogPage() && !this.hasMatchingCatalogItems());
+    }
+    render(preserveResults = false) {
+        this.sourceWarnings.update(this.catalogPage?.sourceErrors ?? [], this.loading);
+        const catalogPending = this.isCatalogPending();
+        const showProgress = this.visible && catalogPending && !this.isLoadingMore();
+        if (showProgress !== this.progressBarActive) {
+            this.progressBarActive = showProgress;
+            if (showProgress) {
+                this.progressBar.infinite().show();
+            } else {
+                this.progressBar.stop().hide();
+            }
+        }
+        this.browseContent.setAttribute("aria-busy", String(catalogPending));
+        const searchMode = !this.query.isEmpty();
+        this.browseScrollable.getDomNode().hidden = searchMode;
+        this.resultListContainer.hidden = !searchMode;
+        if (searchMode) {
+            this.renderSearchResults(preserveResults);
+        } else {
+            this.renderBrowse();
+        }
+        this.layout(this.lastDimension);
+    }
+    scheduleContinuationIfNeeded() {
+        if (!this.visible || this.query.isEmpty() || this.loading || this.errorMessage || !this.hasNextCatalogPage()) {
+            this.continuationScheduler.cancel();
+            return;
+        }
+        const renderHeight = this.resultList.renderHeight;
+        if (renderHeight > 0 && (this.resultList.scrollHeight <= renderHeight || this.resultList.scrollTop + renderHeight >= this.resultList.scrollHeight - resultRowHeight * 3)) {
+            this.continuationScheduler.schedule();
+        }
+    }
+    getLoadingLabel() {
+        return this.loadingMore ? ( localize(10201, "Loading more customizations...")) : this.catalogItems.length ? ( localize(10202, "Reloading customizations...")) : ( localize(10203, "Loading customizations..."));
+    }
+    getSearchMarketplaceResources() {
+        const resources = ( new Map(
+            this.catalogItems.map(resource => [getCustomizationMarketplaceResourceKey(resource), resource])
+        ));
+        for (const {
+            resource
+        } of this.installService.installations.get().installations) {
+            const key = getCustomizationMarketplaceResourceKey(resource);
+            if (!( resources.has(key))) {
+                resources.set(key, resource);
+            }
+        }
+        const query = normalizedName(this.query.text);
+        return [...( resources.values())].filter(resource => {
+            const type = getCatalogType(resource);
+            return !!type && this.matchesType(type) && (!this.selectedSourceId || resource.sourceId === this.selectedSourceId) && (!query || ( [
+                resource.displayName,
+                resource.description,
+                getTypeLabel(type),
+                this.getMarketplaceSourceLabel(resource.sourceId)
+            ].some(value => normalizedName(value).includes(query))));
+        });
+    }
+    renderSearchResults(preserveResults) {
+        this.resultStatusDisposables.clear();
+        const installed = [...this.getFilteredInstalledItems()];
+        const marketplaceInstallations = this.installService.installations.get();
+        const installedByMarketplaceRecord = ( new Map());
+        for (let index = 0; index < installed.length; index++) {
+            const marketplace = getInstalledItemMarketplaceRecord(installed[index], marketplaceInstallations);
+            if (marketplace && !( installedByMarketplaceRecord.has(marketplace))) {
+                installedByMarketplaceRecord.set(marketplace, index);
+            }
+        }
+        const installedCatalog = [];
+        const available = [];
+        for (const resource of this.getSearchMarketplaceResources()) {
+            const type = getCatalogType(resource);
+            const state = this.getInstallState(resource);
+            if (hasInstallationTarget(state)) {
+                const marketplace = marketplaceInstallations.findByResource(resource);
+                const matchingInstalledIndex = marketplace ? installedByMarketplaceRecord.get(marketplace) : undefined;
+                if (matchingInstalledIndex !== undefined) {
+                    installed[matchingInstalledIndex] = {
+                        ...installed[matchingInstalledIndex],
+                        sourceLabel: this.getMarketplaceResourceLabel(resource),
+                        catalogResource: resource
+                    };
+                } else {
+                    installedCatalog.push({
+                        kind: "installed",
+                        id: `installed:catalog:${getCustomizationMarketplaceResourceKey(resource)}`,
+                        name: resource.displayName,
+                        description: resource.description,
+                        sourceLabel: this.getMarketplaceResourceLabel(resource),
+                        type,
+                        section: getSectionForCatalogType(type),
+                        catalogResource: resource,
+                        uri: state.target.kind === "skill" || state.target.kind === "plugin" ? state.target.uri : undefined,
+                        mcpServerId: state.target.kind === "mcp" ? state.target.id : undefined,
+                        mcpConnectorName: state.target.kind === "copilotConnector" ? state.target.name : undefined
+                    });
+                }
+            } else {
+                available.push({
+                    kind: "available",
+                    id: `available:${getCustomizationMarketplaceResourceKey(resource)}`,
+                    resource
+                });
+            }
+        }
+        const allInstalled = [...installed, ...installedCatalog];
+        const entries = this.query.installed ? allInstalled : [...allInstalled, ...available];
+        const resultCount = entries.length;
+        if (this.isLoadingMore() && resultCount > 0) {
+            entries.push({
+                kind: "loading",
+                id: "loading"
+            });
+        }
+        let start = 0;
+        if (preserveResults) {
+            while (start < this.resultList.length && start < entries.length && structuralEquals(this.resultList.element(start), entries[start])) {
+                start++;
+            }
+        }
+        this.resultList.splice(start, this.resultList.length - start, entries.slice(start));
+        const installError = ( this.installErrors.values()).next().value;
+        const catalogPending = this.isCatalogPending();
+        this.resultListContainer.setAttribute("aria-busy", String(catalogPending));
+        if (installError) {
+            this.resultStatus.textContent = installError;
+        } else if (catalogPending) {
+            this.resultStatus.textContent = "";
+        } else if (this.errorMessage) {
+            const message = ( localize(10204, "Could not load available customizations. {0}", this.errorMessage));
+            this.resultStatus.textContent = message;
+            this.announce(message);
+            const retry = this.resultStatusDisposables.add(( new Button(this.resultStatus, {
+                ...defaultButtonStyles,
+                secondary: true,
+                small: true
+            })));
+            retry.label = ( localize(10205, "Retry"));
+            this.resultStatusDisposables.add(retry.onDidClick(() => {
+                this.focus();
+                void this.loadCatalog(this.loadingMore);
+            }));
+        } else if (entries.length === 0 && this.sourceWarnings.hasWarnings) {
+            this.resultStatus.textContent = ( localize(
+                10206,
+                "Available customizations could not be fully loaded. Retry an unavailable source."
+            ));
+        } else if (entries.length === 0 && !this.sourceWarnings.hasErrors) {
+            this.resultStatus.textContent = this.filteredBackfillLimitReached ? ( localize(10207, "More catalog results may match this search.")) : ( localize(10208, "No customizations match this search."));
+        } else {
+            this.resultStatus.textContent = "";
+        }
+        if (this.loading) {
+            this.announce(this.getLoadingLabel());
+        }
+        if (!catalogPending && !this.errorMessage) {
+            this.announce([( localize(10209, "{0} customizations found.", resultCount)), this.sourceWarnings.getAccessibilityContent()].filter(Boolean).join("\n"));
+        }
+    }
+    renderBrowse() {
+        this.browseDisposables.clear();
+        this.browsePrimaryActions.clear();
+        clearNode(this.browseSections);
+        if (!this.isCatalogEnabled()) {
+            this.browseStatus.textContent = ( localize(
+                10210,
+                "Search your installed customizations, or enable a marketplace source to explore available items."
+            ));
+            return;
+        }
+        if (this.loading && this.catalogItems.length === 0) {
+            this.browseStatus.textContent = "";
+            return;
+        }
+        if (this.errorMessage && this.catalogItems.length === 0) {
+            const message = ( localize(10204, "Could not load available customizations. {0}", this.errorMessage));
+            this.browseStatus.textContent = message;
+            this.announce(message);
+            const retry = this.browseDisposables.add(( new Button(this.browseStatus, {
+                ...defaultButtonStyles,
+                secondary: true,
+                small: true
+            })));
+            retry.label = ( localize(10205, "Retry"));
+            this.browseDisposables.add(retry.onDidClick(() => void this.loadCatalog(false)));
+            return;
+        }
+        this.browseStatus.textContent = "";
+        const leading = getLeadingBrowseItems(this.catalogItems);
+        const leadingIds = ( new Set(leading.map(getCustomizationMarketplaceResourceKey)));
+        if (leading.length) {
+            this.renderBrowseSection(( localize(10211, "Expand your agent's horizons")), leading, undefined, true);
+        }
+        const groups = [{
+            type: "skill",
+            label: ( localize(10212, "Skills"))
+        }, {
+            type: "mcp",
+            label: ( localize(10213, "MCP servers"))
+        }, {
+            type: "plugin",
+            label: ( localize(10214, "Plugins"))
+        }];
+        for (const group of groups) {
+            const items = this.catalogItems.filter(item => getCatalogType(item) === group.type && !( leadingIds.has(getCustomizationMarketplaceResourceKey(item)))).slice(0, leadingBrowseItemCount);
+            if (items.length) {
+                this.renderBrowseSection(group.label, items, group.type, false);
+            }
+        }
+        if (this.loading) {
+            this.browseStatus.textContent = "";
+        } else if (this.errorMessage) {
+            const message = ( localize(10204, "Could not load available customizations. {0}", this.errorMessage));
+            this.browseStatus.textContent = message;
+            this.announce(message);
+            const retry = this.browseDisposables.add(( new Button(this.browseStatus, {
+                ...defaultButtonStyles,
+                secondary: true,
+                small: true
+            })));
+            retry.label = ( localize(10205, "Retry"));
+            this.browseDisposables.add(retry.onDidClick(() => void this.loadCatalog(false)));
+        } else if (!this.catalogItems.length && this.loaded && this.sourceWarnings.hasWarnings) {
+            this.browseStatus.textContent = ( localize(
+                10206,
+                "Available customizations could not be fully loaded. Retry an unavailable source."
+            ));
+        } else if (!this.catalogItems.length && this.loaded && !this.sourceWarnings.hasErrors) {
+            this.browseStatus.textContent = ( localize(10215, "No catalog customizations are available."));
+        } else {
+            this.browseStatus.textContent = ( this.installErrors.values()).next().value ?? "";
+        }
+        if (!this.loading && this.sourceWarnings.hasErrors) {
+            this.announce(this.sourceWarnings.getAccessibilityContent());
+        }
+    }
+    renderBrowseSection(label, items, type, elevated) {
+        const section = append(this.browseSections, $(".customization-discovery-section"));
+        section.classList.toggle("featured", elevated);
+        const header = append(section, $(".customization-discovery-section-header"));
+        append(header, $("h3.customization-discovery-section-title")).textContent = label;
+        if (type) {
+            const showAll = append(header, $("button.customization-discovery-show-all"));
+            showAll.type = "button";
+            showAll.textContent = ( localize(10216, "Show All"));
+            this.browseDisposables.add(addDisposableListener(
+                showAll,
+                EventType.CLICK,
+                () => this.setQuery(this.query.withType(type, true))
+            ));
+        }
+        const grid = append(section, $(".customization-discovery-grid"));
+        for (const item of items) {
+            this.renderBrowseCard(grid, item);
+        }
+    }
+    renderBrowseCard(parent, item) {
+        const card = append(parent, $(".customization-discovery-card"));
+        const resourceKey = getCustomizationMarketplaceResourceKey(item);
+        card.dataset.resourceKey = resourceKey;
+        const state = this.getInstallState(item);
+        const primaryAction = createCustomizationCardPrimaryAction(card, state.kind === "installed" ? ( localize(10166, "Open installed customization {0}", item.displayName)) : ( localize(10167, "View details for {0}", item.displayName)), "customization-discovery-card-primary");
+        this.browsePrimaryActions.set(resourceKey, primaryAction);
+        this.browseDisposables.add(addDisposableListener(
+            primaryAction,
+            EventType.CLICK,
+            () => this.openCatalogItem(item, "browse")
+        ));
+        const icon = append(card, $(".customization-discovery-card-icon"));
+        const type = getCatalogType(item);
+        renderCustomizationMarketplaceIcon(
+            icon,
+            type === "mcp" ? Codicon.server : type === "plugin" ? Codicon.extensions : Codicon.lightbulb,
+            item.icon,
+            this.themeService.getColorTheme().type,
+            this.browseDisposables
+        );
+        const body = append(card, $(".customization-discovery-card-body"));
+        const heading = append(body, $(".customization-discovery-card-heading"));
+        const name = append(heading, $(".customization-discovery-card-name"));
+        name.textContent = item.displayName;
+        const metadata = append(heading, $(".customization-discovery-card-metadata"));
+        metadata.textContent = [
+            type ? getTypeLabel(type) : undefined,
+            this.getMarketplaceSourceLabel(item.sourceId)
+        ].filter(Boolean).join(" · ");
+        const description = append(body, $(".customization-discovery-card-description"));
+        description.textContent = item.description;
+        this.browseDisposables.add(this.hoverService.setupDelayedHover(name, {
+            content: item.displayName
+        }));
+        this.browseDisposables.add(this.hoverService.setupDelayedHover(description, {
+            content: item.description
+        }));
+        const actions = append(card, $(".customization-discovery-card-actions"));
+        const setupUrl = state.kind === "unavailable" ? state.setupUrl : undefined;
+        const installError = this.installErrors.get(getCustomizationMarketplaceResourceKey(item));
+        if (hasInstallationTarget(state)) {
+            renderRecordedCustomizationActions(
+                actions,
+                item,
+                item.displayName,
+                state,
+                installError,
+                this.browseDisposables,
+                this.hoverService,
+                () => void this.repair(item),
+                () => this.installService.cancelConnectorOperation(item),
+                () => void this.uninstallMarketplaceResource(item)
+            );
+            return;
+        }
+        const cancellable = isCancellableConnectorOperation(item, state);
+        const install = this.browseDisposables.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            secondary: true,
+            small: true
+        })));
+        install.label = getInstallActionLabel(state, !!setupUrl, installError, isCopilotConnectorResource(item));
+        install.enabled = isInstallActionEnabled(item, state, !!setupUrl);
+        install.setAriaLabel(cancellable ? ( localize(10169, "Cancel connecting {0}", item.displayName)) : setupUrl ? ( localize(10170, "View setup instructions for {0}", item.displayName)) : state.kind === "unavailable" ? ( localize(10172, "Install {0}. {1}", item.displayName, state.message)) : ( localize(10173, "{0} {1}", install.label, item.displayName)));
+        install.element.setAttribute("aria-busy", String(isInstallActionBusy(state) && !cancellable));
+        this.browseDisposables.add(install.onDidClick(
+            () => cancellable ? this.installService.cancelConnectorOperation(item) : setupUrl ? void this.openExternal(setupUrl) : void this.install(item)
+        ));
+        const actionError = getInstallActionError(state, installError);
+        if (actionError) {
+            this.browseDisposables.add(this.hoverService.setupDelayedHover(install.element, {
+                content: actionError
+            }));
+        }
+    }
+    async install(resource) {
+        const resourceKey = getCustomizationMarketplaceResourceKey(resource);
+        if (( this.pendingInstalls.has(resourceKey)) || this.installService.getInstallState(resource).kind !== "available") {
+            return;
+        }
+        const connector = isCopilotConnectorResource(resource);
+        const query = this.query;
+        const sourceId = this.selectedSourceId;
+        this.pendingInstalls.add(resourceKey);
+        this.installErrors.delete(resourceKey);
+        status(connector ? ( localize(10217, "Connecting {0}.", resource.displayName)) : ( localize(10218, "Installing {0}.", resource.displayName)));
+        this.render();
+        try {
+            await this.installService.install(resource);
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (this.installService.getInstallState(resource).kind === "installed") {
+                status(connector ? ( localize(10219, "Connected {0}.", resource.displayName)) : ( localize(10220, "Installed {0}.", resource.displayName)));
+            }
+        } catch (error) {
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (isCancellationError(error)) {
+                status(connector ? ( localize(10221, "Connection cancelled for {0}.", resource.displayName)) : ( localize(10222, "Installation cancelled for {0}.", resource.displayName)));
+            } else {
+                const message = connector ? ( localize(
+                    10223,
+                    "Could not connect {0}. {1}",
+                    resource.displayName,
+                    getErrorMessage(error)
+                )) : ( localize(
+                    10224,
+                    "Could not install {0}. {1}",
+                    resource.displayName,
+                    getErrorMessage(error)
+                ));
+                const currentContext = this.query === query && this.selectedSourceId === sourceId;
+                if (currentContext) {
+                    this.installErrors.set(resourceKey, message);
+                }
+                if (this.visible && currentContext) {
+                    alert(message);
+                    void this.accessibilitySignalService.playSignal(AccessibilitySignal.taskFailed, {
+                        modality: "sound"
+                    }).catch(onUnexpectedError);
+                } else {
+                    this.notificationService.error(message);
+                }
+            }
+        } finally {
+            this.pendingInstalls.delete(resourceKey);
+            if (!this._store.isDisposed) {
+                this.refreshInstalledItems();
+                this.render();
+            }
+        }
+    }
+    async repair(resource) {
+        const resourceKey = getCustomizationMarketplaceResourceKey(resource);
+        if (this.installService.getInstallState(resource).kind !== "missing") {
+            return;
+        }
+        const connector = isCopilotConnectorResource(resource);
+        this.installErrors.delete(resourceKey);
+        status(connector ? ( localize(10225, "Reconnecting {0}.", resource.displayName)) : ( localize(10226, "Repairing {0}.", resource.displayName)));
+        this.render();
+        try {
+            await this.installService.repair(resource);
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (this.installService.getInstallState(resource).kind === "installed") {
+                status(connector ? ( localize(10227, "Reconnected {0}.", resource.displayName)) : ( localize(10228, "Repaired {0}.", resource.displayName)));
+            }
+        } catch (error) {
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (isCancellationError(error)) {
+                status(connector ? ( localize(10229, "Reconnection cancelled for {0}.", resource.displayName)) : ( localize(10230, "Repair cancelled for {0}.", resource.displayName)));
+            } else {
+                const message = connector ? ( localize(
+                    10231,
+                    "Could not reconnect {0}. {1}",
+                    resource.displayName,
+                    getErrorMessage(error)
+                )) : ( localize(
+                    10232,
+                    "Could not repair {0}. {1}",
+                    resource.displayName,
+                    getErrorMessage(error)
+                ));
+                this.installErrors.set(resourceKey, message);
+                if (this.visible) {
+                    alert(message);
+                    void this.accessibilitySignalService.playSignal(AccessibilitySignal.taskFailed, {
+                        modality: "sound"
+                    }).catch(onUnexpectedError);
+                } else {
+                    this.notificationService.error(message);
+                }
+            }
+        } finally {
+            if (!this._store.isDisposed) {
+                this.refreshInstalledItems();
+                this.render();
+            }
+        }
+    }
+    async uninstall(item) {
+        if (!item.catalogResource) {
+            if (( this.pendingDirectUninstalls.has(item.id))) {
+                return;
+            }
+            this.pendingDirectUninstalls.add(item.id);
+            this.render();
+            try {
+                if (item.type === "plugin" && item.uri) {
+                    const plugin = this.pluginService.plugins.get().find(plugin => isEqual(plugin.uri, item.uri));
+                    if (plugin?.remove) {
+                        await plugin.remove();
+                    }
+                } else if (item.type === "mcp" && item.mcpServerId) {
+                    const server = this.mcpWorkbenchService.local.find(server => server.id === item.mcpServerId);
+                    if (server) {
+                        await this.mcpWorkbenchService.uninstall(server);
+                    }
+                } else if (item.uri && item.promptType && item.source) {
+                    await this.commandService.executeCommand(DELETE_AI_CUSTOMIZATION_ID, {
+                        uri: item.uri,
+                        name: item.name,
+                        promptType: item.promptType,
+                        storage: item.source,
+                        itemId: item.itemId
+                    });
+                }
+            } catch (error) {
+                if (this._store.isDisposed) {
+                    return;
+                }
+                const message = ( localize(10233, "Could not uninstall {0}. {1}", item.name, getErrorMessage(error)));
+                if (this.visible) {
+                    alert(message);
+                    void this.accessibilitySignalService.playSignal(AccessibilitySignal.taskFailed, {
+                        modality: "sound"
+                    }).catch(onUnexpectedError);
+                } else {
+                    this.notificationService.error(message);
+                }
+            } finally {
+                this.pendingDirectUninstalls.delete(item.id);
+                if (!this._store.isDisposed) {
+                    this.refreshInstalledItems();
+                }
+            }
+            return;
+        }
+        await this.uninstallMarketplaceResource(item.catalogResource);
+    }
+    async uninstallMarketplaceResource(resource) {
+        const connector = isCopilotConnectorResource(resource);
+        const resourceKey = getCustomizationMarketplaceResourceKey(resource);
+        const state = this.installService.getInstallState(resource);
+        if (( this.pendingUninstalls.has(resourceKey)) || state.kind !== "installed" && state.kind !== "missing") {
+            return;
+        }
+        const query = this.query;
+        const sourceId = this.selectedSourceId;
+        this.pendingUninstalls.add(resourceKey);
+        this.installErrors.delete(resourceKey);
+        status(connector ? ( localize(10234, "Disconnecting {0}.", resource.displayName)) : ( localize(10235, "Uninstalling {0}.", resource.displayName)));
+        this.render();
+        try {
+            await this.installService.uninstall(resource);
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (this.installService.getInstallState(resource).kind === "available") {
+                status(connector ? ( localize(10236, "Disconnected {0}.", resource.displayName)) : ( localize(10237, "Uninstalled {0}.", resource.displayName)));
+            }
+        } catch (error) {
+            if (this._store.isDisposed) {
+                return;
+            }
+            if (isCancellationError(error)) {
+                status(connector ? ( localize(10238, "Disconnection cancelled for {0}.", resource.displayName)) : ( localize(10239, "Uninstallation cancelled for {0}.", resource.displayName)));
+            } else {
+                const message = connector ? ( localize(
+                    10240,
+                    "Could not disconnect {0}. {1}",
+                    resource.displayName,
+                    getErrorMessage(error)
+                )) : ( localize(
+                    10233,
+                    "Could not uninstall {0}. {1}",
+                    resource.displayName,
+                    getErrorMessage(error)
+                ));
+                const currentContext = this.query === query && this.selectedSourceId === sourceId;
+                if (currentContext) {
+                    this.installErrors.set(resourceKey, message);
+                }
+                if (this.visible && currentContext) {
+                    alert(message);
+                    void this.accessibilitySignalService.playSignal(AccessibilitySignal.taskFailed, {
+                        modality: "sound"
+                    }).catch(onUnexpectedError);
+                } else {
+                    this.notificationService.error(message);
+                }
+            }
+        } finally {
+            this.pendingUninstalls.delete(resourceKey);
+            if (!this._store.isDisposed) {
+                this.refreshInstalledItems();
+                this.render();
+            }
+        }
+    }
+    getInstallState(resource) {
+        const state = this.installService.getInstallState(resource);
+        const resourceKey = getCustomizationMarketplaceResourceKey(resource);
+        if (( this.pendingInstalls.has(resourceKey)) && state.kind === "available") {
+            return {
+                kind: "installing"
+            };
+        }
+        return ( this.pendingUninstalls.has(resourceKey)) && (state.kind === "installed" || state.kind === "missing") ? {
+            kind: "uninstalling",
+            target: state.target
+        } : state;
+    }
+    openMarketplaceItem(resource, mode) {
+        this.callbacks.openMarketplaceItem(resource, {
+            resourceKey: getCustomizationMarketplaceResourceKey(resource),
+            mode
+        });
+    }
+    openCatalogItem(resource, mode) {
+        const type = getCatalogType(resource);
+        const state = this.getInstallState(resource);
+        if (type && state.kind === "installed" && this.callbacks.openInstalled) {
+            this.callbacks.openInstalled({
+                section: getSectionForCatalogType(type),
+                name: resource.displayName,
+                uri: state.target.kind === "skill" || state.target.kind === "plugin" ? state.target.uri : undefined,
+                mcpServerId: state.target.kind === "mcp" ? state.target.id : undefined,
+                mcpConnectorName: state.target.kind === "copilotConnector" ? state.target.name : undefined
+            });
+            return;
+        }
+        this.openMarketplaceItem(resource, mode);
+    }
+    openInstalledItem(item) {
+        this.callbacks.openInstalled?.({
+            section: item.section,
+            name: item.name,
+            uri: item.uri,
+            mcpServerId: item.mcpServerId,
+            mcpConnectorName: item.mcpConnectorName,
+            promptDetail: item.promptDetail,
+            pluginDetail: item.pluginDetail,
+            mcpDetail: item.mcpDetail
+        });
+    }
+    async openExternal(resource) {
+        try {
+            await this.openerService.open(resource, {
+                openExternal: true,
+                allowCommands: false,
+                allowContributedOpeners: false
+            });
+        } catch (error) {
+            this.notificationService.error(( localize(
+                10241,
+                "Could not open the customization resource. {0}",
+                getErrorMessage(error)
+            )));
+        }
+    }
+    updateSearchAriaLabel() {
+        const keybinding = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp")?.getAriaLabel();
+        const label = this.configurationService.getValue(AccessibilityVerbositySettingId.CustomizationDiscovery) && keybinding ? ( localize(
+            10242,
+            "Search customizations. Use {0} for accessibility help.",
+            keybinding
+        )) : ( localize(10177, "Search customizations"));
+        this.searchWidget.updateAriaLabel(label);
+    }
+    announce(message) {
+        if (this.visible && message !== this.lastAnnouncement) {
+            this.lastAnnouncement = message;
+            status(message);
+        }
+    }
+    getEntryAriaLabel(entry) {
+        if (entry.kind === "loading") {
+            return this.getLoadingLabel();
+        }
+        if (entry.kind === "installed") {
+            const state = entry.catalogResource ? this.getInstallState(entry.catalogResource) : undefined;
+            const stateLabel = state ? getInstallationStateLabel(state, isCopilotConnectorResource(entry.catalogResource)) : ( localize(10140, "Installed"));
+            const stateDetail = state?.kind === "error" ? ( localize(10243, ", {0}", state.message)) : "";
+            return localize(
+                10244,
+                "{0}, {1}, {2}{3}{4}. {5}",
+                entry.name,
+                getTypeLabel(entry.type),
+                `${stateLabel}${stateDetail}`,
+                entry.sourceLabel ? ( localize(10245, ", source {0}", entry.sourceLabel)) : "",
+                entry.disabled ? ( localize(10246, ", disabled")) : "",
+                entry.description
+            );
+        }
+        const type = getCatalogType(entry.resource);
+        const state = this.getInstallState(entry.resource);
+        return localize(
+            10247,
+            "{0}, {1}, source {2}. {3}. {4}",
+            entry.resource.displayName,
+            type ? getTypeLabel(type) : entry.resource.mediaType,
+            this.getMarketplaceResourceLabel(entry.resource),
+            entry.resource.description,
+            state.kind
+        );
+    }
+    rebuildCards(visibleSectionIds) {
+        this.visibleSectionIds = ( new Set(visibleSectionIds));
+        this.refreshInstalledItems();
+    }
+    setHarnessLabel(_label) {
+        this.refreshInstalledItems();
+    }
+    setVisible(visible) {
+        if (this.visible === visible) {
+            return;
+        }
+        this.visible = visible;
+        if (!visible) {
+            this.cancelCatalogRequest();
+            this.render(true);
+            return;
+        }
+        if (this.shouldQueryCatalog() && (this.pendingRecoveryReload || !this.loaded)) {
+            this.pendingRecoveryReload = false;
+            void this.loadCatalog(false);
+        } else {
+            this.render();
+        }
+        this.render();
+        if (this.lastDimension) {
+            getWindow(this.container).requestAnimationFrame(() => this.layout(this.lastDimension));
+        }
+    }
+    focus() {
+        this.searchWidget.focus();
+    }
+    reset() {
+        this.focus();
+    }
+    resetFilters() {
+        if (this.query.isEmpty() && this.selectedSourceId === undefined) {
+            this.focus();
+            return;
+        }
+        this.selectedSourceId = undefined;
+        this.updateSourceButton();
+        this.setQuery(CustomizationDiscoveryQuery.parse(""));
+    }
+    setSearchQuery(value) {
+        this.setQuery(CustomizationDiscoveryQuery.parse(value));
+    }
+    showMarketplace(query, sourceId) {
+        this.selectedSourceId = sourceId;
+        this.updateSourceButton();
+        this.setQuery(CustomizationDiscoveryQuery.parse(query));
+    }
+    layout(dimension) {
+        if (dimension) {
+            this.lastDimension = dimension;
+        }
+        if (!this.lastDimension || this.container.offsetParent === null) {
+            return;
+        }
+        const width = this.container.clientWidth || this.lastDimension.width;
+        const height = this.container.clientHeight || this.lastDimension.height;
+        this.container.classList.toggle("narrow", width < 800);
+        const searchContainer = this.searchWidget.element;
+        const searchActionsWidth = this.searchActionsContainer.offsetWidth;
+        this.searchWidget.layout(new Dimension(
+            Math.max(0, searchContainer.clientWidth - searchActionsWidth - 4),
+            searchInputHeight
+        ));
+        const availableHeight = Math.max(0, height - this.header.offsetHeight);
+        this.resultListContainer.style.height = `${availableHeight}px`;
+        const statusHeight = this.resultStatus.offsetHeight;
+        this.resultList.layout(
+            Math.max(0, availableHeight - statusHeight),
+            this.resultListContainer.clientWidth
+        );
+        this.browseScrollable.scanDomNode();
+        this.scheduleContinuationIfNeeded();
+    }
+    getAccessibilityContent() {
+        const searchResources = this.getSearchMarketplaceResources();
+        const marketplaceInstallations = this.installService.installations.get();
+        const recorded = searchResources.map(resource => ({
+            resource,
+            state: this.getInstallState(resource)
+        })).filter(entry => hasInstallationTarget(entry.state));
+        const recordedInstallations = ( new Set(recorded.flatMap((
+            {
+                resource
+            }
+        ) => {
+            const installation = marketplaceInstallations.findByResource(resource);
+            return installation ? [installation] : [];
+        })));
+        const installed = this.getFilteredInstalledItems().filter(item => {
+            const marketplace = getInstalledItemMarketplaceRecord(item, marketplaceInstallations);
+            return !marketplace || !( recordedInstallations.has(marketplace));
+        });
+        const available = searchResources.filter(item => {
+            const type = getCatalogType(item);
+            return type && this.matchesType(type) && !hasInstallationTarget(this.getInstallState(item));
+        });
+        return [( localize(10174, "Discover customizations")), this.query.isEmpty() ? ( localize(10248, "Browse mode.")) : ( localize(10249, "Search: {0}", (this.query.toString()))), this.selectedSourceId ? ( localize(
+            10250,
+            "Source: {0}",
+            this.getMarketplaceSourceLabel(this.selectedSourceId)
+        )) : ( localize(10251, "Source: All Sources")), this.loading ? this.getLoadingLabel() : undefined, this.errorMessage, this.sourceWarnings.getAccessibilityContent(), ...installed.map(
+            item => `${item.name}\n${[getTypeLabel(item.type), item.sourceLabel, ( localize(10140, "Installed"))].filter(Boolean).join(" · ")}\n${item.description}`
+        ), ...recorded.map((
+            {
+                resource,
+                state
+            }
+        ) => `${resource.displayName}\n${[
+    getTypeLabel(getCatalogType(resource) ?? "plugin"),
+    this.getMarketplaceSourceLabel(resource.sourceId),
+    getInstallationStateLabel(state, isCopilotConnectorResource(resource))
+].join(" · ")}\n${resource.description}${state.kind === "error" ? `\n${state.message}` : state.kind === "missing" && state.repairUnavailableMessage ? `\n${state.repairUnavailableMessage}` : ""}`), ...available.map(item => {
+            const state = this.getInstallState(item);
+            return `${item.displayName}\n${getTypeLabel(getCatalogType(item) ?? "plugin")} · ${this.getMarketplaceResourceLabel(item)}\n${item.description}${state.kind === "unavailable" && state.setupUrl ? `\n${( localize(
+                10252,
+                "Manual setup required. View Setup opens the publisher's instructions."
+            ))}` : ""}`;
+        })].filter(Boolean).join("\n\n");
+    }
+    restoreMarketplaceItemFocus(origin) {
+        if (origin.mode === "browse") {
+            const action = this.browsePrimaryActions.get(origin.resourceKey);
+            if (action) {
+                action.focus();
+                return;
+            }
+        } else {
+            let index = -1;
+            for (let candidateIndex = 0; candidateIndex < this.resultList.length; candidateIndex++) {
+                const candidate = this.resultList.element(candidateIndex);
+                if (candidate.kind === "loading") {
+                    continue;
+                }
+                const resource = candidate.kind === "available" ? candidate.resource : candidate.catalogResource;
+                if (resource && getCustomizationMarketplaceResourceKey(resource) === origin.resourceKey) {
+                    index = candidateIndex;
+                    break;
+                }
+            }
+            if (index >= 0) {
+                this.resultList.reveal(index);
+                this.resultList.setFocus([index]);
+                this.resultList.setSelection([index]);
+                this.resultList.domFocus();
+                return;
+            }
+        }
+        this.focus();
+    }
+    dispose() {
+        this.cancelCatalogRequest();
+        this.progressBar.stop().hide();
+        super.dispose();
+    }
+};
+AICustomizationDiscoveryPage = ( __decorate([( __param(4, IInstantiationService)), ( __param(5, IContextMenuService)), ( __param(6, IHoverService)), ( __param(7, IOpenerService)), ( __param(8, INotificationService)), ( __param(9, IConfigurationService)), ( __param(10, ICommandService)), ( __param(11, IKeybindingService)), ( __param(12, IChatEntitlementService)), ( __param(13, ICustomizationMarketplaceService)), ( __param(14, ICustomizationMarketplaceInstallService)), ( __param(15, IAICustomizationItemsModel)), ( __param(16, IAgentPluginService)), ( __param(17, IMcpWorkbenchService)), ( __param(18, IAICustomizationWorkspaceService)), ( __param(19, IAccessibilitySignalService)), ( __param(20, IThemeService))], AICustomizationDiscoveryPage));
+
+export { AICustomizationDiscoveryPage };