@codingame/monaco-vscode-chat-service-override 17.2.0 → 18.0.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contributions/languageFeatures/providers/promptPathAutocompletion.js

@@ -1,11 +1,11 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service';
+import { isOneOf } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { extUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { assertOneOf } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { PROMPT_AND_INSTRUCTIONS_LANGUAGE_SELECTOR } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
 import { assert, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
@@ -36,7 +36,7 @@ let PromptPathAutocompletion = class PromptPathAutocompletion extends Disposable
         this.languageService = languageService;
         this._debugDisplayName = 'PromptPathAutocompletion';
         this.triggerCharacters = [':', '.', '/'];
-        this._register(this.languageService.completionProvider.register(PROMPT_AND_INSTRUCTIONS_LANGUAGE_SELECTOR, this));
+        this._register(this.languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
     }
     async provideCompletionItems(model, position, context, token) {
         assert(!token.isCancellationRequested, ( new CancellationError()));
@@ -44,9 +44,9 @@ let PromptPathAutocompletion = class PromptPathAutocompletion extends Disposable
         if (!triggerCharacter) {
             return undefined;
         }
-        assertOneOf(triggerCharacter, this.triggerCharacters, `Prompt path autocompletion provider`);
+        assert(isOneOf(triggerCharacter, this.triggerCharacters), `Prompt path autocompletion provider`);
         const parser = this.promptsService.getSyntaxParserFor(model);
-        assert(!parser.disposed, 'Prompt parser must not be disposed.');
+        assert(parser.isDisposed === false, 'Prompt parser must not be disposed.');
         const { references } = await parser
             .start()
             .settled();

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contributions/languageFeatures/providers/providerInstanceBase.d.ts

@@ -2,9 +2,10 @@ import { TSharedPrompt } from "@codingame/monaco-vscode-api/vscode/vs/workbench/
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
 import { ObservableDisposable } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableDisposable";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 export declare abstract class ProviderInstanceBase extends ObservableDisposable {
     protected readonly model: ITextModel;
-    protected abstract onPromptSettled(error: Error | undefined): Promise<this>;
+    protected abstract onPromptSettled(error: Error | undefined, token: CancellationToken): this;
     abstract toString(): string;
     protected readonly parser: TSharedPrompt;
     constructor(model: ITextModel, promptsService: IPromptsService);

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contributions/languageFeatures/providers/providerInstanceBase.js

@@ -2,17 +2,21 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service';
 import { ObservableDisposable } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableDisposable';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 
 let ProviderInstanceBase = class ProviderInstanceBase extends ObservableDisposable {
     constructor(model, promptsService) {
         super();
         this.model = model;
         this.parser = promptsService.getSyntaxParserFor(model);
-        this._register(this.parser.onSettled(this.onPromptSettled.bind(this)));
-        this.parser
-            .onDispose(this.dispose.bind(this))
-            .start();
-        setTimeout(this.onPromptSettled.bind(this));
+        this._register(this.parser.onDispose(this.dispose.bind(this)));
+        let cancellationSource = ( new CancellationTokenSource());
+        this._register(this.parser.onSettled((error) => {
+            cancellationSource.dispose(true);
+            cancellationSource = ( new CancellationTokenSource());
+            this.onPromptSettled(error, cancellationSource.token);
+        }));
+        this.parser.start();
     }
 };
 ProviderInstanceBase = ( __decorate([

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contributions/languageFeatures/providers/providerInstanceManagerBase.d.ts

@@ -9,9 +9,10 @@ import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 export interface IPromptFileEditor extends IEditor {
     readonly getModel: () => ITextModel;
 }
+export type TProviderClass<TInstance extends ProviderInstanceBase> = new (editor: ITextModel, ...args: any[]) => TInstance;
 export declare abstract class ProviderInstanceManagerBase<TInstance extends ProviderInstanceBase> extends Disposable {
     private readonly instances;
-    protected abstract get InstanceClass(): new (editor: ITextModel, ...args: any[]) => TInstance;
-    constructor(modelService: IModelService, editorService: IEditorService, initService: IInstantiationService, configService: IConfigurationService);
+    protected abstract get InstanceClass(): TProviderClass<TInstance>;
+    constructor(modelService: IModelService, editorService: IEditorService, instantiationService: IInstantiationService, configService: IConfigurationService);
     private handleNewEditor;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contributions/languageFeatures/providers/providerInstanceManagerBase.js

@@ -4,20 +4,20 @@ import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/asser
 import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ObjectCache } from '../../../../../../../../base/common/objectCache.js';
-import { PROMPT_LANGUAGE_ID, INSTRUCTIONS_LANGUAGE_ID } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
+import { PROMPT_LANGUAGE_ID, INSTRUCTIONS_LANGUAGE_ID, MODE_LANGUAGE_ID } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { PromptsConfig } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/config';
+import { PromptsConfig } from '@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/config';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 
 let ProviderInstanceManagerBase = class ProviderInstanceManagerBase extends Disposable {
-    constructor(modelService, editorService, initService, configService) {
+    constructor(modelService, editorService, instantiationService, configService) {
         super();
         this.instances = this._register(( new ObjectCache((model) => {
             assert(model.isDisposed() === false, 'Text model must not be disposed.');
             assertDefined(this.InstanceClass, 'Instance class field must be defined.');
-            const instance = initService.createInstance(this.InstanceClass, model);
+            const instance = instantiationService.createInstance(this.InstanceClass, model);
             instance.assertNotDisposed('Created instance must not be disposed.');
             return instance;
         })));
@@ -40,7 +40,7 @@ let ProviderInstanceManagerBase = class ProviderInstanceManagerBase extends Disp
                 this.instances.get(model);
                 return;
             }
-            if (isPromptOrInstructionsFile(oldLanguageId)) {
+            if (isPromptFile(oldLanguageId)) {
                 this.instances.remove(model, true);
                 return;
             }
@@ -64,8 +64,12 @@ ProviderInstanceManagerBase = ( __decorate([
     ( __param(2, IInstantiationService)),
     ( __param(3, IConfigurationService))
 ], ProviderInstanceManagerBase));
-const isPromptOrInstructionsFile = (languageId) => {
-    return (languageId === PROMPT_LANGUAGE_ID) || (languageId === INSTRUCTIONS_LANGUAGE_ID);
+const isPromptFile = (languageId) => {
+    return [
+        PROMPT_LANGUAGE_ID,
+        INSTRUCTIONS_LANGUAGE_ID,
+        MODE_LANGUAGE_ID,
+    ].includes(languageId);
 };
 const isPromptFileModel = (model) => {
     if ('modified' in model || 'model' in model) {
@@ -74,7 +78,7 @@ const isPromptFileModel = (model) => {
     if (model.isDisposed()) {
         return false;
     }
-    if (isPromptOrInstructionsFile(model.getLanguageId()) === false) {
+    if (isPromptFile(model.getLanguageId()) === false) {
         return false;
     }
     return true;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/textModelPromptParser.d.ts

@@ -5,6 +5,6 @@ import { TextModelContentsProvider } from "@codingame/monaco-vscode-fab30422-b48
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 export declare class TextModelPromptParser extends BasePromptParser<TextModelContentsProvider> {
-    constructor(model: ITextModel, options: Partial<IPromptParserOptions> | undefined, initService: IInstantiationService, workspaceService: IWorkspaceContextService, logService: ILogService);
+    constructor(model: ITextModel, options: Partial<IPromptParserOptions>, instantiationService: IInstantiationService, workspaceService: IWorkspaceContextService, logService: ILogService);
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/textModelPromptParser.js

@@ -7,9 +7,9 @@ import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 
 let TextModelPromptParser = class TextModelPromptParser extends BasePromptParser {
-    constructor(model, options = {}, initService, workspaceService, logService) {
-        const contentsProvider = initService.createInstance(TextModelContentsProvider, model, options);
-        super(contentsProvider, options, initService, workspaceService, logService);
+    constructor(model, options, instantiationService, workspaceService, logService) {
+        const contentsProvider = instantiationService.createInstance(TextModelContentsProvider, model, options);
+        super(contentsProvider, options, instantiationService, workspaceService, logService);
         this._register(contentsProvider);
     }
     toString() {

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

@@ -1,32 +1,43 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { type URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { type ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { TextModelPromptParser } from "../parsers/textModelPromptParser.js";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { TLogFunction } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/decorators/logTime";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
-import { IChatPromptSlashCommand, TCombinedToolsMetadata, IMetadata, IPromptPath, TPromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types";
+import type { IChatPromptSlashCommand, ICustomChatMode, IMetadata, IPromptPath } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types.service";
+import { PromptsType } from "@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/prompts";
 export declare class PromptsService extends Disposable implements IPromptsService {
+    readonly logger: ILogService;
     private readonly labelService;
     private readonly modelService;
-    private readonly initService;
+    private readonly instantiationService;
     private readonly userDataService;
     readonly _serviceBrand: undefined;
     private readonly cache;
     private readonly fileLocator;
-    constructor(labelService: ILabelService, modelService: IModelService, initService: IInstantiationService, userDataService: IUserDataProfileService);
+    logTime: TLogFunction;
+    private onDidChangeCustomChatModesEvent;
+    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService);
+    get onDidChangeCustomChatModes(): Event<void>;
     getSyntaxParserFor(model: ITextModel): TextModelPromptParser & {
-        disposed: false;
+        isDisposed: false;
     };
-    listPromptFiles(type: TPromptsType): Promise<readonly IPromptPath[]>;
-    getSourceFolders(type: TPromptsType): readonly IPromptPath[];
+    listPromptFiles(type: PromptsType, token: CancellationToken): Promise<readonly IPromptPath[]>;
+    getSourceFolders(type: PromptsType): readonly IPromptPath[];
     asPromptSlashCommand(command: string): IChatPromptSlashCommand | undefined;
-    resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IPromptPath | undefined>;
+    resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IMetadata | undefined>;
+    private getPromptPath;
     findPromptSlashCommands(): Promise<IChatPromptSlashCommand[]>;
+    getCustomChatModes(): Promise<readonly ICustomChatMode[]>;
     findInstructionFilesFor(files: readonly URI[]): Promise<readonly URI[]>;
+    getMetadata(promptFileUri: URI): Promise<IMetadata>;
     getAllMetadata(promptUris: readonly URI[]): Promise<IMetadata[]>;
-    getCombinedToolsMetadata(promptUris: readonly URI[]): Promise<TCombinedToolsMetadata | null>;
 }
 export declare function getPromptCommandName(path: string): string;

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

@@ -1,11 +1,10 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { flatten } from '../utils/treeUtils.js';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { PROMPT_LANGUAGE_ID } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/constants';
-import { flatten, forEach } from '../utils/treeUtils.js';
 import { PromptParser } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptParser';
-import { match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
+import { splitGlobAware, match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
 import { pick } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
 import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
@@ -13,44 +12,54 @@ import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/
 import { PromptFilesLocator } from '../utils/promptFilesLocator.js';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ObjectCache } from '../../../../../../base/common/objectCache.js';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { TextModelPromptParser } from '../parsers/textModelPromptParser.js';
 import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-51fed910-d648-5620-9b80-9232cd79d116-common/vscode/vs/platform/prompts/common/constants';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { logTime } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/decorators/logTime';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { PromptsType, isValidPromptType, getCleanPromptName, PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/prompts';
 
 let PromptsService = class PromptsService extends Disposable {
-    constructor(labelService, modelService, initService, userDataService) {
+    constructor(logger, labelService, modelService, instantiationService, userDataService) {
         super();
+        this.logger = logger;
         this.labelService = labelService;
         this.modelService = modelService;
-        this.initService = initService;
+        this.instantiationService = instantiationService;
         this.userDataService = userDataService;
-        this.fileLocator = this.initService.createInstance(PromptFilesLocator);
+        this.fileLocator = this._register(this.instantiationService.createInstance(PromptFilesLocator));
+        this.logTime = this.logger.trace.bind(this.logger);
         this.cache = this._register(( new ObjectCache((model) => {
             assert(model.isDisposed() === false, 'Text model must not be disposed.');
-            const parser = initService.createInstance(TextModelPromptParser, model, { seenReferences: [] }).start();
+            const parser = instantiationService.createInstance(TextModelPromptParser, model, { seenReferences: [] }).start();
             parser.assertNotDisposed('Created prompt parser must not be disposed.');
             return parser;
         })));
     }
+    get onDidChangeCustomChatModes() {
+        if (!this.onDidChangeCustomChatModesEvent) {
+            this.onDidChangeCustomChatModesEvent = this.fileLocator.getFilesUpdatedEvent(PromptsType.mode);
+        }
+        return this.onDidChangeCustomChatModesEvent;
+    }
     getSyntaxParserFor(model) {
         assert(model.isDisposed() === false, 'Cannot create a prompt syntax parser for a disposed model.');
         return this.cache.get(model);
     }
-    async listPromptFiles(type) {
-        const userLocations = [this.userDataService.currentProfile.promptsHome];
+    async listPromptFiles(type, token) {
         const prompts = await Promise.all([
-            this.fileLocator.listFilesIn(userLocations, type)
+            this.fileLocator.listFiles(type, 'user', token)
                 .then(withType('user', type)),
-            this.fileLocator.listFiles(type)
+            this.fileLocator.listFiles(type, 'local', token)
                 .then(withType('local', type)),
         ]);
         return prompts.flat();
     }
     getSourceFolders(type) {
-        assert(type === 'prompt' || type === 'instructions', `Unknown prompt type '${type}'.`);
+        assert(isValidPromptType(type), `Unknown prompt type '${type}'.`);
         const result = [];
         for (const uri of this.fileLocator.getConfigBasedSourceFolders(type)) {
             result.push({ uri, storage: 'local', type });
@@ -61,34 +70,41 @@ let PromptsService = class PromptsService extends Disposable {
     }
     asPromptSlashCommand(command) {
         if (command.match(/^[\w_\-\.]+$/)) {
-            return { command, detail: ( localize(5092, 'Prompt file: {0}', command)) };
+            return { command, detail: ( localize(5202, 'Prompt file: {0}', command)) };
         }
         return undefined;
     }
     async resolvePromptSlashCommand(data) {
+        const promptUri = await this.getPromptPath(data);
+        if (!promptUri) {
+            return undefined;
+        }
+        return await this.getMetadata(promptUri);
+    }
+    async getPromptPath(data) {
         if (data.promptPath) {
-            return data.promptPath;
+            return data.promptPath.uri;
         }
-        const files = await this.listPromptFiles('prompt');
+        const files = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
         const command = data.command;
         const result = files.find(file => getPromptCommandName(file.uri.path) === command);
         if (result) {
-            return result;
+            return result.uri;
         }
-        const model = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getPromptCommandName(model.uri.path) === command);
-        if (model) {
-            return { uri: model.uri, storage: 'local', type: 'prompt' };
+        const textModel = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getPromptCommandName(model.uri.path) === command);
+        if (textModel) {
+            return textModel.uri;
         }
         return undefined;
     }
     async findPromptSlashCommands() {
-        const promptFiles = await this.listPromptFiles('prompt');
+        const promptFiles = await this.listPromptFiles(PromptsType.prompt, CancellationToken.None);
         return (promptFiles.map(promptPath => {
             const command = getPromptCommandName(promptPath.uri.path);
             return {
                 command,
                 detail: ( localize(
-                    5092,
+                    5202,
                     'Prompt file: {0}',
                     this.labelService.getUriLabel(promptPath.uri, { relative: true })
                 )),
@@ -96,36 +112,83 @@ let PromptsService = class PromptsService extends Disposable {
             };
         }));
     }
+    async getCustomChatModes() {
+        const modeFiles = ( (await this.listPromptFiles(PromptsType.mode, CancellationToken.None))
+            .map(modeFile => modeFile.uri));
+        const metadataList = await Promise.all(( modeFiles.map(async (uri) => {
+            let parser;
+            try {
+                parser = this.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true }).start();
+                await parser.settled();
+                const { metadata } = parser;
+                const tools = (metadata && ('tools' in metadata))
+                    ? metadata.tools
+                    : undefined;
+                const body = await parser.getBody();
+                return {
+                    uri: uri,
+                    name: getCleanPromptName(uri),
+                    description: metadata?.description,
+                    tools,
+                    body,
+                };
+            }
+            finally {
+                parser?.dispose();
+            }
+        })));
+        return metadataList;
+    }
     async findInstructionFilesFor(files) {
-        const result = [];
-        const instructionFiles = await this.listPromptFiles('instructions');
+        const instructionFiles = await this.listPromptFiles(PromptsType.instructions, CancellationToken.None);
         if (instructionFiles.length === 0) {
-            return result;
+            return [];
         }
         const instructions = await this.getAllMetadata(( instructionFiles.map(pick('uri'))));
+        const foundFiles = ( new ResourceSet());
         for (const instruction of instructions.flatMap(flatten)) {
             const { metadata, uri } = instruction;
-            const { applyTo } = metadata;
-            if (applyTo === undefined) {
+            if (metadata?.promptType !== PromptsType.instructions) {
                 continue;
             }
-            if ((applyTo === '**') || (applyTo === '**/*')) {
-                result.push(uri);
+            const { applyTo } = metadata;
+            if (applyTo === undefined) {
                 continue;
             }
-            for (const file of files) {
-                if (match(applyTo, file.fsPath)) {
-                    result.push(uri);
+            const patterns = splitGlobAware(applyTo, ',');
+            const patterMatches = (pattern) => {
+                pattern = pattern.trim();
+                if (pattern.length === 0) {
+                    return false;
                 }
+                if (pattern === '**' || pattern === '**/*' || pattern === '*') {
+                    return true;
+                }
+                if (!pattern.startsWith('/') && !pattern.startsWith('**/')) {
+                    pattern = '**/' + pattern;
+                }
+                for (const file of files) {
+                    if (match(pattern, file.path)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+            if (( patterns.some(patterMatches))) {
+                foundFiles.add(uri);
             }
         }
-        return [...( new ResourceSet(result))];
+        return [...foundFiles];
+    }
+    async getMetadata(promptFileUri) {
+        const metaDatas = await this.getAllMetadata([promptFileUri]);
+        return metaDatas[0];
     }
     async getAllMetadata(promptUris) {
         const metadata = await Promise.all(( promptUris.map(async (uri) => {
             let parser;
             try {
-                parser = this.initService.createInstance(PromptParser, uri, { allowNonPromptFiles: true }).start();
+                parser = this.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true }).start();
                 await parser.allSettled();
                 return collectMetadata(parser);
             }
@@ -135,99 +198,23 @@ let PromptsService = class PromptsService extends Disposable {
         })));
         return metadata;
     }
-    async getCombinedToolsMetadata(promptUris) {
-        if (promptUris.length === 0) {
-            return null;
-        }
-        const filesMetadata = await this.getAllMetadata(promptUris);
-        const allTools = ( filesMetadata
-            .map((fileMetadata) => {
-            const result = [];
-            let isFirst = true;
-            let isRootInAgentMode = false;
-            let hasTools = false;
-            let chatMode;
-            forEach((node) => {
-                const { metadata } = node;
-                const { mode, tools } = metadata;
-                if (isFirst === true) {
-                    isFirst = false;
-                    if ((mode === ChatMode.Agent) || (tools !== undefined)) {
-                        isRootInAgentMode = true;
-                        chatMode = ChatMode.Agent;
-                    }
-                }
-                chatMode ??= mode;
-                if (chatMode && mode) {
-                    chatMode = morePrivilegedChatMode(chatMode, mode);
-                }
-                if (isRootInAgentMode && tools !== undefined) {
-                    result.push(...tools);
-                    hasTools = true;
-                }
-                return false;
-            }, fileMetadata);
-            if (chatMode === ChatMode.Agent) {
-                return {
-                    tools: (hasTools)
-                        ? [...( new Set(result))]
-                        : undefined,
-                    mode: ChatMode.Agent,
-                };
-            }
-            return {
-                mode: chatMode,
-            };
-        }));
-        let hasAnyTools = false;
-        let resultingChatMode;
-        const result = [];
-        for (const { tools, mode } of allTools) {
-            resultingChatMode ??= mode;
-            if (resultingChatMode && mode) {
-                resultingChatMode = morePrivilegedChatMode(resultingChatMode, mode);
-            }
-            if (tools) {
-                result.push(...tools);
-                hasAnyTools = true;
-            }
-        }
-        if (resultingChatMode === ChatMode.Agent) {
-            return {
-                tools: (hasAnyTools)
-                    ? [...( new Set(result))]
-                    : undefined,
-                mode: resultingChatMode,
-            };
-        }
-        return {
-            tools: undefined,
-            mode: resultingChatMode,
-        };
-    }
 };
+PromptsService.__decorator = ( __decorate([
+    logTime()
+], PromptsService.prototype, "getCustomChatModes", null));
+PromptsService.__decorator = ( __decorate([
+    logTime()
+], PromptsService.prototype, "findInstructionFilesFor", null));
+PromptsService.__decorator = ( __decorate([
+    logTime()
+], PromptsService.prototype, "getAllMetadata", null));
 PromptsService = ( __decorate([
-    ( __param(0, ILabelService)),
-    ( __param(1, IModelService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IUserDataProfileService))
+    ( __param(0, ILogService)),
+    ( __param(1, ILabelService)),
+    ( __param(2, IModelService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IUserDataProfileService))
 ], PromptsService));
-const morePrivilegedChatMode = (chatMode1, chatMode2) => {
-    if (chatMode1 === chatMode2) {
-        return chatMode1;
-    }
-    if ((chatMode1 === ChatMode.Agent) || (chatMode2 === ChatMode.Agent)) {
-        return ChatMode.Agent;
-    }
-    if ((chatMode1 === ChatMode.Edit) || (chatMode2 === ChatMode.Edit)) {
-        return ChatMode.Edit;
-    }
-    throw ( new Error([
-        'Invalid logic encountered: ',
-        `at this point modes '${chatMode1}' and '${chatMode2}' are different, but`,
-        `both must have be equal to '${ChatMode.Ask}' at the same time.`,
-    ].join(' ')));
-};
 const collectMetadata = (reference) => {
     const childMetadata = [];
     for (const child of reference.references) {

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/utils/promptFilesLocator.d.ts

@@ -1,17 +1,31 @@
-import { TPromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-export declare class PromptFilesLocator {
+import { PromptsType } from "@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/platform/prompts/common/prompts";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { TPromptsStorage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/types";
+import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+export declare class PromptFilesLocator extends Disposable {
     private readonly fileService;
     private readonly configService;
     private readonly workspaceService;
-    constructor(fileService: IFileService, configService: IConfigurationService, workspaceService: IWorkspaceContextService);
-    listFiles(type: TPromptsType): Promise<readonly URI[]>;
-    listFilesIn(folders: readonly URI[], type: TPromptsType): Promise<readonly URI[]>;
-    getConfigBasedSourceFolders(type: TPromptsType): readonly URI[];
-    private findFilesInLocations;
+    private readonly environmentService;
+    private readonly searchService;
+    private readonly userDataService;
+    constructor(fileService: IFileService, configService: IConfigurationService, workspaceService: IWorkspaceContextService, environmentService: IWorkbenchEnvironmentService, searchService: ISearchService, userDataService: IUserDataProfileService);
+    listFiles(type: PromptsType, storage: TPromptsStorage, token: CancellationToken): Promise<readonly URI[]>;
+    private listFilesInUserData;
+    getFilesUpdatedEvent(type: PromptsType): Event<void>;
+    getConfigBasedSourceFolders(type: PromptsType): readonly URI[];
+    private listFilesInLocal;
+    private getLocalParentFolders;
+    private toAbsoluteLocations;
+    private resolveFilesAtLocation;
+    private searchFilesInLocation;
 }
 export declare const isValidGlob: (pattern: string) => boolean;
-export declare const firstNonGlobParent: (location: URI) => URI;