Revert "Only use the main prompt file to decide about the mode and tools (#24…"

This reverts commit f83bd3c.

Author: legomushroom

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

@@ -54,8 +54,7 @@ import { IChatInputState } from '../common/chatWidgetHistoryService.js';
 import { CodeBlockModelCollection } from '../common/codeBlockModelCollection.js';
 import { ChatAgentLocation, ChatMode } from '../common/constants.js';
 import { ILanguageModelToolsService } from '../common/languageModelToolsService.js';
-import { IPromptMetadata } from '../common/promptSyntax/parsers/types.js';
-import { IMetadata, IPromptsService } from '../common/promptSyntax/service/types.js';
+import { IPromptsService } from '../common/promptSyntax/service/types.js';
 import { handleModeSwitch } from './actions/chatActions.js';
 import { ChatTreeItem, IChatAcceptInputOptions, IChatAccessibilityService, IChatCodeBlockInfo, IChatFileTreeInfo, IChatListItemRendererOptions, IChatWidget, IChatWidgetService, IChatWidgetViewContext, IChatWidgetViewOptions } from './chat.js';
 import { ChatAccessibilityProvider } from './chatAccessibilityProvider.js';
@@ -1185,52 +1184,27 @@ export class ChatWidget extends Disposable implements IChatWidget {
 		return inputState;
 	}
 
-	private _findPromptFileInContext(attachedContext: IChatRequestVariableEntry[]): URI | undefined {
-		for (const item of attachedContext) {
-			if (isPromptFileChatVariable(item) && item.isRoot) {
-				return toUri(item);
-			}
-		}
-		return undefined;
-	}
+	private async _handlePromptSlashCommand(input: string, attachedContext: IChatRequestVariableEntry[]): Promise<string> {
 
-	private async _applyPromptFileIfSet(requestInput: { input: string; attachedContext: IChatRequestVariableEntry[] }): Promise<IMetadata | undefined> {
-
-		let metadata: IMetadata | undefined;
-
-		// frst check if the input has a prompt slash command
 		const agentSlashPromptPart = this.parsedInput.parts.find((r): r is ChatRequestSlashPromptPart => r instanceof ChatRequestSlashPromptPart);
-		if (agentSlashPromptPart) {
-			metadata = await this.promptsService.resolvePromptSlashCommand(agentSlashPromptPart.slashPromptCommand);
-			if (metadata) {
-				const uri = metadata.uri;
-				if (!requestInput.attachedContext.some(variable => isPromptFileChatVariable(variable) && isEqual(toUri(variable), uri))) {
-					// not yet attached, so attach it
-					const variable = toChatVariable({ uri: metadata.uri, isPromptFile: true }, true);
-					requestInput.attachedContext.push(variable);
-				}
-				// remove the slash command from the input
-				requestInput.input = this.parsedInput.parts.filter(part => !(part instanceof ChatRequestSlashPromptPart)).map(part => part.text).join('').trim();
-			}
-		} else {
-			// if not, check if the context contains a prompt file: This is the old workflow that we still support for legacy reasons
-			const uri = this._findPromptFileInContext(requestInput.attachedContext);
-			if (uri) {
-				metadata = await this.promptsService.getMetadata(uri);
-			}
+		if (!agentSlashPromptPart) {
+			return input;
 		}
+		// remove the slash command from the input
+		input = this.parsedInput.parts.filter(part => !(part instanceof ChatRequestSlashPromptPart)).map(part => part.text).join('').trim();
 
-		if (!metadata) {
-			return undefined;
+		const promptPath = await this.promptsService.resolvePromptSlashCommand(agentSlashPromptPart.slashPromptCommand);
+		if (!promptPath) {
+			return input;
 		}
 
-		if (!requestInput.input.trim()) {
-			requestInput.input = localize('input.1', "Follow instructions from {0}.", basename(metadata.uri));
+		if (!attachedContext.some(variable => isPromptFileChatVariable(variable) && isEqual(toUri(variable), promptPath.uri))) {
+			// not yet attached, so attach it
+			const variable = toChatVariable({ uri: promptPath.uri, isPromptFile: true }, true);
+			attachedContext.push(variable);
 		}
 
-		await this._applyPromptMetadata(metadata.metadata);
-
-		return metadata;
+		return input;
 	}
 
 	private async _acceptInput(query: { query: string } | undefined, options?: IChatAcceptInputOptions): Promise<IChatResponseModel | undefined> {
@@ -1244,23 +1218,26 @@ export class ChatWidget extends Disposable implements IChatWidget {
 
 			const editorValue = this.getInput();
 			const requestId = this.chatAccessibilityService.acceptRequest();
-			const requestInputs = {
-				input: !query ? editorValue : query.query,
-				attachedContext: await this.inputPart.getAttachedAndImplicitContext(this.viewModel.sessionId),
-			};
-
+			let input = !query ? editorValue : query.query;
 			const isUserQuery = !query;
 
+			let attachedContext = await this.inputPart.getAttachedAndImplicitContext(this.viewModel.sessionId);
+
 			const { promptInstructions } = this.inputPart.attachmentModel;
 			const instructionsEnabled = promptInstructions.featureEnabled;
 			if (instructionsEnabled) {
-				await this._applyPromptFileIfSet(requestInputs);
-				await this.autoAttachInstructions(requestInputs.attachedContext);
+				input = await this._handlePromptSlashCommand(input, attachedContext);
+				await this.autoAttachInstructions(attachedContext);
+				const newInput = await this.setupChatModeAndTools(input, attachedContext);
+				if (newInput === undefined) {
+					return;
+				}
+				input = newInput;
 			}
 
 			if (this.viewOptions.enableWorkingSet !== undefined && this.input.currentMode === ChatMode.Edit && !this.chatService.edits2Enabled) {
 				const uniqueWorkingSetEntries = new ResourceSet(); // NOTE: this is used for bookkeeping so the UI can avoid rendering references in the UI that are already shown in the working set
-				const editingSessionAttachedContext: IChatRequestVariableEntry[] = requestInputs.attachedContext;
+				const editingSessionAttachedContext: IChatRequestVariableEntry[] = attachedContext;
 
 				// Collect file variables from previous requests before sending the request
 				const previousRequests = this.viewModel.model.getRequests();
@@ -1275,7 +1252,7 @@ export class ChatWidget extends Disposable implements IChatWidget {
 						}
 					}
 				}
-				requestInputs.attachedContext = editingSessionAttachedContext;
+				attachedContext = editingSessionAttachedContext;
 
 				type ChatEditingWorkingSetClassification = {
 					owner: 'joyceerhl';
@@ -1305,13 +1282,13 @@ export class ChatWidget extends Disposable implements IChatWidget {
 				}
 			}
 
-			const result = await this.chatService.sendRequest(this.viewModel.sessionId, requestInputs.input, {
+			const result = await this.chatService.sendRequest(this.viewModel.sessionId, input, {
 				mode: this.inputPart.currentMode,
 				userSelectedModelId: this.inputPart.currentLanguageModel,
 				location: this.location,
 				locationData: this._location.resolveData?.(),
 				parserContext: { selectedAgent: this._lastSelectedAgent, mode: this.inputPart.currentMode },
-				attachedContext: requestInputs.attachedContext,
+				attachedContext,
 				noCommandDetection: options?.noCommandDetection,
 				userSelectedTools,
 				userSelectedTools2,
@@ -1528,7 +1505,39 @@ export class ChatWidget extends Disposable implements IChatWidget {
 		this.agentInInput.set(!!currentAgent);
 	}
 
-	private async _applyPromptMetadata(metadata: IPromptMetadata): Promise<void> {
+	/**
+	 * Set's up the `chat mode` and selects required `tools` based on
+	 * the metadata defined in headers of attached prompt files.
+	 */
+	private async setupChatModeAndTools(
+		input: string,
+		attachedContext: readonly IChatRequestVariableEntry[],
+	): Promise<string | undefined> {
+		// process prompt files starting from the 'root' ones
+		const promptFileVariables = attachedContext
+			.filter(isPromptFileChatVariable)
+			.filter(pick('isRoot'));
+		const promptUris = promptFileVariables.map(toUri);
+
+		if (promptFileVariables.length === 0) {
+			return input;
+		}
+
+		if (!input.trim()) {
+			const promptNames = (promptUris.length === 1)
+				? `'${basename(promptUris[0])}'`
+				: `the prompt files`;
+
+			input = `Follow instructions from ${promptNames}.`;
+		}
+
+
+		const metadata = await this.promptsService
+			.getCombinedToolsMetadata(promptUris);
+
+		if (metadata === null) {
+			return input;
+		}
 
 		const { mode, tools } = metadata;
 
@@ -1546,7 +1555,7 @@ export class ChatWidget extends Disposable implements IChatWidget {
 
 		// if not tools to enable are present, we are done
 		if (tools === undefined) {
-			return;
+			return input;
 		}
 
 		// sanity check on the logic of the `getPromptFilesMetadata` method
@@ -1577,6 +1586,8 @@ export class ChatWidget extends Disposable implements IChatWidget {
 		this.inputPart
 			.selectedToolsModel
 			.selectOnly(toolIds);
+
+		return input;
 	}
 
 	/**

src/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.ts

@@ -150,28 +150,19 @@ export class PromptsService extends Disposable implements IPromptsService {
 		return undefined;
 	}
 
-	public async resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IMetadata | undefined> {
-		const promptUri = await this.getPromptPath(data);
-		if (!promptUri) {
-			return undefined;
-		}
-		return await this.getMetadata(promptUri);
-	}
-
-	private async getPromptPath(data: IChatPromptSlashCommand): Promise<URI | undefined> {
+	public async resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IPromptPath | undefined> {
 		if (data.promptPath) {
-			return data.promptPath.uri;
+			return data.promptPath;
 		}
-
 		const files = await this.listPromptFiles('prompt');
 		const command = data.command;
 		const result = files.find(file => getPromptCommandName(file.uri.path) === command);
 		if (result) {
-			return result.uri;
+			return result;
 		}
 		const textModel = this.modelService.getModels().find(model => model.getLanguageId() === PROMPT_LANGUAGE_ID && getPromptCommandName(model.uri.path) === command);
 		if (textModel) {
-			return textModel.uri;
+			return { uri: textModel.uri, storage: 'local', type: 'prompt' };
 		}
 		return undefined;
 	}
@@ -230,11 +221,6 @@ export class PromptsService extends Disposable implements IPromptsService {
 		return [...foundFiles];
 	}
 
-	public async getMetadata(promptFileUri: URI): Promise<IMetadata> {
-		const metaDatas = await this.getAllMetadata([promptFileUri]);
-		return metaDatas[0];
-	}
-
 	@logTime()
 	public async getAllMetadata(
 		promptUris: readonly URI[],

src/vs/workbench/contrib/chat/common/promptSyntax/service/types.ts

@@ -149,7 +149,7 @@ export interface IPromptsService extends IDisposable {
 	/**
 	 * Gets the prompt file for a slash command.
 	 */
-	resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IMetadata | undefined>;
+	resolvePromptSlashCommand(data: IChatPromptSlashCommand): Promise<IPromptPath | undefined>;
 
 	/**
 	 * Returns a prompt command if the command name is valid.
@@ -164,11 +164,6 @@ export interface IPromptsService extends IDisposable {
 		fileUris: readonly URI[],
 	): Promise<readonly URI[]>;
 
-	/**
-	 * Gets the metadata for the given prompt file uri.
-	 */
-	getMetadata(promptFileUri: URI): Promise<IMetadata>;
-
 	/**
 	 * Get all metadata for entire prompt references tree
 	 * that spans out of each of the provided files.

src/vs/workbench/contrib/chat/test/common/mockPromptsService.ts

@@ -17,9 +17,6 @@ export class MockPromptsService implements IPromptsService {
 	getAllMetadata(_files: readonly URI[]): Promise<readonly IMetadata[]> {
 		throw new Error('Method not implemented.');
 	}
-	getMetadata(_file: URI): Promise<IMetadata> {
-		throw new Error('Method not implemented.');
-	}
 	getSyntaxParserFor(_model: ITextModel): TextModelPromptParser & { isDisposed: false } {
 		throw new Error('Method not implemented.');
 	}
@@ -32,7 +29,7 @@ export class MockPromptsService implements IPromptsService {
 	public asPromptSlashCommand(command: string): IChatPromptSlashCommand | undefined {
 		return undefined;
 	}
-	resolvePromptSlashCommand(_data: IChatPromptSlashCommand): Promise<IMetadata | undefined> {
+	resolvePromptSlashCommand(_data: IChatPromptSlashCommand): Promise<IPromptPath | undefined> {
 		throw new Error('Method not implemented.');
 	}
 	findPromptSlashCommands(): Promise<IChatPromptSlashCommand[]> {