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

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

@@ -0,0 +1,300 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } 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 { AICustomizationSource } 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 { IChatPromptSlashCommand, ICustomAgent, IResolvedChatPromptSlashCommand } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { type CustomizationDisabledReason } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement";
+import { ICustomizationHarnessService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service";
+/**
+ * Override for a management section's create-button behavior.
+ */
+export interface ISectionOverride {
+    /**
+     * Label for the primary button. Required when `commandId` or `rootFile`
+     * is set. Ignored otherwise (the widget uses its default label).
+     */
+    readonly label?: string;
+    /** When set, the primary button invokes this command (e.g. hooks quick pick). */
+    readonly commandId?: string;
+    /** When set, the primary button creates this file at the workspace root. */
+    readonly rootFile?: string;
+    /**
+     * Custom type label for the dropdown workspace/user create actions
+     * (e.g. "Rule" instead of "Instruction"). When undefined, the
+     * section's default type label is used.
+     */
+    readonly typeLabel?: string;
+    /**
+     * Root-level file shortcuts added to the dropdown (e.g. `['AGENTS.md']`).
+     * Each entry creates a "New {filename}" action that creates the file at
+     * the workspace root. Harnesses that don't support a file simply omit it.
+     */
+    readonly rootFileShortcuts?: readonly string[];
+    /**
+     * File extension override for new files created under this section.
+     * When set, files are created with this extension (e.g. `.md` for
+     * Claude rules) instead of the default for the prompt type
+     * (e.g. `.instructions.md`).
+     */
+    readonly fileExtension?: string;
+}
+export interface ICustomizationItemAction {
+    readonly id: string;
+    readonly label: string;
+    readonly tooltip?: string;
+    readonly icon?: ThemeIcon;
+    readonly enabled?: boolean;
+    run(): void | Promise<void>;
+}
+/**
+ * Describes a single harness option for the UI toggle.
+ */
+export interface IHarnessDescriptor {
+    /**
+     * The harness/session-type identifier.
+     */
+    readonly id: string;
+    readonly label: string;
+    readonly icon: ThemeIcon;
+    /**
+     * Management sections that should be hidden when this harness is active.
+     * For example, Claude does not support prompt files so the Prompts
+     * section is hidden.
+     */
+    readonly hiddenSections?: readonly string[];
+    /**
+     * When `true`, the "Generate with AI" sparkle button is hidden and replaced
+     * with a plain "New X" manual-creation button (like sessions).
+     */
+    readonly hideGenerateButton?: boolean;
+    /**
+     * Per-section overrides for the create button behavior.
+     *
+     * A `commandId` entry replaces the button entirely with a command invocation.
+     *
+     * A `rootFile` entry makes the primary button create a specific file
+     * at the workspace root (e.g. Claude instructions → `CLAUDE.md`).
+     * When combined with `typeLabel`, the dropdown create actions use
+     * that label instead of the section's default (e.g. "Rule" instead
+     * of "Instruction").
+     */
+    readonly sectionOverrides?: ReadonlyMap<string, ISectionOverride>;
+    /**
+     * The chat agent ID that must be registered for this harness to appear.
+     * When `undefined`, the harness is always available (e.g. Local).
+     */
+    readonly requiredAgentId?: string;
+    /**
+     * When set, this harness is backed by an extension-contributed provider
+     * that can supply customization items directly (bypassing promptsService
+     * discovery and filtering).
+     */
+    readonly itemProvider?: ICustomizationItemProvider;
+    /**
+     * When `true`, the "Troubleshoot" action is available in item context
+     * menus. This opens chat with the `/troubleshoot` command pre-filled
+     * for the selected customization.
+     */
+    readonly supportsTroubleshoot?: boolean;
+    /**
+     * When set, this harness uses an opt-out sync model where all eligible
+     * local customizations are synced by default. The UI shows disable
+     * affordances when this harness is active.
+     */
+    readonly syncProvider?: ICustomizationSyncProvider;
+    /**
+     * Optional plugin-management actions shown in the Plugins section add menu.
+     * Harnesses can use these to add environment-specific commands alongside
+     * the default install-from-source action (for example, configuring plugins on
+     * a remote agent host). The create action remains a separate toolbar button.
+     */
+    readonly pluginActions?: readonly ICustomizationItemAction[];
+    /**
+     * Local MCP collection identifiers that do not apply to this harness.
+     * Host-published MCP servers remain visible even when their local counterpart
+     * belongs to a hidden collection.
+     */
+    readonly hiddenMcpServerCollectionIds?: readonly string[];
+}
+/**
+ * Represents a customization item provided by any source.
+ */
+export interface ICustomizationItem {
+    /** Optional stable identity used by list widgets when URI alone is not unique. */
+    readonly itemKey?: string;
+    readonly uri: URI;
+    readonly type: string;
+    readonly name: string;
+    readonly description?: string;
+    /** Customization source (local, user, extension, plugin, builtin). Set by providers that know the source. */
+    readonly source: AICustomizationSource;
+    /** The extension identifier that contributed this customization, if any. */
+    readonly extensionId: string | undefined;
+    /** The URI of the plugin that contributed this customization, if any. */
+    readonly pluginUri: URI | undefined;
+    /** Human-readable name of the plugin that contributed this customization, if any. */
+    readonly pluginLabel?: string;
+    /** Server-reported loading status for this customization. */
+    readonly status?: "loading" | "loaded" | "degraded" | "error";
+    /** Human-readable status detail (e.g. error message or warning). */
+    readonly statusMessage?: string;
+    /** Whether this customization is currently enabled. */
+    readonly enabled?: boolean;
+    /** Host-published reason for a disabled customization. */
+    readonly disabledReason?: CustomizationDisabledReason;
+    /** When set, items with the same groupKey are displayed under a shared collapsible header. */
+    readonly groupKey?: string;
+    /** When set, shows a small inline badge next to the item name (e.g. an applyTo glob pattern). */
+    readonly badge?: string;
+    /** Tooltip shown when hovering the badge. */
+    readonly badgeTooltip?: string;
+    /**
+     * Whether this customization item can be invoked by the user.
+     * Relevant for prompt / skill and custom agents
+     */
+    readonly userInvocable?: boolean;
+    /** Optional inline/context-menu actions specific to this item. */
+    readonly actions?: readonly ICustomizationItemAction[];
+}
+export interface ICustomizationAgentRef {
+    readonly id: string;
+    readonly uri: URI;
+    /** Agent name (from frontmatter `name`, or file-derived) */
+    readonly name: string;
+    /** Optional short description for UI preview (from frontmatter `description`) */
+    readonly description?: string;
+}
+export declare function isPluginCustomizationItem(item: {
+    readonly type: string;
+}): boolean;
+export declare function getCustomizationDisabledLabel(reason: CustomizationDisabledReason | undefined): string;
+/**
+ * Provider interface for extension-contributed harnesses that supply
+ * customization items directly from their SDK.
+ */
+export interface ICustomizationItemProvider {
+    /**
+     * Event that fires when the provider's customizations change.
+     */
+    readonly onDidChange: Event<void>;
+    /**
+     * Provide the customization items this harness supports.
+     *
+     * @param sessionResource URI of the chat session whose
+     *   customizations should be included. Providers that surface
+     *   session-scoped state (e.g. an agent host) should read from
+     *   this session.
+     */
+    provideChatSessionCustomizations(sessionResource: URI, token: CancellationToken): Promise<ICustomizationItem[] | undefined>;
+    /**
+     * Provide the custom agents this harness supports.
+     *
+     * @param sessionResource URI of the chat session whose
+     *   customizations should be included. Providers that surface
+     *   session-scoped state (e.g. an agent host) should read from
+     *   this session.
+     */
+    provideCustomAgents?(sessionResource: URI, token: CancellationToken): Promise<readonly ICustomAgent[]>;
+    /**
+     * Provide the directories where new customization files of the given
+     * type can be created for this session. The result includes both
+     * workspace-scoped and user-scoped folders; the caller is responsible
+     * for partitioning them by storage target.
+     *
+     * @param sessionResource URI of the chat session whose
+     *   creation locations should be returned.
+     */
+    provideSourceFolders?(sessionResource: URI, type: PromptsType, token: CancellationToken): Promise<readonly ICustomizationSourceFolder[] | undefined>;
+}
+/**
+ * A directory where new customization files of a given type can be created.
+ */
+export interface ICustomizationSourceFolder {
+    readonly uri: URI;
+    /** Display label for the picker when multiple folders are offered. */
+    readonly label: string;
+    /** Customization source for this folder (typically 'local' or 'user' for writable creation locations). */
+    readonly source: AICustomizationSource;
+    /** Opaque provider-defined identity shared by folders that belong to the same destination. */
+    readonly destinationGroupId?: string;
+}
+/**
+ * Provider interface for harnesses that use an opt-out sync model.
+ *
+ * Every eligible local customization is synced by default; the user
+ * can disable individual items. The persisted set captures only the
+ * user's opt-outs.
+ */
+export interface ICustomizationSyncProvider {
+    readonly onDidChange: Event<void>;
+    isDisabled(uri: URI): boolean;
+    setDisabled(uri: URI, disabled: boolean): void;
+}
+/**
+ * Minimal slash-command metadata resolved from the active harness.
+ */
+export interface ICustomizationSlashCommand {
+    readonly uri: URI;
+    readonly type: PromptsType.prompt | PromptsType.skill;
+    readonly name: string;
+    readonly description?: string;
+    readonly userInvocable: boolean;
+    readonly sessionTypes?: readonly string[];
+}
+/**
+ * Builds the full source list from the base set (local, user, plugin)
+ * plus any additional sources specific to the window type.
+ *
+ * Core passes `[PromptsStorage.extension]`; sessions passes its
+ * BUILTIN_STORAGE constant.
+ */
+/**
+ * Creates a "VS Code" harness descriptor that shows all storage sources
+ * with no user-root restrictions.
+ */
+export declare function createVSCodeHarnessDescriptor(): IHarnessDescriptor;
+/**
+ * Reusable base implementation of {@link ICustomizationHarnessService}.
+ * Concrete registrations only need to supply the list of harness
+ * descriptors and a default harness id.
+ */
+export declare class CustomizationHarnessServiceBase implements ICustomizationHarnessService {
+    private readonly promptsService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeSlashCommands;
+    readonly onDidChangeSlashCommands: Event<{
+        readonly sessionType: string;
+    }>;
+    private readonly _onDidChangeCustomAgents;
+    readonly onDidChangeCustomAgents: Event<{
+        readonly sessionType: string;
+    }>;
+    private readonly _providerListeners;
+    private _isDisposed;
+    private readonly _activeSessionResource;
+    readonly activeSessionResource: IObservable<URI>;
+    private readonly _activeHarness;
+    readonly activeHarness: IObservable<string>;
+    private readonly _staticHarnesses;
+    private readonly _externalHarnesses;
+    private readonly _availableHarnesses;
+    readonly availableHarnesses: IObservable<readonly IHarnessDescriptor[]>;
+    constructor(staticHarnesses: readonly IHarnessDescriptor[], defaultHarness: string, promptsService: IPromptsService);
+    private _getAllHarnesses;
+    private _refreshAvailableHarnesses;
+    private _rebindProviderListeners;
+    dispose(): void;
+    registerExternalHarness(descriptor: IHarnessDescriptor): IDisposable;
+    findHarnessById(id: string): IHarnessDescriptor | undefined;
+    setActiveSession(sessionResource: URI): void;
+    getActiveDescriptor(): IHarnessDescriptor;
+    getSlashCommands(sessionResource: URI, token: CancellationToken): Promise<readonly IChatPromptSlashCommand[]>;
+    getCustomAgents(sessionResource: URI, token: CancellationToken): Promise<readonly ICustomAgent[]>;
+    resolvePromptSlashCommand(name: string, sessionResource: URI, token: CancellationToken): Promise<IResolvedChatPromptSlashCommand | undefined>;
+    getSessionResourceForHarness(sessionType: string): URI;
+}

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/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;