@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

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

@@ -0,0 +1,1422 @@
+
+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 { 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 { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+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 { SpecedToolAliases } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { PromptsType, Target, getPromptsTypeForLanguageId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { PromptHeaderAttributes, parseCommaSeparatedList } from '@codingame/monaco-vscode-api/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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.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, CLAUDE_AGENTS_SOURCE_FOLDER, isInClaudeRulesFolder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { HOOKS_BY_TARGET } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { GithubPromptHeaderAttributes } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/promptFileAttributes';
+
+const MARKERS_OWNER_ID = "prompts-diagnostics-provider";
+let PromptValidator = class PromptValidator {
+    constructor(
+        languageModelsService,
+        languageModelToolsService,
+        chatModeService,
+        fileService,
+        labelService,
+        promptsService,
+        configurationService
+    ) {
+        this.languageModelsService = languageModelsService;
+        this.languageModelToolsService = languageModelToolsService;
+        this.chatModeService = chatModeService;
+        this.fileService = fileService;
+        this.labelService = labelService;
+        this.promptsService = promptsService;
+        this.configurationService = configurationService;
+    }
+    async validate(promptAST, promptType, report) {
+        promptAST.header?.errors.forEach(
+            error => report(toMarker(error.message, error.range, MarkerSeverity.Error))
+        );
+        const target = getTarget(promptType, promptAST.header ?? promptAST.uri);
+        await this.validateHeader(promptAST, promptType, target, report);
+        await this.validateBody(promptAST, target, report);
+        await this.validateFileName(promptAST, promptType, report);
+        await this.validateSkillFolderName(promptAST, promptType, 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(
+                    7187,
+                    "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(
+                    7188,
+                    "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 validateSkillFolderName(promptAST, promptType, report) {
+        if (promptType !== PromptsType.skill) {
+            return;
+        }
+        const nameAttribute = promptAST.header?.attributes.find(attr => attr.key === PromptHeaderAttributes.name);
+        if (!nameAttribute || nameAttribute.value.type !== "scalar") {
+            return;
+        }
+        const skillName = nameAttribute.value.value.trim();
+        if (!skillName) {
+            return;
+        }
+        const pathParts = promptAST.uri.path.split("/");
+        const skillIndex = pathParts.findIndex(part => part === "SKILL.md");
+        if (skillIndex > 0) {
+            const folderName = pathParts[skillIndex - 1];
+            if (folderName && skillName !== folderName) {
+                report(toMarker(( localize(
+                    7189,
+                    "The skill name '{0}' should match the folder name '{1}'.",
+                    skillName,
+                    folderName
+                )), nameAttribute.value.range, MarkerSeverity.Warning));
+            }
+        }
+    }
+    async validateBody(promptAST, target, 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(7190, "Invalid file reference '{0}'.", ref.content)), ref.range, MarkerSeverity.Warning));
+                continue;
+            }
+            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(7191, "File '{0}' not found at '{1}'.", ref.content, loc)), ref.range, MarkerSeverity.Warning));
+                })());
+            }
+        }
+        if (body.variableReferences.length && isVSCodeOrDefaultTarget(target)) {
+            const headerTools = promptAST.header?.tools;
+            const headerToolsMap = headerTools ? this.languageModelToolsService.toToolAndToolSetEnablementMap(headerTools, undefined) : undefined;
+            const available = ( new Set(this.languageModelToolsService.getFullReferenceNames()));
+            const deprecatedNames = this.languageModelToolsService.getDeprecatedFullReferenceNames();
+            for (const variable of body.variableReferences) {
+                if (!( available.has(variable.name))) {
+                    if (( deprecatedNames.has(variable.name))) {
+                        const currentNames = deprecatedNames.get(variable.name);
+                        if (currentNames && currentNames.size > 0) {
+                            if (currentNames.size === 1) {
+                                const newName = Array.from(currentNames)[0];
+                                report(toMarker(( localize(
+                                    7192,
+                                    "Tool or toolset '{0}' has been renamed, use '{1}' instead.",
+                                    variable.name,
+                                    newName
+                                )), variable.range, MarkerSeverity.Info));
+                            } else {
+                                const newNames = Array.from(currentNames).sort((a, b) => a.localeCompare(b)).join(", ");
+                                report(toMarker(( localize(
+                                    7193,
+                                    "Tool or toolset '{0}' has been renamed, use the following tools instead: {1}",
+                                    variable.name,
+                                    newNames
+                                )), variable.range, MarkerSeverity.Info));
+                            }
+                        }
+                    } else {
+                        report(toMarker(( localize(7194, "Unknown tool or toolset '{0}'.", variable.name)), variable.range, MarkerSeverity.Warning));
+                    }
+                } else if (headerToolsMap) {
+                    const tool = this.languageModelToolsService.getToolByFullReferenceName(variable.name);
+                    if (tool && headerToolsMap.get(tool) === false) {
+                        report(toMarker(( localize(
+                            7195,
+                            "Tool or toolset '{0}' also needs to be enabled in the header.",
+                            variable.name
+                        )), variable.range, MarkerSeverity.Warning));
+                    }
+                }
+            }
+        }
+        await Promise.all(fileReferenceChecks);
+    }
+    async validateHeader(promptAST, promptType, target, report) {
+        const header = promptAST.header;
+        if (!header) {
+            return;
+        }
+        const attributes = header.attributes;
+        this.checkForInvalidArguments(attributes, promptType, target, report);
+        this.validateName(attributes, 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, target, report);
+                this.validateModel(attributes, agent?.kind ?? ChatModeKind.Agent, report);
+                break;
+            }
+        case PromptsType.instructions:
+            if (target === Target.Claude) {
+                this.validatePaths(attributes, report);
+            } else {
+                this.validateApplyTo(attributes, report);
+            }
+            this.validateExcludeAgent(attributes, report);
+            break;
+        case PromptsType.agent:
+            {
+                this.validateTarget(attributes, report);
+                this.validateInfer(attributes, report);
+                this.validateUserInvocable(attributes, report);
+                this.validateUserInvokable(attributes, report);
+                this.validateDisableModelInvocation(attributes, report);
+                this.validateTools(attributes, ChatModeKind.Agent, target, report);
+                if (this.configurationService.getValue(PromptsConfig.USE_CUSTOM_AGENT_HOOKS)) {
+                    this.validateHooks(attributes, target, report);
+                }
+                if (isVSCodeOrDefaultTarget(target)) {
+                    this.validateModel(attributes, ChatModeKind.Agent, report);
+                    this.validateHandoffs(attributes, report);
+                    await this.validateAgentsAttribute(attributes, header, report);
+                    this.validateGithubPermissions(attributes, report);
+                } else if (target === Target.Claude) {
+                    this.validateClaudeAttributes(attributes, report);
+                } else if (target === Target.GitHubCopilot) {
+                    this.validateGithubPermissions(attributes, report);
+                }
+                break;
+            }
+        case PromptsType.skill:
+            this.validateUserInvocable(attributes, report);
+            this.validateUserInvokable(attributes, report);
+            this.validateDisableModelInvocation(attributes, report);
+            break;
+        }
+    }
+    checkForInvalidArguments(attributes, promptType, target, report) {
+        let validAttributeNames = getValidAttributeNames(promptType, true, target);
+        if (!this.configurationService.getValue(PromptsConfig.USE_CUSTOM_AGENT_HOOKS)) {
+            validAttributeNames = validAttributeNames.filter(name => name !== PromptHeaderAttributes.hooks);
+        }
+        const useCustomAgentHooks = this.configurationService.getValue(PromptsConfig.USE_CUSTOM_AGENT_HOOKS);
+        const validGithubCopilotAttributeNames = ( new Lazy(() => ( new Set(getValidAttributeNames(promptType, false, Target.GitHubCopilot)))));
+        for (const attribute of attributes) {
+            if (!validAttributeNames.includes(attribute.key)) {
+                const supportedNames = ( new Lazy(() => {
+                    let names = getValidAttributeNames(promptType, false, target);
+                    if (!useCustomAgentHooks) {
+                        names = names.filter(name => name !== PromptHeaderAttributes.hooks);
+                    }
+                    return names.sort().join(", ");
+                }));
+                switch (promptType) {
+                case PromptsType.prompt:
+                    report(toMarker(( localize(
+                        7196,
+                        "Attribute '{0}' is not supported in prompt files. Supported: {1}.",
+                        attribute.key,
+                        supportedNames.value
+                    )), attribute.range, MarkerSeverity.Warning));
+                    break;
+                case PromptsType.agent:
+                    if (target === Target.GitHubCopilot) {
+                        report(toMarker(( localize(
+                            7197,
+                            "Attribute '{0}' is not supported in custom GitHub Copilot agent files. Supported: {1}.",
+                            attribute.key,
+                            supportedNames.value
+                        )), attribute.range, MarkerSeverity.Warning));
+                    } else if (target === Target.Claude)
+                        ; else {
+                        if (( validGithubCopilotAttributeNames.value.has(attribute.key))) {
+                            report(toMarker(( localize(
+                                7198,
+                                "Attribute '{0}' is ignored when running locally in VS Code.",
+                                attribute.key
+                            )), attribute.range, MarkerSeverity.Info));
+                        } else {
+                            report(toMarker(( localize(
+                                7199,
+                                "Attribute '{0}' is not supported in VS Code agent files. Supported: {1}.",
+                                attribute.key,
+                                supportedNames.value
+                            )), attribute.range, MarkerSeverity.Warning));
+                        }
+                    }
+                    break;
+                case PromptsType.instructions:
+                    if (target === Target.Claude) {
+                        report(toMarker(( localize(
+                            7200,
+                            "Attribute '{0}' is not supported in rules files. Supported: {1}.",
+                            attribute.key,
+                            supportedNames.value
+                        )), attribute.range, MarkerSeverity.Warning));
+                    } else {
+                        report(toMarker(( localize(
+                            7201,
+                            "Attribute '{0}' is not supported in instructions files. Supported: {1}.",
+                            attribute.key,
+                            supportedNames.value
+                        )), attribute.range, MarkerSeverity.Warning));
+                    }
+                    break;
+                case PromptsType.skill:
+                    report(toMarker(( localize(
+                        7202,
+                        "Attribute '{0}' is not supported in skill files. Supported: {1}.",
+                        attribute.key,
+                        supportedNames.value
+                    )), attribute.range, MarkerSeverity.Warning));
+                    break;
+                }
+            }
+        }
+    }
+    validateName(attributes, report) {
+        const nameAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.name);
+        if (!nameAttribute) {
+            return;
+        }
+        if (nameAttribute.value.type !== "scalar") {
+            report(toMarker(( localize(7203, "The 'name' attribute must be a string.")), nameAttribute.range, MarkerSeverity.Error));
+            return;
+        }
+        if (nameAttribute.value.value.trim().length === 0) {
+            report(toMarker(( localize(7204, "The 'name' attribute must not be empty.")), nameAttribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateDescription(attributes, report) {
+        const descriptionAttribute = attributes.find(attr => attr.key === PromptHeaderAttributes.description);
+        if (!descriptionAttribute) {
+            return;
+        }
+        if (descriptionAttribute.value.type !== "scalar") {
+            report(toMarker(( localize(7205, "The 'description' attribute must be a string.")), descriptionAttribute.range, MarkerSeverity.Error));
+            return;
+        }
+        if (descriptionAttribute.value.value.trim().length === 0) {
+            report(toMarker(( localize(7206, "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 !== "scalar") {
+            report(toMarker(( localize(7207, "The 'argument-hint' attribute must be a string.")), argumentHintAttribute.range, MarkerSeverity.Error));
+            return;
+        }
+        if (argumentHintAttribute.value.value.trim().length === 0) {
+            report(toMarker(( localize(7208, "The 'argument-hint' attribute should not be empty.")), argumentHintAttribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateModel(attributes, agentKind, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.model);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "scalar" && attribute.value.type !== "sequence") {
+            report(toMarker(( localize(7209, "The 'model' attribute must be a string or an array of strings.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const modelNames = [];
+        if (attribute.value.type === "scalar") {
+            const modelName = attribute.value.value.trim();
+            if (modelName.length === 0) {
+                report(toMarker(( localize(7210, "The 'model' attribute must be a non-empty string.")), attribute.value.range, MarkerSeverity.Error));
+                return;
+            }
+            modelNames.push([modelName, attribute.value.range]);
+        } else if (attribute.value.type === "sequence") {
+            if (attribute.value.items.length === 0) {
+                report(toMarker(( localize(7211, "The 'model' array must not be empty.")), attribute.value.range, MarkerSeverity.Error));
+                return;
+            }
+            for (const item of attribute.value.items) {
+                if (item.type !== "scalar") {
+                    report(toMarker(( localize(7212, "The 'model' array must contain only strings.")), item.range, MarkerSeverity.Error));
+                    return;
+                }
+                const modelName = item.value.trim();
+                if (modelName.length === 0) {
+                    report(toMarker(( localize(7213, "Model names in the array must be non-empty strings.")), item.range, MarkerSeverity.Error));
+                    return;
+                }
+                modelNames.push([modelName, item.range]);
+            }
+        }
+        const languageModels = this.languageModelsService.getLanguageModelIds();
+        if (languageModels.length === 0) {
+            return;
+        }
+        for (const [modelName, range] of modelNames) {
+            const modelMetadata = this.findModelByName(modelName);
+            if (!modelMetadata) {
+                report(toMarker(( localize(7214, "Unknown model '{0}'.", modelName)), range, MarkerSeverity.Warning));
+            } else if (agentKind === ChatModeKind.Agent && !ILanguageModelChatMetadata.suitableForAgentMode(modelMetadata)) {
+                report(toMarker(( localize(7215, "Model '{0}' is not suited for agent mode.", modelName)), range, MarkerSeverity.Warning));
+            }
+        }
+    }
+    validateClaudeAttributes(attributes, report) {
+        for (const claudeAttributeName in claudeAgentAttributes) {
+            const claudeAttribute = claudeAgentAttributes[claudeAttributeName];
+            const enumValues = claudeAttribute.enums;
+            if (enumValues) {
+                const attribute = attributes.find(attr => attr.key === claudeAttributeName);
+                if (!attribute) {
+                    continue;
+                }
+                if (attribute.value.type !== "scalar") {
+                    report(toMarker(( localize(7216, "The '{0}' attribute must be a string.", claudeAttributeName)), attribute.value.range, MarkerSeverity.Error));
+                    continue;
+                } else {
+                    const modelName = attribute.value.value.trim();
+                    if (enumValues.every(model => model.name !== modelName)) {
+                        const validValues = ( enumValues.map(model => model.name)).join(", ");
+                        report(toMarker(( localize(7217, "Unknown value '{0}', valid: {1}.", modelName, validValues)), attribute.value.range, MarkerSeverity.Warning));
+                    }
+                }
+            }
+        }
+    }
+    findModelByName(modelName) {
+        const metadataAndId = this.languageModelsService.lookupLanguageModelByQualifiedName(modelName);
+        if (metadataAndId && metadataAndId.metadata.isUserSelectable !== false) {
+            return metadataAndId.metadata;
+        }
+        return undefined;
+    }
+    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(
+                    7218,
+                    "The 'mode' attribute has been deprecated. The 'agent' attribute is used instead."
+                )), modeAttribute.range, MarkerSeverity.Warning));
+            } else {
+                report(toMarker(( localize(
+                    7219,
+                    "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 !== "scalar") {
+            report(toMarker(( localize(7220, "The '{0}' attribute must be a string.", attribute.key)), attribute.value.range, MarkerSeverity.Error));
+            return undefined;
+        }
+        const agentValue = attribute.value.value;
+        if (agentValue.trim().length === 0) {
+            report(toMarker(( localize(7221, "The '{0}' attribute must be a non-empty string.", attribute.key)), attribute.value.range, MarkerSeverity.Error));
+            return undefined;
+        }
+        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;
+            }
+            availableAgents.push(agent.name.get());
+        }
+        const errorMessage = ( localize(
+            7222,
+            "Unknown agent '{0}'. Available agents: {1}.",
+            value.value,
+            availableAgents.join(", ")
+        ));
+        report(toMarker(errorMessage, value.range, MarkerSeverity.Warning));
+        return undefined;
+    }
+    validateTools(attributes, agentKind, target, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.tools);
+        if (!attribute) {
+            return;
+        }
+        if (agentKind !== ChatModeKind.Agent) {
+            report(toMarker(( localize(
+                7223,
+                "The 'tools' attribute is only supported when using agents. Attribute will be ignored."
+            )), attribute.range, MarkerSeverity.Warning));
+        }
+        let value = attribute.value;
+        if (value.type === "scalar") {
+            value = parseCommaSeparatedList(value);
+        }
+        if (value.type !== "sequence") {
+            report(toMarker(( localize(
+                7224,
+                "The 'tools' attribute must be an array or a comma separated string."
+            )), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        if (target === Target.GitHubCopilot || target === Target.Claude)
+            ; else {
+            this.validateVSCodeTools(value, report);
+        }
+    }
+    validateVSCodeTools(valueItem, report) {
+        if (valueItem.items.length > 0) {
+            const available = ( new Set(this.languageModelToolsService.getFullReferenceNames()));
+            const deprecatedNames = this.languageModelToolsService.getDeprecatedFullReferenceNames();
+            for (const item of valueItem.items) {
+                if (item.type !== "scalar") {
+                    report(toMarker(( localize(7225, "Each tool name in the 'tools' attribute must be a string.")), item.range, MarkerSeverity.Error));
+                } else if (item.value) {
+                    if (!( available.has(item.value))) {
+                        const currentNames = deprecatedNames.get(item.value);
+                        if (currentNames) {
+                            if (currentNames?.size === 1) {
+                                const newName = Array.from(currentNames)[0];
+                                report(toMarker(( localize(
+                                    7226,
+                                    "Tool or toolset '{0}' has been renamed, use '{1}' instead.",
+                                    item.value,
+                                    newName
+                                )), item.range, MarkerSeverity.Info));
+                            } else {
+                                const newNames = Array.from(currentNames).sort((a, b) => a.localeCompare(b)).join(", ");
+                                report(toMarker(( localize(
+                                    7227,
+                                    "Tool or toolset '{0}' has been renamed, use the following tools instead: {1}",
+                                    item.value,
+                                    newNames
+                                )), item.range, MarkerSeverity.Info));
+                            }
+                        } else {
+                            report(toMarker(( localize(7228, "Unknown tool '{0}'.", item.value)), item.range, MarkerSeverity.Warning));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    validateApplyTo(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.applyTo);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "scalar") {
+            report(toMarker(( localize(7229, "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(7230, "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(7230, "The 'applyTo' attribute must be a valid glob pattern.")), attribute.value.range, MarkerSeverity.Error));
+                    return;
+                }
+            }
+        } catch (_error) {
+            report(toMarker(( localize(7230, "The 'applyTo' attribute must be a valid glob pattern.")), attribute.value.range, MarkerSeverity.Error));
+        }
+    }
+    validatePaths(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.paths);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "sequence") {
+            report(toMarker(( localize(7231, "The 'paths' attribute must be an array of glob patterns.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        for (const item of attribute.value.items) {
+            if (item.type !== "scalar") {
+                report(toMarker(( localize(7232, "Each entry in the 'paths' attribute must be a string.")), item.range, MarkerSeverity.Error));
+                continue;
+            }
+            const pattern = item.value.trim();
+            if (pattern.length === 0) {
+                report(toMarker(( localize(7233, "Path entries must be non-empty glob patterns.")), item.range, MarkerSeverity.Error));
+                continue;
+            }
+            try {
+                const globPattern = parse(pattern);
+                if (isEmptyPattern(globPattern)) {
+                    report(toMarker(( localize(7234, "'{0}' is not a valid glob pattern.", pattern)), item.range, MarkerSeverity.Error));
+                }
+            } catch (_error) {
+                report(toMarker(( localize(7234, "'{0}' is not a valid glob pattern.", pattern)), item.range, MarkerSeverity.Error));
+            }
+        }
+    }
+    validateExcludeAgent(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.excludeAgent);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "sequence" && attribute.value.type !== "scalar") {
+            report(toMarker(( localize(7235, "The 'excludeAgent' attribute must be an string or array.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateHooks(attributes, target, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.hooks);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "map") {
+            report(toMarker(( localize(
+                7236,
+                "The 'hooks' attribute must be a map of hook event types to command arrays."
+            )), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const validHookNames = ( new Set(( Object.keys(HOOKS_BY_TARGET[target] ?? HOOKS_BY_TARGET[Target.Undefined]))));
+        for (const prop of attribute.value.properties) {
+            if (!( validHookNames.has(prop.key.value))) {
+                report(toMarker(( localize(
+                    7237,
+                    "Unknown hook event type '{0}'. Supported: {1}.",
+                    prop.key.value,
+                    Array.from(validHookNames).join(", ")
+                )), prop.key.range, MarkerSeverity.Warning));
+            }
+            if (prop.value.type !== "sequence") {
+                report(toMarker(( localize(
+                    7238,
+                    "Hook event '{0}' must have an array of command objects as its value.",
+                    prop.key.value
+                )), prop.value.range, MarkerSeverity.Error));
+                continue;
+            }
+            for (const item of prop.value.items) {
+                this.validateHookCommand(item, target, report);
+            }
+        }
+    }
+    validateHookCommand(item, target, report) {
+        if (item.type !== "map") {
+            report(toMarker(( localize(7239, "Each hook command must be an object.")), item.range, MarkerSeverity.Error));
+            return;
+        }
+        const hooksProperty = item.properties.find(p => p.key.value === "hooks");
+        if (hooksProperty) {
+            for (const prop of item.properties) {
+                if (prop.key.value !== "hooks" && prop.key.value !== "matcher") {
+                    report(toMarker(( localize(7240, "Unknown property '{0}' in hook matcher.", prop.key.value)), prop.key.range, MarkerSeverity.Warning));
+                }
+            }
+            if (hooksProperty.value.type !== "sequence") {
+                report(toMarker(( localize(
+                    7241,
+                    "The 'hooks' property in a matcher must be an array of command objects."
+                )), hooksProperty.value.range, MarkerSeverity.Error));
+                return;
+            }
+            for (const nestedItem of hooksProperty.value.items) {
+                this.validateHookCommand(nestedItem, target, report);
+            }
+            return;
+        }
+        const isCopilotCli = target === Target.GitHubCopilot;
+        const validCommandFields = isCopilotCli ? ( new Set(["bash", "powershell"])) : ( new Set(["command", "windows", "linux", "osx", "bash", "powershell"]));
+        const validProperties = isCopilotCli ? ( new Set(["type", "bash", "powershell", "cwd", "env", "timeoutSec"])) : ( new Set([
+            "type",
+            "command",
+            "windows",
+            "linux",
+            "osx",
+            "bash",
+            "powershell",
+            "cwd",
+            "env",
+            "timeout"
+        ]));
+        let hasType = false;
+        let hasCommandField = false;
+        for (const prop of item.properties) {
+            const key = prop.key.value;
+            if (!( validProperties.has(key))) {
+                report(toMarker(( localize(7242, "Unknown property '{0}' in hook command.", key)), prop.key.range, MarkerSeverity.Warning));
+            }
+            if (key === "type") {
+                hasType = true;
+                if (prop.value.type !== "scalar" || prop.value.value !== "command") {
+                    report(toMarker(( localize(7243, "The 'type' property in a hook command must be 'command'.")), prop.value.range, MarkerSeverity.Error));
+                }
+            } else if (( validCommandFields.has(key))) {
+                hasCommandField = true;
+                if (prop.value.type !== "scalar" || prop.value.value.trim().length === 0) {
+                    report(toMarker(( localize(
+                        7244,
+                        "The '{0}' property in a hook command must be a non-empty string.",
+                        key
+                    )), prop.value.range, MarkerSeverity.Error));
+                }
+            } else if (key === "cwd") {
+                if (prop.value.type !== "scalar") {
+                    report(toMarker(( localize(7245, "The 'cwd' property in a hook command must be a string.")), prop.value.range, MarkerSeverity.Error));
+                }
+            } else if (key === "env") {
+                if (prop.value.type !== "map") {
+                    report(toMarker(( localize(
+                        7246,
+                        "The 'env' property in a hook command must be a map of string values."
+                    )), prop.value.range, MarkerSeverity.Error));
+                } else {
+                    for (const envProp of prop.value.properties) {
+                        if (envProp.value.type !== "scalar") {
+                            report(toMarker(( localize(
+                                7247,
+                                "Environment variable '{0}' must have a string value.",
+                                envProp.key.value
+                            )), envProp.value.range, MarkerSeverity.Error));
+                        }
+                    }
+                }
+            } else if (key === "timeout" || key === "timeoutSec") {
+                if (prop.value.type !== "scalar" || isNaN(Number(prop.value.value))) {
+                    report(toMarker(( localize(7248, "The '{0}' property in a hook command must be a number.", key)), prop.value.range, MarkerSeverity.Error));
+                }
+            }
+        }
+        if (!hasType) {
+            report(toMarker(( localize(7249, "Hook command is missing required property 'type'.")), item.range, MarkerSeverity.Error));
+        }
+        if (!hasCommandField) {
+            if (isCopilotCli) {
+                report(toMarker(( localize(7250, "Hook command must specify at least one of 'bash' or 'powershell'.")), item.range, MarkerSeverity.Error));
+            } else {
+                report(toMarker(( localize(
+                    7251,
+                    "Hook command must specify at least one of 'command', 'windows', 'linux', or 'osx'."
+                )), item.range, MarkerSeverity.Error));
+            }
+        }
+    }
+    validateHandoffs(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.handOffs);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "sequence") {
+            report(toMarker(( localize(7252, "The 'handoffs' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        for (const item of attribute.value.items) {
+            if (item.type !== "map") {
+                report(toMarker(( localize(
+                    7253,
+                    "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 !== "scalar" || prop.value.value.trim().length === 0) {
+                        report(toMarker(( localize(7254, "The 'label' property in a handoff must be a non-empty string.")), prop.value.range, MarkerSeverity.Error));
+                    }
+                    break;
+                case "agent":
+                    if (prop.value.type !== "scalar" || prop.value.value.trim().length === 0) {
+                        report(toMarker(( localize(7255, "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 !== "scalar") {
+                        report(toMarker(( localize(7256, "The 'prompt' property in a handoff must be a string.")), prop.value.range, MarkerSeverity.Error));
+                    }
+                    break;
+                case "send":
+                    if (!isTrueOrFalse(prop.value)) {
+                        report(toMarker(( localize(7257, "The 'send' property in a handoff must be a boolean.")), prop.value.range, MarkerSeverity.Error));
+                    }
+                    break;
+                case "showContinueOn":
+                    if (!isTrueOrFalse(prop.value)) {
+                        report(toMarker(( localize(7258, "The 'showContinueOn' property in a handoff must be a boolean.")), prop.value.range, MarkerSeverity.Error));
+                    }
+                    break;
+                case "model":
+                    if (prop.value.type !== "scalar") {
+                        report(toMarker(( localize(7259, "The 'model' property in a handoff must be a string.")), prop.value.range, MarkerSeverity.Error));
+                    }
+                    break;
+                default:
+                    report(toMarker(( localize(
+                        7260,
+                        "Unknown property '{0}' in handoff object. Supported properties are 'label', 'agent', 'prompt' and optional 'send', 'showContinueOn', 'model'.",
+                        prop.key.value
+                    )), prop.value.range, MarkerSeverity.Warning));
+                }
+                required.delete(prop.key.value);
+            }
+            if (required.size > 0) {
+                report(toMarker(( localize(
+                    7261,
+                    "Missing required properties {0} in handoff object.",
+                    ( Array.from(required).map(s => `'${s}'`)).join(", ")
+                )), item.range, MarkerSeverity.Error));
+            }
+        }
+    }
+    validateInfer(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.infer);
+        if (!attribute) {
+            return;
+        }
+        report(toMarker(( localize(
+            7262,
+            "The 'infer' attribute is deprecated in favour of 'user-invocable' and 'disable-model-invocation'."
+        )), attribute.value.range, MarkerSeverity.Error));
+    }
+    validateTarget(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.target);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "scalar") {
+            report(toMarker(( localize(7263, "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(7264, "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(
+                7265,
+                "The 'target' attribute must be one of: {0}.",
+                validTargets.join(", ")
+            )), attribute.value.range, MarkerSeverity.Error));
+        }
+    }
+    validateUserInvocable(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.userInvocable);
+        if (!attribute) {
+            return;
+        }
+        if (!isTrueOrFalse(attribute.value)) {
+            report(toMarker(( localize(7266, "The 'user-invocable' attribute must be 'true' or 'false'.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    validateUserInvokable(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.userInvokable);
+        if (!attribute) {
+            return;
+        }
+        report(toMarker(( localize(
+            7267,
+            "The 'user-invokable' attribute is deprecated. Use 'user-invocable' instead."
+        )), attribute.range, MarkerSeverity.Warning));
+    }
+    validateDisableModelInvocation(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.disableModelInvocation);
+        if (!attribute) {
+            return;
+        }
+        if (!isTrueOrFalse(attribute.value)) {
+            report(toMarker(( localize(
+                7268,
+                "The 'disable-model-invocation' attribute must be 'true' or 'false'."
+            )), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+    }
+    async validateAgentsAttribute(attributes, header, report) {
+        const attribute = attributes.find(attr => attr.key === PromptHeaderAttributes.agents);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "sequence") {
+            report(toMarker(( localize(7269, "The 'agents' attribute must be an array.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        const agents = await this.promptsService.getCustomAgents(CancellationToken.None);
+        const availableAgentNames = ( new Set(( agents.map(agent => agent.name))));
+        availableAgentNames.add(ChatMode.Agent.name.get());
+        const agentNames = [];
+        for (const item of attribute.value.items) {
+            if (item.type !== "scalar") {
+                report(toMarker(( localize(7270, "Each agent name in the 'agents' attribute must be a string.")), item.range, MarkerSeverity.Error));
+            } else if (item.value) {
+                agentNames.push(item.value);
+                if (item.value !== "*" && !( availableAgentNames.has(item.value))) {
+                    report(toMarker(( localize(
+                        7271,
+                        "Unknown agent '{0}'. Available agents: {1}.",
+                        item.value,
+                        Array.from(availableAgentNames).join(", ")
+                    )), item.range, MarkerSeverity.Warning));
+                }
+            }
+        }
+        if (agentNames.length > 0) {
+            const tools = header.tools;
+            if (tools && !tools.includes(SpecedToolAliases.agent)) {
+                report(toMarker(( localize(
+                    7272,
+                    "When 'agents' and 'tools' are specified, the 'agent' tool must be included in the 'tools' attribute."
+                )), attribute.value.range, MarkerSeverity.Warning));
+            }
+        }
+    }
+    validateGithubPermissions(attributes, report) {
+        const attribute = attributes.find(attr => attr.key === GithubPromptHeaderAttributes.github);
+        if (!attribute) {
+            return;
+        }
+        if (attribute.value.type !== "map") {
+            report(toMarker(( localize(7273, "The 'github' attribute must be an object.")), attribute.value.range, MarkerSeverity.Error));
+            return;
+        }
+        for (const prop of attribute.value.properties) {
+            if (prop.key.value !== "permissions") {
+                report(toMarker(( localize(
+                    7274,
+                    "Unknown property '{0}' in 'github' object. Supported: 'permissions'.",
+                    prop.key.value
+                )), prop.key.range, MarkerSeverity.Warning));
+                continue;
+            }
+            if (prop.value.type !== "map") {
+                report(toMarker(( localize(7275, "The 'permissions' property must be an object.")), prop.value.range, MarkerSeverity.Error));
+                continue;
+            }
+            for (const permProp of prop.value.properties) {
+                const scope = permProp.key.value;
+                const scopeInfo = githubPermissionScopes[scope];
+                if (!scopeInfo) {
+                    const validScopes = ( Object.keys(githubPermissionScopes)).sort().join(", ");
+                    report(toMarker(( localize(
+                        7276,
+                        "Unknown permission scope '{0}'. Valid scopes: {1}.",
+                        scope,
+                        validScopes
+                    )), permProp.key.range, MarkerSeverity.Warning));
+                    continue;
+                }
+                if (permProp.value.type !== "scalar") {
+                    report(toMarker(( localize(7277, "The permission value for '{0}' must be a string.", scope)), permProp.value.range, MarkerSeverity.Error));
+                    continue;
+                }
+                const value = permProp.value.value;
+                if (!scopeInfo.allowedValues.includes(value)) {
+                    report(toMarker(( localize(
+                        7278,
+                        "Invalid permission value '{0}' for scope '{1}'. Allowed values: {2}.",
+                        value,
+                        scope,
+                        scopeInfo.allowedValues.join(", ")
+                    )), permProp.value.range, MarkerSeverity.Error));
+                }
+            }
+        }
+    }
+};
+PromptValidator = ( __decorate([( __param(0, ILanguageModelsService)), ( __param(1, ILanguageModelToolsService)), ( __param(2, IChatModeService)), ( __param(3, IFileService)), ( __param(4, ILabelService)), ( __param(5, IPromptsService)), ( __param(6, IConfigurationService))], PromptValidator));
+const githubPermissionScopes = {
+    "actions": {
+        allowedValues: ["read", "write", "none"],
+        description: ( localize(7279, "Access to GitHub Actions workflows and runs"))
+    },
+    "checks": {
+        allowedValues: ["read", "none"],
+        description: ( localize(7280, "Access to check runs and statuses"))
+    },
+    "contents": {
+        allowedValues: ["read", "write", "none"],
+        description: ( localize(7281, "Access to repository contents (files, commits, branches)"))
+    },
+    "discussions": {
+        allowedValues: ["read", "write", "none"],
+        description: ( localize(7282, "Access to discussions"))
+    },
+    "issues": {
+        allowedValues: ["read", "write", "none"],
+        description: ( localize(7283, "Access to issues (read, create, update, comment)"))
+    },
+    "metadata": {
+        allowedValues: ["read"],
+        description: ( localize(7284, "Repository metadata (always read-only)"))
+    },
+    "pull-requests": {
+        allowedValues: ["read", "write", "none"],
+        description: ( localize(7285, "Access to pull requests (read, create, update, review)"))
+    },
+    "security-events": {
+        allowedValues: ["read", "none"],
+        description: ( localize(7286, "Access to security-related events"))
+    },
+    "workflows": {
+        allowedValues: ["write", "none"],
+        description: ( localize(7287, "Access to modify workflow files"))
+    }
+};
+function isTrueOrFalse(value) {
+    if (value.type === "scalar") {
+        return (value.value === "true" || value.value === "false") && value.format === "none";
+    }
+    return false;
+}
+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,
+        PromptHeaderAttributes.infer,
+        PromptHeaderAttributes.agents,
+        PromptHeaderAttributes.hooks,
+        PromptHeaderAttributes.userInvocable,
+        PromptHeaderAttributes.userInvokable,
+        PromptHeaderAttributes.disableModelInvocation,
+        GithubPromptHeaderAttributes.github
+    ],
+    [PromptsType.skill]: [
+        PromptHeaderAttributes.name,
+        PromptHeaderAttributes.description,
+        PromptHeaderAttributes.license,
+        PromptHeaderAttributes.compatibility,
+        PromptHeaderAttributes.metadata,
+        PromptHeaderAttributes.argumentHint,
+        PromptHeaderAttributes.userInvocable,
+        PromptHeaderAttributes.userInvokable,
+        PromptHeaderAttributes.disableModelInvocation
+    ],
+    [PromptsType.hook]: []
+};
+const githubCopilotAgentAttributeNames = [
+    PromptHeaderAttributes.name,
+    PromptHeaderAttributes.description,
+    PromptHeaderAttributes.tools,
+    PromptHeaderAttributes.target,
+    GithubPromptHeaderAttributes.mcpServers,
+    GithubPromptHeaderAttributes.github,
+    PromptHeaderAttributes.infer
+];
+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)),
+    [PromptsType.skill]: allAttributeNames[PromptsType.skill].filter(name => !isNonRecommendedAttribute(name)),
+    [PromptsType.hook]: []
+};
+function getValidAttributeNames(promptType, includeNonRecommended, target) {
+    if (target === Target.Claude) {
+        if (promptType === PromptsType.instructions) {
+            return ( Object.keys(claudeRulesAttributes));
+        }
+        return ( Object.keys(claudeAgentAttributes));
+    } else if (target === Target.GitHubCopilot) {
+        if (promptType === PromptsType.agent) {
+            return githubCopilotAgentAttributeNames;
+        }
+    }
+    return includeNonRecommended ? allAttributeNames[promptType] : recommendedAttributeNames[promptType];
+}
+function isNonRecommendedAttribute(attributeName) {
+    return attributeName === PromptHeaderAttributes.advancedOptions || attributeName === PromptHeaderAttributes.excludeAgent || attributeName === PromptHeaderAttributes.mode || attributeName === PromptHeaderAttributes.infer || attributeName === PromptHeaderAttributes.userInvokable;
+}
+const knownClaudeTools = [{
+    name: "Bash",
+    description: ( localize(7288, "Execute shell commands")),
+    toolEquivalent: [SpecedToolAliases.execute]
+}, {
+    name: "Edit",
+    description: ( localize(7289, "Make targeted file edits")),
+    toolEquivalent: ["edit/editNotebook", "edit/editFiles"]
+}, {
+    name: "Glob",
+    description: ( localize(7290, "Find files by pattern")),
+    toolEquivalent: ["search/fileSearch"]
+}, {
+    name: "Grep",
+    description: ( localize(7291, "Search file contents with regex")),
+    toolEquivalent: ["search/textSearch"]
+}, {
+    name: "Read",
+    description: ( localize(7292, "Read file contents")),
+    toolEquivalent: ["read/readFile", "read/getNotebookSummary"]
+}, {
+    name: "Write",
+    description: ( localize(7293, "Create/overwrite files")),
+    toolEquivalent: ["edit/createDirectory", "edit/createFile", "edit/createJupyterNotebook"]
+}, {
+    name: "WebFetch",
+    description: ( localize(7294, "Fetch URL content")),
+    toolEquivalent: [SpecedToolAliases.web]
+}, {
+    name: "WebSearch",
+    description: ( localize(7295, "Perform web searches")),
+    toolEquivalent: [SpecedToolAliases.web]
+}, {
+    name: "Task",
+    description: ( localize(7296, "Run subagents for complex tasks")),
+    toolEquivalent: [SpecedToolAliases.agent]
+}, {
+    name: "Skill",
+    description: ( localize(7297, "Execute skills")),
+    toolEquivalent: []
+}, {
+    name: "LSP",
+    description: ( localize(7298, "Code intelligence (requires plugin)")),
+    toolEquivalent: []
+}, {
+    name: "NotebookEdit",
+    description: ( localize(7299, "Modify Jupyter notebooks")),
+    toolEquivalent: ["edit/editNotebook"]
+}, {
+    name: "AskUserQuestion",
+    description: ( localize(7300, "Ask multiple-choice questions")),
+    toolEquivalent: ["vscode/askQuestions"]
+}, {
+    name: "MCPSearch",
+    description: ( localize(7301, "Searches for MCP tools when tool search is enabled")),
+    toolEquivalent: []
+}];
+const knownClaudeModels = [{
+    name: "sonnet",
+    description: ( localize(7302, "Latest Claude Sonnet")),
+    modelEquivalent: "Claude Sonnet 4.5 (copilot)"
+}, {
+    name: "opus",
+    description: ( localize(7303, "Latest Claude Opus")),
+    modelEquivalent: "Claude Opus 4.6 (copilot)"
+}, {
+    name: "haiku",
+    description: ( localize(7304, "Latest Claude Haiku, fast for simple tasks")),
+    modelEquivalent: "Claude Haiku 4.5 (copilot)"
+}, {
+    name: "inherit",
+    description: ( localize(7305, "Inherit model from parent agent or prompt")),
+    modelEquivalent: undefined
+}];
+const claudeAgentAttributes = {
+    "name": {
+        type: "scalar",
+        description: ( localize(7306, "Unique identifier using lowercase letters and hyphens (required)"))
+    },
+    "description": {
+        type: "scalar",
+        description: ( localize(7307, "When to delegate to this subagent (required)"))
+    },
+    "tools": {
+        type: "sequence",
+        description: ( localize(7308, "Array of tools the subagent can use. Inherits all tools if omitted")),
+        defaults: ["Read, Edit, Bash"],
+        items: knownClaudeTools
+    },
+    "disallowedTools": {
+        type: "sequence",
+        description: ( localize(7309, "Tools to deny, removed from inherited or specified list")),
+        defaults: ["Write, Edit, Bash"],
+        items: knownClaudeTools
+    },
+    "model": {
+        type: "scalar",
+        description: ( localize(
+            7310,
+            "Model to use: sonnet, opus, haiku, or inherit. Defaults to inherit."
+        )),
+        defaults: ["sonnet", "opus", "haiku", "inherit"],
+        enums: knownClaudeModels
+    },
+    "permissionMode": {
+        type: "scalar",
+        description: ( localize(
+            7311,
+            "Permission mode: default, acceptEdits, dontAsk, bypassPermissions, or plan."
+        )),
+        defaults: ["default", "acceptEdits", "dontAsk", "bypassPermissions", "plan"],
+        enums: [{
+            name: "default",
+            description: ( localize(
+                7312,
+                "Standard behavior: prompts for permission on first use of each tool."
+            ))
+        }, {
+            name: "acceptEdits",
+            description: ( localize(7313, "Automatically accepts file edit permissions for the session."))
+        }, {
+            name: "plan",
+            description: ( localize(
+                7314,
+                "Plan Mode: Claude can analyze but not modify files or execute commands."
+            ))
+        }, {
+            name: "delegate",
+            description: ( localize(
+                7315,
+                "Coordination-only mode for agent team leads. Only available when an agent team is active."
+            ))
+        }, {
+            name: "dontAsk",
+            description: ( localize(
+                7316,
+                "Auto-denies tools unless pre-approved via /permissions or permissions.allow rules."
+            ))
+        }, {
+            name: "bypassPermissions",
+            description: ( localize(
+                7317,
+                "Skips all permission prompts (requires safe environment like containers)."
+            ))
+        }]
+    },
+    "skills": {
+        type: "sequence",
+        description: ( localize(7318, "Skills to load into the subagent's context at startup."))
+    },
+    "mcpServers": {
+        type: "sequence",
+        description: ( localize(7319, "MCP servers available to this subagent."))
+    },
+    "hooks": {
+        type: "object",
+        description: ( localize(7320, "Lifecycle hooks scoped to this subagent."))
+    },
+    "memory": {
+        type: "scalar",
+        description: ( localize(
+            7321,
+            "Persistent memory scope: user, project, or local. Enables cross-session learning."
+        )),
+        defaults: ["user", "project", "local"],
+        enums: [{
+            name: "user",
+            description: ( localize(7322, "Remember learnings across all projects."))
+        }, {
+            name: "project",
+            description: ( localize(
+                7323,
+                "The subagent's knowledge is project-specific and shareable via version control."
+            ))
+        }, {
+            name: "local",
+            description: ( localize(
+                7324,
+                "The subagent's knowledge is project-specific but should not be checked into version control."
+            ))
+        }]
+    }
+};
+const claudeRulesAttributes = {
+    "description": {
+        type: "scalar",
+        description: ( localize(
+            7325,
+            "A description of what this rule covers, used to provide context about when it applies."
+        ))
+    },
+    "paths": {
+        type: "sequence",
+        description: ( localize(
+            7326,
+            "Array of glob patterns that describe for which files the rule applies. Based on these patterns, the file is automatically included in the prompt when the context contains a file that matches.\nExample: `['src/**/*.ts', 'test/**']`"
+        ))
+    }
+};
+function isVSCodeOrDefaultTarget(target) {
+    return target === Target.VSCode || target === Target.Undefined;
+}
+function getTarget(promptType, header) {
+    const uri = header instanceof URI ? header : header.uri;
+    if (promptType === PromptsType.agent) {
+        const parentDir = dirname(uri);
+        if (parentDir.path.endsWith(`/${CLAUDE_AGENTS_SOURCE_FOLDER}`)) {
+            return Target.Claude;
+        }
+        if (!(header instanceof URI)) {
+            const target = header.target;
+            if (target === Target.GitHubCopilot || target === Target.VSCode) {
+                return target;
+            }
+        }
+        return Target.Undefined;
+    } else if (promptType === PromptsType.instructions) {
+        if (isInClaudeRulesFolder(uri)) {
+            return Target.Claude;
+        }
+    }
+    return Target.Undefined;
+}
+function toMarker(message, range, severity = MarkerSeverity.Error) {
+    return {
+        severity,
+        message,
+        ...range
+    };
+}
+let PromptValidatorContribution = class PromptValidatorContribution extends Disposable {
+    constructor(
+        modelService,
+        instantiationService,
+        markerService,
+        promptsService,
+        languageModelsService,
+        languageModelToolsService,
+        chatModeService
+    ) {
+        super();
+        this.modelService = modelService;
+        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();
+    }
+    updateRegistration() {
+        this.localDisposables.clear();
+        const trackers = ( new ResourceMap());
+        this.localDisposables.add(toDisposable(() => {
+            trackers.forEach(tracker => tracker.dispose());
+            trackers.clear();
+        }));
+        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 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)));
+            }
+        }));
+        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()));
+    }
+};
+PromptValidatorContribution = ( __decorate([( __param(0, IModelService)), ( __param(1, IInstantiationService)), ( __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) {
+        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 { MARKERS_OWNER_ID, PromptValidator, PromptValidatorContribution, claudeAgentAttributes, claudeRulesAttributes, getTarget, getValidAttributeNames, githubPermissionScopes, isNonRecommendedAttribute, isVSCodeOrDefaultTarget, knownClaudeModels, knownClaudeTools };