add more tips, make all of them contextual (microsoft#294237)

fixes microsoft#290019

Author: meganrogge

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

@@ -809,6 +809,24 @@ export function registerChatActions() {
 		}
 	});
 
+	registerAction2(class ShowContextUsageAction extends Action2 {
+		constructor() {
+			super({
+				id: 'workbench.action.chat.showContextUsage',
+				title: localize2('interactiveSession.showContextUsage.label', "Show Context Window Usage"),
+				category: CHAT_CATEGORY,
+				f1: true,
+				precondition: ChatContextKeys.enabled,
+			});
+		}
+
+		async run(accessor: ServicesAccessor): Promise<void> {
+			const widgetService = accessor.get(IChatWidgetService);
+			const widget = widgetService.lastFocusedWidget ?? (await widgetService.revealWidget());
+			widget?.input.showContextUsageDetails();
+		}
+	});
+
 	const nonEnterpriseCopilotUsers = ContextKeyExpr.and(ChatContextKeys.enabled, ContextKeyExpr.notEquals(`config.${defaultChat.completionsAdvancedSetting}.authProvider`, defaultChat.provider.enterprise.id));
 	registerAction2(class extends Action2 {
 		constructor() {

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

@@ -19,6 +19,7 @@ import { PromptsType } from '../common/promptSyntax/promptTypes.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { localize } from '../../../../nls.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
+import { ILanguageModelToolsService } from '../common/tools/languageModelToolsService.js';
 
 export const IChatTipService = createDecorator<IChatTipService>('chatTipService');
 
@@ -85,6 +86,21 @@ export interface ITipDefinition {
 	 * Matches against both mode kind (e.g. 'agent') and mode name (e.g. 'Plan').
 	 */
 	readonly excludeWhenModesUsed?: string[];
+	/**
+	 * Tool IDs that, if ever invoked in this workspace, make this tip ineligible.
+	 * The tip won't be shown if the tool it describes has already been used.
+	 */
+	readonly excludeWhenToolsInvoked?: string[];
+	/**
+	 * If set, exclude this tip when prompt files of the specified type exist in the workspace.
+	 */
+	readonly excludeWhenPromptFilesExist?: {
+		readonly promptType: PromptsType;
+		/** Also check for this specific agent instruction file type. */
+		readonly agentFileType?: AgentFileType;
+		/** If true, exclude the tip until the async file check completes. Default: false. */
+		readonly excludeUntilChecked?: boolean;
+	};
 }
 
 /**
@@ -108,10 +124,12 @@ const TIP_CATALOG: ITipDefinition[] = [
 	{
 		id: 'tip.attachFiles',
 		message: localize('tip.attachFiles', "Tip: Attach files or folders with # to give Copilot more context."),
+		excludeWhenCommandsExecuted: ['workbench.action.chat.attachContext', 'workbench.action.chat.attachFile', 'workbench.action.chat.attachFolder', 'workbench.action.chat.attachSelection'],
 	},
 	{
 		id: 'tip.codeActions',
 		message: localize('tip.codeActions', "Tip: Select code and right-click for Copilot actions in the context menu."),
+		excludeWhenCommandsExecuted: ['inlineChat.start'],
 	},
 	{
 		id: 'tip.undoChanges',
@@ -126,7 +144,78 @@ const TIP_CATALOG: ITipDefinition[] = [
 		id: 'tip.customInstructions',
 		message: localize('tip.customInstructions', "Tip: [Generate workspace instructions](command:workbench.action.chat.generateInstructions) so Copilot always has the context it needs when starting a task."),
 		enabledCommands: ['workbench.action.chat.generateInstructions'],
-	}
+		excludeWhenPromptFilesExist: { promptType: PromptsType.instructions, agentFileType: AgentFileType.copilotInstructionsMd, excludeUntilChecked: true },
+	},
+	{
+		id: 'tip.customAgent',
+		message: localize('tip.customAgent', "Tip: [Create a custom agent](command:workbench.command.new.agent) to define reusable personas with tailored instructions and tools for your workflow."),
+		when: ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+		enabledCommands: ['workbench.command.new.agent'],
+		excludeWhenCommandsExecuted: ['workbench.command.new.agent'],
+		excludeWhenPromptFilesExist: { promptType: PromptsType.agent, excludeUntilChecked: true },
+	},
+	{
+		id: 'tip.skill',
+		message: localize('tip.skill', "Tip: [Create a skill](command:workbench.command.new.skill) so agents can perform domain-specific tasks with reusable prompts and tools."),
+		when: ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+		enabledCommands: ['workbench.command.new.skill'],
+		excludeWhenCommandsExecuted: ['workbench.command.new.skill'],
+		excludeWhenPromptFilesExist: { promptType: PromptsType.skill, excludeUntilChecked: true },
+	},
+	{
+		id: 'tip.messageQueueing',
+		message: localize('tip.messageQueueing', "Tip: You can send follow-up messages while the agent is working. They'll be queued and processed in order."),
+		when: ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+		excludeWhenCommandsExecuted: ['workbench.action.chat.queueMessage', 'workbench.action.chat.steerWithMessage'],
+	},
+	{
+		id: 'tip.yoloMode',
+		message: localize('tip.yoloMode', "Tip: Enable [auto-approve mode](command:workbench.action.openSettings?%5B%22chat.tools.global.autoApprove%22%5D) to let the agent run tools without manual confirmation."),
+		when: ContextKeyExpr.and(
+			ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+			ContextKeyExpr.notEquals('config.chat.tools.global.autoApprove', true),
+		),
+		enabledCommands: ['workbench.action.openSettings'],
+	},
+	{
+		id: 'tip.mermaid',
+		message: localize('tip.mermaid', "Tip: Ask the agent to visualize architectures and flows; it can render Mermaid diagrams directly in chat."),
+		when: ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+		excludeWhenToolsInvoked: ['renderMermaidDiagram'],
+	},
+	{
+		id: 'tip.githubRepo',
+		message: localize('tip.githubRepo', "Tip: Mention a GitHub repository (e.g. @owner/repo) in your prompt so the agent can query code and issues across that repo."),
+		when: ContextKeyExpr.and(
+			ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+			ContextKeyExpr.notEquals('gitOpenRepositoryCount', '0'),
+		),
+		excludeWhenToolsInvoked: ['github-pull-request_doSearch', 'github-pull-request_issue_fetch', 'github-pull-request_formSearchQuery'],
+	},
+	{
+		id: 'tip.subagents',
+		message: localize('tip.subagents', "Tip: Ask the agent to implement a plan in parallel; it can delegate work across subagents for faster results."),
+		when: ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+		excludeWhenToolsInvoked: ['runSubagent'],
+	},
+	{
+		id: 'tip.contextUsage',
+		message: localize('tip.contextUsage', "Tip: [View your context window usage](command:workbench.action.chat.showContextUsage) to see how many tokens are being spent and what's consuming them."),
+		when: ContextKeyExpr.and(
+			ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent),
+			ChatContextKeys.contextUsageHasBeenOpened.negate(),
+			ChatContextKeys.chatSessionIsEmpty.negate(),
+		),
+		enabledCommands: ['workbench.action.chat.showContextUsage'],
+		excludeWhenCommandsExecuted: ['workbench.action.chat.showContextUsage'],
+	},
+	{
+		id: 'tip.sendToNewChat',
+		message: localize('tip.sendToNewChat', "Tip: Use [Send to New Chat](command:workbench.action.chat.sendToNewChat) to start a fresh conversation with a clean context window."),
+		when: ChatContextKeys.chatSessionIsEmpty.negate(),
+		enabledCommands: ['workbench.action.chat.sendToNewChat'],
+		excludeWhenCommandsExecuted: ['workbench.action.chat.sendToNewChat'],
+	},
 ];
 
 /**
@@ -138,26 +227,38 @@ export class TipEligibilityTracker extends Disposable {
 
 	private static readonly _COMMANDS_STORAGE_KEY = 'chat.tips.executedCommands';
 	private static readonly _MODES_STORAGE_KEY = 'chat.tips.usedModes';
+	private static readonly _TOOLS_STORAGE_KEY = 'chat.tips.invokedTools';
 
 	private readonly _executedCommands: Set<string>;
 	private readonly _usedModes: Set<string>;
+	private readonly _invokedTools: Set<string>;
 
 	private readonly _pendingCommands: Set<string>;
 	private readonly _pendingModes: Set<string>;
+	private readonly _pendingTools: Set<string>;
 
 	private readonly _commandListener = this._register(new MutableDisposable());
+	private readonly _toolListener = this._register(new MutableDisposable());
 
 	/**
-	 * Whether agent instruction files exist in the workspace.
-	 * Defaults to `true` (hide the tip) until the async check completes.
+	 * Tip IDs excluded because prompt files of the required type exist in the workspace.
+	 * Tips with `excludeUntilChecked` are pre-added and removed if no files are found.
 	 */
-	private _hasInstructionFiles = true;
+	private readonly _excludedByFiles = new Set<string>();
+
+	/** Tips that have file-based exclusions, kept for re-checks. */
+	private readonly _tipsWithFileExclusions: readonly ITipDefinition[];
+
+	/** Generation counter per tip ID to discard stale async file-check results. */
+	private readonly _fileCheckGeneration = new Map<string, number>();
 
 	constructor(
 		tips: readonly ITipDefinition[],
 		@ICommandService commandService: ICommandService,
 		@IStorageService private readonly _storageService: IStorageService,
-		@IPromptsService promptsService: IPromptsService,
+		@IPromptsService private readonly _promptsService: IPromptsService,
+		@ILanguageModelToolsService languageModelToolsService: ILanguageModelToolsService,
+		@ILogService private readonly _logService: ILogService,
 	) {
 		super();
 
@@ -169,6 +270,9 @@ export class TipEligibilityTracker extends Disposable {
 		const storedModes = this._storageService.get(TipEligibilityTracker._MODES_STORAGE_KEY, StorageScope.WORKSPACE);
 		this._usedModes = new Set<string>(storedModes ? JSON.parse(storedModes) : []);
 
+		const storedTools = this._storageService.get(TipEligibilityTracker._TOOLS_STORAGE_KEY, StorageScope.WORKSPACE);
+		this._invokedTools = new Set<string>(storedTools ? JSON.parse(storedTools) : []);
+
 		// --- Derive what still needs tracking ----------------------------------
 
 		this._pendingCommands = new Set<string>();
@@ -189,6 +293,15 @@ export class TipEligibilityTracker extends Disposable {
 			}
 		}
 
+		this._pendingTools = new Set<string>();
+		for (const tip of tips) {
+			for (const toolId of tip.excludeWhenToolsInvoked ?? []) {
+				if (!this._invokedTools.has(toolId)) {
+					this._pendingTools.add(toolId);
+				}
+			}
+		}
+
 		// --- Set up command listener (auto-disposes when all seen) --------------
 
 		if (this._pendingCommands.size > 0) {
@@ -205,9 +318,40 @@ export class TipEligibilityTracker extends Disposable {
 			});
 		}
 
-		// --- Async file check --------------------------------------------------
+		// --- Set up tool listener (auto-disposes when all seen) -----------------
+
+		if (this._pendingTools.size > 0) {
+			this._toolListener.value = languageModelToolsService.onDidInvokeTool(e => {
+				if (this._pendingTools.has(e.toolId)) {
+					this._invokedTools.add(e.toolId);
+					this._persistSet(TipEligibilityTracker._TOOLS_STORAGE_KEY, this._invokedTools);
+					this._pendingTools.delete(e.toolId);
+
+					if (this._pendingTools.size === 0) {
+						this._toolListener.clear();
+					}
+				}
+			});
+		}
+
+		// --- Async file checks -------------------------------------------------
+
+		this._tipsWithFileExclusions = tips.filter(t => t.excludeWhenPromptFilesExist);
+		for (const tip of this._tipsWithFileExclusions) {
+			if (tip.excludeWhenPromptFilesExist!.excludeUntilChecked) {
+				this._excludedByFiles.add(tip.id);
+			}
+			this._checkForPromptFiles(tip);
+		}
 
-		this._checkForInstructionFiles(promptsService);
+		// Re-check agent file exclusions when custom agents change (covers late discovery)
+		this._register(this._promptsService.onDidChangeCustomAgents(() => {
+			for (const tip of this._tipsWithFileExclusions) {
+				if (tip.excludeWhenPromptFilesExist!.promptType === PromptsType.agent) {
+					this._checkForPromptFiles(tip);
+				}
+			}
+		}));
 	}
 
 	/**
@@ -245,33 +389,67 @@ export class TipEligibilityTracker extends Disposable {
 		if (tip.excludeWhenCommandsExecuted) {
 			for (const cmd of tip.excludeWhenCommandsExecuted) {
 				if (this._executedCommands.has(cmd)) {
+					this._logService.debug('#ChatTips: tip excluded because command was executed', tip.id, cmd);
 					return true;
 				}
 			}
 		}
 		if (tip.excludeWhenModesUsed) {
 			for (const mode of tip.excludeWhenModesUsed) {
 				if (this._usedModes.has(mode)) {
+					this._logService.debug('#ChatTips: tip excluded because mode was used', tip.id, mode);
+					return true;
+				}
+			}
+		}
+		if (tip.excludeWhenToolsInvoked) {
+			for (const toolId of tip.excludeWhenToolsInvoked) {
+				if (this._invokedTools.has(toolId)) {
+					this._logService.debug('#ChatTips: tip excluded because tool was invoked', tip.id, toolId);
 					return true;
 				}
 			}
 		}
-		if (tip.id === 'tip.customInstructions' && this._hasInstructionFiles) {
+		if (tip.excludeWhenPromptFilesExist && this._excludedByFiles.has(tip.id)) {
+			this._logService.debug('#ChatTips: tip excluded because prompt files exist', tip.id);
 			return true;
 		}
 		return false;
 	}
 
-	private async _checkForInstructionFiles(promptsService: IPromptsService): Promise<void> {
+	private async _checkForPromptFiles(tip: ITipDefinition): Promise<void> {
+		const config = tip.excludeWhenPromptFilesExist!;
+		const generation = (this._fileCheckGeneration.get(tip.id) ?? 0) + 1;
+		this._fileCheckGeneration.set(tip.id, generation);
+
 		try {
-			const [agentInstructions, instructionFiles] = await Promise.all([
-				promptsService.listAgentInstructions(CancellationToken.None),
-				promptsService.listPromptFiles(PromptsType.instructions, CancellationToken.None),
+			const [promptFiles, agentInstructions] = await Promise.all([
+				this._promptsService.listPromptFiles(config.promptType, CancellationToken.None),
+				config.agentFileType ? this._promptsService.listAgentInstructions(CancellationToken.None) : Promise.resolve([]),
 			]);
-			const hasCopilotInstructions = agentInstructions.some(f => f.type === AgentFileType.copilotInstructionsMd);
-			this._hasInstructionFiles = hasCopilotInstructions || instructionFiles.length > 0;
+
+			// Discard stale result if a newer check was started while we were awaiting
+			if (this._fileCheckGeneration.get(tip.id) !== generation) {
+				return;
+			}
+
+			const hasPromptFiles = promptFiles.length > 0;
+			const hasAgentFile = config.agentFileType
+				? agentInstructions.some(f => f.type === config.agentFileType)
+				: false;
+
+			if (hasPromptFiles || hasAgentFile) {
+				this._excludedByFiles.add(tip.id);
+			} else {
+				this._excludedByFiles.delete(tip.id);
+			}
 		} catch {
-			this._hasInstructionFiles = true;
+			if (this._fileCheckGeneration.get(tip.id) !== generation) {
+				return;
+			}
+			if (config.excludeUntilChecked) {
+				this._excludedByFiles.add(tip.id);
+			}
 		}
 	}
 
@@ -413,7 +591,11 @@ export class ChatTipService extends Disposable implements IChatTipService {
 			this._logService.debug('#ChatTips: tip is not eligible due to when clause', tip.id, tip.when.serialize());
 			return false;
 		}
-		return !this._tracker.isExcluded(tip);
+		if (this._tracker.isExcluded(tip)) {
+			return false;
+		}
+		this._logService.debug('#ChatTips: tip is eligible', tip.id);
+		return true;
 	}
 
 	private _isCopilotEnabled(): boolean {

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

@@ -1698,6 +1698,14 @@ export class ChatInputPart extends Disposable implements IHistoryNavigationWidge
 		}
 	}
 
+	/**
+	 * Shows the context usage details popup and focuses it.
+	 * @returns Whether the details were successfully shown.
+	 */
+	showContextUsageDetails(): boolean {
+		return this.contextUsageWidget?.showDetails() ?? false;
+	}
+
 	/**
 	 * Updates the context usage widget based on the current model.
 	 */