@codingame/monaco-vscode-chat-service-override 18.4.0 → 19.0.0

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

@@ -0,0 +1,36 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { BasePromptParser } from './basePromptParser.js';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { TextModelContentsProvider } from '../contentProviders/textModelContentsProvider.js';
+import { FilePromptContentProvider } from '../contentProviders/filePromptContentsProvider.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+
+function getContentsProvider(uri, options, modelService, instaService) {
+    const model = modelService.getModel(uri);
+    if (model) {
+        return instaService.createInstance(TextModelContentsProvider, model, options);
+    }
+    return instaService.createInstance(FilePromptContentProvider, uri, options);
+}
+let PromptParser = class PromptParser extends BasePromptParser {
+    constructor(uri, options, logService, modelService, instaService, envService) {
+        const contentsProvider = getContentsProvider(uri, options, modelService, instaService);
+        super(contentsProvider, options, instaService, envService, logService);
+        this.contentsProvider = this._register(contentsProvider);
+    }
+    toString() {
+        const { sourceName } = this.contentsProvider;
+        return `prompt-parser:${sourceName}:${this.uri.path}`;
+    }
+};
+PromptParser = ( __decorate([
+    ( __param(2, ILogService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IWorkbenchEnvironmentService))
+], PromptParser));
+
+export { PromptParser };

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

@@ -1,10 +1,10 @@
 import { 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 { BasePromptParser, IPromptParserOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/basePromptParser";
-import { TextModelContentsProvider } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/textModelContentsProvider";
-import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { BasePromptParser, IPromptParserOptions } from "./basePromptParser.js";
+import { TextModelContentsProvider } from "../contentProviders/textModelContentsProvider.js";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
 export declare class TextModelPromptParser extends BasePromptParser<TextModelContentsProvider> {
-    constructor(model: ITextModel, options: Partial<IPromptParserOptions>, instantiationService: IInstantiationService, workspaceService: IWorkspaceContextService, logService: ILogService);
+    constructor(model: ITextModel, options: IPromptParserOptions, instantiationService: IInstantiationService, envService: IWorkbenchEnvironmentService, logService: ILogService);
     toString(): string;
 }

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

@@ -1,15 +1,15 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { BasePromptParser } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/basePromptParser';
-import { TextModelContentsProvider } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/textModelContentsProvider';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { BasePromptParser } from './basePromptParser.js';
+import { TextModelContentsProvider } from '../contentProviders/textModelContentsProvider.js';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 
 let TextModelPromptParser = class TextModelPromptParser extends BasePromptParser {
-    constructor(model, options, instantiationService, workspaceService, logService) {
+    constructor(model, options, instantiationService, envService, logService) {
         const contentsProvider = instantiationService.createInstance(TextModelContentsProvider, model, options);
-        super(contentsProvider, options, instantiationService, workspaceService, logService);
+        super(contentsProvider, options, instantiationService, envService, logService);
         this._register(contentsProvider);
     }
     toString() {
@@ -18,7 +18,7 @@ let TextModelPromptParser = class TextModelPromptParser extends BasePromptParser
 };
 TextModelPromptParser = ( __decorate([
     ( __param(2, IInstantiationService)),
-    ( __param(3, IWorkspaceContextService)),
+    ( __param(3, IWorkbenchEnvironmentService)),
     ( __param(4, ILogService))
 ], TextModelPromptParser));
 

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

@@ -0,0 +1,9 @@
+import { ITopError } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/types";
+export declare class TopError implements ITopError {
+    readonly originalError: ITopError["originalError"];
+    readonly errorSubject: ITopError["errorSubject"];
+    readonly errorsCount: ITopError["errorsCount"];
+    readonly parentUri: ITopError["parentUri"];
+    constructor(options: Omit<ITopError, "localizedMessage">);
+    get localizedMessage(): string;
+}

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

@@ -0,0 +1,50 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { OpenFailed, FailedToResolveContentsStream, RecursiveReference } from '../../promptFileReferenceErrors.js';
+
+class TopError {
+    constructor(options) {
+        this.originalError = options.originalError;
+        this.errorSubject = options.errorSubject;
+        this.errorsCount = options.errorsCount;
+        this.parentUri = options.parentUri;
+    }
+    get localizedMessage() {
+        const { originalError, parentUri, errorSubject: subject, errorsCount } = this;
+        assert(errorsCount >= 1, `Error count must be at least 1, got '${errorsCount}'.`);
+        const moreIssuesLabel = (errorsCount > 1)
+            ? ( localize(5352, "\n(+{0} more issues)", errorsCount - 1))
+            : '';
+        if (subject === 'root') {
+            if (originalError instanceof OpenFailed) {
+                return localize(5353, "Cannot open '{0}'.{1}", originalError.uri.path, moreIssuesLabel);
+            }
+            if (originalError instanceof FailedToResolveContentsStream) {
+                return localize(5354, "Cannot read '{0}'.{1}", originalError.uri.path, moreIssuesLabel);
+            }
+            if (originalError instanceof RecursiveReference) {
+                return localize(5355, "Recursion to itself.");
+            }
+            return originalError.message + moreIssuesLabel;
+        }
+        assertDefined(parentUri, 'Parent URI must be defined for error of non-root link.');
+        const errorMessageStart = (subject === 'child')
+            ? ( localize(5356, "Contains"))
+            : ( localize(5357, "Indirectly referenced prompt '{0}' contains", parentUri.path));
+        const linkIssueName = (originalError instanceof RecursiveReference)
+            ? ( localize(5358, "recursive"))
+            : ( localize(5359, "broken"));
+        return localize(
+            5360,
+            "{0} a {1} link to '{2}' that will be ignored.{3}",
+            errorMessageStart,
+            linkIssueName,
+            originalError.uri.path,
+            moreIssuesLabel
+        );
+    }
+}
+
+export { TopError };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/{contributions/index.d.ts → promptFileContributions.d.ts}

@@ -1,3 +1,3 @@
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-export declare const registerPromptFileContributions: () => void;
+export declare function registerPromptFileContributions(): void;
 export type TContribution = new (...args: any[]) => IWorkbenchContribution;

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

@@ -0,0 +1,29 @@
+
+import { ConfigMigration } from './config/configMigration.js';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { PromptLinkProvider } from './languageProviders/promptLinkProvider.js';
+import { PromptLinkDiagnosticsInstanceManager } from './languageProviders/promptLinkDiagnosticsProvider.js';
+import { PromptHeaderDiagnosticsInstanceManager } from './languageProviders/promptHeaderDiagnosticsProvider.js';
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { PromptPathAutocompletion } from './languageProviders/promptPathAutocompletion.js';
+import { PromptHeaderAutocompletion } from './languageProviders/promptHeaderAutocompletion.js';
+import { PromptHeaderHoverProvider } from './languageProviders/promptHeaderHovers.js';
+
+function registerPromptFileContributions() {
+    registerContribution(PromptLinkProvider);
+    registerContribution(PromptLinkDiagnosticsInstanceManager);
+    registerContribution(PromptHeaderDiagnosticsInstanceManager);
+    if (!isWindows) {
+        registerContribution(PromptPathAutocompletion);
+    }
+    registerContribution(PromptHeaderAutocompletion);
+    registerContribution(PromptHeaderHoverProvider);
+    registerContribution(ConfigMigration);
+}
+function registerContribution(contribution) {
+    ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(contribution, LifecyclePhase.Eventually);
+}
+
+export { registerPromptFileContributions };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/{promptsService.d.ts → promptsServiceImpl.d.ts}

@@ -1,3 +1,4 @@
+import { PromptsType } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 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";
@@ -7,37 +8,39 @@ 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 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";
+import type { IChatPromptSlashCommand, ICustomChatMode, IPromptParserResult, IPromptPath } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 export declare class PromptsService extends Disposable implements IPromptsService {
     readonly logger: ILogService;
     private readonly labelService;
     private readonly modelService;
     private readonly instantiationService;
     private readonly userDataService;
+    private readonly languageService;
+    private readonly configurationService;
     readonly _serviceBrand: undefined;
     private readonly cache;
     private readonly fileLocator;
-    logTime: TLogFunction;
+    private cachedCustomChatModes;
     private onDidChangeCustomChatModesEvent;
-    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService);
+    constructor(logger: ILogService, labelService: ILabelService, modelService: IModelService, instantiationService: IInstantiationService, userDataService: IUserDataProfileService, languageService: ILanguageService, configurationService: IConfigurationService);
     get onDidChangeCustomChatModes(): Event<void>;
+    getPromptFileType(uri: URI): PromptsType | undefined;
     getSyntaxParserFor(model: ITextModel): TextModelPromptParser & {
         isDisposed: false;
     };
     listPromptFiles(type: PromptsType, token: CancellationToken): Promise<readonly IPromptPath[]>;
     getSourceFolders(type: PromptsType): readonly IPromptPath[];
     asPromptSlashCommand(command: string): IChatPromptSlashCommand | undefined;
-    resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IMetadata | undefined>;
+    resolvePromptSlashCommand(data: IChatPromptSlashCommand, token: CancellationToken): Promise<IPromptParserResult | 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[]>;
+    getCustomChatModes(token: CancellationToken): Promise<readonly ICustomChatMode[]>;
+    private computeCustomChatModes;
+    parse(uri: URI, type: PromptsType, token: CancellationToken): Promise<IPromptParserResult>;
 }
 export declare function getPromptCommandName(path: string): string;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/{promptsService.js → promptsServiceImpl.js}

@@ -1,55 +1,65 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-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 { PromptParser } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/parsers/promptParser';
-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 { PromptsType, getPromptsTypeForLanguageId, PROMPT_LANGUAGE_ID, MODE_LANGUAGE_ID, getLanguageIdForPromptsType } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptParser } from '../parsers/promptParser.js';
 import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 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 { ObjectCache } from '../utils/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 { 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';
+import { getCleanPromptName, PROMPT_FILE_EXTENSION } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { PromptsConfig } from '@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 
 let PromptsService = class PromptsService extends Disposable {
-    constructor(logger, labelService, modelService, instantiationService, userDataService) {
+    constructor(logger, labelService, modelService, instantiationService, userDataService, languageService, configurationService) {
         super();
         this.logger = logger;
         this.labelService = labelService;
         this.modelService = modelService;
         this.instantiationService = instantiationService;
         this.userDataService = userDataService;
+        this.languageService = languageService;
+        this.configurationService = configurationService;
         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 = instantiationService.createInstance(TextModelPromptParser, model, { seenReferences: [] }).start();
+            const parser = instantiationService.createInstance(TextModelPromptParser, model, { allowNonPromptFiles: true, languageId: undefined, updateOnChange: true }).start();
             parser.assertNotDisposed('Created prompt parser must not be disposed.');
             return parser;
         })));
     }
     get onDidChangeCustomChatModes() {
         if (!this.onDidChangeCustomChatModesEvent) {
-            this.onDidChangeCustomChatModesEvent = this.fileLocator.getFilesUpdatedEvent(PromptsType.mode);
+            this.onDidChangeCustomChatModesEvent = this._register(this.fileLocator.createFilesUpdatedEvent(PromptsType.mode)).event;
+            this._register(this.onDidChangeCustomChatModesEvent(() => {
+                this.cachedCustomChatModes = undefined;
+            }));
         }
         return this.onDidChangeCustomChatModesEvent;
     }
+    getPromptFileType(uri) {
+        const model = this.modelService.getModel(uri);
+        const languageId = model ? model.getLanguageId() : this.languageService.guessLanguageIdByFilepathOrFirstLine(uri);
+        return languageId ? getPromptsTypeForLanguageId(languageId) : undefined;
+    }
     getSyntaxParserFor(model) {
         assert(model.isDisposed() === false, 'Cannot create a prompt syntax parser for a disposed model.');
         return this.cache.get(model);
     }
     async listPromptFiles(type, token) {
+        if (!PromptsConfig.enabled(this.configurationService)) {
+            return [];
+        }
         const prompts = await Promise.all([
             this.fileLocator.listFiles(type, 'user', token)
                 .then(withType('user', type)),
@@ -59,7 +69,9 @@ let PromptsService = class PromptsService extends Disposable {
         return prompts.flat();
     }
     getSourceFolders(type) {
-        assert(isValidPromptType(type), `Unknown prompt type '${type}'.`);
+        if (!PromptsConfig.enabled(this.configurationService)) {
+            return [];
+        }
         const result = [];
         for (const uri of this.fileLocator.getConfigBasedSourceFolders(type)) {
             result.push({ uri, storage: 'local', type });
@@ -70,16 +82,16 @@ let PromptsService = class PromptsService extends Disposable {
     }
     asPromptSlashCommand(command) {
         if (command.match(/^[\w_\-\.]+$/)) {
-            return { command, detail: ( localize(5202, 'Prompt file: {0}', command)) };
+            return { command, detail: ( localize(5361, 'Prompt file: {0}', command)) };
         }
         return undefined;
     }
-    async resolvePromptSlashCommand(data) {
+    async resolvePromptSlashCommand(data, token) {
         const promptUri = await this.getPromptPath(data);
         if (!promptUri) {
             return undefined;
         }
-        return await this.getMetadata(promptUri);
+        return await this.parse(promptUri, PromptsType.prompt, token);
     }
     async getPromptPath(data) {
         if (data.promptPath) {
@@ -104,7 +116,7 @@ let PromptsService = class PromptsService extends Disposable {
             return {
                 command,
                 detail: ( localize(
-                    5202,
+                    5361,
                     'Prompt file: {0}',
                     this.labelService.getUriLabel(promptPath.uri, { relative: true })
                 )),
@@ -112,26 +124,34 @@ 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) => {
+    async getCustomChatModes(token) {
+        if (!this.cachedCustomChatModes) {
+            const customChatModes = this.computeCustomChatModes(token);
+            if (!this.onDidChangeCustomChatModesEvent) {
+                return customChatModes;
+            }
+            this.cachedCustomChatModes = customChatModes;
+        }
+        return this.cachedCustomChatModes;
+    }
+    async computeCustomChatModes(token) {
+        const modeFiles = await this.listPromptFiles(PromptsType.mode, token);
+        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;
+                parser = this.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true, languageId: MODE_LANGUAGE_ID, updateOnChange: false }).start(token);
+                const completed = await parser.settled();
+                if (!completed) {
+                    throw ( new Error(( localize(5362, "Prompt parser for {0} did not complete.", (uri.toString())))));
+                }
                 const body = await parser.getBody();
-                return {
-                    uri: uri,
-                    name: getCleanPromptName(uri),
-                    description: metadata?.description,
-                    tools,
-                    body,
-                };
+                const name = getCleanPromptName(uri);
+                const metadata = parser.metadata;
+                if (metadata?.promptType !== PromptsType.mode) {
+                    return { uri, name, body };
+                }
+                const { description, model, tools } = metadata;
+                return { uri, name, description, model, tools, body };
             }
             finally {
                 parser?.dispose();
@@ -139,113 +159,50 @@ let PromptsService = class PromptsService extends Disposable {
         })));
         return metadataList;
     }
-    async findInstructionFilesFor(files) {
-        const instructionFiles = await this.listPromptFiles(PromptsType.instructions, CancellationToken.None);
-        if (instructionFiles.length === 0) {
-            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;
-            if (metadata?.promptType !== PromptsType.instructions) {
-                continue;
-            }
-            const { applyTo } = metadata;
-            if (applyTo === undefined) {
-                continue;
+    async parse(uri, type, token) {
+        let parser;
+        try {
+            const languageId = getLanguageIdForPromptsType(type);
+            parser = this.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true, languageId, updateOnChange: false }).start(token);
+            const completed = await parser.settled();
+            if (!completed) {
+                throw ( new Error(( localize(5362, "Prompt parser for {0} did not complete.", (uri.toString())))));
             }
-            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;
+            return {
+                uri: parser.uri,
+                metadata: parser.metadata,
+                topError: parser.topError,
+                references: ( parser.references.map(ref => ref.uri))
             };
-            if (( patterns.some(patterMatches))) {
-                foundFiles.add(uri);
-            }
         }
-        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.instantiationService.createInstance(PromptParser, uri, { allowNonPromptFiles: true }).start();
-                await parser.allSettled();
-                return collectMetadata(parser);
-            }
-            finally {
-                parser?.dispose();
-            }
-        })));
-        return metadata;
+        finally {
+            parser?.dispose();
+        }
     }
 };
-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, ILogService)),
     ( __param(1, ILabelService)),
     ( __param(2, IModelService)),
     ( __param(3, IInstantiationService)),
-    ( __param(4, IUserDataProfileService))
+    ( __param(4, IUserDataProfileService)),
+    ( __param(5, ILanguageService)),
+    ( __param(6, IConfigurationService))
 ], PromptsService));
-const collectMetadata = (reference) => {
-    const childMetadata = [];
-    for (const child of reference.references) {
-        if (child.errorCondition !== undefined) {
-            continue;
-        }
-        childMetadata.push(collectMetadata(child));
-    }
-    const children = (childMetadata.length > 0)
-        ? childMetadata
-        : undefined;
-    return {
-        uri: reference.uri,
-        metadata: reference.metadata,
-        children,
-    };
-};
 function getPromptCommandName(path) {
     const name = basename(path, PROMPT_FILE_EXTENSION);
     return name;
 }
-const addType = (storage, type) => {
+function addType(storage, type) {
     return (uri) => {
         return { uri, storage, type };
     };
-};
-const withType = (storage, type) => {
+}
+function withType(storage, type) {
     return (uris) => {
         return ( uris
             .map(addType(storage, type)));
     };
-};
+}
 
 export { PromptsService, getPromptCommandName };

package/vscode/src/vs/{base/common → workbench/contrib/chat/common/promptSyntax/utils}/objectCache.d.ts

@@ -1,5 +1,5 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ObservableDisposable } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableDisposable";
+import { ObservableDisposable } from "./observableDisposable.js";
 export declare class ObjectCache<TValue extends ObservableDisposable, TKey extends NonNullable<unknown> = string> extends Disposable {
     private readonly factory;
     private readonly cache;

package/vscode/src/vs/{base/common → workbench/contrib/chat/common/promptSyntax/utils}/objectCache.js

@@ -1,6 +1,6 @@
 
 import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { assertNotDisposed } from '@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableDisposable';
+import { assertNotDisposed } from './observableDisposable.js';
 
 class ObjectCache extends Disposable {
     constructor(factory) {

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

@@ -0,0 +1,17 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+export declare abstract class ObservableDisposable extends Disposable {
+    private readonly store;
+    get isDisposed(): boolean;
+    onDispose(callback: () => void): IDisposable;
+    addDisposables(...disposables: IDisposable[]): this;
+    assertNotDisposed(error: string | Error): asserts this is TNotDisposed<this>;
+}
+type TNotDisposed<TObject extends {
+    isDisposed: boolean;
+}> = TObject & {
+    isDisposed: false;
+};
+export declare function assertNotDisposed<TObject extends {
+    isDisposed: boolean;
+}>(object: TObject, error: string | Error): asserts object is TNotDisposed<TObject>;
+export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/utils/observableDisposable.js

@@ -0,0 +1,41 @@
+
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+class ObservableDisposable extends Disposable {
+    constructor() {
+        super(...arguments);
+        this.store = this._register(( new DisposableStore()));
+    }
+    get isDisposed() {
+        return this.store.isDisposed;
+    }
+    onDispose(callback) {
+        if (this.isDisposed) {
+            const timeoutHandle = setTimeout(callback);
+            return toDisposable(() => {
+                clearTimeout(timeoutHandle);
+            });
+        }
+        return this.store.add(toDisposable(callback));
+    }
+    addDisposables(...disposables) {
+        for (const disposable of disposables) {
+            this.store.add(disposable);
+        }
+        return this;
+    }
+    assertNotDisposed(error) {
+        assertNotDisposed(this, error);
+    }
+}
+function assertNotDisposed(object, error) {
+    if (!object.isDisposed) {
+        return;
+    }
+    const errorToThrow = typeof error === 'string'
+        ? ( new Error(error))
+        : error;
+    throw errorToThrow;
+}
+
+export { ObservableDisposable, assertNotDisposed };