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

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

@@ -0,0 +1,26 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import type { IAgentPlugin } from "../../common/plugins/agentPluginService.js";
+import type { IMarketplaceReference, IPluginSourceDescriptor, MarketplaceType } from "../../common/plugins/pluginMarketplaceService.js";
+export declare enum AgentPluginItemKind {
+    Installed = "installed",
+    Marketplace = "marketplace"
+}
+export interface IInstalledPluginItem {
+    readonly kind: AgentPluginItemKind.Installed;
+    readonly name: string;
+    readonly description: string;
+    readonly marketplace?: string;
+    readonly plugin: IAgentPlugin;
+}
+export interface IMarketplacePluginItem {
+    readonly kind: AgentPluginItemKind.Marketplace;
+    readonly name: string;
+    readonly description: string;
+    readonly source: string;
+    readonly sourceDescriptor: IPluginSourceDescriptor;
+    readonly marketplace: string;
+    readonly marketplaceReference: IMarketplaceReference;
+    readonly marketplaceType: MarketplaceType;
+    readonly readmeUri?: URI;
+}
+export type IAgentPluginItem = IInstalledPluginItem | IMarketplacePluginItem;

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

@@ -0,0 +1,9 @@
+
+
+var AgentPluginItemKind;
+(function (AgentPluginItemKind) {
+    AgentPluginItemKind["Installed"] = "installed";
+    AgentPluginItemKind["Marketplace"] = "marketplace";
+})(AgentPluginItemKind || (AgentPluginItemKind = {}));
+
+export { AgentPluginItemKind };

package/vscode/src/vs/workbench/contrib/chat/browser/agentPluginEditor/media/agentPluginEditor.css

@@ -0,0 +1,32 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.agent-plugin-editor {
+	& .marketplace-link {
+		color: var(--vscode-textLink-foreground);
+		text-decoration: none;
+		cursor: pointer;
+
+		&:hover {
+			text-decoration: underline;
+			color: var(--vscode-textLink-activeForeground);
+		}
+	}
+
+	& > .body > .content > .details {
+		display: flex;
+		height: 100%;
+
+		&.narrow {
+			flex-direction: column;
+		}
+
+		& > .content-container {
+			flex: 1;
+			min-width: 0;
+			height: 100%;
+		}
+	}
+}

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

@@ -0,0 +1,48 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IProgressService } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IEnsureRepositoryOptions, IPullRepositoryOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService";
+import { IAgentPluginRepositoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service";
+import { IMarketplacePlugin, IMarketplaceReference, IPluginSourceDescriptor, MarketplaceType, PluginSourceKind } from "../common/plugins/pluginMarketplaceService.js";
+import { IPluginSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginSource";
+export declare class AgentPluginRepositoryService implements IAgentPluginRepositoryService {
+    private readonly _commandService;
+    private readonly _fileService;
+    private readonly _logService;
+    private readonly _notificationService;
+    private readonly _progressService;
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private readonly _cacheRoot;
+    private readonly _marketplaceIndex;
+    private readonly _pluginSources;
+    constructor(_commandService: ICommandService, environmentService: IEnvironmentService, _fileService: IFileService, instantiationService: IInstantiationService, _logService: ILogService, _notificationService: INotificationService, _progressService: IProgressService, _storageService: IStorageService);
+    getPluginSource(kind: PluginSourceKind): IPluginSource;
+    getRepositoryUri(marketplace: IMarketplaceReference, marketplaceType?: MarketplaceType): URI;
+    getPluginInstallUri(plugin: IMarketplacePlugin): URI;
+    ensureRepository(marketplace: IMarketplaceReference, options?: IEnsureRepositoryOptions): Promise<URI>;
+    pullRepository(marketplace: IMarketplaceReference, options?: IPullRepositoryOptions): Promise<void>;
+    private _getRepoCacheDirForReference;
+    private _loadMarketplaceIndex;
+    private _updateMarketplaceIndex;
+    private _saveMarketplaceIndex;
+    private _cloneRepository;
+    private _getPluginDir;
+    getPluginSourceInstallUri(sourceDescriptor: IPluginSourceDescriptor): URI;
+    ensurePluginSource(plugin: IMarketplacePlugin, options?: IEnsureRepositoryOptions): Promise<URI>;
+    updatePluginSource(plugin: IMarketplacePlugin, options?: IPullRepositoryOptions): Promise<void>;
+    cleanupPluginSource(plugin: IMarketplacePlugin): Promise<void>;
+    /**
+     * Walk from {@link child}'s parent toward {@link _cacheRoot}, removing
+     * each directory that is empty. Stops as soon as a non-empty directory
+     * is found or the cache root is reached. Only operates on descendants
+     * of the cache root — returns immediately for paths outside it.
+     */
+    private _pruneEmptyParents;
+}

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

@@ -0,0 +1,282 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Action } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { joinPath, dirname, isEqualOrParent, isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { PluginSourceKind, MarketplaceReferenceKind } from '../common/plugins/pluginMarketplaceService.js';
+import { RelativePathPluginSource, GitHubPluginSource, GitUrlPluginSource, NpmPluginSource, PipPluginSource } from './pluginSources.js';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+const MARKETPLACE_INDEX_STORAGE_KEY = "chat.plugins.marketplaces.index.v1";
+let AgentPluginRepositoryService = class AgentPluginRepositoryService {
+    constructor(
+        _commandService,
+        environmentService,
+        _fileService,
+        instantiationService,
+        _logService,
+        _notificationService,
+        _progressService,
+        _storageService
+    ) {
+        this._commandService = _commandService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._notificationService = _notificationService;
+        this._progressService = _progressService;
+        this._storageService = _storageService;
+        this._marketplaceIndex = ( new Lazy(() => this._loadMarketplaceIndex()));
+        this._cacheRoot = joinPath(environmentService.cacheHome, "agentPlugins");
+        this._pluginSources = ( new Map([[PluginSourceKind.RelativePath, ( new RelativePathPluginSource())], [
+            PluginSourceKind.GitHub,
+            instantiationService.createInstance(GitHubPluginSource)
+        ], [
+            PluginSourceKind.GitUrl,
+            instantiationService.createInstance(GitUrlPluginSource)
+        ], [PluginSourceKind.Npm, instantiationService.createInstance(NpmPluginSource)], [PluginSourceKind.Pip, instantiationService.createInstance(PipPluginSource)]]));
+    }
+    getPluginSource(kind) {
+        const repo = this._pluginSources.get(kind);
+        if (!repo) {
+            throw ( new Error(`No source repository registered for kind '${kind}'`));
+        }
+        return repo;
+    }
+    getRepositoryUri(marketplace, marketplaceType) {
+        if (marketplace.kind === MarketplaceReferenceKind.LocalFileUri && marketplace.localRepositoryUri) {
+            return marketplace.localRepositoryUri;
+        }
+        const indexed = this._marketplaceIndex.value.get(marketplace.canonicalId);
+        if (indexed?.repositoryUri) {
+            return indexed.repositoryUri;
+        }
+        return this._getRepoCacheDirForReference(marketplace);
+    }
+    getPluginInstallUri(plugin) {
+        const repoDir = this.getRepositoryUri(plugin.marketplaceReference, plugin.marketplaceType);
+        return this._getPluginDir(repoDir, plugin.source);
+    }
+    async ensureRepository(marketplace, options) {
+        const repoDir = this.getRepositoryUri(marketplace, options?.marketplaceType);
+        const repoExists = await this._fileService.exists(repoDir);
+        if (repoExists) {
+            this._updateMarketplaceIndex(marketplace, repoDir, options?.marketplaceType);
+            return repoDir;
+        }
+        if (marketplace.kind === MarketplaceReferenceKind.LocalFileUri) {
+            throw ( new Error(`Local marketplace repository does not exist: ${repoDir.fsPath}`));
+        }
+        const progressTitle = options?.progressTitle ?? ( localize(5019, "Preparing plugin marketplace '{0}'...", marketplace.displayLabel));
+        const failureLabel = options?.failureLabel ?? marketplace.displayLabel;
+        await this._cloneRepository(repoDir, marketplace.cloneUrl, progressTitle, failureLabel);
+        this._updateMarketplaceIndex(marketplace, repoDir, options?.marketplaceType);
+        return repoDir;
+    }
+    async pullRepository(marketplace, options) {
+        const repoDir = this.getRepositoryUri(marketplace, options?.marketplaceType);
+        const repoExists = await this._fileService.exists(repoDir);
+        if (!repoExists) {
+            this._logService.warn(
+                `[AgentPluginRepositoryService] Cannot update plugin '${options?.pluginName ?? marketplace.displayLabel}': repository not cloned`
+            );
+            return;
+        }
+        const updateLabel = options?.pluginName ?? marketplace.displayLabel;
+        try {
+            await this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: ( localize(5020, "Updating plugin '{0}'...", updateLabel)),
+                cancellable: false
+            }, async () => {
+                await this._commandService.executeCommand("_git.pull", repoDir.fsPath);
+            });
+        } catch (err) {
+            this._logService.error(
+                `[AgentPluginRepositoryService] Failed to update ${marketplace.displayLabel}:`,
+                err
+            );
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    5021,
+                    "Failed to update plugin '{0}': {1}",
+                    options?.failureLabel ?? updateLabel,
+                    err?.message ?? String(err)
+                )),
+                actions: {
+                    primary: [( new Action("showGitOutput", ( localize(5022, "Show Git Output")), undefined, true, () => {
+                        this._commandService.executeCommand("git.showOutput");
+                    }))]
+                }
+            });
+        }
+    }
+    _getRepoCacheDirForReference(reference) {
+        return joinPath(this._cacheRoot, ...reference.cacheSegments);
+    }
+    _loadMarketplaceIndex() {
+        const result = ( new Map());
+        const stored = this._storageService.getObject(MARKETPLACE_INDEX_STORAGE_KEY, StorageScope.APPLICATION);
+        if (!stored) {
+            return result;
+        }
+        const revived = revive(stored);
+        for (const [canonicalId, entry] of Object.entries(revived)) {
+            if (!entry || !entry.repositoryUri) {
+                continue;
+            }
+            result.set(canonicalId, {
+                repositoryUri: entry.repositoryUri,
+                marketplaceType: entry.marketplaceType
+            });
+        }
+        return result;
+    }
+    _updateMarketplaceIndex(marketplace, repositoryUri, marketplaceType) {
+        if (marketplace.kind === MarketplaceReferenceKind.LocalFileUri) {
+            return;
+        }
+        const previous = this._marketplaceIndex.value.get(marketplace.canonicalId);
+        if (previous && ( previous.repositoryUri.toString()) === ( repositoryUri.toString()) && previous.marketplaceType === marketplaceType) {
+            return;
+        }
+        this._marketplaceIndex.value.set(marketplace.canonicalId, {
+            repositoryUri,
+            marketplaceType
+        });
+        this._saveMarketplaceIndex();
+    }
+    _saveMarketplaceIndex() {
+        const serialized = {};
+        for (const [canonicalId, entry] of this._marketplaceIndex.value) {
+            serialized[canonicalId] = JSON.parse(JSON.stringify({
+                repositoryUri: entry.repositoryUri,
+                marketplaceType: entry.marketplaceType
+            }));
+        }
+        if (( Object.keys(serialized)).length === 0) {
+            this._storageService.remove(MARKETPLACE_INDEX_STORAGE_KEY, StorageScope.APPLICATION);
+            return;
+        }
+        this._storageService.store(
+            MARKETPLACE_INDEX_STORAGE_KEY,
+            JSON.stringify(serialized),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+    async _cloneRepository(repoDir, cloneUrl, progressTitle, failureLabel, ref) {
+        try {
+            await this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title: progressTitle,
+                cancellable: false
+            }, async () => {
+                await this._fileService.createFolder(dirname(repoDir));
+                await this._commandService.executeCommand("_git.cloneRepository", cloneUrl, repoDir.fsPath, ref);
+            });
+        } catch (err) {
+            this._logService.error(`[AgentPluginRepositoryService] Failed to clone ${cloneUrl}:`, err);
+            this._notificationService.notify({
+                severity: Severity.Error,
+                message: ( localize(
+                    5023,
+                    "Failed to install plugin '{0}': {1}",
+                    failureLabel,
+                    err?.message ?? String(err)
+                )),
+                actions: {
+                    primary: [( new Action("showGitOutput", ( localize(5022, "Show Git Output")), undefined, true, () => {
+                        this._commandService.executeCommand("git.showOutput");
+                    }))]
+                }
+            });
+            throw err;
+        }
+    }
+    _getPluginDir(repoDir, source) {
+        const normalizedSource = source.trim().replace(/^\.?\/+|\/+$/g, "");
+        const pluginDir = normalizedSource ? joinPath(repoDir, normalizedSource) : repoDir;
+        if (!isEqualOrParent(pluginDir, repoDir)) {
+            throw ( new Error(`Invalid plugin source path '${source}'`));
+        }
+        return pluginDir;
+    }
+    getPluginSourceInstallUri(sourceDescriptor) {
+        return this.getPluginSource(sourceDescriptor.kind).getInstallUri(this._cacheRoot, sourceDescriptor);
+    }
+    async ensurePluginSource(plugin, options) {
+        const repo = this.getPluginSource(plugin.sourceDescriptor.kind);
+        if (plugin.sourceDescriptor.kind === PluginSourceKind.RelativePath) {
+            return this.ensureRepository(plugin.marketplaceReference, options);
+        }
+        return repo.ensure(this._cacheRoot, plugin, options);
+    }
+    async updatePluginSource(plugin, options) {
+        const repo = this.getPluginSource(plugin.sourceDescriptor.kind);
+        if (plugin.sourceDescriptor.kind === PluginSourceKind.RelativePath) {
+            return this.pullRepository(plugin.marketplaceReference, options);
+        }
+        return repo.update(this._cacheRoot, plugin, options);
+    }
+    async cleanupPluginSource(plugin) {
+        const repo = this.getPluginSource(plugin.sourceDescriptor.kind);
+        const cleanupDir = repo.getCleanupTarget(this._cacheRoot, plugin.sourceDescriptor);
+        if (!cleanupDir) {
+            return;
+        }
+        try {
+            const exists = await this._fileService.exists(cleanupDir);
+            if (exists) {
+                await this._fileService.del(cleanupDir, {
+                    recursive: true
+                });
+                this._logService.info(`[${plugin.sourceDescriptor.kind}] Removed plugin cache: ${( cleanupDir.toString())}`);
+            }
+        } catch (err) {
+            this._logService.warn(
+                `[${plugin.sourceDescriptor.kind}] Failed to remove plugin cache '${( cleanupDir.toString())}':`,
+                err
+            );
+        }
+        try {
+            await this._pruneEmptyParents(cleanupDir);
+        } catch (err) {
+            this._logService.warn(`[${plugin.sourceDescriptor.kind}] Failed to cleanup plugin source:`, err);
+        }
+    }
+    async _pruneEmptyParents(child) {
+        if (!isEqualOrParent(child, this._cacheRoot)) {
+            return;
+        }
+        let current = dirname(child);
+        while (isEqualOrParent(current, this._cacheRoot) && !isEqual(current, this._cacheRoot)) {
+            try {
+                const stat = await this._fileService.resolve(current);
+                if (stat.children && stat.children.length > 0) {
+                    break;
+                }
+                await this._fileService.del(current);
+            } catch {
+                break;
+            }
+            current = dirname(current);
+        }
+    }
+};
+AgentPluginRepositoryService = ( __decorate([( __param(0, ICommandService)), ( __param(1, IEnvironmentService)), ( __param(2, IFileService)), ( __param(3, IInstantiationService)), ( __param(4, ILogService)), ( __param(5, INotificationService)), ( __param(6, IProgressService)), ( __param(7, IStorageService))], AgentPluginRepositoryService));
+
+export { AgentPluginRepositoryService };

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

@@ -0,0 +1,55 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IPagedModel } from "@codingame/monaco-vscode-api/vscode/vs/base/common/paging";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { RawContextKey } 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 { 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 { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IViewletViewOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewsViewlet";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { AbstractExtensionsListView } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/browser/extensionsViews";
+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 { IAgentPluginItem } from "./agentPluginEditor/agentPluginItems.js";
+export declare const HasInstalledAgentPluginsContext: RawContextKey<boolean>;
+export declare const InstalledAgentPluginsViewId = "workbench.views.agentPlugins.installed";
+interface IAgentPluginsListViewOptions {
+    installedOnly?: boolean;
+}
+export declare class AgentPluginsListView extends AbstractExtensionsListView<IAgentPluginItem> {
+    private readonly listOptions;
+    private readonly agentPluginService;
+    private readonly pluginMarketplaceService;
+    private readonly pluginInstallService;
+    private readonly labelService;
+    private readonly editorService;
+    private readonly actionStore;
+    private readonly queryCts;
+    private list;
+    private listContainer;
+    private currentQuery;
+    private readonly refreshOnPluginsChangedScheduler;
+    private bodyTemplate;
+    constructor(listOptions: IAgentPluginsListViewOptions, options: IViewletViewOptions, keybindingService: IKeybindingService, contextMenuService: IContextMenuService, instantiationService: IInstantiationService, themeService: IThemeService, hoverService: IHoverService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, viewDescriptorService: IViewDescriptorService, openerService: IOpenerService, agentPluginService: IAgentPluginService, pluginMarketplaceService: IPluginMarketplaceService, pluginInstallService: IPluginInstallService, labelService: ILabelService, editorService: IEditorService);
+    protected renderBody(container: HTMLElement): void;
+    private onContextMenu;
+    private getContextMenuActions;
+    protected layoutBody(height: number, width: number): void;
+    show(query: string): Promise<IPagedModel<IAgentPluginItem>>;
+    private queryInstalled;
+    private queryMarketplace;
+    private updateBody;
+}
+export declare class AgentPluginsViewsContribution extends Disposable implements IWorkbenchContribution {
+    static ID: string;
+    constructor(contextKeyService: IContextKeyService, agentPluginService: IAgentPluginService);
+}
+export {};