@codingame/monaco-vscode-chat-service-override 4.0.0 → 4.1.0

package/override/vs/platform/dialogs/common/dialogs.js

@@ -1,10 +0,0 @@
-export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
-
-var ConfirmResult;
-( (function(ConfirmResult) {
-    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
-    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
-    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
-})(ConfirmResult || (ConfirmResult = {})));
-
-export { ConfirmResult };

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

@@ -1,17 +0,0 @@
-import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
-import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-
-async function clearChatEditor(accessor) {
-    const editorService = accessor.get(IEditorService);
-    const editorGroupsService = accessor.get(IEditorGroupsService);
-    const chatEditorInput = editorService.activeEditor;
-    if (chatEditorInput instanceof ChatEditorInput && chatEditorInput.providerId) {
-        await editorService.replaceEditors([{
-                editor: chatEditorInput,
-                replacement: { resource: ChatEditorInput.getNewEditorUri(), options: { target: { providerId: chatEditorInput.providerId, pinned: true } } }
-            }], editorGroupsService.activeGroup);
-    }
-}
-
-export { clearChatEditor };

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

@@ -1,115 +0,0 @@
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { localize2WithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IAccessibilitySignalService, AccessibilitySignal } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
-import { ActiveEditorContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
-import { CHAT_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { clearChatEditor } from './chatClear.js';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
-import { CONTEXT_PROVIDER_EXISTS, CONTEXT_IN_CHAT_SESSION } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-
-const ACTION_ID_NEW_CHAT = `workbench.action.chat.newChat`;
-function registerNewChatActions() {
-    registerAction2(class NewChatEditorAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chatEditor.newChat',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatClearActions',
-                    'chat.newChat.label',
-                    "New Chat"
-                )),
-                icon: Codicon.plus,
-                f1: false,
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                menu: [{
-                        id: MenuId.EditorTitle,
-                        group: 'navigation',
-                        order: 0,
-                        when: ( ActiveEditorContext.isEqualTo(ChatEditorInput.EditorID)),
-                    }]
-            });
-        }
-        async run(accessor, ...args) {
-            announceChatCleared(accessor);
-            await clearChatEditor(accessor);
-        }
-    });
-    registerAction2(class GlobalClearChatAction extends Action2 {
-        constructor() {
-            super({
-                id: ACTION_ID_NEW_CHAT,
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatClearActions',
-                    'chat.newChat.label',
-                    "New Chat"
-                )),
-                category: CHAT_CATEGORY,
-                icon: Codicon.plus,
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                f1: true,
-                keybinding: {
-                    weight: 200 ,
-                    primary: 2048  | 42 ,
-                    mac: {
-                        primary: 256  | 42
-                    },
-                    when: CONTEXT_IN_CHAT_SESSION
-                },
-                menu: {
-                    id: MenuId.ChatContext,
-                    group: 'z_clear'
-                }
-            });
-        }
-        run(accessor, ...args) {
-            const widgetService = accessor.get(IChatWidgetService);
-            const widget = widgetService.lastFocusedWidget;
-            if (!widget) {
-                return;
-            }
-            announceChatCleared(accessor);
-            widget.clear();
-            widget.focusInput();
-        }
-    });
-}
-const getNewChatActionDescriptorForViewTitle = (viewId, providerId) => ({
-    viewId,
-    id: `workbench.action.chat.${providerId}.newChat`,
-    title: ( localize2WithPath(
-        'vs/workbench/contrib/chat/browser/actions/chatClearActions',
-        'chat.newChat.label',
-        "New Chat"
-    )),
-    menu: {
-        id: MenuId.ViewTitle,
-        when: ( ContextKeyExpr.equals('view', viewId)),
-        group: 'navigation',
-        order: -1
-    },
-    precondition: CONTEXT_PROVIDER_EXISTS,
-    category: CHAT_CATEGORY,
-    icon: Codicon.plus,
-    f1: false
-});
-function getNewChatAction(viewId, providerId) {
-    return class NewChatAction extends ViewAction {
-        constructor() {
-            super(getNewChatActionDescriptorForViewTitle(viewId, providerId));
-        }
-        async runInView(accessor, view) {
-            announceChatCleared(accessor);
-            await view.clear();
-            view.widget.focusInput();
-        }
-    };
-}
-function announceChatCleared(accessor) {
-    accessor.get(IAccessibilitySignalService).playSignal(AccessibilitySignal.clear);
-}
-
-export { ACTION_ID_NEW_CHAT, getNewChatAction, registerNewChatActions };

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

@@ -1,503 +0,0 @@
-import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { isDiffEditor, isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
-import { IBulkEditService, ResourceTextEdit } from 'vscode/vscode/vs/editor/browser/services/bulkEditService';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { CopyAction } from 'vscode/vscode/vs/editor/contrib/clipboard/browser/clipboard';
-import { localize2WithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { TerminalLocation } from 'vscode/vscode/vs/platform/terminal/common/terminal';
-import { accessibleViewInCodeBlock } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
-import { CHAT_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { IChatWidgetService, IChatCodeBlockContextProviderService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { CONTEXT_PROVIDER_EXISTS, CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_CHAT_INPUT } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { IChatService, ChatCopyKind } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
-import { isResponseVM } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatViewModel';
-import { insertCell } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
-import { NOTEBOOK_EDITOR_ID, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { ITerminalService, ITerminalEditorService, ITerminalGroupService } from 'vscode/vscode/vs/workbench/contrib/terminal/browser/terminal';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
-
-function isCodeBlockActionContext(thing) {
-    return typeof thing === 'object' && thing !== null && 'code' in thing && 'element' in thing;
-}
-function isResponseFiltered(context) {
-    return isResponseVM(context.element) && context.element.errorDetails?.responseIsFiltered;
-}
-function getUsedDocuments(context) {
-    return isResponseVM(context.element) ? context.element.usedContext?.documents : undefined;
-}
-class ChatCodeBlockAction extends Action2 {
-    run(accessor, ...args) {
-        let context = args[0];
-        if (!isCodeBlockActionContext(context)) {
-            const codeEditorService = accessor.get(ICodeEditorService);
-            const editor = codeEditorService.getFocusedCodeEditor() || codeEditorService.getActiveCodeEditor();
-            if (!editor) {
-                return;
-            }
-            context = getContextFromEditor(editor, accessor);
-            if (!isCodeBlockActionContext(context)) {
-                return;
-            }
-        }
-        return this.runWithContext(accessor, context);
-    }
-}
-function registerChatCodeBlockActions() {
-    registerAction2(class CopyCodeBlockAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.copyCodeBlock',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatCodeblockActions',
-                    'interactive.copyCodeBlock.label',
-                    "Copy"
-                )),
-                f1: false,
-                category: CHAT_CATEGORY,
-                icon: Codicon.copy,
-                menu: {
-                    id: MenuId.ChatCodeBlock,
-                    group: 'navigation'
-                }
-            });
-        }
-        run(accessor, ...args) {
-            const context = args[0];
-            if (!isCodeBlockActionContext(context) || isResponseFiltered(context)) {
-                return;
-            }
-            const clipboardService = accessor.get(IClipboardService);
-            clipboardService.writeText(context.code);
-            if (isResponseVM(context.element)) {
-                const chatService = accessor.get(IChatService);
-                chatService.notifyUserAction({
-                    providerId: context.element.providerId,
-                    agentId: context.element.agent?.id,
-                    sessionId: context.element.sessionId,
-                    requestId: context.element.requestId,
-                    result: context.element.result,
-                    action: {
-                        kind: 'copy',
-                        codeBlockIndex: context.codeBlockIndex,
-                        copyKind: ChatCopyKind.Toolbar,
-                        copiedCharacters: context.code.length,
-                        totalCharacters: context.code.length,
-                        copiedText: context.code,
-                    }
-                });
-            }
-        }
-    });
-    CopyAction?.addImplementation(50000, 'chat-codeblock', (accessor) => {
-        const editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
-        if (!editor) {
-            return false;
-        }
-        const editorModel = editor.getModel();
-        if (!editorModel) {
-            return false;
-        }
-        const context = getContextFromEditor(editor, accessor);
-        if (!context) {
-            return false;
-        }
-        const noSelection = editor.getSelections()?.length === 1 && editor.getSelection()?.isEmpty();
-        const copiedText = noSelection ?
-            editorModel.getValue() :
-            editor.getSelections()?.reduce((acc, selection) => acc + editorModel.getValueInRange(selection), '') ?? '';
-        const totalCharacters = editorModel.getValueLength();
-        const chatService = accessor.get(IChatService);
-        const element = context.element;
-        if (element) {
-            chatService.notifyUserAction({
-                providerId: element.providerId,
-                agentId: element.agent?.id,
-                sessionId: element.sessionId,
-                requestId: element.requestId,
-                result: element.result,
-                action: {
-                    kind: 'copy',
-                    codeBlockIndex: context.codeBlockIndex,
-                    copyKind: ChatCopyKind.Action,
-                    copiedText,
-                    copiedCharacters: copiedText.length,
-                    totalCharacters,
-                }
-            });
-        }
-        if (noSelection) {
-            accessor.get(IClipboardService).writeText(context.code);
-            return true;
-        }
-        return false;
-    });
-    registerAction2(class InsertCodeBlockAction extends ChatCodeBlockAction {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.insertCodeBlock',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatCodeblockActions',
-                    'interactive.insertCodeBlock.label',
-                    "Insert at Cursor"
-                )),
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                f1: true,
-                category: CHAT_CATEGORY,
-                icon: Codicon.insert,
-                menu: {
-                    id: MenuId.ChatCodeBlock,
-                    group: 'navigation',
-                    when: CONTEXT_IN_CHAT_SESSION
-                },
-                keybinding: {
-                    when: ( ContextKeyExpr.or(( ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, ( CONTEXT_IN_CHAT_INPUT.negate()))), accessibleViewInCodeBlock)),
-                    primary: 2048  | 3 ,
-                    mac: { primary: 256  | 3  },
-                    weight: 400  + 1
-                },
-            });
-        }
-        async runWithContext(accessor, context) {
-            const editorService = accessor.get(IEditorService);
-            const textFileService = accessor.get(ITextFileService);
-            if (isResponseFiltered(context)) {
-                return;
-            }
-            if (editorService.activeEditorPane?.getId() === NOTEBOOK_EDITOR_ID) {
-                return this.handleNotebookEditor(accessor, editorService.activeEditorPane.getControl(), context);
-            }
-            let activeEditorControl = editorService.activeTextEditorControl;
-            if (isDiffEditor(activeEditorControl)) {
-                activeEditorControl = activeEditorControl.getOriginalEditor().hasTextFocus() ? activeEditorControl.getOriginalEditor() : activeEditorControl.getModifiedEditor();
-            }
-            if (!isCodeEditor(activeEditorControl)) {
-                return;
-            }
-            const activeModel = activeEditorControl.getModel();
-            if (!activeModel) {
-                return;
-            }
-            const activeTextModel = textFileService.files.get(activeModel.uri) ?? textFileService.untitled.get(activeModel.uri);
-            if (!activeTextModel || activeTextModel.isReadonly()) {
-                return;
-            }
-            await this.handleTextEditor(accessor, activeEditorControl, activeModel, context);
-        }
-        async handleNotebookEditor(accessor, notebookEditor, context) {
-            if (!notebookEditor.hasModel()) {
-                return;
-            }
-            if (notebookEditor.isReadOnly) {
-                return;
-            }
-            if (notebookEditor.activeCodeEditor?.hasTextFocus()) {
-                const codeEditor = notebookEditor.activeCodeEditor;
-                const textModel = codeEditor.getModel();
-                if (textModel) {
-                    return this.handleTextEditor(accessor, codeEditor, textModel, context);
-                }
-            }
-            const languageService = accessor.get(ILanguageService);
-            const focusRange = notebookEditor.getFocus();
-            const next = Math.max(focusRange.end - 1, 0);
-            insertCell(languageService, notebookEditor, next, CellKind.Code, 'below', context.code, true);
-            this.notifyUserAction(accessor, context);
-        }
-        async handleTextEditor(accessor, codeEditor, activeModel, codeBlockActionContext) {
-            this.notifyUserAction(accessor, codeBlockActionContext);
-            const bulkEditService = accessor.get(IBulkEditService);
-            const codeEditorService = accessor.get(ICodeEditorService);
-            const mappedEditsProviders = accessor.get(ILanguageFeaturesService).mappedEditsProvider.ordered(activeModel);
-            let mappedEdits = null;
-            if (mappedEditsProviders.length > 0) {
-                const mostRelevantProvider = mappedEditsProviders[0];
-                const docRefs = [];
-                if (codeEditor.hasModel()) {
-                    const model = codeEditor.getModel();
-                    const currentDocUri = model.uri;
-                    const currentDocVersion = model.getVersionId();
-                    const selections = codeEditor.getSelections();
-                    if (selections.length > 0) {
-                        docRefs.push([
-                            {
-                                uri: currentDocUri,
-                                version: currentDocVersion,
-                                ranges: selections,
-                            }
-                        ]);
-                    }
-                }
-                const usedDocuments = getUsedDocuments(codeBlockActionContext);
-                if (usedDocuments) {
-                    docRefs.push(usedDocuments);
-                }
-                const cancellationTokenSource = ( new CancellationTokenSource());
-                mappedEdits = await mostRelevantProvider.provideMappedEdits(activeModel, [codeBlockActionContext.code], { documents: docRefs }, cancellationTokenSource.token);
-            }
-            if (mappedEdits) {
-                await bulkEditService.apply(mappedEdits);
-            }
-            else {
-                const activeSelection = codeEditor.getSelection() ?? ( new Range(activeModel.getLineCount(), 1, activeModel.getLineCount(), 1));
-                await bulkEditService.apply([
-                    ( new ResourceTextEdit(activeModel.uri, {
-                        range: activeSelection,
-                        text: codeBlockActionContext.code,
-                    })),
-                ]);
-            }
-            codeEditorService.listCodeEditors().find(editor => editor.getModel()?.uri.toString() === ( activeModel.uri.toString()))?.focus();
-        }
-        notifyUserAction(accessor, context) {
-            if (isResponseVM(context.element)) {
-                const chatService = accessor.get(IChatService);
-                chatService.notifyUserAction({
-                    providerId: context.element.providerId,
-                    agentId: context.element.agent?.id,
-                    sessionId: context.element.sessionId,
-                    requestId: context.element.requestId,
-                    result: context.element.result,
-                    action: {
-                        kind: 'insert',
-                        codeBlockIndex: context.codeBlockIndex,
-                        totalCharacters: context.code.length,
-                    }
-                });
-            }
-        }
-    });
-    registerAction2(class InsertIntoNewFileAction extends ChatCodeBlockAction {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.insertIntoNewFile',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatCodeblockActions',
-                    'interactive.insertIntoNewFile.label',
-                    "Insert into New File"
-                )),
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                f1: true,
-                category: CHAT_CATEGORY,
-                icon: Codicon.newFile,
-                menu: {
-                    id: MenuId.ChatCodeBlock,
-                    group: 'navigation',
-                    isHiddenByDefault: true
-                }
-            });
-        }
-        async runWithContext(accessor, context) {
-            if (isResponseFiltered(context)) {
-                return;
-            }
-            const editorService = accessor.get(IEditorService);
-            const chatService = accessor.get(IChatService);
-            editorService.openEditor({ contents: context.code, languageId: context.languageId, resource: undefined });
-            if (isResponseVM(context.element)) {
-                chatService.notifyUserAction({
-                    providerId: context.element.providerId,
-                    agentId: context.element.agent?.id,
-                    sessionId: context.element.sessionId,
-                    requestId: context.element.requestId,
-                    result: context.element.result,
-                    action: {
-                        kind: 'insert',
-                        codeBlockIndex: context.codeBlockIndex,
-                        totalCharacters: context.code.length,
-                        newFile: true
-                    }
-                });
-            }
-        }
-    });
-    const shellLangIds = [
-        'fish',
-        'ps1',
-        'pwsh',
-        'powershell',
-        'sh',
-        'shellscript',
-        'zsh'
-    ];
-    registerAction2(class RunInTerminalAction extends ChatCodeBlockAction {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.runInTerminal',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatCodeblockActions',
-                    'interactive.runInTerminal.label',
-                    "Insert into Terminal"
-                )),
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                f1: true,
-                category: CHAT_CATEGORY,
-                icon: Codicon.terminal,
-                menu: [{
-                        id: MenuId.ChatCodeBlock,
-                        group: 'navigation',
-                        when: ( ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, ( ContextKeyExpr.or(...( shellLangIds.map(e => ( ContextKeyExpr.equals(EditorContextKeys.languageId.key, e)))))))),
-                    },
-                    {
-                        id: MenuId.ChatCodeBlock,
-                        group: 'navigation',
-                        isHiddenByDefault: true,
-                        when: ( ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, ...( shellLangIds.map(e => ( ContextKeyExpr.notEquals(EditorContextKeys.languageId.key, e))))))
-                    }],
-                keybinding: [{
-                        primary: 2048  | 512  | 3 ,
-                        mac: {
-                            primary: 256  | 512  | 3
-                        },
-                        weight: 100 ,
-                        when: ( ContextKeyExpr.or(CONTEXT_IN_CHAT_SESSION, accessibleViewInCodeBlock)),
-                    }]
-            });
-        }
-        async runWithContext(accessor, context) {
-            if (isResponseFiltered(context)) {
-                return;
-            }
-            const chatService = accessor.get(IChatService);
-            const terminalService = accessor.get(ITerminalService);
-            const editorService = accessor.get(IEditorService);
-            const terminalEditorService = accessor.get(ITerminalEditorService);
-            const terminalGroupService = accessor.get(ITerminalGroupService);
-            let terminal = await terminalService.getActiveOrCreateInstance();
-            const unusableTerminal = terminal.xterm?.isStdinDisabled || terminal.shellLaunchConfig.isFeatureTerminal;
-            terminal = unusableTerminal ? await terminalService.createTerminal() : terminal;
-            terminalService.setActiveInstance(terminal);
-            await terminal.focusWhenReady(true);
-            if (terminal.target === TerminalLocation.Editor) {
-                const existingEditors = editorService.findEditors(terminal.resource);
-                terminalEditorService.openEditor(terminal, { viewColumn: existingEditors?.[0].groupId });
-            }
-            else {
-                terminalGroupService.showPanel(true);
-            }
-            terminal.runCommand(context.code, false);
-            if (isResponseVM(context.element)) {
-                chatService.notifyUserAction({
-                    providerId: context.element.providerId,
-                    agentId: context.element.agent?.id,
-                    sessionId: context.element.sessionId,
-                    requestId: context.element.requestId,
-                    result: context.element.result,
-                    action: {
-                        kind: 'runInTerminal',
-                        codeBlockIndex: context.codeBlockIndex,
-                        languageId: context.languageId,
-                    }
-                });
-            }
-        }
-    });
-    function navigateCodeBlocks(accessor, reverse) {
-        const codeEditorService = accessor.get(ICodeEditorService);
-        const chatWidgetService = accessor.get(IChatWidgetService);
-        const widget = chatWidgetService.lastFocusedWidget;
-        if (!widget) {
-            return;
-        }
-        const editor = codeEditorService.getFocusedCodeEditor();
-        const editorUri = editor?.getModel()?.uri;
-        const curCodeBlockInfo = editorUri ? widget.getCodeBlockInfoForEditor(editorUri) : undefined;
-        const focused = !widget.inputEditor.hasWidgetFocus() && widget.getFocus();
-        const focusedResponse = isResponseVM(focused) ? focused : undefined;
-        const currentResponse = curCodeBlockInfo ?
-            curCodeBlockInfo.element :
-            (focusedResponse ?? widget.viewModel?.getItems().reverse().find((item) => isResponseVM(item)));
-        if (!currentResponse) {
-            return;
-        }
-        widget.reveal(currentResponse);
-        const responseCodeblocks = widget.getCodeBlockInfosForResponse(currentResponse);
-        const focusIdx = curCodeBlockInfo ?
-            (curCodeBlockInfo.codeBlockIndex + (reverse ? -1 : 1) + responseCodeblocks.length) % responseCodeblocks.length :
-            reverse ? responseCodeblocks.length - 1 : 0;
-        responseCodeblocks[focusIdx]?.focus();
-    }
-    registerAction2(class NextCodeBlockAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.nextCodeBlock',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatCodeblockActions',
-                    'interactive.nextCodeBlock.label',
-                    "Next Code Block"
-                )),
-                keybinding: {
-                    primary: 2048  | 512  | 12 ,
-                    mac: { primary: 2048  | 512  | 12 , },
-                    weight: 200 ,
-                    when: CONTEXT_IN_CHAT_SESSION,
-                },
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                f1: true,
-                category: CHAT_CATEGORY,
-            });
-        }
-        run(accessor, ...args) {
-            navigateCodeBlocks(accessor);
-        }
-    });
-    registerAction2(class PreviousCodeBlockAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.previousCodeBlock',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatCodeblockActions',
-                    'interactive.previousCodeBlock.label',
-                    "Previous Code Block"
-                )),
-                keybinding: {
-                    primary: 2048  | 512  | 11 ,
-                    mac: { primary: 2048  | 512  | 11 , },
-                    weight: 200 ,
-                    when: CONTEXT_IN_CHAT_SESSION,
-                },
-                precondition: CONTEXT_PROVIDER_EXISTS,
-                f1: true,
-                category: CHAT_CATEGORY,
-            });
-        }
-        run(accessor, ...args) {
-            navigateCodeBlocks(accessor, true);
-        }
-    });
-}
-function getContextFromEditor(editor, accessor) {
-    const chatWidgetService = accessor.get(IChatWidgetService);
-    const chatCodeBlockContextProviderService = accessor.get(IChatCodeBlockContextProviderService);
-    const model = editor.getModel();
-    if (!model) {
-        return;
-    }
-    const widget = chatWidgetService.lastFocusedWidget;
-    const codeBlockInfo = widget?.getCodeBlockInfoForEditor(model.uri);
-    if (!codeBlockInfo) {
-        for (const provider of chatCodeBlockContextProviderService.providers) {
-            const context = provider.getCodeBlockContext(editor);
-            if (context) {
-                return context;
-            }
-        }
-        return;
-    }
-    return {
-        element: codeBlockInfo.element,
-        codeBlockIndex: codeBlockInfo.codeBlockIndex,
-        code: editor.getValue(),
-        languageId: editor.getModel().getLanguageId(),
-    };
-}
-
-export { isCodeBlockActionContext, registerChatCodeBlockActions };