Merge pull request microsoft#292775 from microsoft/connor4312/queuing-polishes

chat: polishes for steering/queued messages

Author: connor4312

src/vs/platform/actions/browser/menuEntryActionViewItem.ts

@@ -427,6 +427,7 @@ export class DropdownWithDefaultActionViewItem extends BaseActionViewItem {
 	private readonly _dropdown: DropdownMenuActionViewItem;
 	private _container: HTMLElement | null = null;
 	private readonly _storageKey: string;
+	private readonly _primaryActionListener = this._register(new MutableDisposable());
 
 	get onDidChangeDropdownVisibility(): Event<boolean> {
 		return this._dropdown.onDidChangeVisibility;
@@ -468,14 +469,18 @@ export class DropdownWithDefaultActionViewItem extends BaseActionViewItem {
 
 		this._dropdown = this._register(new DropdownMenuActionViewItem(submenuAction, submenuAction.actions, this._contextMenuService, dropdownOptions));
 		if (options?.togglePrimaryAction) {
-			this._register(this._dropdown.actionRunner.onDidRun((e: IRunEvent) => {
-				if (e.action instanceof MenuItemAction) {
-					this.update(e.action);
-				}
-			}));
+			this.registerTogglePrimaryActionListener();
 		}
 	}
 
+	private registerTogglePrimaryActionListener(): void {
+		this._primaryActionListener.value = this._dropdown.actionRunner.onDidRun((e: IRunEvent) => {
+			if (e.action instanceof MenuItemAction) {
+				this.update(e.action);
+			}
+		});
+	}
+
 	private update(lastAction: MenuItemAction): void {
 		if (this._options?.togglePrimaryAction) {
 			this._storageService.store(this._storageKey, lastAction.id, StorageScope.WORKSPACE, StorageTarget.MACHINE);
@@ -516,6 +521,9 @@ export class DropdownWithDefaultActionViewItem extends BaseActionViewItem {
 
 		this._defaultAction.actionRunner = actionRunner;
 		this._dropdown.actionRunner = actionRunner;
+		if (this._primaryActionListener.value) {
+			this.registerTogglePrimaryActionListener();
+		}
 	}
 
 	override get actionRunner(): IActionRunner {

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

@@ -822,7 +822,8 @@ export class CancelAction extends Action2 {
 				id: MenuId.ChatExecute,
 				when: ContextKeyExpr.and(
 					ChatContextKeys.requestInProgress,
-					ChatContextKeys.remoteJobCreating.negate()
+					ChatContextKeys.remoteJobCreating.negate(),
+					ChatContextKeys.currentlyEditing.negate(),
 				),
 				order: 4,
 				group: 'navigation',

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

@@ -4,14 +4,17 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Codicon } from '../../../../../base/common/codicons.js';
+import { KeyCode, KeyMod } from '../../../../../base/common/keyCodes.js';
 import { URI } from '../../../../../base/common/uri.js';
-import { localize2 } from '../../../../../nls.js';
+import { localize, localize2 } from '../../../../../nls.js';
 import { Action2, MenuId, MenuRegistry, registerAction2 } from '../../../../../platform/actions/common/actions.js';
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { KeybindingWeight } from '../../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { ServicesAccessor } from '../../../../../editor/browser/editorExtensions.js';
 import { ChatContextKeys } from '../../common/actions/chatContextKeys.js';
 import { ChatRequestQueueKind, IChatService } from '../../common/chatService/chatService.js';
 import { ChatConfiguration } from '../../common/constants.js';
+import { isRequestVM } from '../../common/model/chatViewModel.js';
 import { IChatWidgetService } from '../chat.js';
 import { CHAT_CATEGORY } from './chatActions.js';
 
@@ -38,6 +41,7 @@ export class ChatQueueMessageAction extends Action2 {
 		super({
 			id: ChatQueueMessageAction.ID,
 			title: localize2('chat.queueMessage', "Add to Queue"),
+			tooltip: localize('chat.queueMessage.tooltip', "Queue this message to send after the current request completes"),
 			icon: Codicon.add,
 			f1: false,
 			category: CHAT_CATEGORY,
@@ -46,6 +50,15 @@ export class ChatQueueMessageAction extends Action2 {
 				ChatContextKeys.requestInProgress,
 				ChatContextKeys.inputHasText
 			),
+			keybinding: {
+				when: ContextKeyExpr.and(
+					ChatContextKeys.inChatInput,
+					ChatContextKeys.requestInProgress,
+					queueingEnabledCondition
+				),
+				primary: KeyCode.Enter,
+				weight: KeybindingWeight.EditorContrib + 1
+			},
 			menu: [{
 				id: MenuId.ChatExecuteQueue,
 				group: 'navigation',
@@ -77,6 +90,7 @@ export class ChatSteerWithMessageAction extends Action2 {
 		super({
 			id: ChatSteerWithMessageAction.ID,
 			title: localize2('chat.steerWithMessage', "Steer with Message"),
+			tooltip: localize('chat.steerWithMessage.tooltip', "Send this message at the next opportunity, signaling the current request to yield"),
 			icon: Codicon.arrowRight,
 			f1: false,
 			category: CHAT_CATEGORY,
@@ -85,6 +99,15 @@ export class ChatSteerWithMessageAction extends Action2 {
 				ChatContextKeys.requestInProgress,
 				ChatContextKeys.inputHasText
 			),
+			keybinding: {
+				when: ContextKeyExpr.and(
+					ChatContextKeys.inChatInput,
+					ChatContextKeys.requestInProgress,
+					queueingEnabledCondition
+				),
+				primary: KeyMod.Alt | KeyCode.Enter,
+				weight: KeybindingWeight.EditorContrib + 1
+			},
 			menu: [{
 				id: MenuId.ChatExecuteQueue,
 				group: 'navigation',
@@ -119,24 +142,140 @@ export class ChatRemovePendingRequestAction extends Action2 {
 			icon: Codicon.close,
 			f1: false,
 			category: CHAT_CATEGORY,
+			menu: [{
+				id: MenuId.ChatMessageTitle,
+				group: 'navigation',
+				order: 4,
+				when: ContextKeyExpr.and(
+					queueingEnabledCondition,
+					ChatContextKeys.isRequest,
+					ChatContextKeys.isPendingRequest
+				)
+			}]
+		});
+	}
+
+	override run(accessor: ServicesAccessor, ...args: unknown[]): void {
+		const chatService = accessor.get(IChatService);
+		const [context] = args;
+
+		// Support both toolbar context (IChatRequestViewModel) and command context (IChatRemovePendingRequestContext)
+		if (isRequestVM(context) && context.pendingKind) {
+			chatService.removePendingRequest(context.sessionResource, context.id);
+			return;
+		}
+
+		if (isRemovePendingRequestContext(context)) {
+			chatService.removePendingRequest(context.sessionResource, context.pendingRequestId);
+			return;
+		}
+	}
+}
+
+export class ChatSendPendingImmediatelyAction extends Action2 {
+	static readonly ID = 'workbench.action.chat.sendPendingImmediately';
+
+	constructor() {
+		super({
+			id: ChatSendPendingImmediatelyAction.ID,
+			title: localize2('chat.sendPendingImmediately', "Send Immediately"),
+			icon: Codicon.arrowUp,
+			f1: false,
+			category: CHAT_CATEGORY,
+			menu: [{
+				id: MenuId.ChatMessageTitle,
+				group: 'navigation',
+				order: 3,
+				when: ContextKeyExpr.and(
+					queueingEnabledCondition,
+					ChatContextKeys.isRequest,
+					ChatContextKeys.isPendingRequest
+				)
+			}]
 		});
 	}
 
 	override run(accessor: ServicesAccessor, ...args: unknown[]): void {
 		const chatService = accessor.get(IChatService);
+		const widgetService = accessor.get(IChatWidgetService);
 		const [context] = args;
-		if (!isRemovePendingRequestContext(context)) {
+
+		if (!isRequestVM(context) || !context.pendingKind) {
 			return;
 		}
 
-		chatService.removePendingRequest(context.sessionResource, context.pendingRequestId);
+		const widget = widgetService.getWidgetBySessionResource(context.sessionResource);
+		const model = widget?.viewModel?.model;
+		if (!model) {
+			return;
+		}
+
+		const pendingRequests = model.getPendingRequests();
+		const targetIndex = pendingRequests.findIndex(r => r.request.id === context.id);
+		if (targetIndex === -1) {
+			return;
+		}
+
+		// Keep the target item's kind (queued vs steering)
+		const targetRequest = pendingRequests[targetIndex];
+
+		// Reorder: move target to front, keep others in their relative order
+		const reordered = [
+			{ requestId: targetRequest.request.id, kind: targetRequest.kind },
+			...pendingRequests.filter((_, i) => i !== targetIndex).map(r => ({ requestId: r.request.id, kind: r.kind }))
+		];
+
+		chatService.setPendingRequests(context.sessionResource, reordered);
+		chatService.cancelCurrentRequestForSession(context.sessionResource);
+		chatService.processPendingRequests(context.sessionResource);
+	}
+}
+
+export class ChatRemoveAllPendingRequestsAction extends Action2 {
+	static readonly ID = 'workbench.action.chat.removeAllPendingRequests';
+
+	constructor() {
+		super({
+			id: ChatRemoveAllPendingRequestsAction.ID,
+			title: localize2('chat.removeAllPendingRequests', "Remove All Queued"),
+			icon: Codicon.clearAll,
+			f1: false,
+			category: CHAT_CATEGORY,
+			menu: [{
+				id: MenuId.ChatContext,
+				group: 'navigation',
+				order: 3,
+				when: ContextKeyExpr.and(
+					queueingEnabledCondition,
+					ChatContextKeys.hasPendingRequests
+				)
+			}]
+		});
+	}
+
+	override run(accessor: ServicesAccessor, ...args: unknown[]): void {
+		const chatService = accessor.get(IChatService);
+		const widgetService = accessor.get(IChatWidgetService);
+		const [context] = args;
+
+		const widget = (isRequestVM(context) && widgetService.getWidgetBySessionResource(context.sessionResource)) || widgetService.lastFocusedWidget;
+		const model = widget?.viewModel?.model;
+		if (!model) {
+			return;
+		}
+
+		for (const pendingRequest of [...model.getPendingRequests()]) {
+			chatService.removePendingRequest(model.sessionResource, pendingRequest.request.id);
+		}
 	}
 }
 
 export function registerChatQueueActions(): void {
 	registerAction2(ChatQueueMessageAction);
 	registerAction2(ChatSteerWithMessageAction);
 	registerAction2(ChatRemovePendingRequestAction);
+	registerAction2(ChatSendPendingImmediatelyAction);
+	registerAction2(ChatRemoveAllPendingRequestsAction);
 
 	// Register the queue submenu as a split button dropdown in the execute toolbar
 	// This shows "Add to Queue" / "Steer with Message" when a request is in progress and input has text
@@ -150,7 +289,7 @@ export function registerChatQueueActions(): void {
 			ChatContextKeys.inputHasText
 		),
 		group: 'navigation',
-		order: 3,
+		order: 4,
 		isSplitButton: { togglePrimaryAction: true }
 	});
 }

src/vs/workbench/contrib/chat/browser/widget/chatListRenderer.ts

@@ -648,6 +648,7 @@ export class ChatListItemRenderer extends Disposable implements ITreeRenderer<Ch
 		ChatContextKeys.isResponse.bindTo(templateData.contextKeyService).set(isResponseVM(element));
 		ChatContextKeys.itemId.bindTo(templateData.contextKeyService).set(element.id);
 		ChatContextKeys.isRequest.bindTo(templateData.contextKeyService).set(isRequestVM(element));
+		ChatContextKeys.isPendingRequest.bindTo(templateData.contextKeyService).set(isRequestVM(element) && !!element.pendingKind);
 		ChatContextKeys.responseDetectedAgentCommand.bindTo(templateData.contextKeyService).set(isResponseVM(element) && element.agentOrSlashCommandDetected);
 		if (isResponseVM(element)) {
 			ChatContextKeys.responseSupportsIssueReporting.bindTo(templateData.contextKeyService).set(!!element.agent?.metadata.supportIssueReporting);
@@ -698,11 +699,12 @@ export class ChatListItemRenderer extends Disposable implements ITreeRenderer<Ch
 		templateData.checkpointToolbar.context = element;
 		const checkpointEnabled = this.configService.getValue<boolean>(ChatConfiguration.CheckpointsEnabled)
 			&& (this.rendererOptions.restorable ?? true);
+		const isPendingRequest = isRequestVM(element) && !!element.pendingKind;
 
-		templateData.checkpointContainer.classList.toggle('hidden', isResponseVM(element) || !(checkpointEnabled));
+		templateData.checkpointContainer.classList.toggle('hidden', isResponseVM(element) || isPendingRequest || !(checkpointEnabled));
 
-		// Only show restore container when we have a checkpoint and not editing
-		const shouldShowRestore = this.viewModel?.model.checkpoint && !this.viewModel?.editing && (index === this.delegate.getListLength() - 1);
+		// Only show restore container when we have a checkpoint and not editing, and not a pending request
+		const shouldShowRestore = this.viewModel?.model.checkpoint && !this.viewModel?.editing && (index === this.delegate.getListLength() - 1) && !isPendingRequest;
 		templateData.checkpointRestoreContainer.classList.toggle('hidden', !(shouldShowRestore && checkpointEnabled));
 
 		const editing = element.id === this.viewModel?.editing?.id;