@codingame/monaco-vscode-chat-service-override 22.1.9 → 23.0.0

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

@@ -2,9 +2,9 @@
 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 { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 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';
@@ -13,30 +13,53 @@ import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 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 { PromptsType, getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptHeaderAttributes, PROMPT_NAME_REGEXP, Target, GithubPromptHeaderAttributes } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser';
 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';
+import { LEGACY_MODE_FILE_EXTENSION, AGENTS_SOURCE_FOLDER } from '@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
 
 const MARKERS_OWNER_ID = 'prompts-diagnostics-provider';
 let PromptValidator = class PromptValidator {
-    constructor(languageModelsService, languageModelToolsService, chatModeService, fileService, labelService) {
+    constructor(languageModelsService, languageModelToolsService, chatModeService, fileService, labelService, promptsService) {
         this.languageModelsService = languageModelsService;
         this.languageModelToolsService = languageModelToolsService;
         this.chatModeService = chatModeService;
         this.fileService = fileService;
         this.labelService = labelService;
+        this.promptsService = promptsService;
     }
     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);
+        await this.validateBody(promptAST, promptType, report);
+        await this.validateFileName(promptAST, promptType, report);
     }
-    async validateBody(promptAST, report) {
+    async validateFileName(promptAST, promptType, report) {
+        if (promptType === PromptsType.agent && promptAST.uri.path.endsWith(LEGACY_MODE_FILE_EXTENSION)) {
+            const location = this.promptsService.getAgentFileURIFromModeFile(promptAST.uri);
+            if (location && (await this.fileService.canCreateFile(location))) {
+                report(toMarker(( localize(
+                    5871,
+                    "Chat modes have been renamed to agents. Please move this file to {0}",
+                    (location.toString())
+                )), ( new Range(1, 1, 1, 4)), MarkerSeverity.Warning));
+            }
+            else {
+                report(toMarker(( localize(
+                    5872,
+                    "Chat modes have been renamed to agents. Please move the file to {0}",
+                    AGENTS_SOURCE_FOLDER
+                )), ( new Range(1, 1, 1, 4)), MarkerSeverity.Warning));
+            }
+        }
+    }
+    async validateBody(promptAST, promptType, report) {
         const body = promptAST.body;
         if (!body) {
             return;
@@ -45,25 +68,29 @@ let PromptValidator = class PromptValidator {
         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));
+                report(toMarker(( localize(5873, "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;
+            if (promptAST.uri.scheme === resolved.scheme) {
+                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));
-            })());
+                    catch {
+                    }
+                    const loc = this.labelService.getUriLabel(resolved);
+                    report(toMarker(( localize(5874, "File '{0}' not found at '{1}'.", ref.content, loc)), ref.range, MarkerSeverity.Warning));
+                })());
+            }
         }
-        if (body.variableReferences.length) {
+        const isGitHubTarget = isGithubTarget(promptType, promptAST.header?.target);
+        if (body.variableReferences.length && !isGitHubTarget) {
             const headerTools = promptAST.header?.tools;
-            const headerToolsMap = headerTools ? this.languageModelToolsService.toToolAndToolSetEnablementMap(headerTools) : undefined;
+            const headerTarget = promptAST.header?.target;
+            const headerToolsMap = headerTools ? this.languageModelToolsService.toToolAndToolSetEnablementMap(headerTools, headerTarget) : undefined;
             const available = ( new Set(this.languageModelToolsService.getQualifiedToolNames()));
             const deprecatedNames = this.languageModelToolsService.getDeprecatedQualifiedToolNames();
             for (const variable of body.variableReferences) {
@@ -71,21 +98,21 @@ let PromptValidator = class PromptValidator {
                     if (( deprecatedNames.has(variable.name))) {
                         const currentName = deprecatedNames.get(variable.name);
                         report(toMarker(( localize(
-                            5658,
+                            5875,
                             "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));
+                        report(toMarker(( localize(5876, "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,
+                            5877,
                             "Tool or toolset '{0}' also needs to be enabled in the header.",
                             variable.name
                         )), variable.range, MarkerSeverity.Warning));
@@ -100,83 +127,150 @@ let PromptValidator = class PromptValidator {
         if (!header) {
             return;
         }
-        const validAttributeNames = getValidAttributeNames(promptType, true);
         const attributes = header.attributes;
+        const isGitHubTarget = isGithubTarget(promptType, header.target);
+        this.checkForInvalidArguments(attributes, promptType, isGitHubTarget, report);
+        this.validateName(attributes, isGitHubTarget, report);
+        this.validateDescription(attributes, report);
+        this.validateArgumentHint(attributes, report);
+        switch (promptType) {
+            case PromptsType.prompt: {
+                const agent = this.validateAgent(attributes, report);
+                this.validateTools(attributes, agent?.kind ?? ChatModeKind.Agent, header.target, report);
+                this.validateModel(attributes, agent?.kind ?? ChatModeKind.Agent, report);
+                break;
+            }
+            case PromptsType.instructions:
+                this.validateApplyTo(attributes, report);
+                this.validateExcludeAgent(attributes, report);
+                break;
+            case PromptsType.agent: {
+                this.validateTarget(attributes, report);
+                this.validateTools(attributes, ChatModeKind.Agent, header.target, report);
+                if (!isGitHubTarget) {
+                    this.validateModel(attributes, ChatModeKind.Agent, report);
+                    this.validateHandoffs(attributes, report);
+                }
+                break;
+            }
+        }
+    }
+    checkForInvalidArguments(attributes, promptType, isGitHubTarget, report) {
+        const validAttributeNames = getValidAttributeNames(promptType, true, isGitHubTarget);
+        const validGithubCopilotAttributeNames = ( new Lazy(() => ( new Set(getValidAttributeNames(promptType, false, true)))));
         for (const attribute of attributes) {
             if (!validAttributeNames.includes(attribute.key)) {
-                const supportedNames = getValidAttributeNames(promptType, false).join(', ');
+                const supportedNames = ( new Lazy(
+                    () => getValidAttributeNames(promptType, false, isGitHubTarget).sort().join(', ')
+                ));
                 switch (promptType) {
                     case PromptsType.prompt:
                         report(toMarker(( localize(
-                            5661,
+                            5878,
                             "Attribute '{0}' is not supported in prompt files. Supported: {1}.",
                             attribute.key,
-                            supportedNames
+                            supportedNames.value
                         )), 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));
+                    case PromptsType.agent:
+                        if (isGitHubTarget) {
+                            report(toMarker(( localize(
+                                5879,
+                                "Attribute '{0}' is not supported in custom GitHub Copilot agent files. Supported: {1}.",
+                                attribute.key,
+                                supportedNames.value
+                            )), attribute.range, MarkerSeverity.Warning));
+                        }
+                        else {
+                            if (( validGithubCopilotAttributeNames.value.has(attribute.key))) {
+                                report(toMarker(( localize(
+                                    5880,
+                                    "Attribute '{0}' is ignored when running locally in VS Code.",
+                                    attribute.key
+                                )), attribute.range, MarkerSeverity.Info));
+                            }
+                            else {
+                                report(toMarker(( localize(
+                                    5881,
+                                    "Attribute '{0}' is not supported in VS Code agent files. Supported: {1}.",
+                                    attribute.key,
+                                    supportedNames.value
+                                )), attribute.range, MarkerSeverity.Warning));
+                            }
+                        }
                         break;
                     case PromptsType.instructions:
                         report(toMarker(( localize(
-                            5663,
+                            5882,
                             "Attribute '{0}' is not supported in instructions files. Supported: {1}.",
                             attribute.key,
-                            supportedNames
+                            supportedNames.value
                         )), 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;
+    }
+    validateName(attributes, isGitHubTarget, report) {
+        const nameAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.name);
+        if (!nameAttribute) {
+            return;
+        }
+        if (nameAttribute.value.type !== 'string') {
+            report(toMarker(( localize(5883, "The 'name' attribute must be a string.")), nameAttribute.range, MarkerSeverity.Error));
+            return;
+        }
+        if (nameAttribute.value.value.trim().length === 0) {
+            report(toMarker(( localize(5884, "The 'name' attribute must not be empty.")), nameAttribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        if (!PROMPT_NAME_REGEXP.test(nameAttribute.value.value)) {
+            report(toMarker(( localize(
+                5885,
+                "The 'name' attribute can only consist of letters, digits, underscores, hyphens, and periods."
+            )), nameAttribute.value.range, MarkerSeverity.Error));
         }
     }
     validateDescription(attributes, report) {
-        const descriptionAttribute = attributes.find(attr => attr.key === 'description');
+        const descriptionAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.description);
         if (!descriptionAttribute) {
             return;
         }
         if (descriptionAttribute.value.type !== 'string') {
-            report(toMarker(( localize(5664, "The 'description' attribute must be a string.")), descriptionAttribute.range, MarkerSeverity.Error));
+            report(toMarker(( localize(5886, "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));
+            report(toMarker(( localize(5887, "The 'description' attribute should not be empty.")), descriptionAttribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateArgumentHint(attributes, report) {
+        const argumentHintAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.argumentHint);
+        if (!argumentHintAttribute) {
+            return;
+        }
+        if (argumentHintAttribute.value.type !== 'string') {
+            report(toMarker(( localize(5888, "The 'argument-hint' attribute must be a string.")), argumentHintAttribute.range, MarkerSeverity.Error));
+            return;
+        }
+        if (argumentHintAttribute.value.value.trim().length === 0) {
+            report(toMarker(( localize(5889, "The 'argument-hint' attribute should not be empty.")), argumentHintAttribute.value.range, MarkerSeverity.Error));
             return;
         }
     }
-    validateModel(attributes, modeKind, report) {
-        const attribute = attributes.find(attr => attr.key === 'model');
+    validateModel(attributes, agentKind, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.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));
+            report(toMarker(( localize(5890, "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));
+            report(toMarker(( localize(5891, "The 'model' attribute must be a non-empty string.")), attribute.value.range, MarkerSeverity.Error));
             return;
         }
         const languageModes = this.languageModelsService.getLanguageModelIds();
@@ -185,10 +279,10 @@ let PromptValidator = class PromptValidator {
         }
         const modelMetadata = this.findModelByName(languageModes, modelName);
         if (!modelMetadata) {
-            report(toMarker(( localize(5668, "Unknown model '{0}'.", modelName)), attribute.value.range, MarkerSeverity.Warning));
+            report(toMarker(( localize(5892, "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));
+        else if (agentKind === ChatModeKind.Agent && !ILanguageModelChatMetadata.suitableForAgentMode(modelMetadata)) {
+            report(toMarker(( localize(5893, "Model '{0}' is not suited for agent mode.", modelName)), attribute.value.range, MarkerSeverity.Warning));
         }
     }
     findModelByName(languageModes, modelName) {
@@ -200,118 +294,227 @@ let PromptValidator = class PromptValidator {
         }
         return undefined;
     }
-    validateMode(attributes, report) {
-        const attribute = attributes.find(attr => attr.key === 'mode');
+    validateAgent(attributes, report) {
+        const agentAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.agent);
+        const modeAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.mode);
+        if (modeAttribute) {
+            if (agentAttribute) {
+                report(toMarker(( localize(
+                    5894,
+                    "The 'mode' attribute has been deprecated. The 'agent' attribute is used instead."
+                )), modeAttribute.range, MarkerSeverity.Warning));
+            }
+            else {
+                report(toMarker(( localize(
+                    5895,
+                    "The 'mode' attribute has been deprecated. Please rename it to 'agent'."
+                )), modeAttribute.range, MarkerSeverity.Error));
+            }
+        }
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.agent) ?? modeAttribute;
         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));
+            report(toMarker(( localize(5896, "The '{0}' attribute must be a string.", attribute.key)), 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));
+        const agentValue = attribute.value.value;
+        if (agentValue.trim().length === 0) {
+            report(toMarker(( localize(5897, "The '{0}' attribute must be a non-empty string.", attribute.key)), 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;
+        return this.validateAgentValue(attribute.value, report);
+    }
+    validateAgentValue(value, report) {
+        const agents = this.chatModeService.getModes();
+        const availableAgents = [];
+        for (const agent of Iterable.concat(agents.builtin, agents.custom)) {
+            if (agent.name.get() === value.value) {
+                return agent;
             }
-            availableModes.push(mode.name);
+            availableAgents.push(agent.name.get());
         }
         const errorMessage = ( localize(
-            5672,
-            "Unknown mode '{0}'. Available modes: {1}.",
-            modeValue,
-            availableModes.join(', ')
+            5898,
+            "Unknown agent '{0}'. Available agents: {1}.",
+            value.value,
+            availableAgents.join(', ')
         ));
-        report(toMarker(errorMessage, attribute.value.range, MarkerSeverity.Warning));
+        report(toMarker(errorMessage, value.range, MarkerSeverity.Warning));
         return undefined;
     }
-    validateTools(attributes, modeKind, report) {
-        const attribute = attributes.find(attr => attr.key === 'tools');
+    validateTools(attributes, agentKind, target, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.tools);
         if (!attribute) {
             return;
         }
-        if (modeKind !== ChatModeKind.Agent) {
+        if (agentKind !== ChatModeKind.Agent) {
             report(toMarker(( localize(
-                5673,
-                "The 'tools' attribute is only supported in agent mode. Attribute will be ignored."
+                5899,
+                "The 'tools' attribute is only supported when using agents. Attribute will be ignored."
             )), attribute.range, MarkerSeverity.Warning));
         }
         switch (attribute.value.type) {
             case 'array':
-                this.validateToolsArray(attribute.value, report);
+                if (target === Target.GitHubCopilot) ;
+                else {
+                    this.validateVSCodeTools(attribute.value, target, report);
+                }
                 break;
             default:
-                report(toMarker(( localize(5674, "The 'tools' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+                report(toMarker(( localize(5900, "The 'tools' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
         }
     }
-    validateToolsArray(valueItem, report) {
+    validateVSCodeTools(valueItem, target, 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));
+                    report(toMarker(( localize(5901, "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));
+                else if (item.value) {
+                    const toolName = target === undefined ? this.languageModelToolsService.mapGithubToolName(item.value) : item.value;
+                    if (!( available.has(toolName))) {
+                        if (( deprecatedNames.has(toolName))) {
+                            const currentName = deprecatedNames.get(toolName);
+                            report(toMarker(( localize(
+                                5902,
+                                "Tool or toolset '{0}' has been renamed, use '{1}' instead.",
+                                toolName,
+                                currentName
+                            )), item.range, MarkerSeverity.Info));
+                        }
+                        else {
+                            report(toMarker(( localize(5903, "Unknown tool '{0}'.", toolName)), item.range, MarkerSeverity.Warning));
+                        }
                     }
                 }
             }
         }
     }
     validateApplyTo(attributes, report) {
-        const attribute = attributes.find(attr => attr.key === 'applyTo');
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.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));
+            report(toMarker(( localize(5904, "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));
+                report(toMarker(( localize(5905, "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));
+                    report(toMarker(( localize(5905, "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));
+            report(toMarker(( localize(5905, "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');
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.excludeAgent);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== 'array') {
+            report(toMarker(( localize(5906, "The 'excludeAgent' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateHandoffs(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.handOffs);
         if (!attribute) {
             return;
         }
         if (attribute.value.type !== 'array') {
-            report(toMarker(( localize(5680, "The 'excludeAgent' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+            report(toMarker(( localize(5907, "The 'handoffs' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        for (const item of attribute.value.items) {
+            if (item.type !== 'object') {
+                report(toMarker(( localize(
+                    5908,
+                    "Each handoff in the 'handoffs' attribute must be an object with 'label', 'agent', 'prompt' and optional 'send'."
+                )), item.range, MarkerSeverity.Error));
+                continue;
+            }
+            const required = ( new Set(['label', 'agent', 'prompt']));
+            for (const prop of item.properties) {
+                switch (prop.key.value) {
+                    case 'label':
+                        if (prop.value.type !== 'string' || prop.value.value.trim().length === 0) {
+                            report(toMarker(( localize(5909, "The 'label' property in a handoff must be a non-empty string.")), prop.value.range, MarkerSeverity.Error));
+                        }
+                        break;
+                    case 'agent':
+                        if (prop.value.type !== 'string' || prop.value.value.trim().length === 0) {
+                            report(toMarker(( localize(5910, "The 'agent' property in a handoff must be a non-empty string.")), prop.value.range, MarkerSeverity.Error));
+                        }
+                        else {
+                            this.validateAgentValue(prop.value, report);
+                        }
+                        break;
+                    case 'prompt':
+                        if (prop.value.type !== 'string') {
+                            report(toMarker(( localize(5911, "The 'prompt' property in a handoff must be a string.")), prop.value.range, MarkerSeverity.Error));
+                        }
+                        break;
+                    case 'send':
+                        if (prop.value.type !== 'boolean') {
+                            report(toMarker(( localize(5912, "The 'send' property in a handoff must be a boolean.")), prop.value.range, MarkerSeverity.Error));
+                        }
+                        break;
+                    default:
+                        report(toMarker(( localize(
+                            5913,
+                            "Unknown property '{0}' in handoff object. Supported properties are 'label', 'agent', 'prompt' and optional 'send'.",
+                            prop.key.value
+                        )), prop.value.range, MarkerSeverity.Warning));
+                }
+                required.delete(prop.key.value);
+            }
+            if (required.size > 0) {
+                report(toMarker(( localize(
+                    5914,
+                    "Missing required properties {0} in handoff object.",
+                    ( Array.from(required).map(s => `'${s}'`)).join(', ')
+                )), item.range, MarkerSeverity.Error));
+            }
+        }
+    }
+    validateTarget(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.target);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== 'string') {
+            report(toMarker(( localize(5915, "The 'target' attribute must be a string.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const targetValue = attribute.value.value.trim();
+        if (targetValue.length === 0) {
+            report(toMarker(( localize(5916, "The 'target' attribute must be a non-empty string.")), attribute.value.range, MarkerSeverity.Error));
             return;
         }
+        const validTargets = ['github-copilot', 'vscode'];
+        if (!validTargets.includes(targetValue)) {
+            report(toMarker(( localize(
+                5917,
+                "The 'target' attribute must be one of: {0}.",
+                validTargets.join(', ')
+            )), attribute.value.range, MarkerSeverity.Error));
+        }
     }
 };
 PromptValidator = ( __decorate([
@@ -319,32 +522,45 @@ PromptValidator = ( __decorate([
     ( __param(1, ILanguageModelToolsService)),
     ( __param(2, IChatModeService)),
     ( __param(3, IFileService)),
-    ( __param(4, ILabelService))
+    ( __param(4, ILabelService)),
+    ( __param(5, IPromptsService))
 ], PromptValidator));
-const validAttributeNames = {
-    [PromptsType.prompt]: ['description', 'model', 'tools', 'mode'],
-    [PromptsType.instructions]: ['description', 'applyTo', 'excludeAgent'],
-    [PromptsType.mode]: ['description', 'model', 'tools', 'advancedOptions']
+const allAttributeNames = {
+    [PromptsType.prompt]: [PromptHeaderAttributes.name, PromptHeaderAttributes.description, PromptHeaderAttributes.model, PromptHeaderAttributes.tools, PromptHeaderAttributes.mode, PromptHeaderAttributes.agent, PromptHeaderAttributes.argumentHint],
+    [PromptsType.instructions]: [PromptHeaderAttributes.name, PromptHeaderAttributes.description, PromptHeaderAttributes.applyTo, PromptHeaderAttributes.excludeAgent],
+    [PromptsType.agent]: [PromptHeaderAttributes.name, PromptHeaderAttributes.description, PromptHeaderAttributes.model, PromptHeaderAttributes.tools, PromptHeaderAttributes.advancedOptions, PromptHeaderAttributes.handOffs, PromptHeaderAttributes.argumentHint, PromptHeaderAttributes.target]
 };
-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))
+const githubCopilotAgentAttributeNames = [PromptHeaderAttributes.name, PromptHeaderAttributes.description, PromptHeaderAttributes.tools, PromptHeaderAttributes.target, GithubPromptHeaderAttributes.mcpServers];
+const recommendedAttributeNames = {
+    [PromptsType.prompt]: allAttributeNames[PromptsType.prompt].filter(name => !isNonRecommendedAttribute(name)),
+    [PromptsType.instructions]: allAttributeNames[PromptsType.instructions].filter(name => !isNonRecommendedAttribute(name)),
+    [PromptsType.agent]: allAttributeNames[PromptsType.agent].filter(name => !isNonRecommendedAttribute(name))
 };
-function getValidAttributeNames(promptType, includeExperimental) {
-    return includeExperimental ? validAttributeNames[promptType] : validAttributeNamesNoExperimental[promptType];
+function getValidAttributeNames(promptType, includeNonRecommended, isGitHubTarget) {
+    if (isGitHubTarget && promptType === PromptsType.agent) {
+        return githubCopilotAgentAttributeNames;
+    }
+    return includeNonRecommended ? allAttributeNames[promptType] : recommendedAttributeNames[promptType];
 }
-function isExperimentalAttribute(attributeName) {
-    return attributeName === 'advancedOptions' || attributeName === 'excludeAgent';
+function isNonRecommendedAttribute(attributeName) {
+    return attributeName === PromptHeaderAttributes.advancedOptions || attributeName === PromptHeaderAttributes.excludeAgent || attributeName === PromptHeaderAttributes.mode;
+}
+const knownGithubCopilotTools = {
+    'shell': ( localize(5918, 'Execute shell commands')),
+    'edit': ( localize(5919, 'Edit files')),
+    'search': ( localize(5920, 'Search in files')),
+    'custom-agent': ( localize(5921, 'Call custom agents'))
+};
+function isGithubTarget(promptType, target) {
+    return promptType === PromptsType.agent && target === Target.GitHubCopilot;
 }
 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) {
+    constructor(modelService, instantiationService, markerService, promptsService, languageModelsService, languageModelToolsService, chatModeService) {
         super();
         this.modelService = modelService;
-        this.configService = configService;
         this.markerService = markerService;
         this.promptsService = promptsService;
         this.languageModelsService = languageModelsService;
@@ -353,46 +569,31 @@ let PromptValidatorContribution = class PromptValidatorContribution extends Disp
         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());
+            trackers.clear();
         }));
-        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) => {
+        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.has(model.uri))) {
+                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);
-                }
+            const tracker = trackers.get(model.uri);
+            if (tracker) {
+                tracker.dispose();
+                trackers.delete(model.uri);
             }
         }));
         this.localDisposables.add(this.modelService.onModelLanguageChanged((event) => {
@@ -407,21 +608,20 @@ let PromptValidatorContribution = class PromptValidatorContribution extends Disp
                 trackers.set(model.uri, ( new ModelTracker(model, promptType, this.validator, this.promptsService, this.markerService)));
             }
         }));
+        const validateAll = () => trackers.forEach(tracker => tracker.validate());
         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))
+    ( __param(2, IMarkerService)),
+    ( __param(3, IPromptsService)),
+    ( __param(4, ILanguageModelsService)),
+    ( __param(5, ILanguageModelToolsService)),
+    ( __param(6, IChatModeService))
 ], PromptValidatorContribution));
 let ModelTracker = class ModelTracker extends Disposable {
     constructor(textModel, promptType, validator, promptsService, markerService) {
@@ -453,4 +653,4 @@ ModelTracker = ( __decorate([
     ( __param(4, IMarkerService))
 ], ModelTracker));
 
-export { PromptValidator, PromptValidatorContribution, getValidAttributeNames, isExperimentalAttribute };
+export { PromptValidator, PromptValidatorContribution, getValidAttributeNames, isGithubTarget, isNonRecommendedAttribute, knownGithubCopilotTools };