@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.2.0

package/vscode/src/vs/workbench/contrib/chat/common/customizationHarnessService.js

@@ -0,0 +1,272 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+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 { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AICustomizationManagementSection, BUILTIN_STORAGE } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { AGENT_MD_FILENAME } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { matchesSessionType, PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { SessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { CustomAgent } from './promptSyntax/service/promptsServiceImpl.js';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { getCanonicalPluginCommandId } from './plugins/agentPluginService.js';
+import { getChatSessionType, LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { isAgentBuiltinCustomizationUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostCustomizationUri';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
+import { CustomizationEnablementKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+function isPluginCustomizationItem(item) {
+    return item.type === "plugin" || item.type === AICustomizationManagementSection.Plugins;
+}
+function getCustomizationDisabledLabel(reason) {
+    if (reason?.source === "plugin") {
+        return localize(10443, "Disabled (Plugin)");
+    }
+    switch (reason?.scope) {
+    case CustomizationEnablementKind.Workspace:
+        return localize(10444, "Disabled (Workspace)");
+    case CustomizationEnablementKind.Session:
+        return localize(10445, "Disabled (Session)");
+    case CustomizationEnablementKind.Global:
+    case undefined:
+        return localize(10446, "Disabled");
+    }
+}
+const EMPTY_DESCRIPTOR = {
+    id: "",
+    label: "",
+    icon: Codicon.sparkle
+};
+function createVSCodeHarnessDescriptor() {
+    return {
+        id: SessionType.Local,
+        label: ( localize(10447, "Local")),
+        icon: ThemeIcon.fromId(Codicon.vm.id),
+        supportsTroubleshoot: true,
+        hiddenSections: [AICustomizationManagementSection.Tools],
+        sectionOverrides: ( new Map([[AICustomizationManagementSection.Instructions, {
+            rootFileShortcuts: [AGENT_MD_FILENAME]
+        }]]))
+    };
+}
+class CustomizationHarnessServiceBase {
+    constructor(staticHarnesses, defaultHarness, promptsService) {
+        this.promptsService = promptsService;
+        this._onDidChangeSlashCommands = ( new Emitter());
+        this.onDidChangeSlashCommands = this._onDidChangeSlashCommands.event;
+        this._onDidChangeCustomAgents = ( new Emitter());
+        this.onDidChangeCustomAgents = this._onDidChangeCustomAgents.event;
+        this._providerListeners = [];
+        this._isDisposed = false;
+        this._externalHarnesses = [];
+        this._staticHarnesses = staticHarnesses;
+        this.promptsService = promptsService;
+        this._activeSessionResource = observableValue(this, this.getSessionResourceForHarness(defaultHarness));
+        this.activeSessionResource = this._activeSessionResource;
+        this._activeHarness = derived(
+            this,
+            reader => getChatSessionType(this._activeSessionResource.read(reader))
+        );
+        this.activeHarness = this._activeHarness;
+        this._availableHarnesses = observableValue(this, [...this._staticHarnesses]);
+        this.availableHarnesses = this._availableHarnesses;
+        this._rebindProviderListeners();
+    }
+    _getAllHarnesses() {
+        const externalIds = ( new Set(( this._externalHarnesses.map(h => h.id))));
+        return [...this._staticHarnesses.filter(h => !( externalIds.has(h.id))), ...this._externalHarnesses];
+    }
+    _refreshAvailableHarnesses() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._availableHarnesses.set(this._getAllHarnesses(), undefined);
+        this._rebindProviderListeners();
+    }
+    _rebindProviderListeners() {
+        for (const listener of this._providerListeners) {
+            listener.dispose();
+        }
+        this._providerListeners.length = 0;
+        for (const harness of this._getAllHarnesses()) {
+            const provider = harness.itemProvider;
+            if (!provider) {
+                this._providerListeners.push(
+                    this.promptsService.onDidChangeSlashCommands(() => this._onDidChangeSlashCommands.fire({
+                        sessionType: harness.id
+                    }))
+                );
+                this._providerListeners.push(
+                    this.promptsService.onDidChangeCustomAgents(() => this._onDidChangeCustomAgents.fire({
+                        sessionType: harness.id
+                    }))
+                );
+            } else {
+                this._providerListeners.push(provider.onDidChange(() => this._onDidChangeSlashCommands.fire({
+                    sessionType: harness.id
+                })));
+                this._providerListeners.push(provider.onDidChange(() => this._onDidChangeCustomAgents.fire({
+                    sessionType: harness.id
+                })));
+            }
+        }
+    }
+    dispose() {
+        this._isDisposed = true;
+        for (const listener of this._providerListeners) {
+            listener.dispose();
+        }
+        this._providerListeners.length = 0;
+        this._onDidChangeSlashCommands.dispose();
+        this._onDidChangeCustomAgents.dispose();
+    }
+    registerExternalHarness(descriptor) {
+        this._externalHarnesses.push(descriptor);
+        this._refreshAvailableHarnesses();
+        return {
+            dispose: () => {
+                if (this._isDisposed) {
+                    return;
+                }
+                const idx = this._externalHarnesses.indexOf(descriptor);
+                if (idx >= 0) {
+                    this._externalHarnesses.splice(idx, 1);
+                    this._refreshAvailableHarnesses();
+                }
+            }
+        };
+    }
+    findHarnessById(id) {
+        return this._getAllHarnesses().find(h => h.id === id);
+    }
+    setActiveSession(sessionResource) {
+        this._activeSessionResource.set(sessionResource, undefined);
+    }
+    getActiveDescriptor() {
+        const activeId = this._activeHarness.get();
+        const descriptor = this.findHarnessById(activeId);
+        return descriptor ?? EMPTY_DESCRIPTOR;
+    }
+    async getSlashCommands(sessionResource, token) {
+        const sessionType = getChatSessionType(sessionResource);
+        const harness = this.findHarnessById(sessionType);
+        if (!harness || !harness.itemProvider) {
+            const commands = await this.promptsService.getPromptSlashCommands(token);
+            return commands.filter(command => matchesSessionType(command.sessionTypes, sessionType));
+        }
+        const items = await harness.itemProvider.provideChatSessionCustomizations(sessionResource, token);
+        if (!items) {
+            return [];
+        }
+        const result = [];
+        for (const item of items) {
+            if ((item.enabled !== false) && (item.type === PromptsType.prompt || item.type === PromptsType.skill)) {
+                const storage = item.source;
+                const narrowStorage = storage !== undefined && storage !== BUILTIN_STORAGE ? storage : PromptsStorage.local;
+                result.push({
+                    uri: item.uri,
+                    type: item.type,
+                    name: item.pluginUri ? getCanonicalPluginCommandId({
+                        uri: item.pluginUri,
+                        label: item.pluginLabel
+                    }, item.name) : item.name,
+                    description: item.description,
+                    userInvocable: item.userInvocable ?? true,
+                    storage: narrowStorage,
+                    sessionTypes: [sessionType]
+                });
+            }
+        }
+        return result;
+    }
+    async getCustomAgents(sessionResource, token) {
+        const sessionType = getChatSessionType(sessionResource);
+        const harness = this.findHarnessById(sessionType);
+        if (!harness || !harness.itemProvider) {
+            const allAgents = await this.promptsService.getCustomAgents(token);
+            return allAgents.filter(agent => matchesSessionType(agent.sessionTypes, sessionType));
+        }
+        if (harness.itemProvider.provideCustomAgents) {
+            return harness.itemProvider.provideCustomAgents(sessionResource, token);
+        }
+        const items = await harness.itemProvider.provideChatSessionCustomizations(sessionResource, token);
+        if (!items || token.isCancellationRequested) {
+            return [];
+        }
+        const getSource = item => {
+            if (item.source === PromptsStorage.extension && item.extensionId) {
+                return {
+                    storage: PromptsStorage.extension,
+                    extensionId: ( new ExtensionIdentifier(item.extensionId))
+                };
+            } else if (item.source === PromptsStorage.plugin && item.pluginUri) {
+                return {
+                    storage: PromptsStorage.plugin,
+                    pluginUri: item.pluginUri
+                };
+            } else if (item.source === PromptsStorage.user) {
+                return {
+                    storage: PromptsStorage.user
+                };
+            }
+            return {
+                storage: PromptsStorage.local
+            };
+        };
+        const result = [];
+        for (const item of items) {
+            if (item.type === PromptsType.agent) {
+                const promptFile = await this.promptsService.parseNew(item.uri, token);
+                const extra = {
+                    name: item.name,
+                    description: item.description,
+                    sessionTypes: [sessionType],
+                    hooks: undefined,
+                    source: getSource(item),
+                    type: PromptsType.agent,
+                    enabled: item.enabled !== false
+                };
+                result.push(CustomAgent.fromParsedPromptFile(promptFile, extra));
+            }
+        }
+        return result;
+    }
+    async resolvePromptSlashCommand(name, sessionResource, token) {
+        const commands = await this.getSlashCommands(sessionResource, token);
+        const command = commands.find(cmd => cmd.name === name);
+        if (command) {
+            if (isAgentBuiltinCustomizationUri(command.uri)) {
+                return command;
+            }
+            const parsedPromptFile = await this.promptsService.parseNew(command.uri, token);
+            return {
+                ...command,
+                userInvocable: parsedPromptFile.header?.userInvocable ?? command.userInvocable,
+                parsedPromptFile
+            };
+        }
+        return undefined;
+    }
+    getSessionResourceForHarness(sessionType) {
+        if (sessionType === SessionType.Local) {
+            return LocalChatSessionUri.getNewSessionUri();
+        }
+        return ( URI.from({
+            scheme: sessionType,
+            path: "/untitled-2"
+        }));
+    }
+}
+
+export { CustomizationHarnessServiceBase, createVSCodeHarnessDescriptor, getCustomizationDisabledLabel, isPluginCustomizationItem };

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionStore.js

@@ -99,7 +99,7 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
             }
             e.join(this.storeTask, {
                 id: "join.chatSessionStore",
-                label: ( localize(10299, "Saving chat history"))
+                label: ( localize(10494, "Saving chat history"))
             });
         }));
     }
@@ -357,14 +357,14 @@ let ChatSessionStore = class ChatSessionStore extends Disposable {
                             this._didReportIssue = true;
                             this.dialogService.prompt({
                                 custom: true,
-                                title: ( localize(10300, "Error saving chat session")),
+                                title: ( localize(10495, "Error saving chat session")),
                                 message: ( localize(
-                                    10301,
+                                    10496,
                                     "Error serializing chat session for storage. The session will be lost if the window is closed. Please report this issue to the VS Code team:\n\n{0}",
                                     e.stack || toErrorMessage(e)
                                 )),
                                 buttons: [{
-                                    label: ( localize(10302, "Report Issue")),
+                                    label: ( localize(10497, "Report Issue")),
                                     run: () => this.openerService.open("https://github.com/microsoft/vscode/issues/new?template=bug_report.md")
                                 }]
                             });
@@ -757,7 +757,7 @@ function getSessionMetadataSync(session) {
     } : undefined;
     return {
         sessionId: session.sessionId,
-        title: title || ( localize(10303, "New Chat")),
+        title: title || ( localize(10498, "New Chat")),
         lastMessageDate: session.lastMessageDate,
         timing: session.timing,
         initialLocation: session.initialLocation,
@@ -779,7 +779,7 @@ async function getSessionMetadata(session) {
     const lastMessageDate = session.requests.at(-1)?.timestamp ?? session.creationDate;
     return {
         sessionId: session.sessionId,
-        title: session.customTitle || ( localize(10303, "New Chat")),
+        title: session.customTitle || ( localize(10498, "New Chat")),
         lastMessageDate,
         timing: {
             created: session.creationDate,

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginEnablement.d.ts

@@ -0,0 +1,25 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { AgentPluginDiscoveryPriority, IAgentPlugin } from "./agentPluginService.js";
+import { CollisionEnablementModel, IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
+export interface IDiscoveredAgentPlugins {
+    readonly plugins: readonly IAgentPlugin[];
+    readonly priority: AgentPluginDiscoveryPriority;
+    readonly order: number;
+}
+export declare class AgentPluginCollisionEnablementModel extends CollisionEnablementModel {
+    constructor(base: IEnablementModel, collisionGroups: IObservable<ReadonlyMap<string, readonly string[]>>);
+}
+export declare function getSortedAgentPlugins(discoveries: readonly IDiscoveredAgentPlugins[]): readonly IAgentPlugin[];
+export declare function getCanonicalAgentPluginCollisionGroups(discoveries: readonly IDiscoveredAgentPlugins[], isBlocked?: (plugin: IAgentPlugin) => boolean): ReadonlyMap<string, readonly string[]>;
+/**
+ * Whether the `ChatEnabledPlugins` enterprise policy explicitly blocks this plugin.
+ *
+ * The policy is a **deny list**, not an allowlist: enterprise-managed `enabledPlugins` entries
+ * add to (never replace) the plugins a user has installed. A plugin is blocked only when its
+ * policy id is mapped to `false`; entries mapped to `true` enable the plugin, and a plugin the
+ * policy never mentions is left to the user's own enablement. This keeps a customer's existing
+ * plugins working when their enterprise deploys `enabledPlugins` for a different plugin.
+ */
+export declare function isAgentPluginBlockedByPolicy(plugin: IAgentPlugin, enabledPluginsPolicy: Record<string, boolean> | undefined): boolean;
+export declare function isAgentPluginForceEnabledByPolicy(plugin: IAgentPlugin, enabledPluginsPolicy: Record<string, boolean> | undefined): boolean;
+export declare function getAgentPluginPolicyId(plugin: IAgentPlugin): string | undefined;

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginEnablement.js

@@ -0,0 +1,178 @@
+
+import { PluginSourceKind } from './pluginMarketplaceService.js';
+import { CollisionEnablementModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
+
+const COPILOT_CLI_INSTALL_PATH_FRAGMENT = "/.copilot/installed-plugins/";
+class AgentPluginCollisionEnablementModel extends CollisionEnablementModel {
+    constructor(base, collisionGroups) {
+        super(base, collisionGroups);
+    }
+}
+function getSortedAgentPlugins(discoveries) {
+    return ( getUniqueAgentPluginCandidates(discoveries).map(candidate => candidate.plugin)).sort((a, b) => ( a.uri.toString()).localeCompare(( b.uri.toString())));
+}
+function getCanonicalAgentPluginCollisionGroups(discoveries, isBlocked) {
+    const candidates = getUniqueAgentPluginCandidates(discoveries);
+    const byCanonicalKey = ( new Map());
+    for (const candidate of candidates) {
+        if (isBlocked?.(candidate.plugin)) {
+            continue;
+        }
+        let group = byCanonicalKey.get(candidate.canonicalKey);
+        if (!group) {
+            group = [];
+            byCanonicalKey.set(candidate.canonicalKey, group);
+        }
+        group.push(( candidate.plugin.uri.toString()));
+    }
+    const groups = ( new Map());
+    for (const group of ( byCanonicalKey.values())) {
+        if (group.length < 2) {
+            continue;
+        }
+        for (const key of group) {
+            groups.set(key, group);
+        }
+    }
+    return groups;
+}
+function isAgentPluginBlockedByPolicy(plugin, enabledPluginsPolicy) {
+    const pluginId = getAgentPluginPolicyId(plugin);
+    return pluginId !== undefined && enabledPluginsPolicy?.[pluginId] === false;
+}
+function isAgentPluginForceEnabledByPolicy(plugin, enabledPluginsPolicy) {
+    const pluginId = getAgentPluginPolicyId(plugin);
+    return pluginId !== undefined && enabledPluginsPolicy?.[pluginId] === true;
+}
+function getAgentPluginPolicyId(plugin) {
+    const identity = getPolicyIdentity(plugin);
+    return identity ? `${identity.name}@${identity.marketplace}` : undefined;
+}
+function getAgentPluginCandidates(discoveries) {
+    const candidates = [];
+    for (const discovery of discoveries) {
+        for (let pluginOrder = 0; pluginOrder < discovery.plugins.length; pluginOrder++) {
+            const plugin = discovery.plugins[pluginOrder];
+            candidates.push({
+                plugin,
+                priority: discovery.priority,
+                order: discovery.order,
+                pluginOrder,
+                canonicalKey: getCanonicalPluginIdentity(plugin)
+            });
+        }
+    }
+    return candidates.sort(
+        (a, b) => a.priority - b.priority || a.order - b.order || a.pluginOrder - b.pluginOrder || ( a.plugin.uri.toString()).localeCompare(( b.plugin.uri.toString()))
+    );
+}
+function getUniqueAgentPluginCandidates(discoveries) {
+    const unique = [];
+    const seen = ( new Set());
+    for (const candidate of getAgentPluginCandidates(discoveries)) {
+        const key = ( candidate.plugin.uri.toString());
+        if (( seen.has(key))) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(candidate);
+    }
+    return unique;
+}
+function getCanonicalPluginIdentity(plugin) {
+    return getMarketplaceCanonicalIdentity(plugin.fromMarketplace) ?? getCopilotCliInstallCanonicalIdentity(plugin) ?? `uri:${( plugin.uri.toString())}`;
+}
+function getMarketplaceCanonicalIdentity(plugin) {
+    if (!plugin) {
+        return undefined;
+    }
+    const normalizedName = normalizePluginIdentitySegment(plugin.name);
+    const source = plugin.sourceDescriptor;
+    switch (source.kind) {
+    case PluginSourceKind.RelativePath:
+        {
+            if (plugin.marketplaceReference.githubRepo) {
+                return `github:${plugin.marketplaceReference.githubRepo.toLowerCase()}|${normalizedName}`;
+            }
+            return `marketplace:${plugin.marketplaceReference.canonicalId}|${normalizedName}`;
+        }
+    case PluginSourceKind.GitHub:
+        {
+            const github = source;
+            return `github:${github.repo.toLowerCase()}|${normalizedName}`;
+        }
+    case PluginSourceKind.GitUrl:
+        {
+            const git = source;
+            return `git:${git.url.toLowerCase()}|${normalizedName}`;
+        }
+    case PluginSourceKind.Npm:
+        {
+            const npm = source;
+            return `npm:${npm.package.toLowerCase()}|${normalizedName}`;
+        }
+    case PluginSourceKind.Pip:
+        {
+            const pip = source;
+            return `pip:${pip.package.toLowerCase()}|${normalizedName}`;
+        }
+    }
+}
+function getCopilotCliInstallCanonicalIdentity(plugin) {
+    if (plugin.uri.scheme !== "file") {
+        return undefined;
+    }
+    const idx = plugin.uri.path.indexOf(COPILOT_CLI_INSTALL_PATH_FRAGMENT);
+    if (idx === -1) {
+        return undefined;
+    }
+    const segments = plugin.uri.path.slice(idx + COPILOT_CLI_INSTALL_PATH_FRAGMENT.length).split("/").filter(s => s.length > 0);
+    if (segments.length !== 2) {
+        return undefined;
+    }
+    const [bucket, installName] = segments;
+    const normalizedName = normalizePluginIdentitySegment(plugin.label || installName);
+    if (bucket !== "_direct") {
+        return `copilot-cli-marketplace:${normalizePluginIdentitySegment(bucket)}|${normalizedName}`;
+    }
+    const match = /^(?<owner>.+)--(?<repo>.+)--(?<plugin>.+)$/.exec(installName);
+    const groups = match?.groups;
+    if (!groups) {
+        return undefined;
+    }
+    return `github:${groups.owner.toLowerCase()}/${groups.repo.toLowerCase()}|${normalizePluginIdentitySegment(groups.plugin)}`;
+}
+function normalizePluginIdentitySegment(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_.:-]/g, "-").replace(/-+/g, "-").replace(/^[-:.]+|[-:.]+$/g, "");
+}
+function getPolicyIdentity(plugin) {
+    const m = plugin.fromMarketplace;
+    if (m) {
+        return {
+            name: m.name,
+            marketplace: m.marketplace,
+            marketplaceReference: m.marketplaceReference
+        };
+    }
+    if (plugin.uri.scheme !== "file") {
+        return undefined;
+    }
+    const idx = plugin.uri.path.indexOf(COPILOT_CLI_INSTALL_PATH_FRAGMENT);
+    if (idx === -1) {
+        return undefined;
+    }
+    const segments = plugin.uri.path.slice(idx + COPILOT_CLI_INSTALL_PATH_FRAGMENT.length).split("/").filter(s => s.length > 0);
+    if (segments.length !== 2) {
+        return undefined;
+    }
+    const [marketplace, name] = segments;
+    if (marketplace === "_direct") {
+        return undefined;
+    }
+    return {
+        name,
+        marketplace
+    };
+}
+
+export { AgentPluginCollisionEnablementModel, getAgentPluginPolicyId, getCanonicalAgentPluginCollisionGroups, getSortedAgentPlugins, isAgentPluginBlockedByPolicy, isAgentPluginForceEnabledByPolicy };

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginService.d.ts

@@ -0,0 +1,78 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { SyncDescriptor0 } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors";
+import { type INamedPluginResource, type IMcpServerDefinition, type IParsedHookCommand, type PluginFormat } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentPlugins/common/pluginParsers";
+import { ContributionEnablementState, IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
+import { IAutomationBlueprint } from "../automations/automationBlueprint.js";
+import { HookType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
+export interface IAgentPluginHook {
+    readonly type: HookType;
+    readonly hooks: readonly IParsedHookCommand[];
+    /** URI where this hook is defined -- not unique, multiple hooks may be in a manifest */
+    readonly uri: URI;
+    readonly originalId: string;
+}
+export type IAgentPluginCommand = INamedPluginResource;
+export type IAgentPluginSkill = INamedPluginResource;
+export type IAgentPluginAgent = INamedPluginResource;
+export type IAgentPluginInstruction = INamedPluginResource;
+export type IAgentPluginMcpServerDefinition = IMcpServerDefinition;
+export interface IAgentPluginAutomation {
+    readonly uri: URI;
+    readonly blueprint: IAutomationBlueprint;
+}
+export interface IAgentPlugin {
+    readonly uri: URI;
+    readonly format: PluginFormat;
+    /** Human-readable display name for the plugin. */
+    readonly label: string;
+    /** Version declared by the plugin manifest, falling back to marketplace metadata. */
+    readonly version?: IObservable<string | undefined>;
+    readonly enablement: IObservable<ContributionEnablementState>;
+    /**
+     * When `true`, the plugin is blocked by enterprise policy. It remains
+     * visible (shown as disabled) but its contributions are inactive and the
+     * user cannot re-enable it. Folded into {@link enablement} so all gating
+     * consumers honor it automatically.
+     */
+    readonly policyBlocked?: IObservable<boolean>;
+    /** Removes this plugin from its discovery source (config or installed storage). Undefined for policy-managed plugins that cannot be removed by the user. */
+    remove?(): Promise<boolean>;
+    readonly hooks: IObservable<readonly IAgentPluginHook[]>;
+    readonly commands: IObservable<readonly IAgentPluginCommand[]>;
+    readonly skills: IObservable<readonly IAgentPluginSkill[]>;
+    readonly agents: IObservable<readonly IAgentPluginAgent[]>;
+    readonly instructions: IObservable<readonly IAgentPluginInstruction[]>;
+    readonly mcpServerDefinitions: IObservable<readonly IAgentPluginMcpServerDefinition[]>;
+    readonly automations: IObservable<readonly IAgentPluginAutomation[]>;
+    /** Set when the plugin was installed from a marketplace repository. */
+    readonly fromMarketplace?: IMarketplacePlugin;
+}
+export interface IAgentPluginDiscovery extends IDisposable {
+    readonly plugins: IObservable<readonly IAgentPlugin[] | undefined>;
+    start(enablementModel: IEnablementModel): void;
+}
+export declare enum AgentPluginDiscoveryPriority {
+    Configured = 10,
+    Marketplace = 20,
+    Extension = 30,
+    CopilotCli = 40
+}
+export declare function getCanonicalPluginCommandId(plugin: {
+    readonly uri: URI;
+    readonly label?: string;
+}, commandName: string): string;
+declare class AgentPluginDiscoveryRegistry {
+    private readonly _discovery;
+    private _order;
+    register(descriptor: SyncDescriptor0<IAgentPluginDiscovery>, priority: AgentPluginDiscoveryPriority): IDisposable;
+    getAll(): readonly {
+        readonly descriptor: SyncDescriptor0<IAgentPluginDiscovery>;
+        readonly priority: AgentPluginDiscoveryPriority;
+        readonly order: number;
+    }[];
+}
+export declare const agentPluginDiscoveryRegistry: AgentPluginDiscoveryRegistry;
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginService.js

@@ -0,0 +1,51 @@
+
+import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+
+var AgentPluginDiscoveryPriority;
+(function(AgentPluginDiscoveryPriority) {
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["Configured"] = 10] = "Configured";
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["Marketplace"] = 20] = "Marketplace";
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["Extension"] = 30] = "Extension";
+    AgentPluginDiscoveryPriority[AgentPluginDiscoveryPriority["CopilotCli"] = 40] = "CopilotCli";
+})(AgentPluginDiscoveryPriority || (AgentPluginDiscoveryPriority = {}));
+function getCanonicalPluginCommandId(plugin, commandName) {
+    const prefix = (plugin.label ? normalizePluginToken(plugin.label) : "") || normalizePluginToken(basename(plugin.uri));
+    const normalizedCommand = normalizePluginToken(commandName);
+    if (normalizedCommand.startsWith(`${prefix}:`)) {
+        return normalizedCommand;
+    }
+    if (prefix === normalizedCommand) {
+        return prefix;
+    }
+    return `${prefix}:${normalizedCommand}`;
+}
+function normalizePluginToken(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9_.:-]/g, "-").replace(/-+/g, "-").replace(/^[-:.]+|[-:.]+$/g, "");
+}
+class AgentPluginDiscoveryRegistry {
+    constructor() {
+        this._discovery = [];
+        this._order = 0;
+    }
+    register(descriptor, priority) {
+        const registration = {
+            descriptor,
+            priority,
+            order: this._order++
+        };
+        this._discovery.push(registration);
+        return toDisposable(() => {
+            const index = this._discovery.indexOf(registration);
+            if (index >= 0) {
+                this._discovery.splice(index, 1);
+            }
+        });
+    }
+    getAll() {
+        return [...this._discovery].sort((a, b) => a.priority - b.priority || a.order - b.order);
+    }
+}
+const agentPluginDiscoveryRegistry = ( new AgentPluginDiscoveryRegistry());
+
+export { AgentPluginDiscoveryPriority, agentPluginDiscoveryRegistry, getCanonicalPluginCommandId };

package/vscode/src/vs/workbench/contrib/chat/common/plugins/agentPluginServiceImpl.d.ts

@@ -13,9 +13,9 @@ import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
 import { IEnablementModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement";
 import { IAgentPluginRepositoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginRepositoryService.service";
-import { IAgentPlugin, IAgentPluginDiscovery } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService";
+import { IAgentPlugin, IAgentPluginDiscovery } from "./agentPluginService.js";
 import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
-import { IMarketplacePlugin } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService";
+import { IMarketplacePlugin } from "./pluginMarketplaceService.js";
 import { IPluginMarketplaceService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService.service";
 export { shellQuotePluginRootInCommand, resolveMcpServersMap, convertBareEnvVarsToVsCodeSyntax } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentPlugins/common/pluginParsers";
 export declare class AgentPluginService extends Disposable implements IAgentPluginService {