@codingame/monaco-vscode-chat-service-override 23.2.2 → 24.1.0

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

@@ -1,20 +1,18 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-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 { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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 { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
 import { isEqual, dirname } 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 { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { FileOperationError, FileOperationResult } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.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';
@@ -22,102 +20,160 @@ import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
-import { PromptsConfig } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
-import { getCleanPromptName, PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
-import { PromptsType, getPromptsTypeForLanguageId, PROMPT_LANGUAGE_ID, getLanguageIdForPromptsType } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { getCleanPromptName } 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-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
-import { PromptsStorage } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+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 { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 
-var UpdateTracker_1;
 let PromptsService = class PromptsService extends Disposable {
-    constructor(logger, labelService, modelService, instantiationService, userDataService, languageService, configurationService, fileService, filesConfigService, storageService) {
+    constructor(logger, labelService, modelService, instantiationService, userDataService, configurationService, fileService, filesConfigService, storageService, extensionService) {
         super();
         this.logger = logger;
         this.labelService = labelService;
         this.modelService = modelService;
         this.instantiationService = instantiationService;
         this.userDataService = userDataService;
-        this.languageService = languageService;
         this.configurationService = configurationService;
         this.fileService = fileService;
         this.filesConfigService = filesConfigService;
         this.storageService = storageService;
-        this.parsedPromptFileCache = ( new ResourceMap());
-        this.promptFileByCommandCache = ( new Map());
-        this.onDidChangeParsedPromptFilesCacheEmitter = ( new Emitter());
+        this.extensionService = extensionService;
+        this.cachedParsedPromptFromModels = ( new ResourceMap());
+        this.cachedFileLocations = {};
+        this.fileLocatorEvents = {};
         this.contributedFiles = {
             [PromptsType.prompt]: ( new ResourceMap()),
             [PromptsType.instructions]: ( new ResourceMap()),
             [PromptsType.agent]: ( new ResourceMap()),
         };
+        this.customAgentsProviders = [];
         this.disabledPromptsStorageKeyPrefix = 'chat.disabledPromptFiles.';
-        this.onDidChangeParsedPromptFilesCacheEmitter = this._register(( new Emitter()));
-        this.fileLocator = this._register(this.instantiationService.createInstance(PromptFilesLocator));
-        const promptUpdateTracker = this._register(( new UpdateTracker(this.fileLocator, PromptsType.prompt, this.modelService)));
-        this._register(promptUpdateTracker.onDidPromptChange((event) => {
-            if (event.kind === 'fileSystem') {
-                this.promptFileByCommandCache.clear();
-            }
-            else {
-                const pendingDeletes = [];
-                for (const [key, value] of this.promptFileByCommandCache) {
-                    if (isEqual(value.value?.uri, event.uri)) {
-                        pendingDeletes.push(key);
-                    }
-                }
-                for (const key of pendingDeletes) {
-                    this.promptFileByCommandCache.delete(key);
-                }
-            }
-            this.onDidChangeParsedPromptFilesCacheEmitter.fire();
-        }));
+        this.fileLocator = this.instantiationService.createInstance(PromptFilesLocator);
         this._register(this.modelService.onModelRemoved((model) => {
-            this.parsedPromptFileCache.delete(model.uri);
+            this.cachedParsedPromptFromModels.delete(model.uri);
         }));
-    }
-    get onDidChangeCustomAgents() {
-        if (!this.onDidChangeCustomAgentsEmitter) {
-            const emitter = this.onDidChangeCustomAgentsEmitter = this._register(( new Emitter()));
-            const updateTracker = this._register(( new UpdateTracker(this.fileLocator, PromptsType.agent, this.modelService)));
-            this._register(updateTracker.onDidPromptChange((event) => {
-                this.cachedCustomAgents = undefined;
-                emitter.fire();
+        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))
+        )));
+    }
+    getFileLocatorEvent(type) {
+        let event = this.fileLocatorEvents[type];
+        if (!event) {
+            event = this.fileLocatorEvents[type] = this._register(this.fileLocator.createFilesUpdatedEvent(type)).event;
+            this._register(event(() => {
+                this.cachedFileLocations[type] = undefined;
             }));
         }
-        return this.onDidChangeCustomAgentsEmitter.event;
-    }
-    get onDidChangeParsedPromptFilesCache() {
-        return this.onDidChangeParsedPromptFilesCacheEmitter.event;
-    }
-    getPromptFileType(uri) {
-        const model = this.modelService.getModel(uri);
-        const languageId = model ? model.getLanguageId() : this.languageService.guessLanguageIdByFilepathOrFirstLine(uri);
-        return languageId ? getPromptsTypeForLanguageId(languageId) : undefined;
+        return event;
     }
     getParsedPromptFile(textModel) {
-        const cached = this.parsedPromptFileCache.get(textModel.uri);
+        const cached = this.cachedParsedPromptFromModels.get(textModel.uri);
         if (cached && cached[0] === textModel.getVersionId()) {
             return cached[1];
         }
         const ast = ( new PromptFileParser()).parse(textModel.uri, textModel.getValue());
         if (!cached || cached[0] < textModel.getVersionId()) {
-            this.parsedPromptFileCache.set(textModel.uri, [textModel.getVersionId(), ast]);
+            this.cachedParsedPromptFromModels.set(textModel.uri, [textModel.getVersionId(), ast]);
         }
         return ast;
     }
     async listPromptFiles(type, token) {
+        let listPromise = this.cachedFileLocations[type];
+        if (!listPromise) {
+            listPromise = this.computeListPromptFiles(type, token);
+            if (!this.fileLocatorEvents[type]) {
+                return listPromise;
+            }
+            this.cachedFileLocations[type] = listPromise;
+            return listPromise;
+        }
+        return listPromise;
+    }
+    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.getExtensionContributions(type)
+            this.getExtensionPromptFiles(type, token),
         ]);
         return [...prompts.flat()];
     }
+    registerCustomAgentsProvider(extension, provider) {
+        const providerEntry = { extension, ...provider };
+        this.customAgentsProviders.push(providerEntry);
+        const disposables = ( new DisposableStore());
+        if (provider.onDidChangeCustomAgents) {
+            disposables.add(provider.onDidChangeCustomAgents(() => {
+                this.cachedFileLocations[PromptsType.agent] = undefined;
+                this.cachedCustomAgents.refresh();
+            }));
+        }
+        this.cachedFileLocations[PromptsType.agent] = undefined;
+        this.cachedCustomAgents.refresh();
+        disposables.add({
+            dispose: () => {
+                const index = this.customAgentsProviders.findIndex((p) => p === providerEntry);
+                if (index >= 0) {
+                    this.customAgentsProviders.splice(index, 1);
+                    this.cachedFileLocations[PromptsType.agent] = undefined;
+                    this.cachedCustomAgents.refresh();
+                }
+            }
+        });
+        return disposables;
+    }
+    async listCustomAgentsFromProvider(token) {
+        const result = [];
+        if (this.customAgentsProviders.length === 0) {
+            return result;
+        }
+        await this.extensionService.activateByEvent(CUSTOM_AGENTS_PROVIDER_ACTIVATION_EVENT);
+        for (const providerEntry of this.customAgentsProviders) {
+            try {
+                const agents = await providerEntry.provideCustomAgents({}, token);
+                if (!agents || 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);
+                        }
+                    }
+                    result.push({
+                        uri: agent.uri,
+                        name: agent.name,
+                        description: agent.description,
+                        storage: PromptsStorage.extension,
+                        type: PromptsType.agent,
+                        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));
+            }
+        }
+        return result;
+    }
     async listPromptFilesForStorage(type, storage, token) {
         switch (storage) {
             case PromptsStorage.extension:
-                return this.getExtensionContributions(type);
+                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:
@@ -126,8 +182,14 @@ let PromptsService = class PromptsService extends Disposable {
                 throw ( new Error(`[listPromptFilesForStorage] Unsupported prompt storage type: ${storage}`));
         }
     }
-    async getExtensionContributions(type) {
-        return Promise.all(( this.contributedFiles[type].values()));
+    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];
+        }
+        return contributedFiles;
     }
     getSourceFolders(type) {
         const result = [];
@@ -146,110 +208,77 @@ let PromptsService = class PromptsService extends Disposable {
         result.push({ uri: userHome, storage: PromptsStorage.user, type });
         return result;
     }
-    asPromptSlashCommand(command) {
-        if (command.match(/^[\p{L}\d_\-\.]+$/u)) {
-            return { command, detail: ( localize(5945, 'Prompt file: {0}', command)) };
-        }
-        return undefined;
+    get onDidChangeSlashCommands() {
+        return this.cachedSlashCommands.onDidChange;
     }
-    async resolvePromptSlashCommand(data, token) {
-        const promptUri = data.promptPath?.uri ?? (await this.getPromptPath(data.command));
-        if (!promptUri) {
-            return undefined;
-        }
-        try {
-            return await this.parseNew(promptUri, token);
-        }
-        catch (error) {
-            this.logger.error(`[resolvePromptSlashCommand] Failed to parse prompt file: ${promptUri}`, error);
-            return undefined;
-        }
+    async getPromptSlashCommands(token) {
+        return this.cachedSlashCommands.get(token);
     }
-    async populatePromptCommandCache(command) {
-        let cache = this.promptFileByCommandCache.get(command);
-        if (cache && cache.pendingPromise) {
-            return cache.pendingPromise;
-        }
-        const newPromise = this.resolvePromptSlashCommand({ command, detail: '' }, CancellationToken.None);
-        if (cache) {
-            cache.pendingPromise = newPromise;
+    async computePromptSlashCommands(token) {
+        const promptFiles = await this.listPromptFiles(PromptsType.prompt, token);
+        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));
+                return undefined;
+            }
+        })));
+        const result = [];
+        const seen = ( new ResourceSet());
+        for (const detail of details) {
+            if (detail) {
+                result.push(detail);
+                seen.add(detail.promptPath.uri);
+            }
         }
-        else {
-            cache = { value: undefined, pendingPromise: newPromise };
-            this.promptFileByCommandCache.set(command, cache);
+        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 }));
+            }
         }
-        const newValue = await newPromise.finally(() => cache.pendingPromise = undefined);
-        cache.value = newValue;
-        this.onDidChangeParsedPromptFilesCacheEmitter.fire();
-        return newValue;
+        return result;
     }
-    resolvePromptSlashCommandFromCache(command) {
-        const cache = this.promptFileByCommandCache.get(command);
-        const value = cache?.value;
-        if (value === undefined) {
-            void this.populatePromptCommandCache(command).catch((error) => { });
-        }
-        return value;
+    isValidSlashCommandName(command) {
+        return command.match(/^[\p{L}\d_\-\.]+$/u) !== null;
     }
-    async getPromptDetails(promptPath) {
-        const parsedPromptFile = await this.parseNew(promptPath.uri, CancellationToken.None).catch(() => undefined);
+    async resolvePromptSlashCommand(name, token) {
+        const commands = await this.getPromptSlashCommands(token);
+        return commands.find(cmd => cmd.name === name);
+    }
+    asChatPromptSlashCommand(parsedPromptFile, promptPath) {
+        let name = parsedPromptFile?.header?.name ?? promptPath.name ?? getCleanPromptName(promptPath.uri);
+        name = name.replace(/[^\p{L}\d_\-\.]+/gu, '-');
         return {
-            name: parsedPromptFile?.header?.name ?? promptPath.name ?? getCleanPromptName(promptPath.uri),
-            description: parsedPromptFile?.header?.description ?? promptPath.description
+            name: name,
+            description: parsedPromptFile?.header?.description ?? promptPath.description,
+            argumentHint: parsedPromptFile?.header?.argumentHint,
+            parsedPromptFile,
+            promptPath
         };
     }
-    async getPromptPath(command) {
-        const promptPaths = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
-        for (const promptPath of promptPaths) {
-            const details = await this.getPromptDetails(promptPath);
-            if (details.name === command) {
-                return promptPath.uri;
-            }
-        }
-        const textModel = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getCommandNameFromURI(model.uri) === command);
-        if (textModel) {
-            return textModel.uri;
-        }
-        return undefined;
-    }
-    async getPromptCommandName(uri) {
-        const promptPaths = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
-        let promptPath = promptPaths.find(promptPath => isEqual(promptPath.uri, uri));
-        if (!promptPath) {
-            promptPath = { uri, storage: PromptsStorage.local, type: PromptsType.prompt };
+    async getPromptSlashCommandName(uri, token) {
+        const slashCommands = await this.getPromptSlashCommands(token);
+        const slashCommand = slashCommands.find(c => isEqual(c.promptPath.uri, uri));
+        if (!slashCommand) {
+            return getCleanPromptName(uri);
         }
-        const { name } = await this.getPromptDetails(promptPath);
-        return name;
+        return slashCommand.name;
     }
-    async findPromptSlashCommands() {
-        const promptFiles = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
-        return Promise.all(( promptFiles.map(async (promptPath) => {
-            const { name } = await this.getPromptDetails(promptPath);
-            return {
-                command: name,
-                detail: ( localize(
-                    5945,
-                    'Prompt file: {0}',
-                    this.labelService.getUriLabel(promptPath.uri, { relative: true })
-                )),
-                promptPath
-            };
-        })));
+    get onDidChangeCustomAgents() {
+        return this.cachedCustomAgents.onDidChange;
     }
     async getCustomAgents(token) {
-        let customAgents = this.cachedCustomAgents;
-        if (!customAgents) {
-            customAgents = this.computeCustomAgents(token);
-            if (this.onDidChangeCustomAgentsEmitter) {
-                this.cachedCustomAgents = customAgents;
-            }
-        }
-        const disabledAgents = this.getDisabledPromptFiles(PromptsType.agent);
-        return (await customAgents).filter(agent => !( disabledAgents.has(agent.uri)));
+        return this.cachedCustomAgents.get(token);
     }
     async computeCustomAgents(token) {
-        const agentFiles = await this.listPromptFiles(PromptsType.agent, token);
-        const customAgents = await Promise.all(( agentFiles.map(async (promptPath) => {
+        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 uri = promptPath.uri;
             const ast = await this.parseNew(uri, token);
             let metadata;
@@ -284,9 +313,26 @@ let PromptsService = class PromptsService extends Disposable {
             if (!ast.header) {
                 return { uri, name, agentInstructions, source };
             }
-            const { description, model, tools, handOffs, argumentHint, target } = ast.header;
-            return { uri, name, description, model, tools, handOffs, argumentHint, target, agentInstructions, source };
+            const { description, model, tools, handOffs, argumentHint, target, infer } = ast.header;
+            return { uri, name, description, model, tools, handOffs, argumentHint, target, infer, agentInstructions, source };
         })));
+        const customAgents = [];
+        for (let i = 0; i < customAgentsResults.length; i++) {
+            const result = customAgentsResults[i];
+            if (result.status === 'fulfilled') {
+                customAgents.push(result.value);
+            }
+            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.error(`[computeCustomAgents] Failed to parse agent file: ${uri}`, error);
+                }
+            }
+        }
         return customAgents;
     }
     async parseNew(uri, token) {
@@ -313,30 +359,35 @@ let PromptsService = class PromptsService extends Disposable {
                 const msg = e instanceof Error ? e.message : String(e);
                 this.logger.error(`[registerContributedFile] Failed to make prompt file readonly: ${uri}`, msg);
             }
-            return { uri, name, description, storage: PromptsStorage.extension, type, extension };
+            return { uri, name, description, storage: PromptsStorage.extension, type, extension, source: ExtensionAgentSourceType.contribution };
         })();
         bucket.set(uri, entryPromise);
-        const updateAgentsIfRequired = () => {
-            if (type === PromptsType.agent) {
-                this.cachedCustomAgents = undefined;
-                this.onDidChangeCustomAgentsEmitter?.fire();
+        const flushCachesIfRequired = () => {
+            this.cachedFileLocations[type] = undefined;
+            switch (type) {
+                case PromptsType.agent:
+                    this.cachedCustomAgents.refresh();
+                    break;
+                case PromptsType.prompt:
+                    this.cachedSlashCommands.refresh();
+                    break;
             }
         };
-        updateAgentsIfRequired();
+        flushCachesIfRequired();
         return {
             dispose: () => {
                 bucket.delete(uri);
-                updateAgentsIfRequired();
+                flushCachesIfRequired();
             }
         };
     }
     getPromptLocationLabel(promptPath) {
         switch (promptPath.storage) {
             case PromptsStorage.local: return this.labelService.getUriLabel(dirname(promptPath.uri), { relative: true });
-            case PromptsStorage.user: return localize(5946, 'User Data');
+            case PromptsStorage.user: return localize(6066, 'User Data');
             case PromptsStorage.extension: {
                 return localize(
-                    5947,
+                    6067,
                     'Extension: {0}',
                     promptPath.extension.displayName ?? promptPath.extension.id
                 );
@@ -393,8 +444,35 @@ let PromptsService = class PromptsService extends Disposable {
         const disabled = ( Array.from(uris).map(uri => uri.toJSON()));
         this.storageService.store(this.disabledPromptsStorageKeyPrefix + type, JSON.stringify(disabled), StorageScope.PROFILE, StorageTarget.USER);
         if (type === PromptsType.agent) {
-            this.onDidChangeCustomAgentsEmitter?.fire();
+            this.cachedCustomAgents.refresh();
+        }
+    }
+    async findClaudeSkills(token) {
+        const useClaudeSkills = this.configurationService.getValue(PromptsConfig.USE_CLAUDE_SKILLS);
+        if (useClaudeSkills) {
+            const result = [];
+            const process = async (uri, type) => {
+                try {
+                    const parsedFile = await this.parseNew(uri, token);
+                    const name = parsedFile.header?.name;
+                    if (name) {
+                        result.push({ uri, type, name, description: parsedFile.header?.description });
+                    }
+                    else {
+                        this.logger.error(`[findClaudeSkills] Claude skill file missing name attribute: ${uri}`);
+                    }
+                }
+                catch (e) {
+                    this.logger.error(`[findClaudeSkills] Failed to parse Claude skill file: ${uri}`, e instanceof Error ? e.message : String(e));
+                }
+            };
+            const workspaceSkills = await this.fileLocator.findClaudeSkillsInWorkspace(token);
+            await Promise.all(( workspaceSkills.map(uri => process(uri, 'project'))));
+            const userSkills = await this.fileLocator.findClaudeSkillsInUserHome(token);
+            await Promise.all(( userSkills.map(uri => process(uri, 'personal'))));
+            return result;
         }
+        return undefined;
     }
 };
 PromptsService = ( __decorate([
@@ -403,39 +481,69 @@ PromptsService = ( __decorate([
     ( __param(2, IModelService)),
     ( __param(3, IInstantiationService)),
     ( __param(4, IUserDataProfileService)),
-    ( __param(5, ILanguageService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, IFileService)),
-    ( __param(8, IFilesConfigurationService)),
-    ( __param(9, IStorageService))
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IFileService)),
+    ( __param(7, IFilesConfigurationService)),
+    ( __param(8, IStorageService)),
+    ( __param(9, IExtensionService))
 ], PromptsService));
-function getCommandNameFromURI(uri) {
-    return basename(uri.fsPath, PROMPT_FILE_EXTENSION);
+class CachedPromise extends Disposable {
+    constructor(computeFn, getEvent, delay = 0) {
+        super();
+        this.computeFn = computeFn;
+        this.getEvent = getEvent;
+        this.delay = delay;
+        this.cachedPromise = undefined;
+        this.onDidUpdatePromiseEmitter = undefined;
+    }
+    get onDidChange() {
+        if (!this.onDidUpdatePromiseEmitter) {
+            const emitter = this.onDidUpdatePromiseEmitter = this._register(( new Emitter()));
+            const delayer = this._register(( new Delayer(this.delay)));
+            this._register(this.getEvent()(() => {
+                this.cachedPromise = undefined;
+                delayer.trigger(() => emitter.fire());
+            }));
+        }
+        return this.onDidUpdatePromiseEmitter.event;
+    }
+    get(token) {
+        if (this.cachedPromise !== undefined) {
+            return this.cachedPromise;
+        }
+        const result = this.computeFn(token);
+        if (!this.onDidUpdatePromiseEmitter) {
+            return result;
+        }
+        this.cachedPromise = result;
+        this.onDidUpdatePromiseEmitter.fire();
+        return result;
+    }
+    refresh() {
+        this.cachedPromise = undefined;
+        this.onDidUpdatePromiseEmitter?.fire();
+    }
 }
-let UpdateTracker = class UpdateTracker extends Disposable {
-    static { UpdateTracker_1 = this; }
-    static { this.PROMPT_UPDATE_DELAY_MS = 200; }
+class ModelChangeTracker extends Disposable {
     get onDidPromptChange() {
         return this.onDidPromptModelChange.event;
     }
-    constructor(fileLocator, promptType, modelService) {
+    constructor(modelService) {
         super();
         this.listeners = ( new ResourceMap());
         this.onDidPromptModelChange = this._register(( new Emitter()));
-        const delayer = this._register(( new Delayer(UpdateTracker_1.PROMPT_UPDATE_DELAY_MS)));
-        const trigger = (event) => delayer.trigger(() => this.onDidPromptModelChange.fire(event));
-        const filesUpdatedEventRegistration = this._register(fileLocator.createFilesUpdatedEvent(promptType));
-        this._register(filesUpdatedEventRegistration.event(() => trigger({ kind: 'fileSystem' })));
         const onAdd = (model) => {
-            if (model.getLanguageId() === getLanguageIdForPromptsType(promptType)) {
-                this.listeners.set(model.uri, model.onDidChangeContent(() => trigger({ kind: 'textModel', uri: model.uri })));
+            const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+            if (promptType !== undefined) {
+                this.listeners.set(model.uri, model.onDidChangeContent(() => this.onDidPromptModelChange.fire({ uri: model.uri, promptType })));
             }
         };
         const onRemove = (languageId, uri) => {
-            if (languageId === getLanguageIdForPromptsType(promptType)) {
+            const promptType = getPromptsTypeForLanguageId(languageId);
+            if (promptType !== undefined) {
                 this.listeners.get(uri)?.dispose();
                 this.listeners.delete(uri);
-                trigger({ kind: 'textModel', uri });
+                this.onDidPromptModelChange.fire({ uri, promptType });
             }
         };
         this._register(modelService.onModelAdded(model => onAdd(model)));
@@ -450,17 +558,15 @@ let UpdateTracker = class UpdateTracker extends Disposable {
         this.listeners.forEach(listener => listener.dispose());
         this.listeners.clear();
     }
-};
-UpdateTracker = UpdateTracker_1 = ( __decorate([
-    ( __param(2, IModelService))
-], UpdateTracker));
+}
 var IAgentSource;
 (function (IAgentSource) {
     function fromPromptPath(promptPath) {
         if (promptPath.storage === PromptsStorage.extension) {
             return {
                 storage: PromptsStorage.extension,
-                extensionId: promptPath.extension.identifier
+                extensionId: promptPath.extension.identifier,
+                type: promptPath.source
             };
         }
         else {
@@ -472,4 +578,4 @@ var IAgentSource;
     IAgentSource.fromPromptPath = fromPromptPath;
 })(IAgentSource || (IAgentSource = {}));
 
-export { PromptsService, UpdateTracker };
+export { PromptsService };