@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatExecuteActions.js

@@ -0,0 +1,650 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyCode, KeyMod } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { chatVariableLeader } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatModeKind, ChatAgentLocation, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { getEditingSessionContext } from '../chatEditing/chatEditingActions.js';
+import { ctxHasEditorModification } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys';
+import { CHAT_CATEGORY, handleModeSwitch, ACTION_ID_NEW_CHAT, handleCurrentEditingSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ContinueChatInSessionAction } from './chatContinueInAction.js';
+
+class SubmitAction extends Action2 {
+    async run(accessor, ...args) {
+        const context = args[0];
+        const telemetryService = accessor.get(ITelemetryService);
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        if (widget?.viewModel?.editing) {
+            const configurationService = accessor.get(IConfigurationService);
+            const dialogService = accessor.get(IDialogService);
+            const chatService = accessor.get(IChatService);
+            const chatModel = chatService.getSession(widget.viewModel.sessionResource);
+            if (!chatModel) {
+                return;
+            }
+            const session = chatModel.editingSession;
+            if (!session) {
+                return;
+            }
+            const requestId = widget.viewModel?.editing.id;
+            if (requestId) {
+                const chatRequests = chatModel.getRequests();
+                const itemIndex = chatRequests.findIndex(request => request.id === requestId);
+                const editsToUndo = chatRequests.length - itemIndex;
+                const requestsToRemove = chatRequests.slice(itemIndex);
+                const requestIdsToRemove = ( new Set(( requestsToRemove.map(request => request.id))));
+                const entriesModifiedInRequestsToRemove = session.entries.get().filter((entry) => ( requestIdsToRemove.has(entry.lastModifyingRequestId))) ?? [];
+                const shouldPrompt = entriesModifiedInRequestsToRemove.length > 0 && configurationService.getValue('chat.editing.confirmEditRequestRemoval') === true;
+                let message;
+                if (editsToUndo === 1) {
+                    if (entriesModifiedInRequestsToRemove.length === 1) {
+                        message = ( localize(
+                            4709,
+                            "This will remove your last request and undo the edits made to {0}. Do you want to proceed?",
+                            basename(entriesModifiedInRequestsToRemove[0].modifiedURI)
+                        ));
+                    }
+                    else {
+                        message = ( localize(
+                            4710,
+                            "This will remove your last request and undo edits made to {0} files in your working set. Do you want to proceed?",
+                            entriesModifiedInRequestsToRemove.length
+                        ));
+                    }
+                }
+                else {
+                    if (entriesModifiedInRequestsToRemove.length === 1) {
+                        message = ( localize(
+                            4711,
+                            "This will remove all subsequent requests and undo edits made to {0}. Do you want to proceed?",
+                            basename(entriesModifiedInRequestsToRemove[0].modifiedURI)
+                        ));
+                    }
+                    else {
+                        message = ( localize(
+                            4712,
+                            "This will remove all subsequent requests and undo edits made to {0} files in your working set. Do you want to proceed?",
+                            entriesModifiedInRequestsToRemove.length
+                        ));
+                    }
+                }
+                const confirmation = shouldPrompt
+                    ? await dialogService.confirm({
+                        title: editsToUndo === 1
+                            ? ( localize(4713, "Do you want to undo your last edit?"))
+                            : ( localize(4714, "Do you want to undo {0} edits?", editsToUndo)),
+                        message: message,
+                        primaryButton: ( localize(4715, "Yes")),
+                        checkbox: { label: ( localize(4716, "Don't ask again")), checked: false },
+                        type: 'info'
+                    })
+                    : { confirmed: true };
+                if (!confirmation.confirmed) {
+                    telemetryService.publicLog2('chat.undoEditsConfirmation', {
+                        editRequestType: configurationService.getValue('chat.editRequests'),
+                        outcome: 'cancelled',
+                        editsUndoCount: editsToUndo
+                    });
+                    return;
+                }
+                else if (editsToUndo > 0) {
+                    telemetryService.publicLog2('chat.undoEditsConfirmation', {
+                        editRequestType: configurationService.getValue('chat.editRequests'),
+                        outcome: 'applied',
+                        editsUndoCount: editsToUndo
+                    });
+                }
+                if (confirmation.checkboxChecked) {
+                    await configurationService.updateValue('chat.editing.confirmEditRequestRemoval', false);
+                }
+                const snapshotRequestId = chatRequests[itemIndex].id;
+                await session.restoreSnapshot(snapshotRequestId, undefined);
+            }
+        }
+        else if (widget?.viewModel?.model.checkpoint) {
+            widget.viewModel.model.setCheckpoint(undefined);
+        }
+        widget?.acceptInput(context?.inputValue);
+    }
+}
+const whenNotInProgress = ( ChatContextKeys.requestInProgress.negate());
+class ChatSubmitAction extends SubmitAction {
+    static { this.ID = 'workbench.action.chat.submit'; }
+    constructor() {
+        const menuCondition = ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Ask));
+        const precondition = ( ContextKeyExpr.and(ChatContextKeys.inputHasText, whenNotInProgress));
+        super({
+            id: ChatSubmitAction.ID,
+            title: ( localize2(4717, "Send")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.send,
+            precondition,
+            toggled: {
+                condition: ChatContextKeys.lockedToCodingAgent,
+                icon: Codicon.send,
+                tooltip: ( localize(4718, "Send to Agent")),
+            },
+            keybinding: {
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatInput, ( ChatContextKeys.withinEditSessionDiff.negate()))),
+                primary: KeyCode.Enter,
+                weight: KeybindingWeight.EditorContrib
+            },
+            menu: [
+                {
+                    id: MenuId.ChatExecute,
+                    order: 4,
+                    when: ( ContextKeyExpr.and(whenNotInProgress, menuCondition, ( ChatContextKeys.withinEditSessionDiff.negate()))),
+                    group: 'navigation',
+                    alt: {
+                        id: 'workbench.action.chat.sendToNewChat',
+                        title: ( localize2(4719, "Send to New Chat")),
+                        icon: Codicon.plus
+                    }
+                }, {
+                    id: MenuId.ChatEditorInlineExecute,
+                    group: 'navigation',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.or(( ctxHasEditorModification.negate()), ChatContextKeys.inputHasText)), whenNotInProgress, ( ChatContextKeys.requestInProgress.negate()), menuCondition)),
+                }
+            ]
+        });
+    }
+}
+class ChatDelegateToEditSessionAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.delegateToEditSession'; }
+    constructor() {
+        super({
+            id: ChatDelegateToEditSessionAction.ID,
+            title: ( localize2(4720, "Send to Edit Session")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.commentDiscussion,
+            keybinding: {
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatInput, ChatContextKeys.withinEditSessionDiff)),
+                primary: KeyCode.Enter,
+                weight: KeybindingWeight.EditorContrib
+            },
+            menu: [
+                {
+                    id: MenuId.ChatExecute,
+                    order: 4,
+                    when: ( ContextKeyExpr.and(whenNotInProgress, ChatContextKeys.withinEditSessionDiff)),
+                    group: 'navigation',
+                }
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const inlineWidget = context?.widget ?? widgetService.lastFocusedWidget;
+        const locationData = inlineWidget?.locationData;
+        if (inlineWidget && locationData?.type === ChatAgentLocation.EditorInline && locationData.delegateSessionResource) {
+            const sessionWidget = widgetService.getWidgetBySessionResource(locationData.delegateSessionResource);
+            if (sessionWidget) {
+                await widgetService.reveal(sessionWidget);
+                sessionWidget.attachmentModel.addContext({
+                    id: 'vscode.delegate.inline',
+                    kind: 'file',
+                    modelDescription: `User's chat context`,
+                    name: 'delegate-inline',
+                    value: { range: locationData.wholeRange, uri: locationData.document },
+                });
+                sessionWidget.acceptInput(inlineWidget.getInput(), {
+                    noCommandDetection: true,
+                    enableImplicitContext: false,
+                });
+                inlineWidget.setInput('');
+                locationData.close();
+            }
+        }
+    }
+}
+const ToggleAgentModeActionId = 'workbench.action.chat.toggleAgentMode';
+class ToggleChatModeAction extends Action2 {
+    static { this.ID = ToggleAgentModeActionId; }
+    constructor() {
+        super({
+            id: ToggleChatModeAction.ID,
+            title: ( localize2(4721, "Switch to Next Agent")),
+            f1: true,
+            category: CHAT_CATEGORY,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.requestInProgress.negate())))
+        });
+    }
+    async run(accessor, ...args) {
+        const commandService = accessor.get(ICommandService);
+        const configurationService = accessor.get(IConfigurationService);
+        const instaService = accessor.get(IInstantiationService);
+        const modeService = accessor.get(IChatModeService);
+        const telemetryService = accessor.get(ITelemetryService);
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const arg = args.at(0);
+        let widget;
+        if (arg?.sessionResource) {
+            widget = chatWidgetService.getWidgetBySessionResource(arg.sessionResource);
+        }
+        else {
+            widget = getEditingSessionContext(accessor, args)?.chatWidget;
+        }
+        if (!widget) {
+            return;
+        }
+        const chatSession = widget.viewModel?.model;
+        const requestCount = chatSession?.getRequests().length ?? 0;
+        const switchToMode = (arg && modeService.findModeById(arg.modeId)) ?? this.getNextMode(widget, requestCount, configurationService, modeService);
+        const currentMode = widget.input.currentModeObs.get();
+        if (switchToMode.id === currentMode.id) {
+            return;
+        }
+        const chatModeCheck = await instaService.invokeFunction(handleModeSwitch, widget.input.currentModeKind, switchToMode.kind, requestCount, widget.viewModel?.model);
+        if (!chatModeCheck) {
+            return;
+        }
+        const storage = switchToMode.source?.storage ?? 'builtin';
+        const extensionId = switchToMode.source?.storage === 'extension' ? switchToMode.source.extensionId.value : undefined;
+        const toolsCount = switchToMode.customTools?.get()?.length ?? 0;
+        const handoffsCount = switchToMode.handOffs?.get()?.length ?? 0;
+        telemetryService.publicLog2('chat.modeChange', {
+            fromMode: currentMode.name.get(),
+            mode: switchToMode.name.get(),
+            requestCount: requestCount,
+            storage,
+            extensionId,
+            toolsCount,
+            handoffsCount
+        });
+        widget.input.setChatMode(switchToMode.id);
+        if (chatModeCheck.needToClearSession) {
+            await commandService.executeCommand(ACTION_ID_NEW_CHAT);
+        }
+    }
+    getNextMode(chatWidget, requestCount, configurationService, modeService) {
+        const modes = modeService.getModes();
+        const flat = [
+            ...modes.builtin.filter(mode => {
+                return mode.kind !== ChatModeKind.Edit || configurationService.getValue(ChatConfiguration.Edits2Enabled) || requestCount === 0;
+            }),
+            ...(modes.custom ?? []),
+        ];
+        const curModeIndex = flat.findIndex(mode => mode.id === chatWidget.input.currentModeObs.get().id);
+        const newMode = flat[(curModeIndex + 1) % flat.length];
+        return newMode;
+    }
+}
+class SwitchToNextModelAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.switchToNextModel'; }
+    constructor() {
+        super({
+            id: SwitchToNextModelAction.ID,
+            title: ( localize2(4722, "Switch to Next Model")),
+            category: CHAT_CATEGORY,
+            f1: true,
+            precondition: ChatContextKeys.enabled,
+        });
+    }
+    run(accessor, ...args) {
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = widgetService.lastFocusedWidget;
+        widget?.input.switchToNextModel();
+    }
+}
+const ChatOpenModelPickerActionId = 'workbench.action.chat.openModelPicker';
+class OpenModelPickerAction extends Action2 {
+    static { this.ID = ChatOpenModelPickerActionId; }
+    constructor() {
+        super({
+            id: OpenModelPickerAction.ID,
+            title: ( localize2(4723, "Open Model Picker")),
+            category: CHAT_CATEGORY,
+            f1: false,
+            keybinding: {
+                primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.Period,
+                weight: KeybindingWeight.WorkbenchContrib,
+                when: ChatContextKeys.inChatInput
+            },
+            precondition: ChatContextKeys.enabled,
+            menu: {
+                id: MenuId.ChatInput,
+                order: 3,
+                group: 'navigation',
+                when: ( ContextKeyExpr.and(( ChatContextKeys.lockedToCodingAgent.negate()), ( ContextKeyExpr.or(( ContextKeyExpr.equals(ChatContextKeys.location.key, ChatAgentLocation.Chat)), ( ContextKeyExpr.equals(ChatContextKeys.location.key, ChatAgentLocation.EditorInline)), ( ContextKeyExpr.equals(ChatContextKeys.location.key, ChatAgentLocation.Notebook)), ( ContextKeyExpr.equals(ChatContextKeys.location.key, ChatAgentLocation.Terminal))))))
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = widgetService.lastFocusedWidget;
+        if (widget) {
+            await widgetService.reveal(widget);
+            widget.input.openModelPicker();
+        }
+    }
+}
+class OpenModePickerAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.openModePicker'; }
+    constructor() {
+        super({
+            id: OpenModePickerAction.ID,
+            title: ( localize2(4724, "Open Agent Picker")),
+            tooltip: ( localize(4725, "Set Agent")),
+            category: CHAT_CATEGORY,
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+            keybinding: {
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatInput, ( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Chat)))),
+                primary: KeyMod.CtrlCmd | KeyCode.Period,
+                weight: KeybindingWeight.EditorContrib
+            },
+            menu: [
+                {
+                    id: MenuId.ChatInput,
+                    order: 1,
+                    when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Chat)), ( ChatContextKeys.inQuickChat.negate()), ( ChatContextKeys.lockedToCodingAgent.negate()))),
+                    group: 'navigation',
+                },
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = widgetService.lastFocusedWidget;
+        if (widget) {
+            widget.input.openModePicker();
+        }
+    }
+}
+class ChatSessionPrimaryPickerAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.chatSessionPrimaryPicker'; }
+    constructor() {
+        super({
+            id: ChatSessionPrimaryPickerAction.ID,
+            title: ( localize2(4726, "Open Picker")),
+            category: CHAT_CATEGORY,
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+            menu: {
+                id: MenuId.ChatInput,
+                order: 4,
+                group: 'navigation',
+                when: ( ContextKeyExpr.and(ChatContextKeys.lockedToCodingAgent, ChatContextKeys.chatSessionHasModels))
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = widgetService.lastFocusedWidget;
+        if (widget) {
+            widget.input.openChatSessionPicker();
+        }
+    }
+}
+const ChangeChatModelActionId = 'workbench.action.chat.changeModel';
+class ChangeChatModelAction extends Action2 {
+    static { this.ID = ChangeChatModelActionId; }
+    constructor() {
+        super({
+            id: ChangeChatModelAction.ID,
+            title: ( localize2(4727, "Change Model")),
+            category: CHAT_CATEGORY,
+            f1: false,
+            precondition: ChatContextKeys.enabled,
+        });
+    }
+    run(accessor, ...args) {
+        const modelInfo = args[0];
+        assertType(typeof modelInfo.vendor === 'string' && typeof modelInfo.id === 'string' && typeof modelInfo.family === 'string');
+        const widgetService = accessor.get(IChatWidgetService);
+        const widgets = widgetService.getAllWidgets();
+        for (const widget of widgets) {
+            widget.input.switchModel(modelInfo);
+        }
+    }
+}
+class ChatEditingSessionSubmitAction extends SubmitAction {
+    static { this.ID = 'workbench.action.edits.submit'; }
+    constructor() {
+        const menuCondition = ( ChatContextKeys.chatModeKind.notEqualsTo(ChatModeKind.Ask));
+        const precondition = ( ContextKeyExpr.and(ChatContextKeys.inputHasText, whenNotInProgress));
+        super({
+            id: ChatEditingSessionSubmitAction.ID,
+            title: ( localize2(4728, "Send")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.send,
+            precondition,
+            menu: [
+                {
+                    id: MenuId.ChatExecute,
+                    order: 4,
+                    when: ( ContextKeyExpr.and(( ChatContextKeys.requestInProgress.negate()), menuCondition)),
+                    group: 'navigation',
+                    alt: {
+                        id: 'workbench.action.chat.sendToNewChat',
+                        title: ( localize2(4719, "Send to New Chat")),
+                        icon: Codicon.plus
+                    }
+                }
+            ]
+        });
+    }
+}
+class SubmitWithoutDispatchingAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.submitWithoutDispatching'; }
+    constructor() {
+        const precondition = ( ContextKeyExpr.and(ChatContextKeys.inputHasText, whenNotInProgress, ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Ask))));
+        super({
+            id: SubmitWithoutDispatchingAction.ID,
+            title: ( localize2(4729, "Send")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            precondition,
+            keybinding: {
+                when: ChatContextKeys.inChatInput,
+                primary: KeyMod.Alt | KeyMod.Shift | KeyCode.Enter,
+                weight: KeybindingWeight.EditorContrib
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        widget?.acceptInput(context?.inputValue, { noCommandDetection: true });
+    }
+}
+class ChatSubmitWithCodebaseAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.submitWithCodebase'; }
+    constructor() {
+        const precondition = ( ContextKeyExpr.and(ChatContextKeys.inputHasText, whenNotInProgress));
+        super({
+            id: ChatSubmitWithCodebaseAction.ID,
+            title: ( localize2(4730, "Send with {0}", `${chatVariableLeader}codebase`)),
+            precondition,
+            keybinding: {
+                when: ChatContextKeys.inChatInput,
+                primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                weight: KeybindingWeight.EditorContrib
+            },
+        });
+    }
+    run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        const languageModelToolsService = accessor.get(ILanguageModelToolsService);
+        const codebaseTool = languageModelToolsService.getToolByName('codebase');
+        if (!codebaseTool) {
+            return;
+        }
+        widget.input.attachmentModel.addContext({
+            id: codebaseTool.id,
+            name: codebaseTool.displayName ?? '',
+            fullName: codebaseTool.displayName ?? '',
+            value: undefined,
+            icon: ThemeIcon.isThemeIcon(codebaseTool.icon) ? codebaseTool.icon : undefined,
+            kind: 'tool'
+        });
+        widget.acceptInput();
+    }
+}
+class SendToNewChatAction extends Action2 {
+    constructor() {
+        const precondition = ChatContextKeys.inputHasText;
+        super({
+            id: 'workbench.action.chat.sendToNewChat',
+            title: ( localize2(4719, "Send to New Chat")),
+            precondition,
+            category: CHAT_CATEGORY,
+            f1: false,
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Enter,
+                when: ChatContextKeys.inChatInput,
+            }
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const dialogService = accessor.get(IDialogService);
+        const chatService = accessor.get(IChatService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        const inputBeforeClear = widget.getInput();
+        if (widget.viewModel) {
+            chatService.cancelCurrentRequestForSession(widget.viewModel.sessionResource);
+        }
+        if (widget.viewModel?.model) {
+            if (!(await handleCurrentEditingSession(widget.viewModel.model, undefined, dialogService))) {
+                return;
+            }
+        }
+        await widget.clear();
+        widget.acceptInput(inputBeforeClear);
+    }
+}
+const CancelChatActionId = 'workbench.action.chat.cancel';
+class CancelAction extends Action2 {
+    static { this.ID = CancelChatActionId; }
+    constructor() {
+        super({
+            id: CancelAction.ID,
+            title: ( localize2(4731, "Cancel")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.stopCircle,
+            menu: [{
+                    id: MenuId.ChatExecute,
+                    when: ( ContextKeyExpr.and(ChatContextKeys.requestInProgress, ( ChatContextKeys.remoteJobCreating.negate()))),
+                    order: 4,
+                    group: 'navigation',
+                }, {
+                    id: MenuId.ChatEditorInlineExecute,
+                    when: ( ContextKeyExpr.and(ChatContextKeys.requestInProgress, ( ChatContextKeys.remoteJobCreating.negate()))),
+                    order: 4,
+                    group: 'navigation',
+                },
+            ],
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.Escape,
+                win: { primary: KeyMod.Alt | KeyCode.Backspace },
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        const chatService = accessor.get(IChatService);
+        if (widget.viewModel) {
+            chatService.cancelCurrentRequestForSession(widget.viewModel.sessionResource);
+        }
+    }
+}
+const CancelChatEditId = 'workbench.edit.chat.cancel';
+class CancelEdit extends Action2 {
+    static { this.ID = CancelChatEditId; }
+    constructor() {
+        super({
+            id: CancelEdit.ID,
+            title: ( localize2(4732, "Cancel Edit")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.x,
+            menu: [
+                {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(
+                        ChatContextKeys.isRequest,
+                        ChatContextKeys.currentlyEditing,
+                        ( ContextKeyExpr.equals(`config.${ChatConfiguration.EditRequests}`, 'input'))
+                    ))
+                }
+            ],
+            keybinding: {
+                primary: KeyCode.Escape,
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatInput, ( EditorContextKeys.hoverVisible.toNegated()), ( EditorContextKeys.hasNonEmptySelection.toNegated()), ( EditorContextKeys.hasMultipleSelections.toNegated()), ( ContextKeyExpr.or(ChatContextKeys.currentlyEditing, ChatContextKeys.currentlyEditingInput)))),
+                weight: KeybindingWeight.EditorContrib - 5
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const context = args[0];
+        const widgetService = accessor.get(IChatWidgetService);
+        const widget = context?.widget ?? widgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        widget.finishedEditing();
+    }
+}
+function registerChatExecuteActions() {
+    registerAction2(ChatSubmitAction);
+    registerAction2(ChatDelegateToEditSessionAction);
+    registerAction2(ChatEditingSessionSubmitAction);
+    registerAction2(SubmitWithoutDispatchingAction);
+    registerAction2(CancelAction);
+    registerAction2(SendToNewChatAction);
+    registerAction2(ChatSubmitWithCodebaseAction);
+    registerAction2(ContinueChatInSessionAction);
+    registerAction2(ToggleChatModeAction);
+    registerAction2(SwitchToNextModelAction);
+    registerAction2(OpenModelPickerAction);
+    registerAction2(OpenModePickerAction);
+    registerAction2(ChatSessionPrimaryPickerAction);
+    registerAction2(ChangeChatModelAction);
+    registerAction2(CancelEdit);
+}
+
+export { CancelAction, CancelChatActionId, CancelChatEditId, CancelEdit, ChangeChatModelActionId, ChatDelegateToEditSessionAction, ChatEditingSessionSubmitAction, ChatOpenModelPickerActionId, ChatSessionPrimaryPickerAction, ChatSubmitAction, ChatSubmitWithCodebaseAction, OpenModePickerAction, ToggleAgentModeActionId, registerChatExecuteActions };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatTitleActions.d.ts

@@ -0,0 +1,2 @@
+export declare const MarkUnhelpfulActionId = "workbench.action.chat.markUnhelpful";
+export declare function registerChatTitleActions(): void;