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

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/extensionPromptFileService.js

@@ -0,0 +1,335 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { getSkillFolderName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { PromptFileParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
+import { PromptsType, PromptFileSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptsStorage, SKILL_PROVIDER_ACTIVATION_EVENT, PROMPT_FILE_PROVIDER_ACTIVATION_EVENT, INSTRUCTIONS_PROVIDER_ACTIVATION_EVENT, CUSTOM_AGENT_PROVIDER_ACTIVATION_EVENT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+
+const ALL_PROMPT_TYPES = [
+    PromptsType.prompt,
+    PromptsType.instructions,
+    PromptsType.agent,
+    PromptsType.skill,
+    PromptsType.hook
+];
+let ExtensionPromptFileService = class ExtensionPromptFileService extends Disposable {
+    constructor(
+        logger,
+        fileService,
+        modelService,
+        extensionService,
+        filesConfigService,
+        contextKeyService
+    ) {
+        super();
+        this.logger = logger;
+        this.fileService = fileService;
+        this.modelService = modelService;
+        this.extensionService = extensionService;
+        this.filesConfigService = filesConfigService;
+        this.contextKeyService = contextKeyService;
+        this.contributedFiles = {
+            [PromptsType.prompt]: ( new ResourceMap()),
+            [PromptsType.instructions]: ( new ResourceMap()),
+            [PromptsType.agent]: ( new ResourceMap()),
+            [PromptsType.skill]: ( new ResourceMap()),
+            [PromptsType.hook]: ( new ResourceMap())
+        };
+        this._promptFileProviders = [];
+        this._contributedWhenKeys = ( new Set());
+        this._contributedWhenClauses = ( new Map());
+        this._providerWhenClauses = ( new Map());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._pendingReadonlyUris = [];
+        this._pendingReadonlyFlush = false;
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (e.affectsSome(this._contributedWhenKeys)) {
+                for (const type of ALL_PROMPT_TYPES) {
+                    this._onDidChange.fire({
+                        type
+                    });
+                }
+            }
+        }));
+    }
+    async getExtensionPromptFiles(type, token) {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        const settledResults = await Promise.allSettled(( this.contributedFiles[type].values()));
+        const contributedFiles = ( settledResults.filter(result => result.status === "fulfilled").map(result => result.value));
+        const activationEvent = this._getProviderActivationEvent(type);
+        const providerFiles = activationEvent ? await this._listFromProviders(type, activationEvent, token) : [];
+        return [...contributedFiles, ...providerFiles].filter(file => {
+            if (!file.when) {
+                return true;
+            }
+            const when = ContextKeyExpr.deserialize(file.when);
+            if (!when) {
+                this.logger.warn(
+                    `[getExtensionPromptFiles] Ignoring contributed prompt file with invalid when clause: ${file.when}`
+                );
+                return false;
+            }
+            return this.contextKeyService.contextMatchesRules(when);
+        });
+    }
+    registerContributedFile(type, uri, extension, name, description, when, sessionTypes) {
+        const bucket = this.contributedFiles[type];
+        if (( bucket.has(uri))) {
+            return Disposable.None;
+        }
+        const entryPromise = (async () => {
+            if (type === PromptsType.skill) {
+                try {
+                    const validated = await this._validateAndSanitizeSkillFile(uri, CancellationToken.None);
+                    name = validated.name;
+                    description = validated.description;
+                } catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    this.logger.error(
+                        `[registerContributedFile] Extension '${extension.identifier.value}' failed to validate skill file: ${uri}`,
+                        msg
+                    );
+                    throw e;
+                }
+            }
+            return {
+                uri,
+                name,
+                description,
+                when,
+                sessionTypes,
+                storage: PromptsStorage.extension,
+                type,
+                extension,
+                source: PromptFileSource.ExtensionContribution
+            };
+        })();
+        bucket.set(uri, entryPromise);
+        this._enqueueReadonlyUpdate(uri);
+        if (when) {
+            this._contributedWhenClauses.set(`${type}/${( uri.toString())}`, when);
+            this._updateContributedWhenKeys();
+        }
+        this._onDidChange.fire({
+            type
+        });
+        return {
+            dispose: () => {
+                bucket.delete(uri);
+                if (when) {
+                    this._contributedWhenClauses.delete(`${type}/${( uri.toString())}`);
+                    this._updateContributedWhenKeys();
+                }
+                this._onDidChange.fire({
+                    type
+                });
+            }
+        };
+    }
+    registerPromptFileProvider(extension, type, provider) {
+        const providerEntry = {
+            extension,
+            type,
+            ...provider
+        };
+        this._promptFileProviders.push(providerEntry);
+        const disposables = ( new DisposableStore());
+        if (provider.onDidChangePromptFiles) {
+            disposables.add(provider.onDidChangePromptFiles(() => {
+                this._onDidChange.fire({
+                    type
+                });
+            }));
+        }
+        this._onDidChange.fire({
+            type
+        });
+        disposables.add({
+            dispose: () => {
+                const index = this._promptFileProviders.findIndex(p => p === providerEntry);
+                if (index >= 0) {
+                    this._promptFileProviders.splice(index, 1);
+                    this._providerWhenClauses.delete(providerEntry);
+                    this._updateContributedWhenKeys();
+                    this._onDidChange.fire({
+                        type
+                    });
+                }
+            }
+        });
+        return disposables;
+    }
+    async _listFromProviders(type, activationEvent, token) {
+        const result = [];
+        const readonlyUris = [];
+        await this.extensionService.activateByEvent(activationEvent);
+        const providers = this._promptFileProviders.filter(p => p.type === type);
+        if (providers.length === 0) {
+            return result;
+        }
+        for (const providerEntry of providers) {
+            if (token.isCancellationRequested) {
+                break;
+            }
+            try {
+                const files = await providerEntry.providePromptFiles({}, token);
+                this._providerWhenClauses.set(providerEntry, files?.flatMap(file => file.when ? [file.when] : []) ?? []);
+                this._updateContributedWhenKeys();
+                if (!files || token.isCancellationRequested) {
+                    continue;
+                }
+                for (const file of files) {
+                    readonlyUris.push(file.uri);
+                    result.push({
+                        uri: file.uri,
+                        storage: PromptsStorage.extension,
+                        type,
+                        extension: providerEntry.extension,
+                        source: PromptFileSource.ExtensionAPI,
+                        name: file.name,
+                        description: file.description,
+                        when: file.when,
+                        sessionTypes: file.sessionTypes
+                    });
+                }
+            } catch (e) {
+                if (token.isCancellationRequested || isCancellationError(e)) {
+                    break;
+                }
+                this.logger.error(
+                    `[listFromProviders] Failed to get ${type} files from provider`,
+                    e instanceof Error ? e.message : String(e)
+                );
+            }
+        }
+        void this.filesConfigService.updateReadonly(readonlyUris, true);
+        return result;
+    }
+    _getProviderActivationEvent(type) {
+        switch (type) {
+        case PromptsType.agent:
+            return CUSTOM_AGENT_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.instructions:
+            return INSTRUCTIONS_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.prompt:
+            return PROMPT_FILE_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.skill:
+            return SKILL_PROVIDER_ACTIVATION_EVENT;
+        case PromptsType.hook:
+            return undefined;
+        }
+    }
+    _enqueueReadonlyUpdate(uri) {
+        this._pendingReadonlyUris.push(uri);
+        if (!this._pendingReadonlyFlush) {
+            this._pendingReadonlyFlush = true;
+            queueMicrotask(() => {
+                const uris = this._pendingReadonlyUris;
+                this._pendingReadonlyUris = [];
+                this._pendingReadonlyFlush = false;
+                void this.filesConfigService.updateReadonly(uris, true);
+            });
+        }
+    }
+    _updateContributedWhenKeys() {
+        this._contributedWhenKeys.clear();
+        for (const whenClause of ( this._contributedWhenClauses.values())) {
+            const expr = ContextKeyExpr.deserialize(whenClause);
+            for (const key of expr?.keys() ?? []) {
+                this._contributedWhenKeys.add(key);
+            }
+        }
+        for (const whenClauses of ( this._providerWhenClauses.values())) {
+            for (const whenClause of whenClauses) {
+                const expr = ContextKeyExpr.deserialize(whenClause);
+                for (const key of expr?.keys() ?? []) {
+                    this._contributedWhenKeys.add(key);
+                }
+            }
+        }
+    }
+    async _validateAndSanitizeSkillFile(uri, token) {
+        const parsedFile = await this._parsePromptFile(uri, token);
+        const folderName = getSkillFolderName(uri);
+        let name = parsedFile.header?.name;
+        if (!name) {
+            this.logger.debug(
+                `[validateAndSanitizeSkillFile] Agent skill file missing name attribute, using folder name "${folderName}": ${uri}`
+            );
+            name = folderName;
+        }
+        const description = parsedFile.header?.description;
+        let sanitizedName = this._truncateAgentSkillName(name, uri);
+        if (sanitizedName !== folderName) {
+            this.logger.debug(
+                `[validateAndSanitizeSkillFile] Agent skill name "${sanitizedName}" does not match folder name "${folderName}", using folder name: ${uri}`
+            );
+            sanitizedName = folderName;
+        }
+        const sanitizedDescription = description ? this._truncateAgentSkillDescription(description, uri) : undefined;
+        return {
+            name: sanitizedName,
+            description: sanitizedDescription
+        };
+    }
+    async _parsePromptFile(uri, token) {
+        const model = this.modelService.getModel(uri);
+        if (model) {
+            return ( new PromptFileParser()).parse(uri, model.getValue());
+        }
+        const fileContent = await this.fileService.readFile(uri);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        return ( new PromptFileParser()).parse(uri, ( fileContent.value.toString()));
+    }
+    _sanitizeAgentSkillText(text) {
+        return text.replace(/<[^>]+>/g, "");
+    }
+    _truncateAgentSkillName(name, uri) {
+        const MAX_NAME_LENGTH = 64;
+        const sanitized = this._sanitizeAgentSkillText(name);
+        if (sanitized !== name) {
+            this.logger.debug(`[findAgentSkills] Agent skill name contains XML tags, removed: ${uri}`);
+        }
+        if (sanitized.length > MAX_NAME_LENGTH) {
+            this.logger.debug(
+                `[findAgentSkills] Agent skill name exceeds ${MAX_NAME_LENGTH} characters, truncated: ${uri}`
+            );
+            return sanitized.substring(0, MAX_NAME_LENGTH);
+        }
+        return sanitized;
+    }
+    _truncateAgentSkillDescription(description, uri) {
+        const MAX_DESCRIPTION_LENGTH = 1024;
+        const sanitized = this._sanitizeAgentSkillText(description);
+        if (sanitized !== description) {
+            this.logger.debug(
+                `[findAgentSkills] Agent skill description contains XML tags, removed: ${uri}`
+            );
+        }
+        if (sanitized.length > MAX_DESCRIPTION_LENGTH) {
+            this.logger.debug(
+                `[findAgentSkills] Agent skill description exceeds ${MAX_DESCRIPTION_LENGTH} characters, truncated: ${uri}`
+            );
+            return sanitized.substring(0, MAX_DESCRIPTION_LENGTH);
+        }
+        return sanitized;
+    }
+};
+ExtensionPromptFileService = ( __decorate([( __param(0, ILogService)), ( __param(1, IFileService)), ( __param(2, IModelService)), ( __param(3, IExtensionService)), ( __param(4, IFilesConfigurationService)), ( __param(5, IContextKeyService))], ExtensionPromptFileService));
+
+export { ExtensionPromptFileService };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/promptsServiceImpl.d.ts

@@ -0,0 +1,235 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ResourceSet } from "@codingame/monaco-vscode-api/vscode/vs/base/common/map";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IExtensionDescription } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.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 { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+import { IResolvedPromptSourceFolder } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations";
+import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { PromptFilesLocator } from "../utils/promptFilesLocator.js";
+import { ParsedPromptFile } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser";
+import { IAgentSource, IChatPromptSlashCommand, IConfiguredHooksInfo, ICustomAgent, IBuiltinPromptPath, IPromptPath, IAgentSkill, IInstructionFile, PromptsStorage, IPromptFileContext, IPromptFileResource, IPromptDiscoveryInfo, IAgentInstructionFile, Logger, 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 { ChatRequestHooks } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IAgentPluginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service";
+/**
+ * Provides prompt services.
+ */
+export declare class PromptsService extends Disposable implements IPromptsService {
+    readonly logger: ILogService;
+    private readonly labelService;
+    private readonly modelService;
+    protected readonly instantiationService: IInstantiationService;
+    private readonly userDataService;
+    private readonly configurationService;
+    protected readonly fileService: IFileService;
+    private readonly storageService;
+    private readonly telemetryService;
+    private readonly workspaceService;
+    protected readonly pathService: IPathService;
+    private readonly agentPluginService;
+    private readonly workspaceTrustService;
+    readonly _serviceBrand: undefined;
+    /**
+     * Bounds how many prompt files discovery reads in parallel.
+     *
+     * Owned by the service rather than created per invocation on purpose: an
+     * invalidation clears the cached discovery promise without cancelling the
+     * computation it was tracking, so several passes can run at once. A limiter
+     * per invocation would give each pass its own quota and the aggregate would
+     * still grow with the number of passes, which is the exhaustion this bound
+     * exists to prevent.
+     */
+    private readonly _discoveryLimiter;
+    /**
+     * Queues a discovery file read on the shared, service-wide limiter.
+     */
+    private queueDiscoveryRead;
+    /**
+     * Prompt files locator utility.
+     */
+    private readonly fileLocator;
+    /**
+     * Cached agent discovery info.
+     */
+    private readonly cachedCustomAgents;
+    /**
+     * Cached slash command discovery info.
+     */
+    private readonly cachedSlashCommands;
+    /**
+     * Cached hooks. Invalidated when hook files change.
+     */
+    private readonly cachedHooks;
+    /**
+     * Cached skill discovery info.
+     */
+    private readonly cachedSkills;
+    /**
+     * Cached instructions.
+     */
+    private readonly cachedInstructions;
+    private readonly agentInstructionsWatcher;
+    private readonly _onDidChangeAgentInstructions;
+    /**
+     * Synchronous mirror of the names exposed by {@link getPromptSlashCommands},
+     * maintained for {@link hasPromptSlashCommand} so callers (e.g. the chat request
+     * parser) can disambiguate `<cmd>:<sub>` vs bare `<cmd>` without an async hop.
+     */
+    private readonly knownPromptSlashCommandNames;
+    /**
+     * Cache for parsed prompt files keyed by URI.
+     * The number in the returned tuple is textModel.getVersionId(), which is an internal VS Code counter that increments every time the text model's content changes.
+     */
+    private readonly cachedParsedPromptFromModels;
+    /**
+     * Cached file locations commands. Caching only happens if the corresponding `fileLocatorEvents` event is used.
+     */
+    private readonly cachedFileLocations;
+    /**
+     * Lazily created events that notify listeners when the file locations for a given prompt type change.
+     * An event is created on demand for each prompt type and can be used by consumers to react to updates
+     * in the set of prompt files (e.g., when prompt files are added, removed, or modified).
+     */
+    private readonly fileLocatorEvents;
+    /**
+     * Owns the registry of extension-contributed prompt files (both via
+     * contribution points and via provider API).
+     */
+    private readonly extensionPromptFiles;
+    private readonly _onDidPluginPromptFilesChange;
+    private readonly _onDidPluginHooksChange;
+    private _pluginPromptFilesByType;
+    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService, configurationService: IConfigurationService, fileService: IFileService, storageService: IStorageService, telemetryService: ITelemetryService, workspaceService: IWorkspaceContextService, pathService: IPathService, agentPluginService: IAgentPluginService, workspaceTrustService: IWorkspaceTrustManagementService);
+    private watchPluginPromptFilesForType;
+    protected createPromptFilesLocator(): PromptFilesLocator;
+    private getFileLocatorEvent;
+    getParsedPromptFile(textModel: ITextModel): ParsedPromptFile;
+    listPromptFiles(type: PromptsType, token: CancellationToken): Promise<readonly IPromptPath[]>;
+    private computeListPromptFiles;
+    /**
+     * Collects diagnostic information about which source folders were searched for display in the debug panel.
+     */
+    private _collectSourceFolderDiagnostics;
+    /**
+     * Registers a prompt file provider (CustomAgentProvider, InstructionsProvider, or PromptFileProvider).
+     * This will be called by the extension host bridge when
+     * an extension registers a provider via vscode.chat.registerCustomAgentProvider(),
+     * registerInstructionsProvider(), or registerPromptFileProvider().
+     */
+    registerPromptFileProvider(extension: IExtensionDescription, type: PromptsType, provider: {
+        onDidChangePromptFiles?: Event<void>;
+        providePromptFiles: (context: IPromptFileContext, token: CancellationToken) => Promise<IPromptFileResource[] | undefined>;
+    }): IDisposable;
+    listPromptFilesForStorage(type: PromptsType, storage: PromptsStorage, token: CancellationToken, root?: URI): Promise<readonly IPromptPath[]>;
+    private getExtensionPromptFiles;
+    /**
+     * Returns the built-in prompt files of the given type. The base service ships
+     * no built-in prompts; subclasses (e.g. the Agents app) override this to
+     * contribute bundled prompts such as built-in skills.
+     */
+    protected getBuiltinPromptFiles(type: PromptsType, token: CancellationToken): Promise<readonly IBuiltinPromptPath[]>;
+    getSourceFolders(type: PromptsType): Promise<readonly IPromptPath[]>;
+    getResolvedSourceFolders(type: PromptsType): Promise<readonly IResolvedPromptSourceFolder[]>;
+    private areStandalonePromptFilesBlocked;
+    private areAgentHooksAllowed;
+    /**
+     * Emitter for slash commands change events.
+     */
+    get onDidChangeSlashCommands(): Event<void>;
+    getPromptSlashCommands(token: CancellationToken): Promise<readonly IChatPromptSlashCommand[]>;
+    /**
+     * Computes discovery info for slash commands, combining prompts and skills.
+     */
+    private computeSlashCommandDiscoveryInfo;
+    /**
+     * Derives IChatPromptSlashCommand[] from cached discovery info.
+     */
+    private slashCommandsFromDiscoveryInfo;
+    isValidSlashCommandName(command: string): boolean;
+    hasPromptSlashCommand(name: string): boolean;
+    private knownPromptSlashCommandsHydrationStarted;
+    private refreshKnownPromptSlashCommandNames;
+    resolvePromptSlashCommand(name: string, sessionType: string | undefined, token: CancellationToken): Promise<IResolvedChatPromptSlashCommand | undefined>;
+    private asChatPromptSlashCommand;
+    getPromptSlashCommandName(uri: URI, token: CancellationToken): Promise<string>;
+    /**
+     * Emitter for custom agents change events.
+     */
+    get onDidChangeCustomAgents(): Event<void>;
+    get onDidChangeInstructions(): Event<void>;
+    get onDidChangeAgentInstructions(): Event<void>;
+    getCustomAgents(token: CancellationToken): Promise<readonly ICustomAgent[]>;
+    /**
+     * Derives ICustomAgent[] from cached discovery info.
+     */
+    private agentsFromDiscoveryInfo;
+    private computeAgentDiscoveryInfo;
+    parseNew(uri: URI, token: CancellationToken): Promise<ParsedPromptFile>;
+    registerContributedFile(type: PromptsType, uri: URI, extension: IExtensionDescription, name?: string, description?: string, when?: string, sessionTypes?: readonly string[]): IDisposable;
+    getPromptLocationLabel(promptPath: IPromptPath): string;
+    listNestedAgentMDs(token: CancellationToken): Promise<IAgentInstructionFile[]>;
+    listAgentInstructions(token: CancellationToken, logger: Logger | undefined): Promise<IAgentInstructionFile[]>;
+    getVoiceInstructions(token: CancellationToken): Promise<string | undefined>;
+    getDictationInstructions(token: CancellationToken): Promise<string | undefined>;
+    private getSpeechInstructions;
+    getAgentFileURIFromModeFile(oldURI: URI): URI | undefined;
+    private readonly disabledPromptsStorageKeyPrefix;
+    getDisabledPromptFiles(type: PromptsType): ResourceSet;
+    setDisabledPromptFiles(type: PromptsType, uris: ResourceSet): void;
+    private sanitizeAgentSkillText;
+    private truncateAgentSkillName;
+    private truncateAgentSkillDescription;
+    get onDidChangeSkills(): Event<void>;
+    get onDidChangeHooks(): Event<void>;
+    findAgentSkills(token: CancellationToken): Promise<IAgentSkill[] | undefined>;
+    /**
+     * Derives IAgentSkill[] from cached discovery info.
+     */
+    private skillsFromDiscoveryInfo;
+    /**
+     * Computes the full skill discovery info, including source folders and telemetry.
+     */
+    private computeSkillDiscovery;
+    getHooks(token: CancellationToken): Promise<IConfiguredHooksInfo | undefined>;
+    getDiscoveryInfo(type: PromptsType, token: CancellationToken): Promise<IPromptDiscoveryInfo>;
+    getInstructionFiles(token: CancellationToken): Promise<readonly IInstructionFile[]>;
+    private instructionsFromDiscoveryInfo;
+    private withPromptPathMetadata;
+    private computeInstructionFiles;
+    private computeHooks;
+    /**
+     * Precedence used when deduplicating skills that share the same canonical
+     * name: workspace > personal > plugin > extension API > extension contribution.
+     * Lower numbers win.
+     */
+    private getSkillPriority;
+    /**
+     * Returns the discovery results for skill files.
+     */
+    private computeSkillDiscoveryInfo;
+    private getInstructionsDiscoveryInfo;
+}
+export declare namespace CustomAgent {
+    function fromParsedPromptFile(ast: ParsedPromptFile, extra: {
+        name?: string;
+        description?: string;
+        source: IAgentSource;
+        hooks?: ChatRequestHooks;
+        sessionTypes: readonly string[] | undefined;
+        enabled: boolean;
+    }): ICustomAgent;
+}