@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -1,10 +1,11 @@
 
 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 { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Event, 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, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { isEqual, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isEqual, dirname, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { OffsetRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
@@ -22,17 +23,50 @@ import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform
 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 { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
-import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
-import { getCleanPromptName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { getCleanPromptName, PromptFileSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
 import { PromptsType, PROMPT_LANGUAGE_ID, getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { PromptFilesLocator } from '../utils/promptFilesLocator.js';
 import { PromptFileParser, PromptHeaderAttributes } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
-import { PromptsStorage, CUSTOM_AGENTS_PROVIDER_ACTIVATION_EVENT, ExtensionAgentSourceType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { PromptsStorage, ExtensionAgentSourceType, 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';
 import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 
+class SkillMissingNameError extends Error {
+    constructor(uri) {
+        super("Skill file must have a name attribute");
+        this.uri = uri;
+    }
+}
+class SkillMissingDescriptionError extends Error {
+    constructor(uri) {
+        super("Skill file must have a description attribute");
+        this.uri = uri;
+    }
+}
+class SkillNameMismatchError extends Error {
+    constructor(uri, skillName, folderName) {
+        super(
+            `Skill name must match folder name: expected "${folderName}" but got "${skillName}"`
+        );
+        this.uri = uri;
+        this.skillName = skillName;
+        this.folderName = folderName;
+    }
+}
 let PromptsService = class PromptsService extends Disposable {
-    constructor(logger, labelService, modelService, instantiationService, userDataService, configurationService, fileService, filesConfigService, storageService, extensionService, defaultAccountService, telemetryService) {
+    constructor(
+        logger,
+        labelService,
+        modelService,
+        instantiationService,
+        userDataService,
+        configurationService,
+        fileService,
+        filesConfigService,
+        storageService,
+        extensionService,
+        telemetryService
+    ) {
         super();
         this.logger = logger;
         this.labelService = labelService;
@@ -44,7 +78,6 @@ let PromptsService = class PromptsService extends Disposable {
         this.filesConfigService = filesConfigService;
         this.storageService = storageService;
         this.extensionService = extensionService;
-        this.defaultAccountService = defaultAccountService;
         this.telemetryService = telemetryService;
         this.cachedParsedPromptFromModels = ( new ResourceMap());
         this.cachedFileLocations = {};
@@ -53,22 +86,23 @@ let PromptsService = class PromptsService extends Disposable {
             [PromptsType.prompt]: ( new ResourceMap()),
             [PromptsType.instructions]: ( new ResourceMap()),
             [PromptsType.agent]: ( new ResourceMap()),
+            [PromptsType.skill]: ( new ResourceMap())
         };
-        this.customAgentsProviders = [];
-        this.disabledPromptsStorageKeyPrefix = 'chat.disabledPromptFiles.';
+        this.promptFileProviders = [];
+        this.disabledPromptsStorageKeyPrefix = "chat.disabledPromptFiles.";
         this.fileLocator = this.instantiationService.createInstance(PromptFilesLocator);
-        this._register(this.modelService.onModelRemoved((model) => {
+        this._register(this.modelService.onModelRemoved(model => {
             this.cachedParsedPromptFromModels.delete(model.uri);
         }));
         const modelChangeEvent = this._register(( new ModelChangeTracker(this.modelService))).onDidPromptChange;
-        this.cachedCustomAgents = this._register(( new CachedPromise(
-            (token) => this.computeCustomAgents(token),
-            () => Event.any(this.getFileLocatorEvent(PromptsType.agent), Event.filter(modelChangeEvent, e => e.promptType === PromptsType.agent))
-        )));
-        this.cachedSlashCommands = this._register(( new CachedPromise(
-            (token) => this.computePromptSlashCommands(token),
-            () => Event.any(this.getFileLocatorEvent(PromptsType.prompt), Event.filter(modelChangeEvent, e => e.promptType === PromptsType.prompt))
-        )));
+        this.cachedCustomAgents = this._register(( new CachedPromise(token => this.computeCustomAgents(token), () => Event.any(
+            this.getFileLocatorEvent(PromptsType.agent),
+            Event.filter(modelChangeEvent, e => e.promptType === PromptsType.agent)
+        ))));
+        this.cachedSlashCommands = this._register(( new CachedPromise(token => this.computePromptSlashCommands(token), () => Event.any(
+            this.getFileLocatorEvent(PromptsType.prompt),
+            Event.filter(modelChangeEvent, e => e.promptType === PromptsType.prompt)
+        ))));
     }
     getFileLocatorEvent(type) {
         let event = this.fileLocatorEvents[type];
@@ -105,113 +139,185 @@ let PromptsService = class PromptsService extends Disposable {
     }
     async computeListPromptFiles(type, token) {
         const prompts = await Promise.all([
-            this.fileLocator.listFiles(type, PromptsStorage.user, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.user, type })))),
-            this.fileLocator.listFiles(type, PromptsStorage.local, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.local, type })))),
-            this.getExtensionPromptFiles(type, token),
+            this.fileLocator.listFiles(type, PromptsStorage.user, token).then(uris => ( uris.map(uri => ({
+                uri,
+                storage: PromptsStorage.user,
+                type
+            })))),
+            this.fileLocator.listFiles(type, PromptsStorage.local, token).then(uris => ( uris.map(uri => ({
+                uri,
+                storage: PromptsStorage.local,
+                type
+            })))),
+            this.getExtensionPromptFiles(type, token)
         ]);
         return [...prompts.flat()];
     }
-    registerCustomAgentsProvider(extension, provider) {
-        const providerEntry = { extension, ...provider };
-        this.customAgentsProviders.push(providerEntry);
+    registerPromptFileProvider(extension, type, provider) {
+        const providerEntry = {
+            extension,
+            type,
+            ...provider
+        };
+        this.promptFileProviders.push(providerEntry);
         const disposables = ( new DisposableStore());
-        if (provider.onDidChangeCustomAgents) {
-            disposables.add(provider.onDidChangeCustomAgents(() => {
-                this.cachedFileLocations[PromptsType.agent] = undefined;
-                this.cachedCustomAgents.refresh();
+        if (provider.onDidChangePromptFiles) {
+            disposables.add(provider.onDidChangePromptFiles(() => {
+                if (type === PromptsType.agent) {
+                    this.cachedFileLocations[PromptsType.agent] = undefined;
+                    this.cachedCustomAgents.refresh();
+                } else if (type === PromptsType.instructions) {
+                    this.cachedFileLocations[PromptsType.instructions] = undefined;
+                } else if (type === PromptsType.prompt) {
+                    this.cachedFileLocations[PromptsType.prompt] = undefined;
+                    this.cachedSlashCommands.refresh();
+                } else if (type === PromptsType.skill) {
+                    this.cachedFileLocations[PromptsType.skill] = undefined;
+                }
             }));
         }
-        this.cachedFileLocations[PromptsType.agent] = undefined;
-        this.cachedCustomAgents.refresh();
+        if (type === PromptsType.agent) {
+            this.cachedFileLocations[PromptsType.agent] = undefined;
+            this.cachedCustomAgents.refresh();
+        } else if (type === PromptsType.instructions) {
+            this.cachedFileLocations[PromptsType.instructions] = undefined;
+        } else if (type === PromptsType.prompt) {
+            this.cachedFileLocations[PromptsType.prompt] = undefined;
+            this.cachedSlashCommands.refresh();
+        } else if (type === PromptsType.skill) {
+            this.cachedFileLocations[PromptsType.skill] = undefined;
+        }
         disposables.add({
             dispose: () => {
-                const index = this.customAgentsProviders.findIndex((p) => p === providerEntry);
+                const index = this.promptFileProviders.findIndex(p => p === providerEntry);
                 if (index >= 0) {
-                    this.customAgentsProviders.splice(index, 1);
-                    this.cachedFileLocations[PromptsType.agent] = undefined;
-                    this.cachedCustomAgents.refresh();
+                    this.promptFileProviders.splice(index, 1);
+                    if (type === PromptsType.agent) {
+                        this.cachedFileLocations[PromptsType.agent] = undefined;
+                        this.cachedCustomAgents.refresh();
+                    } else if (type === PromptsType.instructions) {
+                        this.cachedFileLocations[PromptsType.instructions] = undefined;
+                    } else if (type === PromptsType.prompt) {
+                        this.cachedFileLocations[PromptsType.prompt] = undefined;
+                        this.cachedSlashCommands.refresh();
+                    } else if (type === PromptsType.skill) {
+                        this.cachedFileLocations[PromptsType.skill] = undefined;
+                    }
                 }
             }
         });
         return disposables;
     }
-    async listCustomAgentsFromProvider(token) {
+    async listFromProviders(type, activationEvent, token) {
         const result = [];
-        if (this.customAgentsProviders.length === 0) {
+        await this.extensionService.activateByEvent(activationEvent);
+        const providers = this.promptFileProviders.filter(p => p.type === type);
+        if (providers.length === 0) {
             return result;
         }
-        await this.extensionService.activateByEvent(CUSTOM_AGENTS_PROVIDER_ACTIVATION_EVENT);
-        for (const providerEntry of this.customAgentsProviders) {
+        for (const providerEntry of providers) {
             try {
-                const agents = await providerEntry.provideCustomAgents({}, token);
-                if (!agents || token.isCancellationRequested) {
+                const files = await providerEntry.providePromptFiles({}, token);
+                if (!files || token.isCancellationRequested) {
                     continue;
                 }
-                for (const agent of agents) {
-                    if (!agent.isEditable) {
-                        try {
-                            await this.filesConfigService.updateReadonly(agent.uri, true);
-                        }
-                        catch (e) {
-                            const msg = e instanceof Error ? e.message : String(e);
-                            this.logger.error(`[listCustomAgentsFromProvider] Failed to make agent file readonly: ${agent.uri}`, msg);
-                        }
+                for (const file of files) {
+                    try {
+                        await this.filesConfigService.updateReadonly(file.uri, true);
+                    } catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        this.logger.error(`[listFromProviders] Failed to make file readonly: ${file.uri}`, msg);
                     }
                     result.push({
-                        uri: agent.uri,
-                        name: agent.name,
-                        description: agent.description,
+                        uri: file.uri,
                         storage: PromptsStorage.extension,
-                        type: PromptsType.agent,
+                        type,
                         extension: providerEntry.extension,
                         source: ExtensionAgentSourceType.provider
                     });
                 }
-            }
-            catch (e) {
-                this.logger.error(`[listCustomAgentsFromProvider] Failed to get custom agents from provider`, e instanceof Error ? e.message : String(e));
+            } catch (e) {
+                this.logger.error(
+                    `[listFromProviders] Failed to get ${type} files from provider`,
+                    e instanceof Error ? e.message : String(e)
+                );
             }
         }
         return result;
     }
     async listPromptFilesForStorage(type, storage, token) {
         switch (storage) {
-            case PromptsStorage.extension:
-                return this.getExtensionPromptFiles(type, token);
-            case PromptsStorage.local:
-                return this.fileLocator.listFiles(type, PromptsStorage.local, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.local, type }))));
-            case PromptsStorage.user:
-                return this.fileLocator.listFiles(type, PromptsStorage.user, token).then(uris => ( uris.map(uri => ({ uri, storage: PromptsStorage.user, type }))));
-            default:
-                throw ( new Error(`[listPromptFilesForStorage] Unsupported prompt storage type: ${storage}`));
+        case PromptsStorage.extension:
+            return this.getExtensionPromptFiles(type, token);
+        case PromptsStorage.local:
+            return this.fileLocator.listFiles(type, PromptsStorage.local, token).then(uris => ( uris.map(uri => ({
+                uri,
+                storage: PromptsStorage.local,
+                type
+            }))));
+        case PromptsStorage.user:
+            return this.fileLocator.listFiles(type, PromptsStorage.user, token).then(uris => ( uris.map(uri => ({
+                uri,
+                storage: PromptsStorage.user,
+                type
+            }))));
+        default:
+            throw ( new Error(`[listPromptFilesForStorage] Unsupported prompt storage type: ${storage}`));
         }
     }
     async getExtensionPromptFiles(type, token) {
         await this.extensionService.whenInstalledExtensionsRegistered();
-        const contributedFiles = await Promise.all(( this.contributedFiles[type].values()));
-        if (type === PromptsType.agent) {
-            const providerAgents = await this.listCustomAgentsFromProvider(token);
-            return [...contributedFiles, ...providerAgents];
+        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 = await this.listFromProviders(type, activationEvent, token);
+        return [...contributedFiles, ...providerFiles];
+    }
+    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;
         }
-        return contributedFiles;
     }
-    getSourceFolders(type) {
+    async getSourceFolders(type) {
         const result = [];
         if (type === PromptsType.agent) {
-            const folders = this.fileLocator.getAgentSourceFolder();
+            const folders = await this.fileLocator.getAgentSourceFolders();
             for (const uri of folders) {
-                result.push({ uri, storage: PromptsStorage.local, type });
+                result.push({
+                    uri,
+                    storage: PromptsStorage.local,
+                    type
+                });
             }
-        }
-        else {
-            for (const uri of this.fileLocator.getConfigBasedSourceFolders(type)) {
-                result.push({ uri, storage: PromptsStorage.local, type });
+        } else {
+            for (const uri of await this.fileLocator.getConfigBasedSourceFolders(type)) {
+                result.push({
+                    uri,
+                    storage: PromptsStorage.local,
+                    type
+                });
             }
         }
-        const userHome = this.userDataService.currentProfile.promptsHome;
-        result.push({ uri: userHome, storage: PromptsStorage.user, type });
+        if (type !== PromptsType.skill) {
+            const userHome = this.userDataService.currentProfile.promptsHome;
+            result.push({
+                uri: userHome,
+                storage: PromptsStorage.user,
+                type
+            });
+        }
         return result;
     }
+    async getResolvedSourceFolders(type) {
+        return this.fileLocator.getResolvedSourceFolders(type);
+    }
     get onDidChangeSlashCommands() {
         return this.cachedSlashCommands.onDidChange;
     }
@@ -220,13 +326,15 @@ let PromptsService = class PromptsService extends Disposable {
     }
     async computePromptSlashCommands(token) {
         const promptFiles = await this.listPromptFiles(PromptsType.prompt, token);
-        const details = await Promise.all(( promptFiles.map(async (promptPath) => {
+        const details = await Promise.all(( promptFiles.map(async promptPath => {
             try {
                 const parsedPromptFile = await this.parseNew(promptPath.uri, token);
                 return this.asChatPromptSlashCommand(parsedPromptFile, promptPath);
-            }
-            catch (e) {
-                this.logger.error(`[computePromptSlashCommands] Failed to parse prompt file for slash command: ${promptPath.uri}`, e instanceof Error ? e.message : String(e));
+            } catch (e) {
+                this.logger.error(
+                    `[computePromptSlashCommands] Failed to parse prompt file for slash command: ${promptPath.uri}`,
+                    e instanceof Error ? e.message : String(e)
+                );
                 return undefined;
             }
         })));
@@ -241,7 +349,11 @@ let PromptsService = class PromptsService extends Disposable {
         for (const model of this.modelService.getModels()) {
             if (model.getLanguageId() === PROMPT_LANGUAGE_ID && model.uri.scheme === Schemas.untitled && !( seen.has(model.uri))) {
                 const parsedPromptFile = this.getParsedPromptFile(model);
-                result.push(this.asChatPromptSlashCommand(parsedPromptFile, { uri: model.uri, storage: PromptsStorage.local, type: PromptsType.prompt }));
+                result.push(this.asChatPromptSlashCommand(parsedPromptFile, {
+                    uri: model.uri,
+                    storage: PromptsStorage.local,
+                    type: PromptsType.prompt
+                }));
             }
         }
         return result;
@@ -255,7 +367,7 @@ let PromptsService = class PromptsService extends Disposable {
     }
     asChatPromptSlashCommand(parsedPromptFile, promptPath) {
         let name = parsedPromptFile?.header?.name ?? promptPath.name ?? getCleanPromptName(promptPath.uri);
-        name = name.replace(/[^\p{L}\d_\-\.]+/gu, '-');
+        name = name.replace(/[^\p{L}\d_\-\.]+/gu, "-");
         return {
             name: name,
             description: parsedPromptFile?.header?.description ?? promptPath.description,
@@ -282,16 +394,16 @@ let PromptsService = class PromptsService extends Disposable {
         let agentFiles = await this.listPromptFiles(PromptsType.agent, token);
         const disabledAgents = this.getDisabledPromptFiles(PromptsType.agent);
         agentFiles = agentFiles.filter(promptPath => !( disabledAgents.has(promptPath.uri)));
-        const customAgentsResults = await Promise.allSettled(( agentFiles.map(async (promptPath) => {
+        const customAgentsResults = await Promise.allSettled(( agentFiles.map(async promptPath => {
             const uri = promptPath.uri;
             const ast = await this.parseNew(uri, token);
             let metadata;
             if (ast.header) {
                 const advanced = ast.header.getAttribute(PromptHeaderAttributes.advancedOptions);
-                if (advanced && advanced.value.type === 'object') {
+                if (advanced && advanced.value.type === "object") {
                     metadata = {};
                     for (const [key, value] of Object.entries(advanced.value)) {
-                        if (['string', 'number', 'boolean'].includes(value.type)) {
+                        if (["string", "number", "boolean"].includes(value.type)) {
                             metadata[key] = value;
                         }
                     }
@@ -302,37 +414,78 @@ let PromptsService = class PromptsService extends Disposable {
                 const bodyOffset = ast.body.offset;
                 const bodyVarRefs = ast.body.variableReferences;
                 for (let i = bodyVarRefs.length - 1; i >= 0; i--) {
-                    const { name, offset } = bodyVarRefs[i];
+                    const {
+                        name,
+                        offset
+                    } = bodyVarRefs[i];
                     const range = ( new OffsetRange(offset - bodyOffset, offset - bodyOffset + name.length + 1));
-                    toolReferences.push({ name, range });
+                    toolReferences.push({
+                        name,
+                        range
+                    });
                 }
             }
             const agentInstructions = {
-                content: ast.body?.getContent() ?? '',
+                content: ast.body?.getContent() ?? "",
                 toolReferences,
-                metadata,
+                metadata
             };
             const name = ast.header?.name ?? promptPath.name ?? getCleanPromptName(uri);
             const source = IAgentSource.fromPromptPath(promptPath);
             if (!ast.header) {
-                return { uri, name, agentInstructions, source };
+                return {
+                    uri,
+                    name,
+                    agentInstructions,
+                    source,
+                    visibility: {
+                        userInvokable: true,
+                        agentInvokable: true
+                    }
+                };
             }
-            const { description, model, tools, handOffs, argumentHint, target, infer } = ast.header;
-            return { uri, name, description, model, tools, handOffs, argumentHint, target, infer, agentInstructions, source };
+            const visibility = {
+                userInvokable: ast.header.userInvokable !== false,
+                agentInvokable: ast.header.infer === true || ast.header.disableModelInvocation !== true
+            };
+            const {
+                description,
+                model,
+                tools,
+                handOffs,
+                argumentHint,
+                target,
+                agents
+            } = ast.header;
+            return {
+                uri,
+                name,
+                description,
+                model,
+                tools,
+                handOffs,
+                argumentHint,
+                target,
+                visibility,
+                agents,
+                agentInstructions,
+                source
+            };
         })));
         const customAgents = [];
         for (let i = 0; i < customAgentsResults.length; i++) {
             const result = customAgentsResults[i];
-            if (result.status === 'fulfilled') {
+            if (result.status === "fulfilled") {
                 customAgents.push(result.value);
-            }
-            else {
+            } else {
                 const uri = agentFiles[i].uri;
                 const error = result.reason;
                 if (error instanceof FileOperationError && error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
-                    this.logger.warn(`[computeCustomAgents] Skipping agent file that does not exist: ${uri}`, error.message);
-                }
-                else {
+                    this.logger.warn(
+                        `[computeCustomAgents] Skipping agent file that does not exist: ${uri}`,
+                        error.message
+                    );
+                } else {
                     this.logger.error(`[computeCustomAgents] Failed to parse agent file: ${uri}`, error);
                 }
             }
@@ -356,25 +509,49 @@ let PromptsService = class PromptsService extends Disposable {
             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;
+                }
+            }
             try {
                 await this.filesConfigService.updateReadonly(uri, true);
-            }
-            catch (e) {
+            } catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
-                this.logger.error(`[registerContributedFile] Failed to make prompt file readonly: ${uri}`, msg);
+                this.logger.error(
+                    `[registerContributedFile] Failed to make prompt file readonly: ${uri}`,
+                    msg
+                );
             }
-            return { uri, name, description, storage: PromptsStorage.extension, type, extension, source: ExtensionAgentSourceType.contribution };
+            return {
+                uri,
+                name,
+                description,
+                storage: PromptsStorage.extension,
+                type,
+                extension,
+                source: ExtensionAgentSourceType.contribution
+            };
         })();
         bucket.set(uri, entryPromise);
         const flushCachesIfRequired = () => {
             this.cachedFileLocations[type] = undefined;
             switch (type) {
-                case PromptsType.agent:
-                    this.cachedCustomAgents.refresh();
-                    break;
-                case PromptsType.prompt:
-                    this.cachedSlashCommands.refresh();
-                    break;
+            case PromptsType.agent:
+                this.cachedCustomAgents.refresh();
+                break;
+            case PromptsType.prompt:
+                this.cachedSlashCommands.refresh();
+                break;
             }
         };
         flushCachesIfRequired();
@@ -387,16 +564,22 @@ let PromptsService = class PromptsService extends Disposable {
     }
     getPromptLocationLabel(promptPath) {
         switch (promptPath.storage) {
-            case PromptsStorage.local: return this.labelService.getUriLabel(dirname(promptPath.uri), { relative: true });
-            case PromptsStorage.user: return localize(6068, 'User Data');
-            case PromptsStorage.extension: {
+        case PromptsStorage.local:
+            return this.labelService.getUriLabel(dirname(promptPath.uri), {
+                relative: true
+            });
+        case PromptsStorage.user:
+            return localize(6380, "User Data");
+        case PromptsStorage.extension:
+            {
                 return localize(
-                    6069,
-                    'Extension: {0}',
+                    6381,
+                    "Extension: {0}",
                     promptPath.extension.displayName ?? promptPath.extension.id
                 );
             }
-            default: throw ( new Error('Unknown prompt storage type'));
+        default:
+            throw ( new Error("Unknown prompt storage type"));
         }
     }
     findAgentMDsInWorkspace(token) {
@@ -409,8 +592,7 @@ let PromptsService = class PromptsService extends Disposable {
         }
         if (includeNested) {
             return await this.fileLocator.findAgentMDsInWorkspace(token);
-        }
-        else {
+        } else {
             return await this.fileLocator.findAgentMDsInWorkspaceRoots(token);
         }
     }
@@ -426,7 +608,7 @@ let PromptsService = class PromptsService extends Disposable {
     }
     getDisabledPromptFiles(type) {
         const disabledKey = this.disabledPromptsStorageKeyPrefix + type;
-        const value = this.storageService.get(disabledKey, StorageScope.PROFILE, '[]');
+        const value = this.storageService.get(disabledKey, StorageScope.PROFILE, "[]");
         const result = ( new ResourceSet());
         try {
             const arr = JSON.parse(value);
@@ -434,25 +616,57 @@ let PromptsService = class PromptsService extends Disposable {
                 for (const s of arr) {
                     try {
                         result.add(URI.revive(s));
-                    }
-                    catch {
-                    }
+                    } catch {}
                 }
             }
-        }
-        catch {
-        }
+        } catch {}
         return result;
     }
     setDisabledPromptFiles(type, uris) {
         const disabled = ( Array.from(uris).map(uri => uri.toJSON()));
-        this.storageService.store(this.disabledPromptsStorageKeyPrefix + type, JSON.stringify(disabled), StorageScope.PROFILE, StorageTarget.USER);
+        this.storageService.store(
+            this.disabledPromptsStorageKeyPrefix + type,
+            JSON.stringify(disabled),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
         if (type === PromptsType.agent) {
             this.cachedCustomAgents.refresh();
         }
     }
     sanitizeAgentSkillText(text) {
-        return text.replace(/<[^>]+>/g, '');
+        return text.replace(/<[^>]+>/g, "");
+    }
+    async validateAndSanitizeSkillFile(uri, token) {
+        const parsedFile = await this.parseNew(uri, token);
+        const name = parsedFile.header?.name;
+        if (!name) {
+            this.logger.error(
+                `[validateAndSanitizeSkillFile] Agent skill file missing name attribute: ${uri}`
+            );
+            throw ( new SkillMissingNameError(uri));
+        }
+        const description = parsedFile.header?.description;
+        if (!description) {
+            this.logger.error(
+                `[validateAndSanitizeSkillFile] Agent skill file missing description attribute: ${uri}`
+            );
+            throw ( new SkillMissingDescriptionError(uri));
+        }
+        const sanitizedName = this.truncateAgentSkillName(name, uri);
+        const skillFolderUri = dirname(uri);
+        const folderName = basename(skillFolderUri);
+        if (sanitizedName !== folderName) {
+            this.logger.error(
+                `[validateAndSanitizeSkillFile] Agent skill name "${sanitizedName}" does not match folder name "${folderName}": ${uri}`
+            );
+            throw ( new SkillNameMismatchError(uri, sanitizedName, folderName));
+        }
+        const sanitizedDescription = this.truncateAgentSkillDescription(parsedFile.header?.description, uri);
+        return {
+            name: sanitizedName,
+            description: sanitizedDescription
+        };
     }
     truncateAgentSkillName(name, uri) {
         const MAX_NAME_LENGTH = 64;
@@ -461,7 +675,9 @@ let PromptsService = class PromptsService extends Disposable {
             this.logger.warn(`[findAgentSkills] Agent skill name contains XML tags, removed: ${uri}`);
         }
         if (sanitized.length > MAX_NAME_LENGTH) {
-            this.logger.warn(`[findAgentSkills] Agent skill name exceeds ${MAX_NAME_LENGTH} characters, truncated: ${uri}`);
+            this.logger.warn(
+                `[findAgentSkills] Agent skill name exceeds ${MAX_NAME_LENGTH} characters, truncated: ${uri}`
+            );
             return sanitized.substring(0, MAX_NAME_LENGTH);
         }
         return sanitized;
@@ -473,85 +689,376 @@ let PromptsService = class PromptsService extends Disposable {
         const MAX_DESCRIPTION_LENGTH = 1024;
         const sanitized = this.sanitizeAgentSkillText(description);
         if (sanitized !== description) {
-            this.logger.warn(`[findAgentSkills] Agent skill description contains XML tags, removed: ${uri}`);
+            this.logger.warn(
+                `[findAgentSkills] Agent skill description contains XML tags, removed: ${uri}`
+            );
         }
         if (sanitized.length > MAX_DESCRIPTION_LENGTH) {
-            this.logger.warn(`[findAgentSkills] Agent skill description exceeds ${MAX_DESCRIPTION_LENGTH} characters, truncated: ${uri}`);
+            this.logger.warn(
+                `[findAgentSkills] Agent skill description exceeds ${MAX_DESCRIPTION_LENGTH} characters, truncated: ${uri}`
+            );
             return sanitized.substring(0, MAX_DESCRIPTION_LENGTH);
         }
         return sanitized;
     }
     async findAgentSkills(token) {
         const useAgentSkills = this.configurationService.getValue(PromptsConfig.USE_AGENT_SKILLS);
-        const defaultAccount = await this.defaultAccountService.getDefaultAccount();
-        const previewFeaturesEnabled = defaultAccount?.chat_preview_features_enabled ?? true;
-        if (useAgentSkills && previewFeaturesEnabled) {
-            const result = [];
-            const seenNames = ( new Set());
-            const skillTypes = ( new Map());
-            let skippedMissingName = 0;
-            let skippedDuplicateName = 0;
-            let skippedParseFailed = 0;
-            const process = async (uri, skillType, scopeType) => {
-                try {
-                    const parsedFile = await this.parseNew(uri, token);
-                    const name = parsedFile.header?.name;
-                    if (!name) {
-                        skippedMissingName++;
-                        this.logger.error(`[findAgentSkills] Agent skill file missing name attribute: ${uri}`);
-                        return;
-                    }
-                    const sanitizedName = this.truncateAgentSkillName(name, uri);
-                    if (( seenNames.has(sanitizedName))) {
-                        skippedDuplicateName++;
-                        this.logger.warn(`[findAgentSkills] Skipping duplicate agent skill name: ${sanitizedName} at ${uri}`);
-                        return;
-                    }
-                    seenNames.add(sanitizedName);
-                    const sanitizedDescription = this.truncateAgentSkillDescription(parsedFile.header?.description, uri);
-                    result.push({ uri, type: scopeType, name: sanitizedName, description: sanitizedDescription });
-                    skillTypes.set(skillType, (skillTypes.get(skillType) || 0) + 1);
-                }
-                catch (e) {
+        if (!useAgentSkills) {
+            return undefined;
+        }
+        const {
+            files,
+            skillsBySource
+        } = await this.computeSkillDiscoveryInfo(token);
+        const result = [];
+        for (const file of files) {
+            if (file.status === "loaded" && file.name) {
+                const sanitizedDescription = this.truncateAgentSkillDescription(file.description, file.uri);
+                result.push({
+                    uri: file.uri,
+                    storage: file.storage,
+                    name: file.name,
+                    description: sanitizedDescription
+                });
+            }
+        }
+        let skippedMissingName = 0;
+        let skippedMissingDescription = 0;
+        let skippedDuplicateName = 0;
+        let skippedParseFailed = 0;
+        let skippedNameMismatch = 0;
+        for (const file of files) {
+            if (file.status === "skipped") {
+                switch (file.skipReason) {
+                case "missing-name":
+                    skippedMissingName++;
+                    break;
+                case "missing-description":
+                    skippedMissingDescription++;
+                    break;
+                case "duplicate-name":
+                    skippedDuplicateName++;
+                    break;
+                case "name-mismatch":
+                    skippedNameMismatch++;
+                    break;
+                case "parse-error":
                     skippedParseFailed++;
-                    this.logger.error(`[findAgentSkills] Failed to parse Agent skill file: ${uri}`, e instanceof Error ? e.message : String(e));
+                    break;
                 }
+            }
+        }
+        this.telemetryService.publicLog2("agentSkillsFound", {
+            totalSkillsFound: result.length,
+            claudePersonal: skillsBySource.get(PromptFileSource.ClaudePersonal) ?? 0,
+            claudeWorkspace: skillsBySource.get(PromptFileSource.ClaudeWorkspace) ?? 0,
+            copilotPersonal: skillsBySource.get(PromptFileSource.CopilotPersonal) ?? 0,
+            githubWorkspace: skillsBySource.get(PromptFileSource.GitHubWorkspace) ?? 0,
+            agentsPersonal: skillsBySource.get(PromptFileSource.AgentsPersonal) ?? 0,
+            agentsWorkspace: skillsBySource.get(PromptFileSource.AgentsWorkspace) ?? 0,
+            configWorkspace: skillsBySource.get(PromptFileSource.ConfigWorkspace) ?? 0,
+            configPersonal: skillsBySource.get(PromptFileSource.ConfigPersonal) ?? 0,
+            extensionContribution: skillsBySource.get(PromptFileSource.ExtensionContribution) ?? 0,
+            extensionAPI: skillsBySource.get(PromptFileSource.ExtensionAPI) ?? 0,
+            skippedDuplicateName,
+            skippedMissingName,
+            skippedMissingDescription,
+            skippedNameMismatch,
+            skippedParseFailed
+        });
+        return result;
+    }
+    async getPromptDiscoveryInfo(type, token) {
+        const files = [];
+        if (type === PromptsType.skill) {
+            return this.getSkillDiscoveryInfo(token);
+        } else if (type === PromptsType.agent) {
+            return this.getAgentDiscoveryInfo(token);
+        } else if (type === PromptsType.prompt) {
+            return this.getPromptSlashCommandDiscoveryInfo(token);
+        } else if (type === PromptsType.instructions) {
+            return this.getInstructionsDiscoveryInfo(token);
+        }
+        return {
+            type,
+            files
+        };
+    }
+    async getSkillDiscoveryInfo(token) {
+        const useAgentSkills = this.configurationService.getValue(PromptsConfig.USE_AGENT_SKILLS);
+        if (!useAgentSkills) {
+            const allFiles = await this.listPromptFiles(PromptsType.skill, token);
+            const files = ( allFiles.map(promptPath => ({
+                uri: promptPath.uri,
+                storage: promptPath.storage,
+                status: "skipped",
+                skipReason: "disabled",
+                extensionId: promptPath.extension?.identifier?.value
+            })));
+            return {
+                type: PromptsType.skill,
+                files
             };
-            const workspaceSkills = await this.fileLocator.findAgentSkillsInWorkspace(token);
-            await Promise.all(( workspaceSkills.map(({ uri, type }) => process(uri, type, 'project'))));
-            const userSkills = await this.fileLocator.findAgentSkillsInUserHome(token);
-            await Promise.all(( userSkills.map(({ uri, type }) => process(uri, type, 'personal'))));
-            this.telemetryService.publicLog2('agentSkillsFound', {
-                totalSkillsFound: result.length,
-                claudePersonal: skillTypes.get('claude-personal') ?? 0,
-                claudeWorkspace: skillTypes.get('claude-workspace') ?? 0,
-                copilotPersonal: skillTypes.get('copilot-personal') ?? 0,
-                githubWorkspace: skillTypes.get('github-workspace') ?? 0,
-                customPersonal: skillTypes.get('custom-personal') ?? 0,
-                customWorkspace: skillTypes.get('custom-workspace') ?? 0,
-                skippedDuplicateName,
-                skippedMissingName,
-                skippedParseFailed
-            });
-            return result;
         }
-        return undefined;
+        const {
+            files
+        } = await this.computeSkillDiscoveryInfo(token);
+        return {
+            type: PromptsType.skill,
+            files
+        };
+    }
+    async computeSkillDiscoveryInfo(token) {
+        const files = [];
+        const skillsBySource = ( new Map());
+        const seenNames = ( new Set());
+        const nameToUri = ( new Map());
+        const allSkills = [];
+        const discoveredSkills = await this.fileLocator.findAgentSkills(token);
+        const extensionSkills = await this.getExtensionPromptFiles(PromptsType.skill, token);
+        allSkills.push(...discoveredSkills, ...( extensionSkills.map(extPath => ({
+            fileUri: extPath.uri,
+            storage: extPath.storage,
+            source: extPath.source === ExtensionAgentSourceType.contribution ? PromptFileSource.ExtensionContribution : PromptFileSource.ExtensionAPI
+        }))));
+        const getPriority = skill => {
+            if (skill.storage === PromptsStorage.local) {
+                return 0;
+            }
+            if (skill.storage === PromptsStorage.user) {
+                return 1;
+            }
+            if (skill.source === PromptFileSource.ExtensionAPI) {
+                return 2;
+            }
+            if (skill.source === PromptFileSource.ExtensionContribution) {
+                return 3;
+            }
+            return 4;
+        };
+        allSkills.sort((a, b) => getPriority(a) - getPriority(b));
+        const extensionIdByUri = ( new Map());
+        for (const extSkill of extensionSkills) {
+            extensionIdByUri.set(( extSkill.uri.toString()), extSkill.extension.identifier.value);
+        }
+        for (const skill of allSkills) {
+            const uri = skill.fileUri;
+            const storage = skill.storage;
+            const source = skill.source;
+            const extensionId = extensionIdByUri.get(( uri.toString()));
+            try {
+                const parsedFile = await this.parseNew(uri, token);
+                const name = parsedFile.header?.name;
+                if (!name) {
+                    this.logger.error(
+                        `[computeSkillDiscoveryInfo] Agent skill file missing name attribute: ${uri}`
+                    );
+                    files.push({
+                        uri,
+                        storage,
+                        status: "skipped",
+                        skipReason: "missing-name",
+                        extensionId,
+                        source
+                    });
+                    continue;
+                }
+                const sanitizedName = this.truncateAgentSkillName(name, uri);
+                const skillFolderUri = dirname(uri);
+                const folderName = basename(skillFolderUri);
+                if (sanitizedName !== folderName) {
+                    this.logger.error(
+                        `[computeSkillDiscoveryInfo] Agent skill name "${sanitizedName}" does not match folder name "${folderName}": ${uri}`
+                    );
+                    files.push({
+                        uri,
+                        storage,
+                        status: "skipped",
+                        skipReason: "name-mismatch",
+                        name: sanitizedName,
+                        extensionId,
+                        source
+                    });
+                    continue;
+                }
+                if (( seenNames.has(sanitizedName))) {
+                    this.logger.warn(
+                        `[computeSkillDiscoveryInfo] Skipping duplicate agent skill name: ${sanitizedName} at ${uri}`
+                    );
+                    files.push({
+                        uri,
+                        storage,
+                        status: "skipped",
+                        skipReason: "duplicate-name",
+                        name: sanitizedName,
+                        duplicateOf: nameToUri.get(sanitizedName),
+                        extensionId,
+                        source
+                    });
+                    continue;
+                }
+                const description = parsedFile.header?.description;
+                if (!description) {
+                    this.logger.error(
+                        `[computeSkillDiscoveryInfo] Agent skill file missing description attribute: ${uri}`
+                    );
+                    files.push({
+                        uri,
+                        storage,
+                        status: "skipped",
+                        skipReason: "missing-description",
+                        name: sanitizedName,
+                        extensionId,
+                        source
+                    });
+                    continue;
+                }
+                seenNames.add(sanitizedName);
+                nameToUri.set(sanitizedName, uri);
+                files.push({
+                    uri,
+                    storage,
+                    status: "loaded",
+                    name: sanitizedName,
+                    description,
+                    extensionId,
+                    source
+                });
+                skillsBySource.set(source, (skillsBySource.get(source) || 0) + 1);
+            } catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                this.logger.error(
+                    `[computeSkillDiscoveryInfo] Failed to validate Agent skill file: ${uri}`,
+                    msg
+                );
+                files.push({
+                    uri,
+                    storage,
+                    status: "skipped",
+                    skipReason: "parse-error",
+                    errorMessage: msg,
+                    extensionId,
+                    source
+                });
+            }
+        }
+        return {
+            files,
+            skillsBySource
+        };
+    }
+    async getAgentDiscoveryInfo(token) {
+        const files = [];
+        const disabledAgents = this.getDisabledPromptFiles(PromptsType.agent);
+        const agentFiles = await this.listPromptFiles(PromptsType.agent, token);
+        for (const promptPath of agentFiles) {
+            const uri = promptPath.uri;
+            const storage = promptPath.storage;
+            const extensionId = promptPath.extension?.identifier?.value;
+            if (( disabledAgents.has(uri))) {
+                files.push({
+                    uri,
+                    storage,
+                    status: "skipped",
+                    skipReason: "disabled",
+                    extensionId
+                });
+                continue;
+            }
+            try {
+                const ast = await this.parseNew(uri, token);
+                const name = ast.header?.name ?? promptPath.name ?? getCleanPromptName(uri);
+                files.push({
+                    uri,
+                    storage,
+                    status: "loaded",
+                    name,
+                    extensionId
+                });
+            } catch (e) {
+                files.push({
+                    uri,
+                    storage,
+                    status: "skipped",
+                    skipReason: "parse-error",
+                    errorMessage: e instanceof Error ? e.message : String(e),
+                    extensionId
+                });
+            }
+        }
+        return {
+            type: PromptsType.agent,
+            files
+        };
+    }
+    async getPromptSlashCommandDiscoveryInfo(token) {
+        const files = [];
+        const promptFiles = await this.listPromptFiles(PromptsType.prompt, token);
+        for (const promptPath of promptFiles) {
+            const uri = promptPath.uri;
+            const storage = promptPath.storage;
+            const extensionId = promptPath.extension?.identifier?.value;
+            try {
+                const parsedPromptFile = await this.parseNew(uri, token);
+                const name = parsedPromptFile?.header?.name ?? promptPath.name ?? getCleanPromptName(uri);
+                files.push({
+                    uri,
+                    storage,
+                    status: "loaded",
+                    name,
+                    extensionId
+                });
+            } catch (e) {
+                files.push({
+                    uri,
+                    storage,
+                    status: "skipped",
+                    skipReason: "parse-error",
+                    errorMessage: e instanceof Error ? e.message : String(e),
+                    extensionId
+                });
+            }
+        }
+        return {
+            type: PromptsType.prompt,
+            files
+        };
+    }
+    async getInstructionsDiscoveryInfo(token) {
+        const files = [];
+        const instructionsFiles = await this.listPromptFiles(PromptsType.instructions, token);
+        for (const promptPath of instructionsFiles) {
+            const uri = promptPath.uri;
+            const storage = promptPath.storage;
+            const extensionId = promptPath.extension?.identifier?.value;
+            try {
+                const parsedPromptFile = await this.parseNew(uri, token);
+                const name = parsedPromptFile?.header?.name ?? promptPath.name ?? getCleanPromptName(uri);
+                files.push({
+                    uri,
+                    storage,
+                    status: "loaded",
+                    name,
+                    extensionId
+                });
+            } catch (e) {
+                files.push({
+                    uri,
+                    storage,
+                    status: "skipped",
+                    skipReason: "parse-error",
+                    errorMessage: e instanceof Error ? e.message : String(e),
+                    extensionId
+                });
+            }
+        }
+        return {
+            type: PromptsType.instructions,
+            files
+        };
     }
 };
-PromptsService = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, ILabelService)),
-    ( __param(2, IModelService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IUserDataProfileService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IFileService)),
-    ( __param(7, IFilesConfigurationService)),
-    ( __param(8, IStorageService)),
-    ( __param(9, IExtensionService)),
-    ( __param(10, IDefaultAccountService)),
-    ( __param(11, ITelemetryService))
-], PromptsService));
+PromptsService = ( __decorate([( __param(0, ILogService)), ( __param(1, ILabelService)), ( __param(2, IModelService)), ( __param(3, IInstantiationService)), ( __param(4, IUserDataProfileService)), ( __param(5, IConfigurationService)), ( __param(6, IFileService)), ( __param(7, IFilesConfigurationService)), ( __param(8, IStorageService)), ( __param(9, IExtensionService)), ( __param(10, ITelemetryService))], PromptsService));
 class CachedPromise extends Disposable {
     constructor(computeFn, getEvent, delay = 0) {
         super();
@@ -597,10 +1104,16 @@ class ModelChangeTracker extends Disposable {
         super();
         this.listeners = ( new ResourceMap());
         this.onDidPromptModelChange = this._register(( new Emitter()));
-        const onAdd = (model) => {
+        const onAdd = model => {
             const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
             if (promptType !== undefined) {
-                this.listeners.set(model.uri, model.onDidChangeContent(() => this.onDidPromptModelChange.fire({ uri: model.uri, promptType })));
+                this.listeners.set(
+                    model.uri,
+                    model.onDidChangeContent(() => this.onDidPromptModelChange.fire({
+                        uri: model.uri,
+                        promptType
+                    }))
+                );
             }
         };
         const onRemove = (languageId, uri) => {
@@ -608,7 +1121,10 @@ class ModelChangeTracker extends Disposable {
             if (promptType !== undefined) {
                 this.listeners.get(uri)?.dispose();
                 this.listeners.delete(uri);
-                this.onDidPromptModelChange.fire({ uri, promptType });
+                this.onDidPromptModelChange.fire({
+                    uri,
+                    promptType
+                });
             }
         };
         this._register(modelService.onModelAdded(model => onAdd(model)));
@@ -616,7 +1132,9 @@ class ModelChangeTracker extends Disposable {
             onRemove(e.oldLanguageId, e.model.uri);
             onAdd(e.model);
         }));
-        this._register(modelService.onModelRemoved(model => onRemove(model.getLanguageId(), model.uri)));
+        this._register(
+            modelService.onModelRemoved(model => onRemove(model.getLanguageId(), model.uri))
+        );
     }
     dispose() {
         super.dispose();
@@ -625,7 +1143,7 @@ class ModelChangeTracker extends Disposable {
     }
 }
 var IAgentSource;
-(function (IAgentSource) {
+(function(IAgentSource) {
     function fromPromptPath(promptPath) {
         if (promptPath.storage === PromptsStorage.extension) {
             return {
@@ -633,8 +1151,7 @@ var IAgentSource;
                 extensionId: promptPath.extension.identifier,
                 type: promptPath.source
             };
-        }
-        else {
+        } else {
             return {
                 storage: promptPath.storage
             };
@@ -643,4 +1160,4 @@ var IAgentSource;
     IAgentSource.fromPromptPath = fromPromptPath;
 })(IAgentSource || (IAgentSource = {}));
 
-export { PromptsService };
+export { PromptsService, SkillMissingDescriptionError, SkillMissingNameError, SkillNameMismatchError };