@codingame/monaco-vscode-chat-service-override 21.6.0 → 22.0.0

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

@@ -0,0 +1,456 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { splitGlobAware, parse, isEmptyPattern } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+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 { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { PromptsType, getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptsConfig } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Delayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+
+const MARKERS_OWNER_ID = 'prompts-diagnostics-provider';
+let PromptValidator = class PromptValidator {
+    constructor(languageModelsService, languageModelToolsService, chatModeService, fileService, labelService) {
+        this.languageModelsService = languageModelsService;
+        this.languageModelToolsService = languageModelToolsService;
+        this.chatModeService = chatModeService;
+        this.fileService = fileService;
+        this.labelService = labelService;
+    }
+    async validate(promptAST, promptType, report) {
+        promptAST.header?.errors.forEach(error => report(toMarker(error.message, error.range, MarkerSeverity.Error)));
+        this.validateHeader(promptAST, promptType, report);
+        await this.validateBody(promptAST, report);
+    }
+    async validateBody(promptAST, report) {
+        const body = promptAST.body;
+        if (!body) {
+            return;
+        }
+        const fileReferenceChecks = [];
+        for (const ref of body.fileReferences) {
+            const resolved = body.resolveFilePath(ref.content);
+            if (!resolved) {
+                report(toMarker(( localize(5656, "Invalid file reference '{0}'.", ref.content)), ref.range, MarkerSeverity.Warning));
+                continue;
+            }
+            fileReferenceChecks.push((async () => {
+                try {
+                    const exists = await this.fileService.exists(resolved);
+                    if (exists) {
+                        return;
+                    }
+                }
+                catch {
+                }
+                const loc = this.labelService.getUriLabel(resolved);
+                report(toMarker(( localize(5657, "File '{0}' not found at '{1}'.", ref.content, loc)), ref.range, MarkerSeverity.Warning));
+            })());
+        }
+        if (body.variableReferences.length) {
+            const headerTools = promptAST.header?.tools;
+            const headerToolsMap = headerTools ? this.languageModelToolsService.toToolAndToolSetEnablementMap(headerTools) : undefined;
+            const available = ( new Set(this.languageModelToolsService.getQualifiedToolNames()));
+            const deprecatedNames = this.languageModelToolsService.getDeprecatedQualifiedToolNames();
+            for (const variable of body.variableReferences) {
+                if (!( available.has(variable.name))) {
+                    if (( deprecatedNames.has(variable.name))) {
+                        const currentName = deprecatedNames.get(variable.name);
+                        report(toMarker(( localize(
+                            5658,
+                            "Tool or toolset '{0}' has been renamed, use '{1}' instead.",
+                            variable.name,
+                            currentName
+                        )), variable.range, MarkerSeverity.Info));
+                    }
+                    else {
+                        report(toMarker(( localize(5659, "Unknown tool or toolset '{0}'.", variable.name)), variable.range, MarkerSeverity.Warning));
+                    }
+                }
+                else if (headerToolsMap) {
+                    const tool = this.languageModelToolsService.getToolByQualifiedName(variable.name);
+                    if (tool && headerToolsMap.get(tool) === false) {
+                        report(toMarker(( localize(
+                            5660,
+                            "Tool or toolset '{0}' also needs to be enabled in the header.",
+                            variable.name
+                        )), variable.range, MarkerSeverity.Warning));
+                    }
+                }
+            }
+        }
+        await Promise.all(fileReferenceChecks);
+    }
+    validateHeader(promptAST, promptType, report) {
+        const header = promptAST.header;
+        if (!header) {
+            return;
+        }
+        const validAttributeNames = getValidAttributeNames(promptType, true);
+        const attributes = header.attributes;
+        for (const attribute of attributes) {
+            if (!validAttributeNames.includes(attribute.key)) {
+                const supportedNames = getValidAttributeNames(promptType, false).join(', ');
+                switch (promptType) {
+                    case PromptsType.prompt:
+                        report(toMarker(( localize(
+                            5661,
+                            "Attribute '{0}' is not supported in prompt files. Supported: {1}.",
+                            attribute.key,
+                            supportedNames
+                        )), attribute.range, MarkerSeverity.Warning));
+                        break;
+                    case PromptsType.mode:
+                        report(toMarker(( localize(
+                            5662,
+                            "Attribute '{0}' is not supported in mode files. Supported: {1}.",
+                            attribute.key,
+                            supportedNames
+                        )), attribute.range, MarkerSeverity.Warning));
+                        break;
+                    case PromptsType.instructions:
+                        report(toMarker(( localize(
+                            5663,
+                            "Attribute '{0}' is not supported in instructions files. Supported: {1}.",
+                            attribute.key,
+                            supportedNames
+                        )), attribute.range, MarkerSeverity.Warning));
+                        break;
+                }
+            }
+        }
+        this.validateDescription(attributes, report);
+        switch (promptType) {
+            case PromptsType.prompt: {
+                const mode = this.validateMode(attributes, report);
+                this.validateTools(attributes, mode?.kind ?? ChatModeKind.Agent, report);
+                this.validateModel(attributes, mode?.kind ?? ChatModeKind.Agent, report);
+                break;
+            }
+            case PromptsType.instructions:
+                this.validateApplyTo(attributes, report);
+                this.validateExcludeAgent(attributes, report);
+                break;
+            case PromptsType.mode:
+                this.validateTools(attributes, ChatModeKind.Agent, report);
+                this.validateModel(attributes, ChatModeKind.Agent, report);
+                break;
+        }
+    }
+    validateDescription(attributes, report) {
+        const descriptionAttribute = attributes.find(attr => attr.key === 'description');
+        if (!descriptionAttribute) {
+            return;
+        }
+        if (descriptionAttribute.value.type !== 'string') {
+            report(toMarker(( localize(5664, "The 'description' attribute must be a string.")), descriptionAttribute.range, MarkerSeverity.Error));
+            return;
+        }
+        if (descriptionAttribute.value.value.trim().length === 0) {
+            report(toMarker(( localize(5665, "The 'description' attribute should not be empty.")), descriptionAttribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateModel(attributes, modeKind, report) {
+        const attribute = attributes.find(attr => attr.key === 'model');
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== 'string') {
+            report(toMarker(( localize(5666, "The 'model' attribute must be a string.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const modelName = attribute.value.value.trim();
+        if (modelName.length === 0) {
+            report(toMarker(( localize(5667, "The 'model' attribute must be a non-empty string.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const languageModes = this.languageModelsService.getLanguageModelIds();
+        if (languageModes.length === 0) {
+            return;
+        }
+        const modelMetadata = this.findModelByName(languageModes, modelName);
+        if (!modelMetadata) {
+            report(toMarker(( localize(5668, "Unknown model '{0}'.", modelName)), attribute.value.range, MarkerSeverity.Warning));
+        }
+        else if (modeKind === ChatModeKind.Agent && !ILanguageModelChatMetadata.suitableForAgentMode(modelMetadata)) {
+            report(toMarker(( localize(5669, "Model '{0}' is not suited for agent mode.", modelName)), attribute.value.range, MarkerSeverity.Warning));
+        }
+    }
+    findModelByName(languageModes, modelName) {
+        for (const model of languageModes) {
+            const metadata = this.languageModelsService.lookupLanguageModel(model);
+            if (metadata && metadata.isUserSelectable !== false && ILanguageModelChatMetadata.matchesQualifiedName(modelName, metadata)) {
+                return metadata;
+            }
+        }
+        return undefined;
+    }
+    validateMode(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === 'mode');
+        if (!attribute) {
+            return undefined;
+        }
+        if (attribute.value.type !== 'string') {
+            report(toMarker(( localize(5670, "The 'mode' attribute must be a string.")), attribute.value.range, MarkerSeverity.Error));
+            return undefined;
+        }
+        const modeValue = attribute.value.value;
+        if (modeValue.trim().length === 0) {
+            report(toMarker(( localize(5671, "The 'mode' attribute must be a non-empty string.")), attribute.value.range, MarkerSeverity.Error));
+            return undefined;
+        }
+        const modes = this.chatModeService.getModes();
+        const availableModes = [];
+        for (const mode of Iterable.concat(modes.builtin, modes.custom)) {
+            if (mode.name === modeValue) {
+                return mode;
+            }
+            availableModes.push(mode.name);
+        }
+        const errorMessage = ( localize(
+            5672,
+            "Unknown mode '{0}'. Available modes: {1}.",
+            modeValue,
+            availableModes.join(', ')
+        ));
+        report(toMarker(errorMessage, attribute.value.range, MarkerSeverity.Warning));
+        return undefined;
+    }
+    validateTools(attributes, modeKind, report) {
+        const attribute = attributes.find(attr => attr.key === 'tools');
+        if (!attribute) {
+            return;
+        }
+        if (modeKind !== ChatModeKind.Agent) {
+            report(toMarker(( localize(
+                5673,
+                "The 'tools' attribute is only supported in agent mode. Attribute will be ignored."
+            )), attribute.range, MarkerSeverity.Warning));
+        }
+        switch (attribute.value.type) {
+            case 'array':
+                this.validateToolsArray(attribute.value, report);
+                break;
+            default:
+                report(toMarker(( localize(5674, "The 'tools' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+        }
+    }
+    validateToolsArray(valueItem, report) {
+        if (valueItem.items.length > 0) {
+            const available = ( new Set(this.languageModelToolsService.getQualifiedToolNames()));
+            const deprecatedNames = this.languageModelToolsService.getDeprecatedQualifiedToolNames();
+            for (const item of valueItem.items) {
+                if (item.type !== 'string') {
+                    report(toMarker(( localize(5675, "Each tool name in the 'tools' attribute must be a string.")), item.range, MarkerSeverity.Error));
+                }
+                else if (item.value && !( available.has(item.value))) {
+                    if (( deprecatedNames.has(item.value))) {
+                        const currentName = deprecatedNames.get(item.value);
+                        report(toMarker(( localize(
+                            5676,
+                            "Tool or toolset '{0}' has been renamed, use '{1}' instead.",
+                            item.value,
+                            currentName
+                        )), item.range, MarkerSeverity.Info));
+                    }
+                    else {
+                        report(toMarker(( localize(5677, "Unknown tool '{0}'.", item.value)), item.range, MarkerSeverity.Warning));
+                    }
+                }
+            }
+        }
+    }
+    validateApplyTo(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === 'applyTo');
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== 'string') {
+            report(toMarker(( localize(5678, "The 'applyTo' attribute must be a string.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const pattern = attribute.value.value;
+        try {
+            const patterns = splitGlobAware(pattern, ',');
+            if (patterns.length === 0) {
+                report(toMarker(( localize(5679, "The 'applyTo' attribute must be a valid glob pattern.")), attribute.value.range, MarkerSeverity.Error));
+                return;
+            }
+            for (const pattern of patterns) {
+                const globPattern = parse(pattern);
+                if (isEmptyPattern(globPattern)) {
+                    report(toMarker(( localize(5679, "The 'applyTo' attribute must be a valid glob pattern.")), attribute.value.range, MarkerSeverity.Error));
+                    return;
+                }
+            }
+        }
+        catch (_error) {
+            report(toMarker(( localize(5679, "The 'applyTo' attribute must be a valid glob pattern.")), attribute.value.range, MarkerSeverity.Error));
+        }
+    }
+    validateExcludeAgent(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === 'excludeAgent');
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== 'array') {
+            report(toMarker(( localize(5680, "The 'excludeAgent' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+};
+PromptValidator = ( __decorate([
+    ( __param(0, ILanguageModelsService)),
+    ( __param(1, ILanguageModelToolsService)),
+    ( __param(2, IChatModeService)),
+    ( __param(3, IFileService)),
+    ( __param(4, ILabelService))
+], PromptValidator));
+const validAttributeNames = {
+    [PromptsType.prompt]: ['description', 'model', 'tools', 'mode'],
+    [PromptsType.instructions]: ['description', 'applyTo', 'excludeAgent'],
+    [PromptsType.mode]: ['description', 'model', 'tools', 'advancedOptions']
+};
+const validAttributeNamesNoExperimental = {
+    [PromptsType.prompt]: validAttributeNames[PromptsType.prompt].filter(name => !isExperimentalAttribute(name)),
+    [PromptsType.instructions]: validAttributeNames[PromptsType.instructions].filter(name => !isExperimentalAttribute(name)),
+    [PromptsType.mode]: validAttributeNames[PromptsType.mode].filter(name => !isExperimentalAttribute(name))
+};
+function getValidAttributeNames(promptType, includeExperimental) {
+    return includeExperimental ? validAttributeNames[promptType] : validAttributeNamesNoExperimental[promptType];
+}
+function isExperimentalAttribute(attributeName) {
+    return attributeName === 'advancedOptions' || attributeName === 'excludeAgent';
+}
+function toMarker(message, range, severity = MarkerSeverity.Error) {
+    return { severity, message, ...range };
+}
+let PromptValidatorContribution = class PromptValidatorContribution extends Disposable {
+    constructor(modelService, instantiationService, configService, markerService, promptsService, languageModelsService, languageModelToolsService, chatModeService) {
+        super();
+        this.modelService = modelService;
+        this.configService = configService;
+        this.markerService = markerService;
+        this.promptsService = promptsService;
+        this.languageModelsService = languageModelsService;
+        this.languageModelToolsService = languageModelToolsService;
+        this.chatModeService = chatModeService;
+        this.localDisposables = this._register(( new DisposableStore()));
+        this.validator = instantiationService.createInstance(PromptValidator);
+        this.updateRegistration();
+        this._register(this.configService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(PromptsConfig.KEY)) {
+                this.updateRegistration();
+            }
+        }));
+    }
+    updateRegistration() {
+        this.localDisposables.clear();
+        if (!PromptsConfig.enabled(this.configService)) {
+            return;
+        }
+        const trackers = ( new ResourceMap());
+        this.localDisposables.add(toDisposable(() => {
+            trackers.forEach(tracker => tracker.dispose());
+        }));
+        const validateAllDelayer = this._register(( new Delayer(200)));
+        const validateAll = () => {
+            validateAllDelayer.trigger(async () => {
+                this.modelService.getModels().forEach(model => {
+                    const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+                    if (promptType) {
+                        trackers.set(model.uri, ( new ModelTracker(model, promptType, this.validator, this.promptsService, this.markerService)));
+                    }
+                });
+            });
+        };
+        this.localDisposables.add(this.modelService.onModelAdded((model) => {
+            const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+            if (promptType) {
+                trackers.set(model.uri, ( new ModelTracker(model, promptType, this.validator, this.promptsService, this.markerService)));
+            }
+        }));
+        this.localDisposables.add(this.modelService.onModelRemoved((model) => {
+            const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+            if (promptType) {
+                const tracker = trackers.get(model.uri);
+                if (tracker) {
+                    tracker.dispose();
+                    trackers.delete(model.uri);
+                }
+            }
+        }));
+        this.localDisposables.add(this.modelService.onModelLanguageChanged((event) => {
+            const { model } = event;
+            const tracker = trackers.get(model.uri);
+            if (tracker) {
+                tracker.dispose();
+                trackers.delete(model.uri);
+            }
+            const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+            if (promptType) {
+                trackers.set(model.uri, ( new ModelTracker(model, promptType, this.validator, this.promptsService, this.markerService)));
+            }
+        }));
+        this.localDisposables.add(this.languageModelToolsService.onDidChangeTools(() => validateAll()));
+        this.localDisposables.add(this.chatModeService.onDidChangeChatModes(() => validateAll()));
+        this.localDisposables.add(this.languageModelsService.onDidChangeLanguageModels(() => validateAll()));
+        validateAll();
+    }
+};
+PromptValidatorContribution = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IMarkerService)),
+    ( __param(4, IPromptsService)),
+    ( __param(5, ILanguageModelsService)),
+    ( __param(6, ILanguageModelToolsService)),
+    ( __param(7, IChatModeService))
+], PromptValidatorContribution));
+let ModelTracker = class ModelTracker extends Disposable {
+    constructor(textModel, promptType, validator, promptsService, markerService) {
+        super();
+        this.textModel = textModel;
+        this.promptType = promptType;
+        this.validator = validator;
+        this.promptsService = promptsService;
+        this.markerService = markerService;
+        this.delayer = this._register(( new Delayer(200)));
+        this._register(textModel.onDidChangeContent(() => this.validate()));
+        this.validate();
+    }
+    validate() {
+        this.delayer.trigger(async () => {
+            const markers = [];
+            const ast = this.promptsService.getParsedPromptFile(this.textModel);
+            await this.validator.validate(ast, this.promptType, m => markers.push(m));
+            this.markerService.changeOne(MARKERS_OWNER_ID, this.textModel.uri, markers);
+        });
+    }
+    dispose() {
+        this.markerService.remove(MARKERS_OWNER_ID, [this.textModel.uri]);
+        super.dispose();
+    }
+};
+ModelTracker = ( __decorate([
+    ( __param(3, IPromptsService)),
+    ( __param(4, IMarkerService))
+], ModelTracker));
+
+export { PromptValidator, PromptValidatorContribution, getValidAttributeNames, isExperimentalAttribute };

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

@@ -1,9 +1,8 @@
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
-/**
- * Function that registers all prompt-file related contributions.
- */
-export declare function registerPromptFileContributions(): void;
-/**
- * Type for a generic workbench contribution.
- */
-export type TContribution = new (...args: any[]) => IWorkbenchContribution;
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare class PromptLanguageFeaturesProvider extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "chat.promptLanguageFeatures";
+    constructor(languageService: ILanguageFeaturesService, instantiationService: IInstantiationService);
+}

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

@@ -1,28 +1,35 @@
 
-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 { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { PromptLinkProvider } from './languageProviders/promptLinkProvider.js';
-import { PromptLinkDiagnosticsInstanceManager } from './languageProviders/promptLinkDiagnosticsProvider.js';
-import { PromptHeaderDiagnosticsInstanceManager } from './languageProviders/promptHeaderDiagnosticsProvider.js';
 import { PromptBodyAutocompletion } from './languageProviders/promptBodyAutocompletion.js';
 import { PromptHeaderAutocompletion } from './languageProviders/promptHeaderAutocompletion.js';
-import { PromptHeaderHoverProvider } from './languageProviders/promptHeaderHovers.js';
+import { PromptHoverProvider } from './languageProviders/promptHovers.js';
 import { PromptHeaderDefinitionProvider } from './languageProviders/PromptHeaderDefinitionProvider.js';
+import { PromptValidatorContribution } from './languageProviders/promptValidator.js';
+import { PromptDocumentSemanticTokensProvider } from './languageProviders/promptDocumentSemanticTokensProvider.js';
+import { PromptCodeActionProvider } from './languageProviders/promptCodeActions.js';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 
-function registerPromptFileContributions() {
-    registerContribution(PromptLinkProvider);
-    registerContribution(PromptLinkDiagnosticsInstanceManager);
-    registerContribution(PromptHeaderDiagnosticsInstanceManager);
-    registerContribution(PromptBodyAutocompletion);
-    registerContribution(PromptHeaderAutocompletion);
-    registerContribution(PromptHeaderHoverProvider);
-    registerContribution(PromptHeaderDefinitionProvider);
-    registerContribution(ConfigMigration);
-}
-function registerContribution(contribution) {
-    ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(contribution, LifecyclePhase.Eventually);
-}
+let PromptLanguageFeaturesProvider = class PromptLanguageFeaturesProvider extends Disposable {
+    static { this.ID = 'chat.promptLanguageFeatures'; }
+    constructor(languageService, instantiationService) {
+        super();
+        this._register(languageService.linkProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptLinkProvider)));
+        this._register(languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptBodyAutocompletion)));
+        this._register(languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptHeaderAutocompletion)));
+        this._register(languageService.hoverProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptHoverProvider)));
+        this._register(languageService.definitionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptHeaderDefinitionProvider)));
+        this._register(languageService.documentSemanticTokensProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptDocumentSemanticTokensProvider)));
+        this._register(languageService.codeActionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, instantiationService.createInstance(PromptCodeActionProvider)));
+        this._register(instantiationService.createInstance(PromptValidatorContribution));
+    }
+};
+PromptLanguageFeaturesProvider = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IInstantiationService))
+], PromptLanguageFeaturesProvider));
 
-export { registerPromptFileContributions };
+export { PromptLanguageFeaturesProvider };

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

@@ -0,0 +1,97 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+export declare class NewPromptsParser {
+    constructor();
+    parse(uri: URI, content: string): ParsedPromptFile;
+}
+export declare class ParsedPromptFile {
+    readonly uri: URI;
+    readonly header?: PromptHeader | undefined;
+    readonly body?: PromptBody | undefined;
+    constructor(uri: URI, header?: PromptHeader | undefined, body?: PromptBody | undefined);
+}
+export interface ParseError {
+    readonly message: string;
+    readonly range: Range;
+    readonly code: string;
+}
+export declare class PromptHeader {
+    readonly range: Range;
+    private readonly linesWithEOL;
+    private _parsed;
+    constructor(range: Range, linesWithEOL: string[]);
+    private get _parsedHeader();
+    private asRange;
+    private asValue;
+    get attributes(): IHeaderAttribute[];
+    getAttribute(key: string): IHeaderAttribute | undefined;
+    get errors(): ParseError[];
+    private getStringAttribute;
+    get description(): string | undefined;
+    get mode(): string | undefined;
+    get model(): string | undefined;
+    get applyTo(): string | undefined;
+    get tools(): string[] | undefined;
+}
+export interface IHeaderAttribute {
+    readonly range: Range;
+    readonly key: string;
+    readonly value: IValue;
+}
+export interface IStringValue {
+    readonly type: "string";
+    readonly value: string;
+    readonly range: Range;
+}
+export interface INumberValue {
+    readonly type: "number";
+    readonly value: number;
+    readonly range: Range;
+}
+export interface INullValue {
+    readonly type: "null";
+    readonly value: null;
+    readonly range: Range;
+}
+export interface IBooleanValue {
+    readonly type: "boolean";
+    readonly value: boolean;
+    readonly range: Range;
+}
+export interface IArrayValue {
+    readonly type: "array";
+    readonly items: readonly IValue[];
+    readonly range: Range;
+}
+export interface IObjectValue {
+    readonly type: "object";
+    readonly properties: {
+        key: IStringValue;
+        value: IValue;
+    }[];
+    readonly range: Range;
+}
+export type IValue = IStringValue | INumberValue | IBooleanValue | IArrayValue | IObjectValue | INullValue;
+export declare class PromptBody {
+    readonly range: Range;
+    private readonly linesWithEOL;
+    readonly uri: URI;
+    private _parsed;
+    constructor(range: Range, linesWithEOL: string[], uri: URI);
+    get fileReferences(): readonly IBodyFileReference[];
+    get variableReferences(): readonly IBodyVariableReference[];
+    get offset(): number;
+    private getParsedBody;
+    getContent(): string;
+    resolveFilePath(path: string): URI | undefined;
+}
+export interface IBodyFileReference {
+    readonly content: string;
+    readonly range: Range;
+    readonly isMarkdownLink: boolean;
+}
+export interface IBodyVariableReference {
+    readonly name: string;
+    readonly range: Range;
+    readonly offset: number;
+}