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

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginsView.js

@@ -0,0 +1,634 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { getDomNodePagePosition, append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Action, Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { disposeIfDisposable, DisposableStore, MutableDisposable, isDisposable, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { PagedModel } from '@codingame/monaco-vscode-api/vscode/vs/base/common/paging';
+import { dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { WorkbenchPagedList } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { getLocationBasedViewColors } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewPane';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { MODAL_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { VIEW_CONTAINER } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensions.contribution';
+import { manageExtensionIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionsIcons';
+import { AbstractExtensionsListView } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionsViews';
+import { extensionsFilterSubMenu, DefaultViewsContext, SearchAgentPluginsContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions';
+import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { IPluginInstallService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginInstallService.service';
+import { IPluginMarketplaceService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service';
+import { AgentPluginEditorInput } from './agentPluginEditor/agentPluginEditorInput.js';
+import { AgentPluginItemKind } from './agentPluginEditor/agentPluginItems.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var InstallPluginAction_1, EnablePluginAction_1, DisablePluginAction_1, OpenPluginFolderAction_1, OpenPluginReadmeAction_1, ManagePluginAction_1, AgentPluginRenderer_1;
+const HasInstalledAgentPluginsContext = ( new RawContextKey("hasInstalledAgentPlugins", false));
+const InstalledAgentPluginsViewId = "workbench.views.agentPlugins.installed";
+function installedPluginToItem(plugin, labelService) {
+    const name = plugin.label;
+    const description = plugin.fromMarketplace?.description ?? labelService.getUriLabel(dirname(plugin.uri), {
+        relative: true
+    });
+    const marketplace = plugin.fromMarketplace?.marketplace;
+    return {
+        kind: AgentPluginItemKind.Installed,
+        name,
+        description,
+        marketplace,
+        plugin
+    };
+}
+function marketplacePluginToItem(plugin) {
+    return {
+        kind: AgentPluginItemKind.Marketplace,
+        name: plugin.name,
+        description: plugin.description,
+        source: plugin.source,
+        sourceDescriptor: plugin.sourceDescriptor,
+        marketplace: plugin.marketplace,
+        marketplaceReference: plugin.marketplaceReference,
+        marketplaceType: plugin.marketplaceType,
+        readmeUri: plugin.readmeUri
+    };
+}
+let InstallPluginAction = class InstallPluginAction extends Action {
+    static {
+        InstallPluginAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.install";
+    }
+    constructor(item, pluginInstallService) {
+        super(InstallPluginAction_1.ID, ( localize(5024, "Install")), "extension-action label prominent install");
+        this.item = item;
+        this.pluginInstallService = pluginInstallService;
+    }
+    async run() {
+        await this.pluginInstallService.installPlugin({
+            name: this.item.name,
+            description: this.item.description,
+            version: "",
+            source: this.item.source,
+            sourceDescriptor: this.item.sourceDescriptor,
+            marketplace: this.item.marketplace,
+            marketplaceReference: this.item.marketplaceReference,
+            marketplaceType: this.item.marketplaceType,
+            readmeUri: this.item.readmeUri
+        });
+    }
+};
+InstallPluginAction = InstallPluginAction_1 = ( __decorate([( __param(1, IPluginInstallService))], InstallPluginAction));
+let EnablePluginAction = class EnablePluginAction extends Action {
+    static {
+        EnablePluginAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.enable";
+    }
+    constructor(plugin, agentPluginService) {
+        super(EnablePluginAction_1.ID, ( localize(5025, "Enable")));
+        this.plugin = plugin;
+        this.agentPluginService = agentPluginService;
+    }
+    async run() {
+        this.agentPluginService.setPluginEnabled(this.plugin.uri, true);
+    }
+};
+EnablePluginAction = EnablePluginAction_1 = ( __decorate([( __param(1, IAgentPluginService))], EnablePluginAction));
+let DisablePluginAction = class DisablePluginAction extends Action {
+    static {
+        DisablePluginAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.disable";
+    }
+    constructor(plugin, agentPluginService) {
+        super(DisablePluginAction_1.ID, ( localize(5026, "Disable")));
+        this.plugin = plugin;
+        this.agentPluginService = agentPluginService;
+    }
+    async run() {
+        this.agentPluginService.setPluginEnabled(this.plugin.uri, false);
+    }
+};
+DisablePluginAction = DisablePluginAction_1 = ( __decorate([( __param(1, IAgentPluginService))], DisablePluginAction));
+class UninstallPluginAction extends Action {
+    static {
+        this.ID = "agentPlugin.uninstall";
+    }
+    constructor(plugin) {
+        super(UninstallPluginAction.ID, ( localize(5027, "Uninstall")));
+        this.plugin = plugin;
+    }
+    async run() {
+        this.plugin.remove();
+    }
+}
+let OpenPluginFolderAction = class OpenPluginFolderAction extends Action {
+    static {
+        OpenPluginFolderAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.openFolder";
+    }
+    constructor(plugin, commandService, openerService) {
+        super(OpenPluginFolderAction_1.ID, ( localize(5028, "Open Plugin Folder")));
+        this.plugin = plugin;
+        this.commandService = commandService;
+        this.openerService = openerService;
+    }
+    async run() {
+        try {
+            await this.commandService.executeCommand("revealFileInOS", this.plugin.uri);
+        } catch {
+            await this.openerService.open(dirname(this.plugin.uri));
+        }
+    }
+};
+OpenPluginFolderAction = OpenPluginFolderAction_1 = ( __decorate([( __param(1, ICommandService)), ( __param(2, IOpenerService))], OpenPluginFolderAction));
+let OpenPluginReadmeAction = class OpenPluginReadmeAction extends Action {
+    static {
+        OpenPluginReadmeAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.openReadme";
+    }
+    constructor(readmeUri, openerService) {
+        super(OpenPluginReadmeAction_1.ID, ( localize(5029, "Open README")));
+        this.readmeUri = readmeUri;
+        this.openerService = openerService;
+    }
+    async run() {
+        await this.openerService.open(this.readmeUri);
+    }
+};
+OpenPluginReadmeAction = OpenPluginReadmeAction_1 = ( __decorate([( __param(1, IOpenerService))], OpenPluginReadmeAction));
+function getInstalledPluginContextMenuActionGroups(plugin, instantiationService) {
+    const groups = [];
+    if (plugin.enabled.get()) {
+        groups.push([instantiationService.createInstance(DisablePluginAction, plugin)]);
+    } else {
+        groups.push([instantiationService.createInstance(EnablePluginAction, plugin)]);
+    }
+    groups.push([
+        instantiationService.createInstance(OpenPluginFolderAction, plugin),
+        instantiationService.createInstance(OpenPluginReadmeAction, joinPath(plugin.uri, "README.md"))
+    ]);
+    groups.push([instantiationService.createInstance(UninstallPluginAction, plugin)]);
+    return groups;
+}
+let ManagePluginAction = class ManagePluginAction extends Action {
+    static {
+        ManagePluginAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.manage";
+    }
+    static {
+        this.CLASS = `extension-action icon manage ${ThemeIcon.asClassName(manageExtensionIcon)}`;
+    }
+    constructor(getActionGroups, instantiationService) {
+        super(ManagePluginAction_1.ID, "", ManagePluginAction_1.CLASS, true);
+        this.getActionGroups = getActionGroups;
+        this.instantiationService = instantiationService;
+        this._actionViewItem = null;
+        this.tooltip = ( localize(5030, "Manage"));
+    }
+    createActionViewItem(options) {
+        this._actionViewItem = this.instantiationService.createInstance(DropDownActionViewItem, this, options);
+        return this._actionViewItem;
+    }
+    async run() {
+        this._actionViewItem?.showMenu(this.getActionGroups());
+    }
+};
+ManagePluginAction = ManagePluginAction_1 = ( __decorate([( __param(1, IInstantiationService))], ManagePluginAction));
+let DropDownActionViewItem = class DropDownActionViewItem extends ActionViewItem {
+    constructor(action, options, contextMenuService) {
+        super(null, action, {
+            ...options,
+            icon: true,
+            label: false
+        });
+        this.contextMenuService = contextMenuService;
+    }
+    showMenu(actionGroups) {
+        if (!this.element) {
+            return;
+        }
+        const actions = actionGroups.flatMap(group => [...group, ( new Separator())]);
+        if (actions.length > 0) {
+            actions.pop();
+        }
+        const {
+            left,
+            top,
+            height
+        } = getDomNodePagePosition(this.element);
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => ({
+                x: left,
+                y: top + height + 10
+            }),
+            getActions: () => actions,
+            onHide: () => disposeIfDisposable(actions)
+        });
+    }
+};
+DropDownActionViewItem = ( __decorate([( __param(2, IContextMenuService))], DropDownActionViewItem));
+let AgentPluginRenderer = class AgentPluginRenderer {
+    static {
+        AgentPluginRenderer_1 = this;
+    }
+    static {
+        this.templateId = "agentPlugin";
+    }
+    constructor(instantiationService) {
+        this.instantiationService = instantiationService;
+        this.templateId = AgentPluginRenderer_1.templateId;
+    }
+    renderTemplate(root) {
+        const element = append(root, $(".agent-plugin-item.extension-list-item"));
+        const details = append(element, $(".details"));
+        const headerContainer = append(details, $(".header-container"));
+        const header = append(headerContainer, $(".header"));
+        const name = append(header, $("span.name"));
+        const description = append(details, $(".description.ellipsis"));
+        const footer = append(details, $(".footer"));
+        const detailContainer = append(footer, $(".publisher-container"));
+        const detail = append(detailContainer, $("span.publisher-name"));
+        const actionbar = ( new ActionBar(footer, {
+            focusOnlyEnabledItems: true,
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof ManagePluginAction) {
+                    return action.createActionViewItem(options);
+                }
+                return undefined;
+            }
+        }));
+        actionbar.setFocusable(false);
+        return {
+            root,
+            name,
+            description,
+            detail,
+            actionbar,
+            disposables: [actionbar],
+            elementDisposables: []
+        };
+    }
+    renderPlaceholder(_index, data) {
+        data.name.textContent = "";
+        data.description.textContent = "";
+        data.detail.textContent = "";
+        data.actionbar.clear();
+        this.disposeElement(undefined, 0, data);
+    }
+    renderElement(element, _index, data) {
+        this.disposeElement(undefined, 0, data);
+        data.name.textContent = element.name;
+        data.description.textContent = element.description;
+        data.elementDisposables.push(autorun(reader => {
+            data.root.classList.toggle(
+                "disabled",
+                element.kind === AgentPluginItemKind.Installed && !element.plugin.enabled.read(reader)
+            );
+        }));
+        data.actionbar.clear();
+        if (element.kind === AgentPluginItemKind.Marketplace) {
+            data.detail.textContent = element.marketplace;
+            const installAction = this.instantiationService.createInstance(InstallPluginAction, element);
+            data.elementDisposables.push(installAction);
+            data.actionbar.push([installAction], {
+                icon: true,
+                label: true
+            });
+        } else {
+            data.detail.textContent = element.marketplace ?? "";
+            const manageAction = this.instantiationService.createInstance(
+                ManagePluginAction,
+                () => getInstalledPluginContextMenuActionGroups(element.plugin, this.instantiationService)
+            );
+            data.elementDisposables.push(manageAction);
+            data.actionbar.push([manageAction], {
+                icon: true,
+                label: false
+            });
+        }
+    }
+    disposeElement(_element, _index, data) {
+        for (const d of data.elementDisposables) {
+            d.dispose();
+        }
+        data.elementDisposables = [];
+    }
+    disposeTemplate(data) {
+        for (const d of data.disposables) {
+            d.dispose();
+        }
+        this.disposeElement(undefined, 0, data);
+    }
+};
+AgentPluginRenderer = AgentPluginRenderer_1 = ( __decorate([( __param(0, IInstantiationService))], AgentPluginRenderer));
+let AgentPluginsListView = class AgentPluginsListView extends AbstractExtensionsListView {
+    constructor(
+        listOptions,
+        options,
+        keybindingService,
+        contextMenuService,
+        instantiationService,
+        themeService,
+        hoverService,
+        configurationService,
+        contextKeyService,
+        viewDescriptorService,
+        openerService,
+        agentPluginService,
+        pluginMarketplaceService,
+        pluginInstallService,
+        labelService,
+        editorService
+    ) {
+        super(
+            options,
+            keybindingService,
+            contextMenuService,
+            configurationService,
+            contextKeyService,
+            viewDescriptorService,
+            instantiationService,
+            openerService,
+            themeService,
+            hoverService
+        );
+        this.listOptions = listOptions;
+        this.agentPluginService = agentPluginService;
+        this.pluginMarketplaceService = pluginMarketplaceService;
+        this.pluginInstallService = pluginInstallService;
+        this.labelService = labelService;
+        this.editorService = editorService;
+        this.actionStore = this._register(( new DisposableStore()));
+        this.queryCts = ( new MutableDisposable());
+        this.list = null;
+        this.listContainer = null;
+        this.currentQuery = "@agentPlugins";
+        this.refreshOnPluginsChangedScheduler = this._register(( new RunOnceScheduler(() => {
+            if (this.list) {
+                void this.show(this.currentQuery);
+            }
+        }, 0)));
+        this._register(autorun(reader => {
+            this.agentPluginService.plugins.read(reader);
+            if (this.list && this.isBodyVisible()) {
+                this.refreshOnPluginsChangedScheduler.schedule();
+            }
+        }));
+        this._register(this.pluginMarketplaceService.onDidChangeMarketplaces(() => {
+            if (this.list && this.isBodyVisible()) {
+                this.refreshOnPluginsChangedScheduler.schedule();
+            }
+        }));
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        const messageContainer = append(container, $(".message-container"));
+        const messageBox = append(messageContainer, $(".message"));
+        const pluginsList = $(".agent-plugins-list");
+        this.bodyTemplate = {
+            pluginsList,
+            messageBox,
+            messageContainer
+        };
+        this.listContainer = append(container, pluginsList);
+        this.list = this._register(
+            this.instantiationService.createInstance(WorkbenchPagedList, `${this.id}-Agent-Plugins`, this.listContainer, {
+                getHeight() {
+                    return 72;
+                },
+                getTemplateId: () => AgentPluginRenderer.templateId
+            }, [this.instantiationService.createInstance(AgentPluginRenderer)], {
+                multipleSelectionSupport: false,
+                setRowLineHeight: false,
+                horizontalScrolling: false,
+                accessibilityProvider: {
+                    getAriaLabel(item) {
+                        return item?.name ?? "";
+                    },
+                    getWidgetAriaLabel() {
+                        return localize(5031, "Agent Plugins");
+                    }
+                },
+                overrideStyles: getLocationBasedViewColors(this.viewDescriptorService.getViewLocationById(this.id)).listOverrideStyles
+            })
+        );
+        this._register(this.list.onContextMenu(e => this.onContextMenu(e), this));
+        this._register(Event.debounce(
+            Event.filter(this.list.onDidOpen, e => e.element !== null),
+            (_, event) => event,
+            75,
+            true
+        )(options => {
+            this.editorService.openEditor(
+                this.instantiationService.createInstance(AgentPluginEditorInput, options.element),
+                options.editorOptions,
+                MODAL_GROUP
+            );
+        }));
+    }
+    onContextMenu(e) {
+        if (!e.element) {
+            return;
+        }
+        const actions = this.getContextMenuActions(e.element);
+        if (actions.length === 0) {
+            return;
+        }
+        this.contextMenuService.showContextMenu({
+            getAnchor: () => e.anchor,
+            getActions: () => actions
+        });
+    }
+    getContextMenuActions(item) {
+        let actions;
+        if (item.kind === AgentPluginItemKind.Installed) {
+            const groups = getInstalledPluginContextMenuActionGroups(item.plugin, this.instantiationService);
+            actions = groups.flatMap(group => [...group, ( new Separator())]);
+            if (actions.length > 0) {
+                actions.pop();
+            }
+        } else {
+            actions = [];
+            if (item.readmeUri) {
+                actions.push(
+                    this.instantiationService.createInstance(OpenPluginReadmeAction, item.readmeUri)
+                );
+            }
+            actions.push(this.instantiationService.createInstance(InstallPluginAction, item));
+        }
+        this.actionStore.clear();
+        for (const action of actions) {
+            if (isDisposable(action)) {
+                this.actionStore.add(action);
+            }
+        }
+        return actions;
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this.list?.layout(height, width);
+    }
+    async show(query) {
+        this.currentQuery = query;
+        const text = query.replace(/@agentPlugins/i, "").trim().toLowerCase();
+        let installed = this.queryInstalled();
+        if (text) {
+            installed = installed.filter(
+                p => p.name.toLowerCase().includes(text) || p.description.toLowerCase().includes(text)
+            );
+        }
+        let items = installed;
+        if (!this.listOptions.installedOnly) {
+            const marketplace = await this.queryMarketplace(text);
+            const installedPaths = ( new Set(( installed.map(i => ( i.plugin.uri.toString())))));
+            const filteredMarketplace = marketplace.filter(m => {
+                const expectedUri = this.pluginInstallService.getPluginInstallUri({
+                    name: m.name,
+                    description: m.description,
+                    version: "",
+                    source: m.source,
+                    sourceDescriptor: m.sourceDescriptor,
+                    marketplace: m.marketplace,
+                    marketplaceReference: m.marketplaceReference,
+                    marketplaceType: m.marketplaceType
+                });
+                return !( installedPaths.has(( expectedUri.toString())));
+            });
+            items = [...installed, ...filteredMarketplace];
+        }
+        const model = ( new PagedModel(items));
+        if (this.list) {
+            this.list.model = model;
+        }
+        this.updateBody(model.length);
+        return model;
+    }
+    queryInstalled() {
+        const allPlugins = this.agentPluginService.allPlugins.get();
+        return ( allPlugins.map(p => installedPluginToItem(p, this.labelService)));
+    }
+    async queryMarketplace(text) {
+        this.queryCts.value?.cancel();
+        const cts = ( new CancellationTokenSource());
+        this.queryCts.value = cts;
+        try {
+            const plugins = await this.pluginMarketplaceService.fetchMarketplacePlugins(cts.token);
+            const lowerText = text.toLowerCase();
+            return ( plugins.filter(
+                p => p.name.toLowerCase().includes(lowerText) || p.description.toLowerCase().includes(lowerText)
+            ).map(marketplacePluginToItem));
+        } catch {
+            return [];
+        }
+    }
+    updateBody(count) {
+        if (this.bodyTemplate) {
+            this.bodyTemplate.pluginsList.classList.toggle("hidden", count === 0);
+            this.bodyTemplate.messageContainer.classList.toggle("hidden", count > 0);
+            if (count === 0 && this.isBodyVisible()) {
+                this.bodyTemplate.messageBox.textContent = ( localize(5032, "No agent plugins found."));
+            }
+        }
+    }
+};
+AgentPluginsListView = ( __decorate([( __param(2, IKeybindingService)), ( __param(3, IContextMenuService)), ( __param(4, IInstantiationService)), ( __param(5, IThemeService)), ( __param(6, IHoverService)), ( __param(7, IConfigurationService)), ( __param(8, IContextKeyService)), ( __param(9, IViewDescriptorService)), ( __param(10, IOpenerService)), ( __param(11, IAgentPluginService)), ( __param(12, IPluginMarketplaceService)), ( __param(13, IPluginInstallService)), ( __param(14, ILabelService)), ( __param(15, IEditorService))], AgentPluginsListView));
+class AgentPluginsBrowseCommand extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.agentPlugins.browse",
+            title: ( localize2(5033, "Agent Plugins")),
+            tooltip: ( localize2(5034, "Browse Agent Plugins")),
+            icon: Codicon.search,
+            precondition: ( ChatContextKeys.Setup.hidden.negate()),
+            menu: [{
+                id: extensionsFilterSubMenu,
+                group: "1_predefined",
+                order: 2,
+                when: ( ChatContextKeys.Setup.hidden.negate())
+            }, {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("view", InstalledAgentPluginsViewId)), ( ChatContextKeys.Setup.hidden.negate()))),
+                group: "navigation"
+            }]
+        });
+    }
+    async run(accessor) {
+        accessor.get(IExtensionsWorkbenchService).openSearch("@agentPlugins ");
+    }
+}
+let AgentPluginsViewsContribution = class AgentPluginsViewsContribution extends Disposable {
+    static {
+        this.ID = "workbench.chat.agentPlugins.views.contribution";
+    }
+    constructor(contextKeyService, agentPluginService) {
+        super();
+        const hasInstalledKey = HasInstalledAgentPluginsContext.bindTo(contextKeyService);
+        this._register(autorun(reader => {
+            hasInstalledKey.set(agentPluginService.allPlugins.read(reader).length > 0);
+        }));
+        registerAction2(AgentPluginsBrowseCommand);
+        ( Registry.as(Extensions.ViewsRegistry)).registerViews([{
+            id: InstalledAgentPluginsViewId,
+            name: ( localize2(5035, "Agent Plugins - Installed")),
+            ctorDescriptor: ( new SyncDescriptor(AgentPluginsListView, [{
+                installedOnly: true
+            }])),
+            when: ( ContextKeyExpr.and(DefaultViewsContext, HasInstalledAgentPluginsContext, ( ChatContextKeys.Setup.hidden.negate()))),
+            weight: 30,
+            order: 5,
+            canToggleVisibility: true
+        }, {
+            id: "workbench.views.agentPlugins.default.marketplace",
+            name: ( localize2(5036, "Agent Plugins")),
+            ctorDescriptor: ( new SyncDescriptor(AgentPluginsListView, [{}])),
+            when: ( ContextKeyExpr.and(DefaultViewsContext, ( HasInstalledAgentPluginsContext.toNegated()), ( ChatContextKeys.Setup.hidden.negate()))),
+            weight: 30,
+            order: 5,
+            canToggleVisibility: true,
+            hideByDefault: true
+        }, {
+            id: "workbench.views.agentPlugins.marketplace",
+            name: ( localize2(5036, "Agent Plugins")),
+            ctorDescriptor: ( new SyncDescriptor(AgentPluginsListView, [{}])),
+            when: ( ContextKeyExpr.and(SearchAgentPluginsContext, ( ChatContextKeys.Setup.hidden.negate())))
+        }], VIEW_CONTAINER);
+    }
+};
+AgentPluginsViewsContribution = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, IAgentPluginService))], AgentPluginsViewsContribution));
+
+export { AgentPluginsListView, AgentPluginsViewsContribution, HasInstalledAgentPluginsContext, InstalledAgentPluginsViewId };