@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatActions.js

@@ -0,0 +1,667 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { isCodeEditor, isDiffEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { EditorAction2 } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { EmbeddedDiffEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/diffEditor/embeddedDiffEditorWidget';
+import { EmbeddedCodeEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/embeddedCodeEditorWidget';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { InlineChatController, InlineChatRunOptions, InlineChatController1, InlineChatController2 } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { ACTION_ACCEPT_CHANGES, CTX_INLINE_CHAT_HAS_AGENT, CTX_INLINE_CHAT_HAS_AGENT2, CTX_INLINE_CHAT_POSSIBLE, ACTION_START, CTX_INLINE_CHAT_OUTER_CURSOR_POSITION, CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_HAS_STASHED_SESSION, CTX_INLINE_CHAT_INNER_CURSOR_FIRST, CTX_INLINE_CHAT_INNER_CURSOR_LAST, MENU_INLINE_CHAT_WIDGET_STATUS, MENU_INLINE_CHAT_ZONE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_RESPONSE_TYPE, InlineChatResponseType, ACTION_DISCARD_CHANGES, ACTION_REGENERATE_RESPONSE, MENU_INLINE_CHAT_SIDE, ACTION_VIEW_IN_CHAT, CTX_INLINE_CHAT_CHANGE_HAS_DIFF, CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF, ACTION_TOGGLE_DIFF } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { ctxRequestCount, ctxHasEditorModification, ctxHasRequestInProgress, ctxIsGlobalEditingSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { CONTEXT_ACCESSIBILITY_MODE_ENABLED } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { IPreferencesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/preferences/common/preferences.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
+
+CommandsRegistry.registerCommandAlias('interactiveEditor.start', 'inlineChat.start');
+CommandsRegistry.registerCommandAlias('interactive.acceptChanges', ACTION_ACCEPT_CHANGES);
+const START_INLINE_CHAT = registerIcon('start-inline-chat', Codicon.sparkle, ( localize(7653, 'Icon which spawns the inline chat from the editor toolbar.')));
+class StartSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: ACTION_START,
+            title: ( localize2(7654, 'Editor Inline Chat')),
+            category: AbstractInline1ChatAction.category,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.or(CTX_INLINE_CHAT_HAS_AGENT, CTX_INLINE_CHAT_HAS_AGENT2)), CTX_INLINE_CHAT_POSSIBLE, EditorContextKeys.writable, ( EditorContextKeys.editorSimpleInput.negate()))),
+            keybinding: {
+                when: EditorContextKeys.focus,
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyI
+            },
+            icon: START_INLINE_CHAT,
+            menu: [{
+                    id: MenuId.ChatTitleBarMenu,
+                    group: 'a_open',
+                    order: 3,
+                }, {
+                    id: MenuId.ChatTextEditorMenu,
+                    group: 'a_open',
+                    order: 1
+                }]
+        });
+    }
+    run(accessor, ...args) {
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const editor = codeEditorService.getActiveCodeEditor();
+        if (!editor || editor.isSimpleWidget) {
+            return;
+        }
+        return editor.invokeWithinContext((editorAccessor) => {
+            const kbService = editorAccessor.get(IContextKeyService);
+            const logService = editorAccessor.get(ILogService);
+            const enabled = kbService.contextMatchesRules(this.desc.precondition ?? undefined);
+            if (!enabled) {
+                logService.debug(`[EditorAction2] NOT running command because its precondition is FALSE`, this.desc.id, this.desc.precondition?.serialize());
+                return;
+            }
+            return this._runEditorCommand(editorAccessor, editor, ...args);
+        });
+    }
+    _runEditorCommand(accessor, editor, ..._args) {
+        const ctrl = InlineChatController.get(editor);
+        if (!ctrl) {
+            return;
+        }
+        let options;
+        const arg = _args[0];
+        if (arg && InlineChatRunOptions.isInlineChatRunOptions(arg)) {
+            options = arg;
+        }
+        InlineChatController.get(editor)?.run({ ...options });
+    }
+}
+class FocusInlineChat extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlineChat.focus',
+            title: ( localize2(7655, "Focus Input")),
+            f1: true,
+            category: AbstractInline1ChatAction.category,
+            precondition: ( ContextKeyExpr.and(EditorContextKeys.editorTextFocus, CTX_INLINE_CHAT_VISIBLE, ( CTX_INLINE_CHAT_FOCUSED.negate()), ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+            keybinding: [{
+                    weight: KeybindingWeight.EditorCore + 10,
+                    when: ( ContextKeyExpr.and(( CTX_INLINE_CHAT_OUTER_CURSOR_POSITION.isEqualTo('above')), ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: KeyMod.CtrlCmd | KeyCode.DownArrow,
+                }, {
+                    weight: KeybindingWeight.EditorCore + 10,
+                    when: ( ContextKeyExpr.and(( CTX_INLINE_CHAT_OUTER_CURSOR_POSITION.isEqualTo('below')), ( EditorContextKeys.isEmbeddedDiffEditor.negate()))),
+                    primary: KeyMod.CtrlCmd | KeyCode.UpArrow,
+                }]
+        });
+    }
+    runEditorCommand(_accessor, editor, ..._args) {
+        InlineChatController.get(editor)?.focus();
+    }
+}
+class UnstashSessionAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'inlineChat.unstash',
+            title: ( localize2(7656, "Resume Last Dismissed Inline Chat")),
+            category: AbstractInline1ChatAction.category,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_STASHED_SESSION, EditorContextKeys.writable)),
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyZ,
+            }
+        });
+    }
+    async runEditorCommand(_accessor, editor, ..._args) {
+        const ctrl = InlineChatController1.get(editor);
+        if (ctrl) {
+            const session = ctrl.unstashLastSession();
+            if (session) {
+                ctrl.run({
+                    existingSession: session,
+                });
+            }
+        }
+    }
+}
+class AbstractInline1ChatAction extends EditorAction2 {
+    static { this.category = ( localize2(7657, "Inline Chat")); }
+    constructor(desc) {
+        const massageMenu = (menu) => {
+            if (Array.isArray(menu)) {
+                for (const entry of menu) {
+                    entry.when = ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT, entry.when));
+                }
+            }
+            else if (menu) {
+                menu.when = ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT, menu.when));
+            }
+        };
+        if (Array.isArray(desc.menu)) {
+            massageMenu(desc.menu);
+        }
+        else {
+            massageMenu(desc.menu);
+        }
+        super({
+            ...desc,
+            category: AbstractInline1ChatAction.category,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT, desc.precondition))
+        });
+    }
+    runEditorCommand(accessor, editor, ..._args) {
+        const editorService = accessor.get(IEditorService);
+        const logService = accessor.get(ILogService);
+        let ctrl = InlineChatController1.get(editor);
+        if (!ctrl) {
+            const { activeTextEditorControl } = editorService;
+            if (isCodeEditor(activeTextEditorControl)) {
+                editor = activeTextEditorControl;
+            }
+            else if (isDiffEditor(activeTextEditorControl)) {
+                editor = activeTextEditorControl.getModifiedEditor();
+            }
+            ctrl = InlineChatController1.get(editor);
+        }
+        if (!ctrl) {
+            logService.warn('[IE] NO controller found for action', this.desc.id, editor.getModel()?.uri);
+            return;
+        }
+        if (editor instanceof EmbeddedCodeEditorWidget) {
+            editor = editor.getParentEditor();
+        }
+        if (!ctrl) {
+            for (const diffEditor of accessor.get(ICodeEditorService).listDiffEditors()) {
+                if (diffEditor.getOriginalEditor() === editor || diffEditor.getModifiedEditor() === editor) {
+                    if (diffEditor instanceof EmbeddedDiffEditorWidget) {
+                        this.runEditorCommand(accessor, diffEditor.getParentEditor(), ..._args);
+                    }
+                }
+            }
+            return;
+        }
+        this.runInlineChatCommand(accessor, ctrl, editor, ..._args);
+    }
+}
+class ArrowOutUpAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat.arrowOutUp',
+            title: ( localize(7658, 'Cursor Up')),
+            precondition: ( ContextKeyExpr.and(
+                CTX_INLINE_CHAT_FOCUSED,
+                CTX_INLINE_CHAT_INNER_CURSOR_FIRST,
+                ( EditorContextKeys.isEmbeddedDiffEditor.negate()),
+                ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate())
+            )),
+            keybinding: {
+                weight: KeybindingWeight.EditorCore,
+                primary: KeyMod.CtrlCmd | KeyCode.UpArrow
+            }
+        });
+    }
+    runInlineChatCommand(_accessor, ctrl, _editor, ..._args) {
+        ctrl.arrowOut(true);
+    }
+}
+class ArrowOutDownAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat.arrowOutDown',
+            title: ( localize(7659, 'Cursor Down')),
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, ( EditorContextKeys.isEmbeddedDiffEditor.negate()), ( CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate()))),
+            keybinding: {
+                weight: KeybindingWeight.EditorCore,
+                primary: KeyMod.CtrlCmd | KeyCode.DownArrow
+            }
+        });
+    }
+    runInlineChatCommand(_accessor, ctrl, _editor, ..._args) {
+        ctrl.arrowOut(false);
+    }
+}
+class AcceptChanges extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: ACTION_ACCEPT_CHANGES,
+            title: ( localize2(7660, "Accept Changes")),
+            shortTitle: ( localize(7661, 'Accept')),
+            icon: Codicon.check,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_VISIBLE)),
+            keybinding: [{
+                    weight: KeybindingWeight.WorkbenchContrib + 10,
+                    primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                }],
+            menu: [{
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: '0_main',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(( ChatContextKeys.inputHasText.toNegated()), ( CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.toNegated()), ( CTX_INLINE_CHAT_RESPONSE_TYPE.isEqualTo(InlineChatResponseType.MessagesAndEdits)))),
+                }, {
+                    id: MENU_INLINE_CHAT_ZONE,
+                    group: 'navigation',
+                    order: 1,
+                }]
+        });
+    }
+    async runInlineChatCommand(_accessor, ctrl, _editor, hunk) {
+        ctrl.acceptHunk(hunk);
+    }
+}
+class DiscardHunkAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: ACTION_DISCARD_CHANGES,
+            title: ( localize(7662, 'Discard')),
+            icon: Codicon.chromeClose,
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            menu: [{
+                    id: MENU_INLINE_CHAT_ZONE,
+                    group: 'navigation',
+                    order: 2
+                }],
+            keybinding: {
+                weight: KeybindingWeight.EditorContrib,
+                primary: KeyCode.Escape,
+                when: ( CTX_INLINE_CHAT_RESPONSE_TYPE.isEqualTo(InlineChatResponseType.MessagesAndEdits))
+            }
+        });
+    }
+    async runInlineChatCommand(_accessor, ctrl, _editor, hunk) {
+        return ctrl.discardHunk(hunk);
+    }
+}
+class RerunAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: ACTION_REGENERATE_RESPONSE,
+            title: ( localize2(7663, "Rerun Request")),
+            shortTitle: ( localize(7664, 'Rerun')),
+            f1: false,
+            icon: Codicon.refresh,
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            menu: {
+                id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                group: '0_main',
+                order: 5,
+                when: ( ContextKeyExpr.and(( ChatContextKeys.inputHasText.toNegated()), ( CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.negate()), ( CTX_INLINE_CHAT_RESPONSE_TYPE.notEqualsTo(InlineChatResponseType.None))))
+            },
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyR
+            }
+        });
+    }
+    async runInlineChatCommand(accessor, ctrl, _editor, ..._args) {
+        const chatService = accessor.get(IChatService);
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const model = ctrl.chatWidget.viewModel?.model;
+        if (!model) {
+            return;
+        }
+        const lastRequest = model.getRequests().at(-1);
+        if (lastRequest) {
+            const widget = chatWidgetService.getWidgetBySessionId(model.sessionId);
+            await chatService.resendRequest(lastRequest, {
+                noCommandDetection: false,
+                attempt: lastRequest.attempt + 1,
+                location: ctrl.chatWidget.location,
+                userSelectedModelId: widget?.input.currentLanguageModel
+            });
+        }
+    }
+}
+class CloseAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat.close',
+            title: ( localize(7665, 'Close')),
+            icon: Codicon.close,
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            keybinding: {
+                weight: KeybindingWeight.EditorContrib + 1,
+                primary: KeyCode.Escape,
+            },
+            menu: [{
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: '0_main',
+                    order: 1,
+                    when: ( CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.negate())
+                }, {
+                    id: MENU_INLINE_CHAT_SIDE,
+                    group: 'navigation',
+                    when: ( CTX_INLINE_CHAT_RESPONSE_TYPE.isEqualTo(InlineChatResponseType.None))
+                }]
+        });
+    }
+    async runInlineChatCommand(_accessor, ctrl, _editor, ..._args) {
+        ctrl.cancelSession();
+    }
+}
+class ConfigureInlineChatAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat.configure',
+            title: ( localize2(7666, 'Configure Inline Chat')),
+            icon: Codicon.settingsGear,
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            f1: true,
+            menu: {
+                id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                group: 'zzz',
+                order: 5
+            }
+        });
+    }
+    async runInlineChatCommand(accessor, ctrl, _editor, ..._args) {
+        accessor.get(IPreferencesService).openSettings({ query: 'inlineChat' });
+    }
+}
+class MoveToNextHunk extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat.moveToNextHunk',
+            title: ( localize2(7667, 'Move to Next Change')),
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            f1: true,
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyCode.F7
+            }
+        });
+    }
+    runInlineChatCommand(accessor, ctrl, editor, ...args) {
+        ctrl.moveHunk(true);
+    }
+}
+class MoveToPreviousHunk extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat.moveToPreviousHunk',
+            title: ( localize2(7668, 'Move to Previous Change')),
+            f1: true,
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.Shift | KeyCode.F7
+            }
+        });
+    }
+    runInlineChatCommand(accessor, ctrl, editor, ...args) {
+        ctrl.moveHunk(false);
+    }
+}
+class ViewInChatAction extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: ACTION_VIEW_IN_CHAT,
+            title: ( localize(7669, 'View in Chat')),
+            icon: Codicon.commentDiscussion,
+            precondition: CTX_INLINE_CHAT_VISIBLE,
+            menu: [{
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: 'more',
+                    order: 1,
+                    when: ( CTX_INLINE_CHAT_RESPONSE_TYPE.notEqualsTo(InlineChatResponseType.Messages))
+                }, {
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: '0_main',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(( ChatContextKeys.inputHasText.toNegated()), ( CTX_INLINE_CHAT_RESPONSE_TYPE.isEqualTo(InlineChatResponseType.Messages)), ( CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.negate())))
+                }],
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.DownArrow,
+                when: ChatContextKeys.inChatInput
+            }
+        });
+    }
+    runInlineChatCommand(_accessor, ctrl, _editor, ..._args) {
+        return ctrl.viewInChat();
+    }
+}
+class ToggleDiffForChange extends AbstractInline1ChatAction {
+    constructor() {
+        super({
+            id: ACTION_TOGGLE_DIFF,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_CHANGE_HAS_DIFF)),
+            title: ( localize2(7670, 'Toggle Changes')),
+            icon: Codicon.diffSingle,
+            toggled: {
+                condition: CTX_INLINE_CHAT_CHANGE_SHOWS_DIFF,
+            },
+            menu: [{
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: 'zzz',
+                    order: 1,
+                }, {
+                    id: MENU_INLINE_CHAT_ZONE,
+                    group: 'navigation',
+                    when: CTX_INLINE_CHAT_CHANGE_HAS_DIFF,
+                    order: 2
+                }]
+        });
+    }
+    runInlineChatCommand(_accessor, ctrl, _editor, hunkInfo) {
+        ctrl.toggleDiff(hunkInfo);
+    }
+}
+class AbstractInline2ChatAction extends EditorAction2 {
+    static { this.category = ( localize2(7657, "Inline Chat")); }
+    constructor(desc) {
+        const massageMenu = (menu) => {
+            if (Array.isArray(menu)) {
+                for (const entry of menu) {
+                    entry.when = ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT2, entry.when));
+                }
+            }
+            else if (menu) {
+                menu.when = ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT2, menu.when));
+            }
+        };
+        if (Array.isArray(desc.menu)) {
+            massageMenu(desc.menu);
+        }
+        else {
+            massageMenu(desc.menu);
+        }
+        super({
+            ...desc,
+            category: AbstractInline2ChatAction.category,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT2, desc.precondition))
+        });
+    }
+    runEditorCommand(accessor, editor, ..._args) {
+        const editorService = accessor.get(IEditorService);
+        const logService = accessor.get(ILogService);
+        let ctrl = InlineChatController2.get(editor);
+        if (!ctrl) {
+            const { activeTextEditorControl } = editorService;
+            if (isCodeEditor(activeTextEditorControl)) {
+                editor = activeTextEditorControl;
+            }
+            else if (isDiffEditor(activeTextEditorControl)) {
+                editor = activeTextEditorControl.getModifiedEditor();
+            }
+            ctrl = InlineChatController2.get(editor);
+        }
+        if (!ctrl) {
+            logService.warn('[IE] NO controller found for action', this.desc.id, editor.getModel()?.uri);
+            return;
+        }
+        if (editor instanceof EmbeddedCodeEditorWidget) {
+            editor = editor.getParentEditor();
+        }
+        if (!ctrl) {
+            for (const diffEditor of accessor.get(ICodeEditorService).listDiffEditors()) {
+                if (diffEditor.getOriginalEditor() === editor || diffEditor.getModifiedEditor() === editor) {
+                    if (diffEditor instanceof EmbeddedDiffEditorWidget) {
+                        this.runEditorCommand(accessor, diffEditor.getParentEditor(), ..._args);
+                    }
+                }
+            }
+            return;
+        }
+        this.runInlineChatCommand(accessor, ctrl, editor, ..._args);
+    }
+}
+class KeepOrUndoSessionAction extends AbstractInline2ChatAction {
+    constructor(id, _keep) {
+        super({
+            id,
+            title: _keep
+                ? ( localize2(7671, "Keep"))
+                : ( localize2(7672, "Undo")),
+            f1: true,
+            icon: _keep ? Codicon.check : Codicon.discard,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_VISIBLE, ( ctxHasRequestInProgress.negate()))),
+            keybinding: [{
+                    weight: KeybindingWeight.WorkbenchContrib + 10,
+                    primary: _keep
+                        ? KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyY
+                        : KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyN
+                }],
+            menu: [{
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: '0_main',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(
+                        CTX_INLINE_CHAT_HAS_AGENT2,
+                        ContextKeyExpr.greater(ctxRequestCount.key, 0),
+                        ctxHasEditorModification
+                    )),
+                }]
+        });
+        this._keep = _keep;
+    }
+    async runInlineChatCommand(accessor, _ctrl, editor, ..._args) {
+        const inlineChatSessions = accessor.get(IInlineChatSessionService);
+        if (!editor.hasModel()) {
+            return;
+        }
+        const textModel = editor.getModel();
+        const session = inlineChatSessions.getSession2(textModel.uri);
+        if (session) {
+            if (this._keep) {
+                await session.editingSession.accept();
+            }
+            else {
+                await session.editingSession.reject();
+            }
+            session.dispose();
+        }
+    }
+}
+class KeepSessionAction2 extends KeepOrUndoSessionAction {
+    constructor() {
+        super('inlineChat2.keep', true);
+    }
+}
+class UndoSessionAction2 extends KeepOrUndoSessionAction {
+    constructor() {
+        super('inlineChat2.undo', false);
+    }
+}
+class CloseSessionAction2 extends AbstractInline2ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat2.close',
+            title: ( localize2(7673, "Close")),
+            f1: true,
+            icon: Codicon.close,
+            precondition: ( ContextKeyExpr.and(CTX_INLINE_CHAT_VISIBLE, ( ctxHasRequestInProgress.negate()), ( ContextKeyExpr.or(( ctxRequestCount.isEqualTo(0)), ( ctxHasEditorModification.negate()))))),
+            keybinding: [{
+                    when: ( ctxRequestCount.isEqualTo(0)),
+                    weight: KeybindingWeight.WorkbenchContrib,
+                    primary: KeyMod.CtrlCmd | KeyCode.KeyI,
+                }, {
+                    weight: KeybindingWeight.WorkbenchContrib,
+                    primary: KeyCode.Escape,
+                }],
+            menu: [{
+                    id: MENU_INLINE_CHAT_SIDE,
+                    group: 'navigation',
+                    when: ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT2, ( ctxRequestCount.isEqualTo(0)))),
+                }, {
+                    id: MENU_INLINE_CHAT_WIDGET_STATUS,
+                    group: '0_main',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(CTX_INLINE_CHAT_HAS_AGENT2, ( ctxHasEditorModification.negate()))),
+                }]
+        });
+    }
+    runInlineChatCommand(accessor, _ctrl, editor, ...args) {
+        const inlineChatSessions = accessor.get(IInlineChatSessionService);
+        if (editor.hasModel()) {
+            const textModel = editor.getModel();
+            inlineChatSessions.getSession2(textModel.uri)?.dispose();
+        }
+    }
+}
+class RevealWidget extends AbstractInline2ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat2.reveal',
+            title: ( localize2(7674, "Toggle Inline Chat")),
+            f1: true,
+            icon: Codicon.copilot,
+            precondition: ( ContextKeyExpr.and(( ctxIsGlobalEditingSession.negate()), ContextKeyExpr.greaterEquals(ctxRequestCount.key, 1))),
+            toggled: {
+                condition: CTX_INLINE_CHAT_VISIBLE,
+            },
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.KeyI
+            },
+            menu: {
+                id: MenuId.ChatEditingEditorContent,
+                when: ( ContextKeyExpr.and(ContextKeyExpr.greaterEquals(ctxRequestCount.key, 1), ( ctxIsGlobalEditingSession.negate()))),
+                group: 'navigate',
+                order: 4,
+            }
+        });
+    }
+    runInlineChatCommand(_accessor, ctrl, _editor) {
+        ctrl.toggleWidgetUntilNextRequest();
+        ctrl.markActiveController();
+    }
+}
+class CancelRequestAction extends AbstractInline2ChatAction {
+    constructor() {
+        super({
+            id: 'inlineChat2.cancelRequest',
+            title: ( localize2(7675, "Cancel Request")),
+            f1: true,
+            icon: Codicon.stopCircle,
+            precondition: ( ContextKeyExpr.and(( ctxIsGlobalEditingSession.negate()), ctxHasRequestInProgress)),
+            toggled: CTX_INLINE_CHAT_VISIBLE,
+            menu: {
+                id: MenuId.ChatEditingEditorContent,
+                when: ( ContextKeyExpr.and(( ctxIsGlobalEditingSession.negate()), ctxHasRequestInProgress)),
+                group: 'a_request',
+                order: 1,
+            }
+        });
+    }
+    runInlineChatCommand(accessor, ctrl, _editor) {
+        const chatService = accessor.get(IChatService);
+        const { viewModel } = ctrl.widget.chatWidget;
+        if (viewModel) {
+            ctrl.toggleWidgetUntilNextRequest();
+            ctrl.markActiveController();
+            chatService.cancelCurrentRequestForSession(viewModel.sessionId);
+        }
+    }
+}
+
+export { AbstractInline1ChatAction, AcceptChanges, ArrowOutDownAction, ArrowOutUpAction, CancelRequestAction, CloseAction, CloseSessionAction2, ConfigureInlineChatAction, DiscardHunkAction, FocusInlineChat, KeepSessionAction2, MoveToNextHunk, MoveToPreviousHunk, RerunAction, RevealWidget, START_INLINE_CHAT, StartSessionAction, ToggleDiffForChange, UndoSessionAction2, UnstashSessionAction, ViewInChatAction };