@codingame/monaco-vscode-chat-service-override 16.1.0 → 17.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/chatEditingNotebookEditorIntegration.js

@@ -2,30 +2,33 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { debouncedObservable, observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
 import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/lineRange';
 import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { nullDocumentDiff } from '../../../../../../editor/common/diff/documentDiffProvider.js';
+import { PrefixSumComputer } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/prefixSumComputer';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
 import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
 import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { NotebookDeletedCellDecorator } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookDeletedCellDecorator';
-import { NotebookInsertedCellDecorator } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookInsertedCellDecorator';
+import { NotebookDeletedCellDecorator } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookDeletedCellDecorator';
+import { NotebookInsertedCellDecorator } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/notebook/browser/diff/inlineDiff/notebookInsertedCellDecorator';
 import { NotebookModifiedCellDecorator } from '../../../../notebook/browser/diff/inlineDiff/notebookModifiedCellDecorator.js';
-import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { getNotebookEditorFromEditorPane, CellEditState } from '@codingame/monaco-vscode-324f9a6e-6231-5bfc-af17-e147abd2dfd2-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
 import { CellKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { ChatEditingCodeEditorIntegration } from '../chatEditingCodeEditorIntegration.js';
 import { sortCellChanges, countChanges } from './notebookCellChanges.js';
+import { OverlayToolbarDecorator } from './overlayToolbarDecorator.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+import { debouncedObservable, observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils';
 
 let ChatEditingNotebookEditorIntegration = class ChatEditingNotebookEditorIntegration extends Disposable {
     constructor(_entry, editor, notebookModel, originalModel, cellChanges, instantiationService) {
@@ -60,13 +63,13 @@ let ChatEditingNotebookEditorIntegration = class ChatEditingNotebookEditorIntegr
         this.integration.enableAccessibleDiffView();
     }
     acceptNearestChange(change) {
-        this.integration.acceptNearestChange(change);
+        return this.integration.acceptNearestChange(change);
     }
     rejectNearestChange(change) {
-        this.integration.rejectNearestChange(change);
+        return this.integration.rejectNearestChange(change);
     }
-    toggleDiff(change) {
-        return this.integration.toggleDiff(change);
+    toggleDiff(change, show) {
+        return this.integration.toggleDiff(change, show);
     }
     dispose() {
         this.integration.dispose();
@@ -77,7 +80,7 @@ ChatEditingNotebookEditorIntegration = ( __decorate([
     ( __param(5, IInstantiationService))
 ], ChatEditingNotebookEditorIntegration));
 let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditorWidgetIntegration extends Disposable {
-    constructor(_entry, notebookEditor, notebookModel, originalModel, cellChanges, instantiationService, _editorService, _chatAgentService, notebookEditorService, accessibilitySignalService) {
+    constructor(_entry, notebookEditor, notebookModel, originalModel, cellChanges, instantiationService, _editorService, _chatAgentService, notebookEditorService, accessibilitySignalService, logService) {
         super();
         this._entry = _entry;
         this.notebookEditor = notebookEditor;
@@ -87,13 +90,14 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
         this._editorService = _editorService;
         this._chatAgentService = _chatAgentService;
         this.accessibilitySignalService = accessibilitySignalService;
+        this.logService = logService;
         this._currentIndex = observableValue(this, -1);
         this.currentIndex = this._currentIndex;
-        this._currentChange = observableValue(this, undefined);
-        this.currentChange = this._currentChange;
         this.cellEditorIntegrations = ( new Map());
-        this.mdCellEditorAttached = observableValue(this, -1);
+        this.markdownEditState = observableValue(this, '');
         this.markupCellListeners = ( new Map());
+        this.sortedCellChanges = [];
+        this.changeIndexComputer = ( new PrefixSumComputer(( new Uint32Array(0))));
         const onDidChangeVisibleRanges = debouncedObservable(observableFromEvent(notebookEditor.onDidChangeVisibleRanges, () => notebookEditor.visibleRanges), 50);
         this._register(toDisposable(() => {
             this.markupCellListeners.forEach((v) => v.dispose());
@@ -131,6 +135,19 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                 this.reveal(true);
             }
         }));
+        this._register(autorun(r => {
+            this.sortedCellChanges = sortCellChanges(cellChanges.read(r));
+            const indexes = [];
+            for (const change of this.sortedCellChanges) {
+                indexes.push(change.type === 'insert' || change.type === 'delete' ? 1
+                    : change.type === 'modified' ? change.diff.read(r).changes.length
+                        : 0);
+            }
+            this.changeIndexComputer = ( new PrefixSumComputer(( new Uint32Array(indexes))));
+            if (this.changeIndexComputer.getTotalSum() === 0) {
+                this.revertMarkupCellState();
+            }
+        }));
         this._register(autorun(r => {
             if (this.notebookEditor.textModel !== this.notebookModel) {
                 return;
@@ -144,7 +161,7 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                 });
                 return;
             }
-            this.mdCellEditorAttached.read(r);
+            this.markdownEditState.read(r);
             const validCells = ( new Set());
             changes.forEach((change) => {
                 if (change.modifiedCellIndex === undefined || change.modifiedCellIndex >= notebookModel.cells.length) {
@@ -157,20 +174,18 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                 if (!cell || !originalModel || !modifiedModel) {
                     return;
                 }
-                if (!editor) {
-                    if (!( this.markupCellListeners.has(cell.handle)) && cell.cellKind === CellKind.Markup) {
-                        const cellModel = this.notebookEditor.getViewModel()?.viewCells.find(c => c.handle === cell.handle);
-                        if (cellModel) {
-                            const listener = cellModel.onDidChangeEditorAttachState(() => {
-                                if (cellModel.editorAttached) {
-                                    this.mdCellEditorAttached.set(cell.handle, undefined);
-                                    listener.dispose();
-                                    this.markupCellListeners.delete(cell.handle);
-                                }
-                            });
-                            this.markupCellListeners.set(cell.handle, listener);
-                        }
+                if (cell.cellKind === CellKind.Markup && !( this.markupCellListeners.has(cell.handle))) {
+                    const cellModel = this.notebookEditor.getViewModel()?.viewCells.find(c => c.handle === cell.handle);
+                    if (cellModel) {
+                        const listener = cellModel.onDidChangeState((e) => {
+                            if (e.editStateChanged) {
+                                setTimeout(() => this.markdownEditState.set(cellModel.handle + '-' + cellModel.getEditState(), undefined), 0);
+                            }
+                        });
+                        this.markupCellListeners.set(cell.handle, listener);
                     }
+                }
+                if (!editor) {
                     return;
                 }
                 const diff = {
@@ -189,7 +204,7 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                 }
                 else {
                     const diff2 = observableValue(`diff${cell.handle}`, diff);
-                    const integration = this.instantiationService.createInstance(ChatEditingCodeEditorIntegration, _entry, editor, diff2);
+                    const integration = this.instantiationService.createInstance(ChatEditingCodeEditorIntegration, _entry, editor, diff2, true);
                     this.cellEditorIntegrations.set(cell, { integration, diff: diff2 });
                     this._register(integration);
                     this._register(editor.onDidDispose(() => {
@@ -211,30 +226,6 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                 }
             });
         }));
-        this._register(autorun(r => {
-            const currentChange = this.currentChange.read(r);
-            if (!currentChange) {
-                this._currentIndex.set(-1, undefined);
-                return;
-            }
-            let index = 0;
-            const sortedCellChanges = sortCellChanges(cellChanges.read(r));
-            for (const change of sortedCellChanges) {
-                if (currentChange && currentChange.change === change) {
-                    if (change.type === 'modified') {
-                        index += currentChange.index;
-                    }
-                    break;
-                }
-                if (change.type === 'insert' || change.type === 'delete') {
-                    index++;
-                }
-                else if (change.type === 'modified') {
-                    index += change.diff.read(r).changes.length;
-                }
-            }
-            this._currentIndex.set(index, undefined);
-        }));
         const cellsAreVisible = ( onDidChangeVisibleRanges.map(v => v.length > 0));
         const debouncedChanges = debouncedObservable(cellChanges, 10);
         this._register(autorun(r => {
@@ -244,16 +235,38 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
             const changes = debouncedChanges.read(r).filter(c => c.type === 'insert' ? !c.diff.read(r).identical : true);
             const modifiedChanges = changes.filter(c => c.type === 'modified');
             this.createDecorators();
-            this.insertedCellDecorator?.apply(changes);
-            this.modifiedCellDecorator?.apply(modifiedChanges);
-            this.deletedCellDecorator?.apply(changes, originalModel);
+            if (changes.every(c => c.type === 'insert')) {
+                this.insertedCellDecorator?.apply([]);
+                this.modifiedCellDecorator?.apply([]);
+                this.deletedCellDecorator?.apply([], originalModel);
+                this.overlayToolbarDecorator?.decorate([]);
+            }
+            else {
+                this.insertedCellDecorator?.apply(changes);
+                this.modifiedCellDecorator?.apply(modifiedChanges);
+                this.deletedCellDecorator?.apply(changes, originalModel);
+                this.overlayToolbarDecorator?.decorate(changes.filter(c => c.type === 'insert' || c.type === 'modified'));
+            }
         }));
     }
+    getCurrentChange() {
+        const currentIndex = Math.min(this._currentIndex.get(), this.changeIndexComputer.getTotalSum() - 1);
+        const index = this.changeIndexComputer.getIndexOf(currentIndex);
+        const change = this.sortedCellChanges[index.index];
+        return change ? { change, index: index.remainder } : undefined;
+    }
+    updateCurrentIndex(change, indexInCell = 0) {
+        const index = this.sortedCellChanges.indexOf(change);
+        const changeIndex = this.changeIndexComputer.getPrefixSum(index - 1);
+        const currentIndex = Math.min(changeIndex + indexInCell, this.changeIndexComputer.getTotalSum() - 1);
+        this._currentIndex.set(currentIndex, undefined);
+    }
     createDecorators() {
         const cellChanges = this.cellChanges.get();
         const accessibilitySignalService = this.accessibilitySignalService;
         this.insertedCellDecorator ??= this._register(this.instantiationService.createInstance(NotebookInsertedCellDecorator, this.notebookEditor));
         this.modifiedCellDecorator ??= this._register(this.instantiationService.createInstance(NotebookModifiedCellDecorator, this.notebookEditor));
+        this.overlayToolbarDecorator ??= this._register(this.instantiationService.createInstance(OverlayToolbarDecorator, this.notebookEditor, this.notebookModel));
         if (this.deletedCellDecorator) {
             this._store.delete(this.deletedCellDecorator);
             this.deletedCellDecorator.dispose();
@@ -290,9 +303,9 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
         return integration;
     }
     reveal(firstOrLast) {
-        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
+        const changes = this.sortedCellChanges.filter(c => c.type !== 'unchanged');
         if (!changes.length) {
-            return undefined;
+            return;
         }
         const change = firstOrLast ? changes[0] : changes[changes.length - 1];
         this._revealFirstOrLast(change, firstOrLast);
@@ -302,20 +315,14 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
             case 'insert':
             case 'modified':
                 {
+                    this.blur(this.getCurrentChange()?.change);
                     const index = firstOrLast || change.type === 'insert' ? 0 : change.diff.get().changes.length - 1;
-                    const cellIntegration = this.getCell(change.modifiedCellIndex);
-                    if (cellIntegration) {
-                        cellIntegration.reveal(firstOrLast);
-                        this._currentChange.set({ change: change, index }, undefined);
-                        return true;
-                    }
-                    else {
-                        return this._revealChange(change, index);
-                    }
+                    return this._revealChange(change, index);
                 }
             case 'delete':
+                this.blur(this.getCurrentChange()?.change);
                 this.deletedCellDecorator?.reveal(change.originalCellIndex);
-                this._currentChange.set({ change: change, index: 0 }, undefined);
+                this.updateCurrentIndex(change);
                 return true;
         }
         return false;
@@ -328,34 +335,58 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                     const textChange = change.diff.get().changes[indexInCell];
                     const cellViewModel = this.getCellViewModel(change);
                     if (cellViewModel) {
-                        this.revealChangeInView(cellViewModel, textChange?.modified);
-                        this._currentChange.set({ change: change, index: indexInCell }, undefined);
+                        this.updateCurrentIndex(change, indexInCell);
+                        this.revealChangeInView(cellViewModel, textChange?.modified, change)
+                            .catch(err => { this.logService.warn(`Error revealing change in view: ${err}`); });
+                        return true;
                     }
-                    return true;
+                    break;
                 }
             case 'delete':
+                this.updateCurrentIndex(change);
                 this.deletedCellDecorator?.reveal(change.originalCellIndex);
-                this._currentChange.set({ change: change, index: 0 }, undefined);
                 return true;
         }
         return false;
     }
     getCellViewModel(change) {
-        if (change.type === 'delete' || change.modifiedCellIndex === undefined) {
+        if (change.type === 'delete' || change.modifiedCellIndex === undefined || change.modifiedCellIndex >= this.notebookModel.cells.length) {
             return undefined;
         }
         const cell = this.notebookModel.cells[change.modifiedCellIndex];
         const cellViewModel = this.notebookEditor.getViewModel()?.viewCells.find(c => c.handle === cell.handle);
         return cellViewModel;
     }
-    async revealChangeInView(cell, lines) {
+    async revealChangeInView(cell, lines, change) {
         const targetLines = lines ?? ( new LineRange(0, 0));
-        await this.notebookEditor.focusNotebookCell(cell, 'container', { focusEditorLine: targetLines.startLineNumber });
+        if (change.type === 'modified' && cell.cellKind === CellKind.Markup && cell.getEditState() === CellEditState.Preview) {
+            cell.updateEditState(CellEditState.Editing, 'chatEditNavigation');
+        }
+        const focusTarget = cell.cellKind === CellKind.Code || change.type === 'modified' ? 'editor' : 'container';
+        await this.notebookEditor.focusNotebookCell(cell, focusTarget, { focusEditorLine: targetLines.startLineNumber });
         await this.notebookEditor.revealRangeInCenterAsync(cell, ( new Range(targetLines.startLineNumber, 0, targetLines.endLineNumberExclusive, 0)));
     }
+    revertMarkupCellState() {
+        for (const change of this.sortedCellChanges) {
+            const cellViewModel = this.getCellViewModel(change);
+            if (cellViewModel?.cellKind === CellKind.Markup && cellViewModel.getEditState() === CellEditState.Editing &&
+                (cellViewModel.editStateSource === 'chatEditNavigation' || cellViewModel.editStateSource === 'chatEdit')) {
+                cellViewModel.updateEditState(CellEditState.Preview, 'chatEdit');
+            }
+        }
+    }
+    blur(change) {
+        if (!change) {
+            return;
+        }
+        const cellViewModel = this.getCellViewModel(change);
+        if (cellViewModel?.cellKind === CellKind.Markup && cellViewModel.getEditState() === CellEditState.Editing && cellViewModel.editStateSource === 'chatEditNavigation') {
+            cellViewModel.updateEditState(CellEditState.Preview, 'chatEditNavigation');
+        }
+    }
     next(wrap) {
-        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
-        const currentChange = this.currentChange.get();
+        const changes = this.sortedCellChanges.filter(c => c.type !== 'unchanged');
+        const currentChange = this.getCurrentChange();
         if (!currentChange) {
             const firstChange = changes[0];
             if (firstChange) {
@@ -369,36 +400,45 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                     const cellIntegration = this.getCell(currentChange.change.modifiedCellIndex);
                     if (cellIntegration) {
                         if (cellIntegration.next(false)) {
-                            this._currentChange.set({ change: currentChange.change, index: cellIntegration.currentIndex.get() }, undefined);
+                            this.updateCurrentIndex(currentChange.change, cellIntegration.currentIndex.get());
                             return true;
                         }
                     }
-                    const isLastChangeInCell = currentChange.index === lastChangeIndex(currentChange.change);
+                    const isLastChangeInCell = currentChange.index >= lastChangeIndex(currentChange.change);
                     const index = isLastChangeInCell ? 0 : currentChange.index + 1;
                     const change = isLastChangeInCell ? changes[changes.indexOf(currentChange.change) + 1] : currentChange.change;
                     if (change) {
-                        return this._revealChange(change, index);
+                        if (isLastChangeInCell) {
+                            this.blur(currentChange.change);
+                        }
+                        if (this._revealChange(change, index)) {
+                            return true;
+                        }
                     }
                 }
                 break;
             case 'insert':
             case 'delete':
                 {
+                    this.blur(currentChange.change);
                     const nextChange = changes[changes.indexOf(currentChange.change) + 1];
-                    if (nextChange) {
-                        return this._revealFirstOrLast(nextChange, true);
+                    if (nextChange && this._revealFirstOrLast(nextChange, true)) {
+                        return true;
                     }
                 }
                 break;
         }
         if (wrap) {
-            return this.next(false);
+            const firstChange = changes[0];
+            if (firstChange) {
+                return this._revealFirstOrLast(firstChange, true);
+            }
         }
         return false;
     }
     previous(wrap) {
-        const changes = sortCellChanges(this.cellChanges.get().filter(c => c.type !== 'unchanged'));
-        const currentChange = this.currentChange.get();
+        const changes = this.sortedCellChanges.filter(c => c.type !== 'unchanged');
+        const currentChange = this.getCurrentChange();
         if (!currentChange) {
             const lastChange = changes[changes.length - 1];
             if (lastChange) {
@@ -412,24 +452,30 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
                     const cellIntegration = this.getCell(currentChange.change.modifiedCellIndex);
                     if (cellIntegration) {
                         if (cellIntegration.previous(false)) {
-                            this._currentChange.set({ change: currentChange.change, index: cellIntegration.currentIndex.get() }, undefined);
+                            this.updateCurrentIndex(currentChange.change, cellIntegration.currentIndex.get());
                             return true;
                         }
                     }
-                    const isFirstChangeInCell = currentChange.index === 0;
+                    const isFirstChangeInCell = currentChange.index <= 0;
                     const change = isFirstChangeInCell ? changes[changes.indexOf(currentChange.change) - 1] : currentChange.change;
                     if (change) {
                         const index = isFirstChangeInCell ? lastChangeIndex(change) : currentChange.index - 1;
-                        return this._revealChange(change, index);
+                        if (isFirstChangeInCell) {
+                            this.blur(currentChange.change);
+                        }
+                        if (this._revealChange(change, index)) {
+                            return true;
+                        }
                     }
                 }
                 break;
             case 'insert':
             case 'delete':
                 {
+                    this.blur(currentChange.change);
                     const prevChange = changes[changes.indexOf(currentChange.change) - 1];
-                    if (prevChange) {
-                        return this._revealFirstOrLast(prevChange, false);
+                    if (prevChange && this._revealFirstOrLast(prevChange, false)) {
+                        return true;
                     }
                 }
                 break;
@@ -449,27 +495,60 @@ let ChatEditingNotebookEditorWidgetIntegration = class ChatEditingNotebookEditor
             integration?.enableAccessibleDiffView();
         }
     }
-    acceptNearestChange(change) {
-        change.accept();
-        this.next(true);
+    getfocusedIntegration() {
+        const first = this.notebookEditor.getSelectionViewModels()[0];
+        if (first) {
+            return this.cellEditorIntegrations.get(first.model)?.integration;
+        }
+        return undefined;
     }
-    rejectNearestChange(change) {
-        change.reject();
-        this.next(true);
+    async acceptNearestChange(hunk) {
+        if (hunk) {
+            await hunk.accept();
+        }
+        else {
+            const current = this.getCurrentChange();
+            const focused = this.getfocusedIntegration();
+            if (current && !focused || current?.change.type === 'delete') {
+                current.change.keep(current?.change.diff.get().changes[current.index]);
+            }
+            else if (focused) {
+                await focused.acceptNearestChange();
+            }
+            this._currentIndex.set(this._currentIndex.get() - 1, undefined);
+            this.next(true);
+        }
     }
-    async toggleDiff(_change) {
-        const defaultAgentName = this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditingSession)?.fullName;
+    async rejectNearestChange(hunk) {
+        if (hunk) {
+            await hunk.reject();
+        }
+        else {
+            const current = this.getCurrentChange();
+            const focused = this.getfocusedIntegration();
+            if (current && !focused || current?.change.type === 'delete') {
+                current.change.undo(current.change.diff.get().changes[current.index]);
+            }
+            else if (focused) {
+                await focused.rejectNearestChange();
+            }
+            this._currentIndex.set(this._currentIndex.get() - 1, undefined);
+            this.next(true);
+        }
+    }
+    async toggleDiff(_change, _show) {
+        const defaultAgentName = this._chatAgentService.getDefaultAgent(ChatAgentLocation.Panel)?.fullName;
         const diffInput = {
-            original: { resource: this._entry.originalURI, options: { selection: undefined } },
-            modified: { resource: this._entry.modifiedURI, options: { selection: undefined } },
+            original: { resource: this._entry.originalURI },
+            modified: { resource: this._entry.modifiedURI },
             label: defaultAgentName
                 ? ( localize(
-                4695,
+                4759,
                 '{0} (changes from {1})',
                 basename(this._entry.modifiedURI),
                 defaultAgentName
             ))
-                : ( localize(4696, '{0} (changes from chat)', basename(this._entry.modifiedURI)))
+                : ( localize(4760, '{0} (changes from chat)', basename(this._entry.modifiedURI)))
         };
         await this._editorService.openEditor(diffInput);
     }
@@ -479,7 +558,8 @@ ChatEditingNotebookEditorWidgetIntegration = ( __decorate([
     ( __param(6, IEditorService)),
     ( __param(7, IChatAgentService)),
     ( __param(8, INotebookEditorService)),
-    ( __param(9, IAccessibilitySignalService))
+    ( __param(9, IAccessibilitySignalService)),
+    ( __param(10, ILogService))
 ], ChatEditingNotebookEditorWidgetIntegration));
 class ChatEditingNotebookDiffEditorIntegration extends Disposable {
     constructor(notebookDiffEditor, cellChanges) {
@@ -530,15 +610,15 @@ class ChatEditingNotebookDiffEditorIntegration extends Disposable {
     }
     enableAccessibleDiffView() {
     }
-    acceptNearestChange(change) {
-        change.accept();
+    async acceptNearestChange(change) {
+        await change.accept();
         this.next(true);
     }
-    rejectNearestChange(change) {
-        change.reject();
+    async rejectNearestChange(change) {
+        await change.reject();
         this.next(true);
     }
-    async toggleDiff(_change) {
+    async toggleDiff(_change, _show) {
     }
 }
 function areDocumentDiff2Equal(diff1, diff2) {

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/notebook/overlayToolbarDecorator.d.ts

@@ -0,0 +1,19 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotebookEditor } from "@codingame/monaco-vscode-324f9a6e-6231-5bfc-af17-e147abd2dfd2-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { ICellDiffInfo } from "./notebookCellChanges.js";
+export declare class OverlayToolbarDecorator extends Disposable {
+    private readonly notebookEditor;
+    private readonly notebookModel;
+    private readonly instantiationService;
+    private readonly accessibilitySignalService;
+    private _timeout;
+    private readonly overlayDisposables;
+    constructor(notebookEditor: INotebookEditor, notebookModel: NotebookTextModel, instantiationService: IInstantiationService, accessibilitySignalService: IAccessibilitySignalService);
+    decorate(changes: ICellDiffInfo[]): void;
+    private createMarkdownPreviewToolbars;
+    private getCellViewModel;
+    dispose(): void;
+}