Support custom modes in prompt files

src/vs/workbench/contrib/chat/browser/actions/chatActions.ts

@@ -122,7 +122,7 @@ export const CHAT_CONFIG_MENU_ID = new MenuId('workbench.chat.menu.config');
 const OPEN_CHAT_QUOTA_EXCEEDED_DIALOG = 'workbench.action.chat.openQuotaExceededDialog';
 
 abstract class OpenChatGlobalAction extends Action2 {
-	constructor(overrides: Pick<ICommandPaletteOptions, 'keybinding' | 'title' | 'id' | 'menu'>, private readonly mode?: ChatModeKind) {
+	constructor(overrides: Pick<ICommandPaletteOptions, 'keybinding' | 'title' | 'id' | 'menu'>, private readonly mode?: IChatMode) {
 		super({
 			...overrides,
 			icon: Codicon.copilot,
@@ -160,8 +160,7 @@ abstract class OpenChatGlobalAction extends Action2 {
 			return;
 		}
 
-		const switchToModeInput = opts?.mode ?? this.mode;
-		const switchToMode = switchToModeInput && (chatModeService.findModeById(switchToModeInput) ?? chatModeService.findModeByName(switchToModeInput));
+		const switchToMode = (opts?.mode ? chatModeService.findModeByName(opts?.mode) : undefined) ?? this.mode;
 		if (switchToMode) {
 			await this.handleSwitchToMode(switchToMode, chatWidget, instaService, commandService);
 		}
@@ -275,9 +274,9 @@ abstract class ModeOpenChatGlobalAction extends OpenChatGlobalAction {
 	constructor(mode: IChatMode, keybinding?: ICommandPaletteOptions['keybinding']) {
 		super({
 			id: getOpenChatActionIdForMode(mode),
-			title: localize2('openChatMode', "Open Chat ({0})", mode.name),
+			title: localize2('openChatMode', "Open Chat ({0})", mode.label),
 			keybinding
-		}, mode.kind);
+		}, mode);
 	}
 }
 

src/vs/workbench/contrib/chat/browser/actions/chatToolActions.ts

@@ -128,7 +128,7 @@ class ConfigureToolsAction extends Action2 {
 				break;
 			case ToolsScope.Mode:
 				placeholder = localize('chat.tools.placeholder.mode', "Select tools for this chat mode");
-				description = localize('chat.tools.description.mode', "The selected tools are configured by the '{0}' chat mode. Changes to the tools will be applied to the mode file as well.", widget.input.currentModeObs.get().name);
+				description = localize('chat.tools.description.mode', "The selected tools are configured by the '{0}' chat mode. Changes to the tools will be applied to the mode file as well.", widget.input.currentModeObs.get().label);
 				break;
 			case ToolsScope.Global:
 				placeholder = localize('chat.tools.placeholder.global', "Select tools that are available to chat.");

src/vs/workbench/contrib/chat/browser/chatInputPart.ts

@@ -479,7 +479,7 @@ export class ChatInputPart extends Disposable implements IHistoryNavigationWidge
 		this.initSelectedModel();
 
 		this._register(this.onDidChangeCurrentChatMode(() => {
-			this.accessibilityService.alert(this._currentModeObservable.get().name);
+			this.accessibilityService.alert(this._currentModeObservable.get().label);
 			if (this._inputEditor) {
 				this._inputEditor.updateOptions({ ariaLabel: this._getAriaLabel() });
 			}

src/vs/workbench/contrib/chat/browser/chatSelectedTools.ts

@@ -82,7 +82,7 @@ export class ChatSelectedTools extends Disposable {
 
 			const currentMode = this._mode.read(r);
 
-			let currentMap = this._sessionStates.get(currentMode.id);
+			let currentMap = this._sessionStates.observable.read(r).get(currentMode.id);
 			const modeTools = currentMode.customTools?.read(r);
 			if (!currentMap && currentMode.kind === ChatModeKind.Agent && modeTools) {
 				currentMap = this._toolsService.toToolAndToolSetEnablementMap(modeTools);

src/vs/workbench/contrib/chat/browser/chatWidget.ts

@@ -51,6 +51,7 @@ import { ChatViewModel, IChatRequestViewModel, IChatResponseViewModel, isRequest
 import { IChatInputState } from '../common/chatWidgetHistoryService.js';
 import { CodeBlockModelCollection } from '../common/codeBlockModelCollection.js';
 import { ChatAgentLocation, ChatConfiguration, ChatModeKind } from '../common/constants.js';
+import { IChatModeService } from '../common/chatModes.js';
 import { ILanguageModelToolsService, IToolData, ToolSet } from '../common/languageModelToolsService.js';
 import { type TPromptMetadata } from '../common/promptSyntax/parsers/promptHeader/promptHeader.js';
 import { IPromptParserResult, IPromptsService } from '../common/promptSyntax/service/promptsService.js';
@@ -305,7 +306,8 @@ export class ChatWidget extends Disposable implements IChatWidget {
 		@ITelemetryService private readonly telemetryService: ITelemetryService,
 		@IPromptsService private readonly promptsService: IPromptsService,
 		@ILanguageModelToolsService private readonly toolsService: ILanguageModelToolsService,
-		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService
+		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService,
+		@IChatModeService private readonly chatModeService: IChatModeService
 	) {
 		super();
 		this._lockedToCodingAgentContextKey = ChatContextKeys.lockedToCodingAgent.bindTo(this.contextKeyService);
@@ -2095,16 +2097,24 @@ export class ChatWidget extends Disposable implements IChatWidget {
 
 		const { mode, tools, model } = metadata;
 
+		const currentMode = this.input.currentModeObs.get();
+
 		// switch to appropriate chat mode if needed
-		if (mode && mode !== this.input.currentModeKind) {
-			const chatModeCheck = await this.instantiationService.invokeFunction(handleModeSwitch, this.input.currentModeKind, mode, this.viewModel?.model.getRequests().length ?? 0, this.viewModel?.model.editingSession);
-			if (!chatModeCheck) {
-				return undefined;
-			} else if (chatModeCheck.needToClearSession) {
-				this.clear();
-				await this.waitForReady();
+		if (mode && mode !== currentMode.name) {
+			// Find the mode object to get its kind
+			const chatMode = this.chatModeService.findModeByName(mode);
+			if (chatMode) {
+				if (currentMode.kind !== chatMode.kind) {
+					const chatModeCheck = await this.instantiationService.invokeFunction(handleModeSwitch, currentMode.kind, chatMode.kind, this.viewModel?.model.getRequests().length ?? 0, this.viewModel?.model.editingSession);
+					if (!chatModeCheck) {
+						return undefined;
+					} else if (chatModeCheck.needToClearSession) {
+						this.clear();
+						await this.waitForReady();
+					}
+				}
+				this.input.setChatMode(chatMode.id);
 			}
-			this.input.setChatMode(mode);
 		}
 
 		// if not tools to enable are present, we are done

src/vs/workbench/contrib/chat/browser/modelPicker/modePickerActionItem.ts

@@ -40,7 +40,7 @@ export class ModePickerActionItem extends ActionWidgetDropdownActionViewItem {
 		const makeAction = (mode: IChatMode, currentMode: IChatMode): IActionWidgetDropdownAction => ({
 			...action,
 			id: getOpenChatActionIdForMode(mode),
-			label: mode.name,
+			label: mode.label,
 			class: undefined,
 			enabled: true,
 			checked: currentMode.id === mode.id,
@@ -56,7 +56,7 @@ export class ModePickerActionItem extends ActionWidgetDropdownActionViewItem {
 		const makeActionFromCustomMode = (mode: IChatMode, currentMode: IChatMode): IActionWidgetDropdownAction => ({
 			...action,
 			id: getOpenChatActionIdForMode(mode),
-			label: mode.name,
+			label: mode.label,
 			class: undefined,
 			enabled: true,
 			checked: currentMode.id === mode.id,
@@ -111,7 +111,7 @@ export class ModePickerActionItem extends ActionWidgetDropdownActionViewItem {
 			return null;
 		}
 		this.setAriaLabelAttributes(element);
-		const state = this.delegate.currentMode.get().name;
+		const state = this.delegate.currentMode.get().label;
 		dom.reset(element, dom.$('span.chat-model-label', undefined, state), ...renderLabelWithIcons(`$(chevron-down)`));
 		return null;
 	}

src/vs/workbench/contrib/chat/browser/promptSyntax/newPromptFileActions.ts

@@ -27,6 +27,7 @@ import { ChatContextKeys } from '../../common/chatContextKeys.js';
 import { CHAT_CATEGORY } from '../actions/chatActions.js';
 import { askForPromptFileName } from './pickers/askForPromptName.js';
 import { askForPromptSourceFolder } from './pickers/askForPromptSourceFolder.js';
+import { IChatModeService } from '../../common/chatModes.js';
 
 
 class AbstractNewPromptFileAction extends Action2 {
@@ -57,6 +58,7 @@ class AbstractNewPromptFileAction extends Action2 {
 		const editorService = accessor.get(IEditorService);
 		const fileService = accessor.get(IFileService);
 		const instaService = accessor.get(IInstantiationService);
+		const chatModeService = accessor.get(IChatModeService);
 
 		const selectedFolder = await instaService.invokeFunction(askForPromptSourceFolder, this.type);
 		if (!selectedFolder) {
@@ -81,7 +83,7 @@ class AbstractNewPromptFileAction extends Action2 {
 		if (editor && editor.hasModel() && isEqual(editor.getModel().uri, promptUri)) {
 			SnippetController2.get(editor)?.apply([{
 				range: editor.getModel().getFullModelRange(),
-				template: getDefaultContentSnippet(this.type),
+				template: this.getDefaultContentSnippet(this.type, chatModeService),
 			}]);
 		}
 
@@ -137,37 +139,41 @@ class AbstractNewPromptFileAction extends Action2 {
 			},
 		);
 	}
-}
 
-function getDefaultContentSnippet(promptType: PromptsType): string {
-	switch (promptType) {
-		case PromptsType.prompt:
-			return [
-				`---`,
-				`mode: \${1|ask,edit,agent|}`,
-				`---`,
-				`\${2:Define the task to achieve, including specific requirements, constraints, and success criteria.}`,
-			].join('\n');
-		case PromptsType.instructions:
-			return [
-				`---`,
-				`applyTo: '\${1|**,**/*.ts|}'`,
-				`---`,
-				`\${2:Provide project context and coding guidelines that AI should follow when generating code, answering questions, or reviewing changes.}`,
-			].join('\n');
-		case PromptsType.mode:
-			return [
-				`---`,
-				`description: '\${1:Description of the custom chat mode.}'`,
-				`tools: []`,
-				`---`,
-				`\${2:Define the purpose of this chat mode and how AI should behave: response style, available tools, focus areas, and any mode-specific instructions or constraints.}`,
-			].join('\n');
-		default:
-			throw new Error(`Unknown prompt type: ${promptType}`);
+	private getDefaultContentSnippet(promptType: PromptsType, chatModeService: IChatModeService): string {
+		const modes = chatModeService.getModes();
+		const modeNames = modes.builtin.map(mode => mode.name).join(',') + (modes.custom.length ? (',' + modes.custom.map(mode => mode.name).join(',')) : '');
+		switch (promptType) {
+			case PromptsType.prompt:
+				return [
+					`---`,
+					`mode: \${1|${modeNames}|}`,
+					`---`,
+					`\${2:Define the task to achieve, including specific requirements, constraints, and success criteria.}`,
+				].join('\n');
+			case PromptsType.instructions:
+				return [
+					`---`,
+					`applyTo: '\${1|**,**/*.ts|}'`,
+					`---`,
+					`\${2:Provide project context and coding guidelines that AI should follow when generating code, answering questions, or reviewing changes.}`,
+				].join('\n');
+			case PromptsType.mode:
+				return [
+					`---`,
+					`description: '\${1:Description of the custom chat mode.}'`,
+					`tools: []`,
+					`---`,
+					`\${2:Define the purpose of this chat mode and how AI should behave: response style, available tools, focus areas, and any mode-specific instructions or constraints.}`,
+				].join('\n');
+			default:
+				throw new Error(`Unknown prompt type: ${promptType}`);
+		}
 	}
 }
 
+
+
 export const NEW_PROMPT_COMMAND_ID = 'workbench.command.new.prompt';
 export const NEW_INSTRUCTIONS_COMMAND_ID = 'workbench.command.new.instructions';
 export const NEW_MODE_COMMAND_ID = 'workbench.command.new.mode';

src/vs/workbench/contrib/chat/common/chatModes.ts

@@ -162,25 +162,16 @@ export class ChatModeService extends Disposable implements IChatModeService {
 	getModes(): { builtin: readonly IChatMode[]; custom: readonly IChatMode[] } {
 		return {
 			builtin: this.getBuiltinModes(),
-			custom: this.chatAgentService.hasToolsAgent ?
-				Array.from(this._customModeInstances.values()) :
-				[]
+			custom: this.getCustomModes(),
 		};
 	}
 
-	private getFlatModes(): IChatMode[] {
-		const allModes = this.getModes();
-		return [...allModes.builtin, ...allModes.custom];
-	}
-
 	findModeById(id: string | ChatModeKind): IChatMode | undefined {
-		const allModes = this.getFlatModes();
-		return allModes.find(mode => mode.id === id);
+		return this.getBuiltinModes().find(mode => mode.id === id) ?? this.getCustomModes().find(mode => mode.id === id);
 	}
 
 	findModeByName(name: string): IChatMode | undefined {
-		const allModes = this.getFlatModes();
-		return allModes.find(mode => mode.name === name);
+		return this.getBuiltinModes().find(mode => mode.name === name) ?? this.getCustomModes().find(mode => mode.name === name);
 	}
 
 	private getBuiltinModes(): IChatMode[] {
@@ -194,6 +185,10 @@ export class ChatModeService extends Disposable implements IChatModeService {
 		builtinModes.push(ChatMode.Edit);
 		return builtinModes;
 	}
+
+	private getCustomModes(): IChatMode[] {
+		return this.chatAgentService.hasToolsAgent ? Array.from(this._customModeInstances.values()) : [];
+	}
 }
 
 export interface IChatModeData {
@@ -210,6 +205,7 @@ export interface IChatModeData {
 export interface IChatMode {
 	readonly id: string;
 	readonly name: string;
+	readonly label: string;
 	readonly description: IObservable<string | undefined>;
 	readonly isBuiltin: boolean;
 	readonly kind: ChatModeKind;
@@ -270,6 +266,10 @@ export class CustomChatMode implements IChatMode {
 		return this._uriObservable;
 	}
 
+	get label(): string {
+		return this.name;
+	}
+
 	public readonly kind = ChatModeKind.Agent;
 
 	constructor(
@@ -317,7 +317,7 @@ export class BuiltinChatMode implements IChatMode {
 
 	constructor(
 		public readonly kind: ChatModeKind,
-		public readonly name: string,
+		public readonly label: string,
 		description: string
 	) {
 		this.description = observableValue('description', description);
@@ -332,6 +332,10 @@ export class BuiltinChatMode implements IChatMode {
 		return this.kind;
 	}
 
+	get name(): string {
+		return this.kind;
+	}
+
 	/**
 	 * Getters are not json-stringified
 	 */

src/vs/workbench/contrib/chat/common/promptSyntax/languageProviders/PromptHeaderDefinitionProvider.ts

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { CancellationToken } from '../../../../../../base/common/cancellation.js';
+import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { Position } from '../../../../../../editor/common/core/position.js';
+import { Range } from '../../../../../../editor/common/core/range.js';
+import { Definition, DefinitionProvider } from '../../../../../../editor/common/languages.js';
+import { ITextModel } from '../../../../../../editor/common/model.js';
+import { ILanguageFeaturesService } from '../../../../../../editor/common/services/languageFeatures.js';
+import { IChatModeService } from '../../chatModes.js';
+import { ALL_PROMPTS_LANGUAGE_SELECTOR, getPromptsTypeForLanguageId } from '../promptTypes.js';
+import { IPromptsService } from '../service/promptsService.js';
+import { PromptModeMetadata } from '../parsers/promptHeader/metadata/mode.js';
+import { PromptHeader } from '../parsers/promptHeader/promptHeader.js';
+
+export class PromptHeaderDefinitionProvider extends Disposable implements DefinitionProvider {
+	/**
+	 * Debug display name for this provider.
+	 */
+	public readonly _debugDisplayName: string = 'PromptHeaderHoverProvider';
+
+	constructor(
+		@IPromptsService private readonly promptsService: IPromptsService,
+		@ILanguageFeaturesService private readonly languageService: ILanguageFeaturesService,
+		@IChatModeService private readonly chatModeService: IChatModeService,
+	) {
+		super();
+
+		this._register(this.languageService.definitionProvider.register(ALL_PROMPTS_LANGUAGE_SELECTOR, this));
+	}
+	async provideDefinition(model: ITextModel, position: Position, token: CancellationToken): Promise<Definition | undefined> {
+		const promptType = getPromptsTypeForLanguageId(model.getLanguageId());
+		if (!promptType) {
+			// if the model is not a prompt, we don't provide any completions
+			return undefined;
+		}
+
+		const parser = this.promptsService.getSyntaxParserFor(model);
+		await parser.start(token).settled();
+
+		if (token.isCancellationRequested) {
+			return undefined;
+		}
+
+		const header = parser.header;
+		if (!header) {
+			return undefined;
+		}
+
+		const completed = await header.settled;
+		if (!completed || token.isCancellationRequested) {
+			return undefined;
+		}
+
+		if (header instanceof PromptHeader) {
+			const mode = header.metadataUtility.mode;
+			if (mode?.range.containsPosition(position)) {
+				return this.getModeDefinition(mode, position);
+			}
+		}
+		return undefined;
+	}
+
+
+	private getModeDefinition(mode: PromptModeMetadata, position: Position): Definition | undefined {
+		const value = mode.value;
+		if (value && mode.valueRange?.containsPosition(position)) {
+			const mode = this.chatModeService.findModeByName(value);
+			if (mode && mode.uri) {
+				return {
+					uri: mode.uri.get(),
+					range: new Range(1, 1, 1, 1)
+				};
+			}
+		}
+		return undefined;
+	}
+
+}