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

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

@@ -1,59 +1,39 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CharCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { CompletionItemInsertTextRule, CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
-import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
 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 { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
-import { ModeHeader } from '../parsers/promptHeader/modeHeader.js';
-import { PromptHeader } from '../parsers/promptHeader/promptHeader.js';
-import { ALL_PROMPTS_LANGUAGE_SELECTOR, getPromptsTypeForLanguageId, PromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { getPromptsTypeForLanguageId, PromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { getValidAttributeNames } from './promptValidator.js';
 
-let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Disposable {
-    constructor(promptsService, languageService, languageModelsService, languageModelToolsService, chatModeService) {
-        super();
+let PromptHeaderAutocompletion = class PromptHeaderAutocompletion {
+    constructor(promptsService, languageModelsService, languageModelToolsService, chatModeService) {
         this.promptsService = promptsService;
-        this.languageService = languageService;
         this.languageModelsService = languageModelsService;
         this.languageModelToolsService = languageModelToolsService;
         this.chatModeService = chatModeService;
         this._debugDisplayName = 'PromptHeaderAutocompletion';
         this.triggerCharacters = [':'];
-        this._register(this.languageService.completionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
     }
     async provideCompletionItems(model, position, context, token) {
         const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
         if (!promptType) {
             return undefined;
         }
-        const parser = this.promptsService.getSyntaxParserFor(model);
-        await parser.start(token).settled();
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
+        const parser = this.promptsService.getParsedPromptFile(model);
         const header = parser.header;
         if (!header) {
             return undefined;
         }
-        const completed = await header.settled;
-        if (!completed || token.isCancellationRequested) {
-            return undefined;
-        }
-        const fullHeaderRange = parser.header.range;
-        const headerRange = ( new Range(
-            fullHeaderRange.startLineNumber + 1,
-            0,
-            fullHeaderRange.endLineNumber - 1,
-            model.getLineMaxColumn(fullHeaderRange.endLineNumber - 1)
-        ));
-        if (!headerRange.containsPosition(position)) {
+        const headerRange = parser.header.range;
+        if (position.lineNumber < headerRange.startLineNumber || position.lineNumber >= headerRange.endLineNumber) {
             return undefined;
         }
         const lineText = model.getLineContent(position.lineNumber);
@@ -69,7 +49,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
     }
     async providePropertyCompletions(model, position, headerRange, colonPosition, promptType) {
         const suggestions = [];
-        const supportedProperties = this.getSupportedProperties(promptType);
+        const supportedProperties = ( new Set(getValidAttributeNames(promptType, false)));
         this.removeUsedProperties(supportedProperties, model, headerRange, position);
         const getInsertText = (property) => {
             if (colonPosition) {
@@ -104,16 +84,13 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
         const suggestions = [];
         const lineContent = model.getLineContent(position.lineNumber);
         const property = lineContent.substring(0, colonPosition.column - 1).trim();
-        if (!( this.getSupportedProperties(promptType).has(property))) {
+        if (!getValidAttributeNames(promptType, true).includes(property)) {
             return undefined;
         }
-        if (header instanceof PromptHeader || header instanceof ModeHeader) {
-            const tools = header.metadataUtility.tools;
-            if (tools) {
-                const result = this.provideToolCompletions(model, position, tools);
-                if (result) {
-                    return result;
-                }
+        if (promptType === PromptsType.prompt || promptType === PromptsType.mode) {
+            const result = this.provideToolCompletions(model, position, header);
+            if (result) {
+                return result;
             }
         }
         const bracketIndex = lineContent.indexOf('[');
@@ -138,16 +115,6 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
         }
         return { suggestions };
     }
-    getSupportedProperties(promptType) {
-        switch (promptType) {
-            case PromptsType.instructions:
-                return ( new Set(['applyTo', 'description']));
-            case PromptsType.prompt:
-                return ( new Set(['mode', 'tools', 'description', 'model']));
-            default:
-                return ( new Set(['tools', 'description', 'model']));
-        }
-    }
     removeUsedProperties(properties, model, headerRange, position) {
         for (let i = headerRange.startLineNumber; i <= headerRange.endLineNumber; i++) {
             if (i !== position.lineNumber) {
@@ -162,7 +129,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
     }
     getValueSuggestions(promptType, property) {
         if (promptType === PromptsType.instructions && property === 'applyTo') {
-            return ['**', '**/*.ts, **/*.js', '**/*.php', '**/*.py'];
+            return [`'**'`, `'**/*.ts, **/*.js'`, `'**/*.php'`, `'**/*.py'`];
         }
         if (promptType === PromptsType.prompt && property === 'mode') {
             const modes = this.chatModeService.getModes();
@@ -173,7 +140,7 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
             return suggestions;
         }
         if (property === 'tools' && (promptType === PromptsType.prompt || promptType === PromptsType.mode)) {
-            return ['[]', `['codebase', 'editFiles', 'fetch']`];
+            return ['[]', `['search', 'edit', 'fetch']`];
         }
         if (property === 'model' && (promptType === PromptsType.prompt || promptType === PromptsType.mode)) {
             return this.getModelNames(promptType === PromptsType.mode);
@@ -192,14 +159,14 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
         }
         return result;
     }
-    provideToolCompletions(model, position, node) {
-        const tools = node.value;
-        if (!tools || !node.range.containsPosition(position)) {
+    provideToolCompletions(model, position, header) {
+        const toolsAttr = header.getAttribute('tools');
+        if (!toolsAttr || toolsAttr.value.type !== 'array' || !toolsAttr.range.containsPosition(position)) {
             return undefined;
         }
         const getSuggestions = (toolRange) => {
             const suggestions = [];
-            const addSuggestion = (toolName, toolRange) => {
+            for (const toolName of this.languageModelToolsService.getQualifiedToolNames()) {
                 let insertText;
                 if (!toolRange.isEmpty()) {
                     const firstChar = model.getValueInRange(toolRange).charCodeAt(0);
@@ -215,21 +182,12 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
                     insertText: insertText,
                     range: toolRange,
                 });
-            };
-            for (const tool of this.languageModelToolsService.getTools()) {
-                if (tool.canBeReferencedInPrompt) {
-                    addSuggestion(tool.toolReferenceName ?? tool.displayName, toolRange);
-                }
-            }
-            for (const toolSet of this.languageModelToolsService.toolSets.get()) {
-                addSuggestion(toolSet.referenceName, toolRange);
             }
             return { suggestions };
         };
-        for (const tool of tools) {
-            const toolRange = node.getToolRange(tool);
-            if (toolRange?.containsPosition(position)) {
-                return getSuggestions(toolRange);
+        for (const toolNameNode of toolsAttr.value.items) {
+            if (toolNameNode.range.containsPosition(position)) {
+                return getSuggestions(toolNameNode.range);
             }
         }
         const prefix = model.getValueInRange(( new Range(position.lineNumber, 1, position.lineNumber, position.column)));
@@ -241,10 +199,9 @@ let PromptHeaderAutocompletion = class PromptHeaderAutocompletion extends Dispos
 };
 PromptHeaderAutocompletion = ( __decorate([
     ( __param(0, IPromptsService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ILanguageModelsService)),
-    ( __param(3, ILanguageModelToolsService)),
-    ( __param(4, IChatModeService))
+    ( __param(1, ILanguageModelsService)),
+    ( __param(2, ILanguageModelToolsService)),
+    ( __param(3, IChatModeService))
 ], PromptHeaderAutocompletion));
 
 export { PromptHeaderAutocompletion };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/{promptHeaderHovers.d.ts → promptHovers.d.ts}

@@ -1,16 +1,13 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
 import { Hover, HoverContext, HoverProvider } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
 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 { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
-export declare class PromptHeaderHoverProvider extends Disposable implements HoverProvider {
+export declare class PromptHoverProvider implements HoverProvider {
     private readonly promptsService;
-    private readonly languageService;
     private readonly languageModelToolsService;
     private readonly languageModelsService;
     private readonly chatModeService;
@@ -18,10 +15,13 @@ export declare class PromptHeaderHoverProvider extends Disposable implements Hov
      * Debug display name for this provider.
      */
     readonly _debugDisplayName: string;
-    constructor(promptsService: IPromptsService, languageService: ILanguageFeaturesService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, chatModeService: IChatModeService);
+    constructor(promptsService: IPromptsService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, chatModeService: IChatModeService);
     private createHover;
     provideHover(model: ITextModel, position: Position, token: CancellationToken, _context?: HoverContext): Promise<Hover | undefined>;
+    private provideBodyHover;
+    private provideHeaderHover;
     private getToolHover;
+    private getToolHoverByName;
     private getToolsetHover;
     private getModelHover;
     private getModeHover;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/{promptHeaderHovers.js → promptHovers.js}

@@ -1,29 +1,23 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 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 { ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
 import { isBuiltinChatMode } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModes';
 import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
-import { InstructionsHeader } from '../parsers/promptHeader/instructionsHeader.js';
-import { ModeHeader } from '../parsers/promptHeader/modeHeader.js';
-import { ALL_PROMPTS_LANGUAGE_SELECTOR, getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { getPromptsTypeForLanguageId, PromptsType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
 
-let PromptHeaderHoverProvider = class PromptHeaderHoverProvider extends Disposable {
-    constructor(promptsService, languageService, languageModelToolsService, languageModelsService, chatModeService) {
-        super();
+let PromptHoverProvider = class PromptHoverProvider {
+    constructor(promptsService, languageModelToolsService, languageModelsService, chatModeService) {
         this.promptsService = promptsService;
-        this.languageService = languageService;
         this.languageModelToolsService = languageModelToolsService;
         this.languageModelsService = languageModelsService;
         this.chatModeService = chatModeService;
-        this._debugDisplayName = 'PromptHeaderHoverProvider';
-        this._register(this.languageService.hoverProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+        this._debugDisplayName = 'PromptHoverProvider';
     }
     createHover(contents, range) {
         return {
@@ -36,96 +30,106 @@ let PromptHeaderHoverProvider = class PromptHeaderHoverProvider extends Disposab
         if (!promptType) {
             return undefined;
         }
-        const parser = this.promptsService.getSyntaxParserFor(model);
-        await parser.start(token).settled();
-        if (token.isCancellationRequested) {
-            return undefined;
+        const parser = this.promptsService.getParsedPromptFile(model);
+        if (parser.header?.range.containsPosition(position)) {
+            return this.provideHeaderHover(position, promptType, parser.header);
         }
-        const header = parser.header;
-        if (!header) {
-            return undefined;
+        if (parser.body?.range.containsPosition(position)) {
+            return this.provideBodyHover(position, parser.body);
         }
-        const completed = await header.settled;
-        if (!completed || token.isCancellationRequested) {
-            return undefined;
+        return undefined;
+    }
+    async provideBodyHover(position, body) {
+        for (const ref of body.variableReferences) {
+            if (ref.range.containsPosition(position)) {
+                const toolName = ref.name;
+                return this.getToolHoverByName(toolName, ref.range);
+            }
         }
-        if (header instanceof InstructionsHeader) {
-            const descriptionRange = header.metadataUtility.description?.range;
+        return undefined;
+    }
+    async provideHeaderHover(position, promptType, header) {
+        if (promptType === PromptsType.instructions) {
+            const descriptionRange = header.getAttribute('description')?.range;
             if (descriptionRange?.containsPosition(position)) {
                 return this.createHover(( localize(
-                    5573,
+                    5638,
                     'The description of the instruction file. It can be used to provide additional context or information about the instructions and is passed to the language model as part of the prompt.'
                 )), descriptionRange);
             }
-            const applyToRange = header.metadataUtility.applyTo?.range;
+            const applyToRange = header.getAttribute('applyTo')?.range;
             if (applyToRange?.containsPosition(position)) {
                 return this.createHover(( localize(
-                    5574,
-                    'One or more glob pattern (separated by comma) that describe for which files the instructions apply to. Based on these patterns, the file is automatically included in the prompt, when the context contains a file that matches one or more of these patterns. Use `**` when you want this file to always be added.\nExample: **/*.ts, **/*.js, client/**'
+                    5639,
+                    'One or more glob pattern (separated by comma) that describe for which files the instructions apply to. Based on these patterns, the file is automatically included in the prompt, when the context contains a file that matches one or more of these patterns. Use `**` when you want this file to always be added.\nExample: `**/*.ts`, `**/*.js`, `client/**`'
                 )), applyToRange);
             }
         }
-        else if (header instanceof ModeHeader) {
-            const descriptionRange = header.metadataUtility.description?.range;
+        else if (promptType === PromptsType.mode) {
+            const descriptionRange = header.getAttribute('description')?.range;
             if (descriptionRange?.containsPosition(position)) {
                 return this.createHover(( localize(
-                    5575,
+                    5640,
                     'The description of the mode file. It can be used to provide additional context or information about the mode to the mode author.'
                 )), descriptionRange);
             }
-            const model = header.metadataUtility.model;
+            const model = header.getAttribute('model');
             if (model?.range.containsPosition(position)) {
-                return this.getModelHover(model, model.range, ( localize(5576, 'The model to use in this mode.')));
+                return this.getModelHover(model, model.range, ( localize(5641, 'The model to use in this mode.')));
             }
-            const tools = header.metadataUtility.tools;
+            const tools = header.getAttribute('tools');
             if (tools?.range.containsPosition(position)) {
-                return this.getToolHover(tools, position, ( localize(5577, 'The tools to use in this mode.')));
+                return this.getToolHover(tools, position, ( localize(5642, 'The tools to use in this mode.')));
             }
         }
         else {
-            const descriptionRange = header.metadataUtility.description?.range;
+            const descriptionRange = header.getAttribute('description')?.range;
             if (descriptionRange?.containsPosition(position)) {
                 return this.createHover(( localize(
-                    5578,
+                    5643,
                     'The description of the prompt file. It can be used to provide additional context or information about the prompt to the prompt author.'
                 )), descriptionRange);
             }
-            const model = header.metadataUtility.model;
+            const model = header.getAttribute('model');
             if (model?.range.containsPosition(position)) {
-                return this.getModelHover(model, model.range, ( localize(5579, 'The model to use in this prompt.')));
+                return this.getModelHover(model, model.range, ( localize(5644, 'The model to use in this prompt.')));
             }
-            const tools = header.metadataUtility.tools;
+            const tools = header.getAttribute('tools');
             if (tools?.range.containsPosition(position)) {
-                return this.getToolHover(tools, position, ( localize(5580, 'The tools to use in this prompt.')));
+                return this.getToolHover(tools, position, ( localize(5645, 'The tools to use in this prompt.')));
             }
-            const mode = header.metadataUtility.mode;
+            const mode = header.getAttribute('mode');
             if (mode?.range.containsPosition(position)) {
-                return this.getModeHover(mode, position, ( localize(5581, 'The mode to use in this prompt.')));
+                return this.getModeHover(mode, position, ( localize(5646, 'The mode to use in this prompt.')));
             }
         }
         return undefined;
     }
     getToolHover(node, position, baseMessage) {
-        if (node.value) {
-            for (const toolName of node.value) {
-                const toolRange = node.getToolRange(toolName);
-                if (toolRange?.containsPosition(position)) {
-                    const tool = this.languageModelToolsService.getToolByName(toolName);
-                    if (tool) {
-                        return this.createHover(tool.modelDescription, toolRange);
-                    }
-                    const toolSet = this.languageModelToolsService.getToolSetByName(toolName);
-                    if (toolSet) {
-                        return this.getToolsetHover(toolSet, toolRange);
-                    }
+        if (node.value.type === 'array') {
+            for (const toolName of node.value.items) {
+                if (toolName.type === 'string' && toolName.range.containsPosition(position)) {
+                    return this.getToolHoverByName(toolName.value, toolName.range);
                 }
             }
         }
         return this.createHover(baseMessage, node.range);
     }
+    getToolHoverByName(toolName, range) {
+        const tool = this.languageModelToolsService.getToolByQualifiedName(toolName);
+        if (tool !== undefined) {
+            if (tool instanceof ToolSet) {
+                return this.getToolsetHover(tool, range);
+            }
+            else {
+                return this.createHover(tool.modelDescription, range);
+            }
+        }
+        return undefined;
+    }
     getToolsetHover(toolSet, range) {
         const lines = [];
-        lines.push(( localize(5582, 'ToolSet: {0}\n\n', toolSet.referenceName)));
+        lines.push(( localize(5647, 'ToolSet: {0}\n\n', toolSet.referenceName)));
         if (toolSet.description) {
             lines.push(toolSet.description);
         }
@@ -135,16 +139,15 @@ let PromptHeaderHoverProvider = class PromptHeaderHoverProvider extends Disposab
         return this.createHover(lines.join('\n'), range);
     }
     getModelHover(node, range, baseMessage) {
-        const modelName = node.value;
-        if (modelName) {
+        if (node.value.type === 'string') {
             for (const id of this.languageModelsService.getLanguageModelIds()) {
                 const meta = this.languageModelsService.lookupLanguageModel(id);
-                if (meta && ILanguageModelChatMetadata.matchesQualifiedName(modelName, meta)) {
+                if (meta && ILanguageModelChatMetadata.matchesQualifiedName(node.value.value, meta)) {
                     const lines = [];
                     lines.push(baseMessage + '\n');
-                    lines.push(( localize(5583, '- Name: {0}', meta.name)));
-                    lines.push(( localize(5584, '- Family: {0}', meta.family)));
-                    lines.push(( localize(5585, '- Vendor: {0}', meta.vendor)));
+                    lines.push(( localize(5648, '- Name: {0}', meta.name)));
+                    lines.push(( localize(5649, '- Family: {0}', meta.family)));
+                    lines.push(( localize(5650, '- Vendor: {0}', meta.vendor)));
                     if (meta.tooltip) {
                         lines.push('', '', meta.tooltip);
                     }
@@ -157,39 +160,38 @@ let PromptHeaderHoverProvider = class PromptHeaderHoverProvider extends Disposab
     getModeHover(mode, position, baseMessage) {
         const lines = [];
         const value = mode.value;
-        if (value && mode.valueRange?.containsPosition(position)) {
-            const mode = this.chatModeService.findModeByName(value);
+        if (value.type === 'string' && value.range.containsPosition(position)) {
+            const mode = this.chatModeService.findModeByName(value.value);
             if (mode) {
-                const description = mode.description.get() || (isBuiltinChatMode(mode) ? ( localize(5586, 'Built-in chat mode')) : ( localize(5587, 'Custom chat mode')));
+                const description = mode.description.get() || (isBuiltinChatMode(mode) ? ( localize(5651, 'Built-in chat mode')) : ( localize(5652, 'Custom chat mode')));
                 lines.push(`\`${mode.name}\`: ${description}`);
             }
         }
         else {
             const modes = this.chatModeService.getModes();
-            lines.push(( localize(5588, 'The chat mode to use when running this prompt.')));
+            lines.push(( localize(5653, 'The chat mode to use when running this prompt.')));
             lines.push('');
-            lines.push(( localize(5589, '**Built-in modes:**')));
+            lines.push(( localize(5654, '**Built-in modes:**')));
             for (const mode of modes.builtin) {
                 lines.push(`- \`${mode.name}\`: ${mode.description.get() || mode.label}`);
             }
             if (modes.custom.length > 0) {
                 lines.push('');
-                lines.push(( localize(5590, '**Custom modes:**')));
+                lines.push(( localize(5655, '**Custom modes:**')));
                 for (const mode of modes.custom) {
                     const description = mode.description.get();
-                    lines.push(`- \`${mode.name}\`: ${description || ( localize(5587, 'Custom chat mode'))}`);
+                    lines.push(`- \`${mode.name}\`: ${description || ( localize(5652, 'Custom chat mode'))}`);
                 }
             }
         }
         return this.createHover(lines.join('\n'), mode.range);
     }
 };
-PromptHeaderHoverProvider = ( __decorate([
+PromptHoverProvider = ( __decorate([
     ( __param(0, IPromptsService)),
-    ( __param(1, ILanguageFeaturesService)),
-    ( __param(2, ILanguageModelToolsService)),
-    ( __param(3, ILanguageModelsService)),
-    ( __param(4, IChatModeService))
-], PromptHeaderHoverProvider));
+    ( __param(1, ILanguageModelToolsService)),
+    ( __param(2, ILanguageModelsService)),
+    ( __param(3, IChatModeService))
+], PromptHoverProvider));
 
-export { PromptHeaderHoverProvider };
+export { PromptHoverProvider };

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

@@ -1,35 +1,26 @@
 
 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/promptsService.service';
-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 { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 
 let PromptLinkProvider = class PromptLinkProvider {
     constructor(promptsService) {
         this.promptsService = promptsService;
     }
     async provideLinks(model, token) {
-        assert(!token.isCancellationRequested, ( new CancellationError()));
-        const parser = this.promptsService.getSyntaxParserFor(model);
-        assert(parser.isDisposed === false, 'Prompt parser must not be disposed.');
-        const completed = await parser.start(token).settled();
-        if (!completed || token.isCancellationRequested) {
-            return undefined;
+        const parser = this.promptsService.getParsedPromptFile(model);
+        if (!parser.body) {
+            return;
         }
-        const { references } = parser;
-        const links = ( references
-            .map((reference) => {
-            const { uri, linkRange } = reference;
-            assertDefined(linkRange, 'Link range must be defined.');
-            return {
-                range: linkRange,
-                url: uri,
-            };
-        }));
-        return {
-            links,
-        };
+        const links = [];
+        for (const ref of parser.body.fileReferences) {
+            if (!ref.isMarkdownLink) {
+                const url = parser.body.resolveFilePath(ref.content);
+                if (url) {
+                    links.push({ range: ref.range, url });
+                }
+            }
+        }
+        return { links };
     }
 };
 PromptLinkProvider = ( __decorate([

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

@@ -0,0 +1,48 @@
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+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 { IMarkerData } 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 { 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 } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { ParsedPromptFile } from "../service/newPromptsParser.js";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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";
+export declare class PromptValidator {
+    private readonly languageModelsService;
+    private readonly languageModelToolsService;
+    private readonly chatModeService;
+    private readonly fileService;
+    private readonly labelService;
+    constructor(languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService, chatModeService: IChatModeService, fileService: IFileService, labelService: ILabelService);
+    validate(promptAST: ParsedPromptFile, promptType: PromptsType, report: (markers: IMarkerData) => void): Promise<void>;
+    private validateBody;
+    private validateHeader;
+    private validateDescription;
+    private validateModel;
+    private findModelByName;
+    private validateMode;
+    private validateTools;
+    private validateToolsArray;
+    private validateApplyTo;
+    private validateExcludeAgent;
+}
+export declare function getValidAttributeNames(promptType: PromptsType, includeExperimental: boolean): string[];
+export declare function isExperimentalAttribute(attributeName: string): boolean;
+export declare class PromptValidatorContribution extends Disposable {
+    private modelService;
+    private configService;
+    private readonly markerService;
+    private readonly promptsService;
+    private readonly languageModelsService;
+    private readonly languageModelToolsService;
+    private readonly chatModeService;
+    private readonly validator;
+    private readonly localDisposables;
+    constructor(modelService: IModelService, instantiationService: IInstantiationService, configService: IConfigurationService, markerService: IMarkerService, promptsService: IPromptsService, languageModelsService: ILanguageModelsService, languageModelToolsService: ILanguageModelToolsService, chatModeService: IChatModeService);
+    updateRegistration(): void;
+}