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

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginEditor/agentPluginEditor.d.ts

@@ -0,0 +1,58 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IWebview } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview";
+import { IWebviewService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview.service";
+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 { AgentPluginEditorInput } from "./agentPluginEditorInput.js";
+export declare class AgentPluginEditor extends EditorPane {
+    private readonly instantiationService;
+    private readonly openerService;
+    private readonly extensionService;
+    private readonly webviewService;
+    private readonly languageService;
+    private readonly fileService;
+    private readonly requestService;
+    private readonly agentPluginService;
+    private readonly pluginInstallService;
+    private readonly labelService;
+    static readonly ID: string;
+    private template;
+    private pluginReadme;
+    private initialScrollProgress;
+    private currentIdentifier;
+    private layoutParticipants;
+    private readonly contentDisposables;
+    private readonly transientDisposables;
+    private activeElement;
+    private dimension;
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, instantiationService: IInstantiationService, themeService: IThemeService, openerService: IOpenerService, storageService: IStorageService, extensionService: IExtensionService, webviewService: IWebviewService, languageService: ILanguageService, fileService: IFileService, requestService: IRequestService, agentPluginService: IAgentPluginService, pluginInstallService: IPluginInstallService, labelService: ILabelService);
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: AgentPluginEditorInput, options: undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    private render;
+    private getItemActions;
+    private installedPluginToItem;
+    private fetchReadme;
+    private openDetails;
+    private openMarkdown;
+    private renderMarkdown;
+    private renderBody;
+    private loadContents;
+    clearInput(): void;
+    focus(): void;
+    get activeWebview(): IWebview | undefined;
+    layout(dimension: Dimension): void;
+}

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

@@ -0,0 +1,537 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { append, $, addDisposableListener, EventType, reset, setParentFlowTo } 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 { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { insert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { Cache } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cache';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas, matchesScheme } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { dirname, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { TokenizationRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { generateTokensCSSForColorMap } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/supports/tokenization';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { asText } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+import { IRequestService } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { EditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { renderMarkdownDocument, DEFAULT_MARKDOWN_STYLES } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/markdown/browser/markdownDocumentRenderer';
+import { IWebviewService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview.service';
+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 { AgentPluginItemKind } from './agentPluginItems.js';
+import * as agentPluginEditor from './media/agentPluginEditor.css';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var AgentPluginEditor_1, InstallPluginEditorAction_1, EnablePluginEditorAction_1, DisablePluginEditorAction_1;
+registerCss(agentPluginEditor);
+var WebviewIndex;
+(function(WebviewIndex) {
+    WebviewIndex[WebviewIndex["Readme"] = 0] = "Readme";
+})(WebviewIndex || (WebviewIndex = {}));
+let AgentPluginEditor = class AgentPluginEditor extends EditorPane {
+    static {
+        AgentPluginEditor_1 = this;
+    }
+    static {
+        this.ID = "workbench.editor.agentPlugin";
+    }
+    constructor(
+        group,
+        telemetryService,
+        instantiationService,
+        themeService,
+        openerService,
+        storageService,
+        extensionService,
+        webviewService,
+        languageService,
+        fileService,
+        requestService,
+        agentPluginService,
+        pluginInstallService,
+        labelService
+    ) {
+        super(
+            AgentPluginEditor_1.ID,
+            group,
+            telemetryService,
+            themeService,
+            storageService
+        );
+        this.instantiationService = instantiationService;
+        this.openerService = openerService;
+        this.extensionService = extensionService;
+        this.webviewService = webviewService;
+        this.languageService = languageService;
+        this.fileService = fileService;
+        this.requestService = requestService;
+        this.agentPluginService = agentPluginService;
+        this.pluginInstallService = pluginInstallService;
+        this.labelService = labelService;
+        this.pluginReadme = null;
+        this.initialScrollProgress = ( new Map());
+        this.currentIdentifier = "";
+        this.layoutParticipants = [];
+        this.contentDisposables = this._register(( new DisposableStore()));
+        this.transientDisposables = this._register(( new DisposableStore()));
+        this.activeElement = null;
+    }
+    createEditor(parent) {
+        const root = append(parent, $(".extension-editor.agent-plugin-editor"));
+        root.tabIndex = 0;
+        root.style.outline = "none";
+        root.setAttribute("role", "document");
+        const header = append(root, $(".header"));
+        const iconContainer = append(header, $(".icon-container"));
+        const icon = append(iconContainer, $("span.codicon.codicon-extensions"));
+        icon.style.fontSize = "64px";
+        const details = append(header, $(".details"));
+        const title = append(details, $(".title"));
+        const name = append(title, $("span.name", {
+            role: "heading",
+            tabIndex: 0
+        }));
+        const description = append(details, $(".description"));
+        const subtitle = append(details, $(".subtitle"));
+        const marketplace = append(subtitle, $("span.subtitle-entry"));
+        const actionsAndStatusContainer = append(details, $(".actions-status-container"));
+        const actionBar = this._register(( new ActionBar(actionsAndStatusContainer, {
+            focusOnlyEnabledItems: true
+        })));
+        actionBar.setFocusable(true);
+        const body = append(root, $(".body"));
+        const content = append(body, $(".content"));
+        content.id = generateUuid();
+        this.template = {
+            content,
+            description,
+            header,
+            name,
+            marketplace,
+            actionBar
+        };
+    }
+    async setInput(input, options, context, token) {
+        await super.setInput(input, options, context, token);
+        if (this.template) {
+            await this.render(input.item, this.template);
+        }
+    }
+    async render(item, template) {
+        this.activeElement = null;
+        this.transientDisposables.clear();
+        this.contentDisposables.clear();
+        template.content.innerText = "";
+        const cts = ( new CancellationTokenSource());
+        this.transientDisposables.add(toDisposable(() => cts.dispose(true)));
+        const token = cts.token;
+        const itemId = item.kind === AgentPluginItemKind.Installed ? ( item.plugin.uri.toString()) : `${item.marketplaceReference.canonicalId}/${item.source}`;
+        if (this.currentIdentifier !== itemId) {
+            this.initialScrollProgress.clear();
+            this.currentIdentifier = itemId;
+        }
+        this.pluginReadme = ( new Cache(() => this.fetchReadme(item, token)));
+        template.name.textContent = item.name;
+        template.description.textContent = item.description;
+        const marketplaceLabel = item.marketplace ?? "";
+        const githubRepo = item.kind === AgentPluginItemKind.Marketplace ? item.marketplaceReference.githubRepo : item.plugin.fromMarketplace?.marketplaceReference.githubRepo;
+        if (marketplaceLabel && githubRepo) {
+            const url = `https://github.com/${githubRepo}`;
+            const link = $("a.marketplace-link", {
+                href: url
+            }, marketplaceLabel);
+            this.transientDisposables.add(addDisposableListener(link, EventType.CLICK, e => {
+                e.preventDefault();
+                e.stopPropagation();
+                this.openerService.open(( URI.parse(url)));
+            }));
+            reset(template.marketplace, link);
+        } else {
+            reset(template.marketplace, marketplaceLabel);
+        }
+        const actionDisposables = this.transientDisposables.add(( new DisposableStore()));
+        this.transientDisposables.add(autorun(reader => {
+            actionDisposables.clear();
+            template.actionBar.clear();
+            const allPlugins = this.agentPluginService.allPlugins.read(reader);
+            let currentItem = item;
+            if (item.kind === AgentPluginItemKind.Marketplace) {
+                const expectedUri = this.pluginInstallService.getPluginInstallUri({
+                    name: item.name,
+                    description: item.description,
+                    version: "",
+                    source: item.source,
+                    sourceDescriptor: item.sourceDescriptor,
+                    marketplace: item.marketplace,
+                    marketplaceReference: item.marketplaceReference,
+                    marketplaceType: item.marketplaceType
+                });
+                const installedPlugin = allPlugins.find(p => ( p.uri.toString()) === ( expectedUri.toString()));
+                if (installedPlugin) {
+                    currentItem = this.installedPluginToItem(installedPlugin);
+                }
+            } else {
+                const stillInstalled = allPlugins.find(p => ( p.uri.toString()) === ( item.plugin.uri.toString()));
+                if (!stillInstalled) {
+                    if (item.plugin.fromMarketplace) {
+                        const mp = item.plugin.fromMarketplace;
+                        currentItem = {
+                            kind: AgentPluginItemKind.Marketplace,
+                            name: item.name,
+                            description: mp.description,
+                            source: mp.source,
+                            sourceDescriptor: mp.sourceDescriptor,
+                            marketplace: mp.marketplace,
+                            marketplaceReference: mp.marketplaceReference,
+                            marketplaceType: mp.marketplaceType,
+                            readmeUri: mp.readmeUri
+                        };
+                    } else {
+                        return;
+                    }
+                } else {
+                    stillInstalled.enabled.read(reader);
+                    currentItem = this.installedPluginToItem(stillInstalled);
+                }
+            }
+            const actions = this.getItemActions(currentItem);
+            if (actions.length > 0) {
+                template.actionBar.push(actions, {
+                    icon: true,
+                    label: true
+                });
+            }
+            for (const action of actions) {
+                actionDisposables.add(action);
+            }
+        }));
+        this.activeElement = await this.openDetails(item, template, token);
+    }
+    getItemActions(item) {
+        if (item.kind === AgentPluginItemKind.Marketplace) {
+            return [this.instantiationService.createInstance(InstallPluginEditorAction, item)];
+        }
+        const actions = [];
+        if (item.plugin.enabled.get()) {
+            actions.push(
+                this.instantiationService.createInstance(DisablePluginEditorAction, item.plugin)
+            );
+        } else {
+            actions.push(
+                this.instantiationService.createInstance(EnablePluginEditorAction, item.plugin)
+            );
+        }
+        actions.push(
+            this.instantiationService.createInstance(UninstallPluginEditorAction, item.plugin)
+        );
+        return actions;
+    }
+    installedPluginToItem(plugin) {
+        const name = plugin.label;
+        const description = plugin.fromMarketplace?.description ?? this.labelService.getUriLabel(dirname(plugin.uri), {
+            relative: true
+        });
+        const marketplace = plugin.fromMarketplace?.marketplace;
+        return {
+            kind: AgentPluginItemKind.Installed,
+            name,
+            description,
+            marketplace,
+            plugin
+        };
+    }
+    async fetchReadme(item, token) {
+        let readmeUri;
+        if (item.kind === AgentPluginItemKind.Installed) {
+            readmeUri = joinPath(item.plugin.uri, "README.md");
+        } else {
+            readmeUri = item.readmeUri;
+        }
+        if (!readmeUri) {
+            return "";
+        }
+        if (readmeUri.scheme === Schemas.file || readmeUri.scheme === Schemas.vscodeRemote) {
+            try {
+                const content = await this.fileService.readFile(readmeUri);
+                return ( content.value.toString());
+            } catch {
+                return "";
+            }
+        }
+        if (readmeUri.scheme === Schemas.https) {
+            let rawUrl = ( readmeUri.toString());
+            const githubBlobMatch = rawUrl.match(
+                /^https:\/\/github\.com\/(?<owner>[^/]+)\/(?<repo>[^/]+)\/blob\/(?<rest>.+)$/
+            );
+            if (githubBlobMatch?.groups) {
+                rawUrl = `https://raw.githubusercontent.com/${githubBlobMatch.groups["owner"]}/${githubBlobMatch.groups["repo"]}/${githubBlobMatch.groups["rest"]}`;
+            }
+            try {
+                const context = await this.requestService.request({
+                    type: "GET",
+                    url: rawUrl
+                }, token);
+                const text = await asText(context);
+                return text ?? "";
+            } catch {
+                return "";
+            }
+        }
+        return "";
+    }
+    async openDetails(item, template, token) {
+        const details = append(template.content, $(".details"));
+        const readmeContainer = append(details, $(".content-container"));
+        const layout = () => details.classList.toggle("narrow", this.dimension !== undefined && this.dimension.width < 500);
+        layout();
+        this.contentDisposables.add(toDisposable(insert(this.layoutParticipants, {
+            layout
+        })));
+        return this.openMarkdown(this.pluginReadme.get(), ( localize(5011, "No README available.")), readmeContainer, WebviewIndex.Readme, ( localize(5012, "Readme")), token);
+    }
+    async openMarkdown(cacheResult, noContentCopy, container, webviewIndex, title, token) {
+        try {
+            const body = await this.renderMarkdown(cacheResult, container, token);
+            if (token.isCancellationRequested) {
+                return null;
+            }
+            const webview = this.contentDisposables.add(this.webviewService.createWebviewOverlay({
+                title,
+                options: {
+                    enableFindWidget: true,
+                    tryRestoreScrollPosition: true,
+                    disableServiceWorker: true
+                },
+                contentOptions: {},
+                extension: undefined
+            }));
+            webview.initialScrollProgress = this.initialScrollProgress.get(webviewIndex) || 0;
+            webview.claim(this, this.window, undefined);
+            setParentFlowTo(webview.container, container);
+            webview.layoutWebviewOverElement(container);
+            webview.setHtml(body);
+            webview.claim(this, this.window, undefined);
+            this.contentDisposables.add(webview.onDidFocus(() => this._onDidFocus?.fire()));
+            this.contentDisposables.add(webview.onDidScroll(
+                () => this.initialScrollProgress.set(webviewIndex, webview.initialScrollProgress)
+            ));
+            const removeLayoutParticipant = insert(this.layoutParticipants, {
+                layout: () => {
+                    webview.layoutWebviewOverElement(container);
+                }
+            });
+            this.contentDisposables.add(toDisposable(removeLayoutParticipant));
+            let isDisposed = false;
+            this.contentDisposables.add(toDisposable(() => {
+                isDisposed = true;
+            }));
+            this.contentDisposables.add(this.themeService.onDidColorThemeChange(async () => {
+                const body = await this.renderMarkdown(cacheResult, container);
+                if (!isDisposed) {
+                    webview.setHtml(body);
+                }
+            }));
+            this.contentDisposables.add(webview.onDidClickLink(link => {
+                if (!link) {
+                    return;
+                }
+                if (matchesScheme(link, Schemas.http) || matchesScheme(link, Schemas.https) || matchesScheme(link, Schemas.mailto)) {
+                    this.openerService.open(link);
+                }
+            }));
+            return webview;
+        } catch (e) {
+            const p = append(container, $("p.nocontent"));
+            p.textContent = noContentCopy;
+            return p;
+        }
+    }
+    async renderMarkdown(cacheResult, container, token) {
+        const contents = await this.loadContents(() => cacheResult, container);
+        if (token?.isCancellationRequested) {
+            return "";
+        }
+        const content = await renderMarkdownDocument(contents, this.extensionService, this.languageService, {}, token);
+        if (token?.isCancellationRequested) {
+            return "";
+        }
+        return this.renderBody(content);
+    }
+    renderBody(body) {
+        const nonce = generateUuid();
+        const colorMap = TokenizationRegistry.getColorMap();
+        const css = colorMap ? generateTokensCSSForColorMap(colorMap) : "";
+        return `<!DOCTYPE html>
+        <html>
+            <head>
+                <meta http-equiv="Content-type" content="text/html;charset=UTF-8">
+                <meta http-equiv="Content-Security-Policy" content="default-src 'none'; img-src https: data:; media-src https:; script-src 'none'; style-src 'nonce-${nonce}';">
+                <style nonce="${nonce}">
+                    ${DEFAULT_MARKDOWN_STYLES}
+
+                    body {
+                        padding-bottom: 75px;
+                    }
+
+                    #scroll-to-top {
+                        position: fixed;
+                        width: 32px;
+                        height: 32px;
+                        right: 25px;
+                        bottom: 25px;
+                        background-color: var(--vscode-button-secondaryBackground);
+                        border-color: var(--vscode-button-border);
+                        border-radius: 50%;
+                        cursor: pointer;
+                        box-shadow: 1px 1px 1px rgba(0,0,0,.25);
+                        outline: none;
+                        display: flex;
+                        justify-content: center;
+                        align-items: center;
+                    }
+
+                    #scroll-to-top:hover {
+                        background-color: var(--vscode-button-secondaryHoverBackground);
+                        box-shadow: 2px 2px 2px rgba(0,0,0,.25);
+                    }
+
+                    body.vscode-high-contrast #scroll-to-top {
+                        border-width: 2px;
+                        border-style: solid;
+                        box-shadow: none;
+                    }
+
+                    #scroll-to-top span.icon::before {
+                        content: "";
+                        display: block;
+                        background: var(--vscode-button-secondaryForeground);
+                        -webkit-mask-image: url('data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDE5LjIuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgMCkgIC0tPgo8c3ZnIHZlcnNpb249IjEuMSIgaWQ9IkxheWVyXzEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IgoJIHZpZXdCb3g9IjAgMCAxNiAxNiIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMTYgMTY7IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KCS5zdDB7ZmlsbDojRkZGRkZGO30KCS5zdDF7ZmlsbDpub25lO30KPC9zdHlsZT4KPHRpdGxlPnVwY2hldnJvbjwvdGl0bGU+CjxwYXRoIGNsYXNzPSJzdDAiIGQ9Ik04LDUuMWwtNy4zLDcuM0wwLDExLjZsOC04bDgsOGwtMC43LDAuN0w4LDUuMXoiLz4KPHJlY3QgY2xhc3M9InN0MSIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+Cjwvc3ZnPgo=');
+                        width: 16px;
+                        height: 16px;
+                    }
+                    ${css}
+                </style>
+            </head>
+            <body>
+                <a id="scroll-to-top" role="button" aria-label="scroll to top" href="#"><span class="icon"></span></a>
+                ${body}
+            </body>
+        </html>`;
+    }
+    loadContents(loadingTask, container) {
+        container.classList.add("loading");
+        const result = this.contentDisposables.add(loadingTask());
+        const onDone = () => container.classList.remove("loading");
+        result.promise.then(onDone, onDone);
+        return result.promise;
+    }
+    clearInput() {
+        this.contentDisposables.clear();
+        this.transientDisposables.clear();
+        super.clearInput();
+    }
+    focus() {
+        super.focus();
+        this.activeElement?.focus();
+    }
+    get activeWebview() {
+        if (!this.activeElement || !this.activeElement.runFindAction) {
+            return undefined;
+        }
+        return this.activeElement;
+    }
+    layout(dimension) {
+        this.dimension = dimension;
+        this.layoutParticipants.forEach(p => p.layout());
+    }
+};
+AgentPluginEditor = AgentPluginEditor_1 = ( __decorate([( __param(1, ITelemetryService)), ( __param(2, IInstantiationService)), ( __param(3, IThemeService)), ( __param(4, IOpenerService)), ( __param(5, IStorageService)), ( __param(6, IExtensionService)), ( __param(7, IWebviewService)), ( __param(8, ILanguageService)), ( __param(9, IFileService)), ( __param(10, IRequestService)), ( __param(11, IAgentPluginService)), ( __param(12, IPluginInstallService)), ( __param(13, ILabelService))], AgentPluginEditor));
+let InstallPluginEditorAction = class InstallPluginEditorAction extends Action {
+    static {
+        InstallPluginEditorAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.editor.install";
+    }
+    constructor(item, pluginInstallService) {
+        super(InstallPluginEditorAction_1.ID, ( localize(5013, "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
+        });
+    }
+};
+InstallPluginEditorAction = InstallPluginEditorAction_1 = ( __decorate([( __param(1, IPluginInstallService))], InstallPluginEditorAction));
+let EnablePluginEditorAction = class EnablePluginEditorAction extends Action {
+    static {
+        EnablePluginEditorAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.editor.enable";
+    }
+    constructor(plugin, agentPluginService) {
+        super(EnablePluginEditorAction_1.ID, ( localize(5014, "Enable")), "extension-action label prominent");
+        this.plugin = plugin;
+        this.agentPluginService = agentPluginService;
+    }
+    async run() {
+        this.agentPluginService.setPluginEnabled(this.plugin.uri, true);
+    }
+};
+EnablePluginEditorAction = EnablePluginEditorAction_1 = ( __decorate([( __param(1, IAgentPluginService))], EnablePluginEditorAction));
+let DisablePluginEditorAction = class DisablePluginEditorAction extends Action {
+    static {
+        DisablePluginEditorAction_1 = this;
+    }
+    static {
+        this.ID = "agentPlugin.editor.disable";
+    }
+    constructor(plugin, agentPluginService) {
+        super(DisablePluginEditorAction_1.ID, ( localize(5015, "Disable")), "extension-action label disable");
+        this.plugin = plugin;
+        this.agentPluginService = agentPluginService;
+    }
+    async run() {
+        this.agentPluginService.setPluginEnabled(this.plugin.uri, false);
+    }
+};
+DisablePluginEditorAction = DisablePluginEditorAction_1 = ( __decorate([( __param(1, IAgentPluginService))], DisablePluginEditorAction));
+class UninstallPluginEditorAction extends Action {
+    static {
+        this.ID = "agentPlugin.editor.uninstall";
+    }
+    constructor(plugin) {
+        super(UninstallPluginEditorAction.ID, ( localize(5016, "Uninstall")), "extension-action label uninstall");
+        this.plugin = plugin;
+    }
+    async run() {
+        this.plugin.remove();
+    }
+}
+
+export { AgentPluginEditor };

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginEditor/agentPluginEditorInput.d.ts

@@ -0,0 +1,17 @@
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { EditorInputCapabilities, IUntypedEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IAgentPluginItem } from "./agentPluginItems.js";
+export declare class AgentPluginEditorInput extends EditorInput {
+    private _item;
+    static readonly ID = "workbench.agentPlugin.input";
+    get typeId(): string;
+    get capabilities(): EditorInputCapabilities;
+    get resource(): URI;
+    constructor(_item: IAgentPluginItem);
+    get item(): IAgentPluginItem;
+    getName(): string;
+    getIcon(): ThemeIcon | undefined;
+    matches(other: EditorInput | IUntypedEditorInput): boolean;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginEditor/agentPluginEditorInput.js

@@ -0,0 +1,55 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { EditorInputCapabilities } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { EditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput';
+import { AgentPluginItemKind } from './agentPluginItems.js';
+
+const AgentPluginEditorIcon = registerIcon("agent-plugin-editor-icon", Codicon.extensions, ( localize(5017, "Icon of the Agent Plugin editor.")));
+function getPluginId(item) {
+    if (item.kind === AgentPluginItemKind.Installed) {
+        return ( item.plugin.uri.toString());
+    }
+    return `${item.marketplaceReference.canonicalId}/${item.source}`;
+}
+class AgentPluginEditorInput extends EditorInput {
+    static {
+        this.ID = "workbench.agentPlugin.input";
+    }
+    get typeId() {
+        return AgentPluginEditorInput.ID;
+    }
+    get capabilities() {
+        return EditorInputCapabilities.Readonly | EditorInputCapabilities.Singleton;
+    }
+    get resource() {
+        return ( URI.from({
+            scheme: Schemas.extension,
+            path: `/agentPlugin/${encodeURIComponent(getPluginId(this._item))}`
+        }));
+    }
+    constructor(_item) {
+        super();
+        this._item = _item;
+    }
+    get item() {
+        return this._item;
+    }
+    getName() {
+        return localize(5018, "Plugin: {0}", this._item.name);
+    }
+    getIcon() {
+        return AgentPluginEditorIcon;
+    }
+    matches(other) {
+        if (super.matches(other)) {
+            return true;
+        }
+        return other instanceof AgentPluginEditorInput && getPluginId(this._item) === getPluginId(other._item);
+    }
+}
+
+export { AgentPluginEditorInput };