@codingame/monaco-vscode-notebook-service-override 2.2.2 → 3.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController.js

@@ -0,0 +1,744 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { getWindow, scheduleAtNextAnimationFrame, trackFocus, WindowIntervalTimer, Dimension } from 'vscode/vscode/vs/base/browser/dom';
+import { disposableTimeout, createCancelablePromise, Queue, raceCancellationError } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { MovingAverage } from 'vscode/vscode/vs/base/common/numbers';
+import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
+import { assertType } from 'vscode/vscode/vs/base/common/types';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditorWidget';
+import { Selection } from 'vscode/vscode/vs/editor/common/core/selection';
+import { TextEdit } from 'vscode/vscode/vs/editor/common/languages';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/editorWorker';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { AsyncProgress } from 'vscode/vscode/vs/platform/progress/common/progress';
+import { countWords } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatWordCounter';
+import { IInlineChatSavingService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSavingService';
+import { SessionPrompt, EmptyResponse, ReplyResponse, ErrorResponse, SessionExchange } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
+import { InlineChatWidget } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatWidget';
+import { performAsyncTextEdit, asProgressiveEdit } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/utils';
+import { CTX_INLINE_CHAT_LAST_RESPONSE_TYPE } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { insertCell, runDeleteAction } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/cellOperations';
+import { CTX_NOTEBOOK_CHAT_HAS_ACTIVE_REQUEST, CTX_NOTEBOOK_CELL_CHAT_FOCUSED, CTX_NOTEBOOK_CHAT_USER_DID_EDIT, CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION, MENU_CELL_CHAT_INPUT, MENU_CELL_CHAT_WIDGET, MENU_CELL_CHAT_WIDGET_STATUS, MENU_CELL_CHAT_WIDGET_FEEDBACK } from './notebookChatContext.js';
+import { ScrollToRevealBehavior } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NotebookExecutionType, INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
+
+var NotebookChatController_1;
+const WIDGET_MARGIN_BOTTOM = 16;
+class NotebookChatWidget extends Disposable {
+    set afterModelPosition(afterModelPosition) {
+        this.notebookViewZone.afterModelPosition = afterModelPosition;
+    }
+    get afterModelPosition() {
+        return this.notebookViewZone.afterModelPosition;
+    }
+    set heightInPx(heightInPx) {
+        this.notebookViewZone.heightInPx = heightInPx;
+    }
+    get heightInPx() {
+        return this.notebookViewZone.heightInPx;
+    }
+    get editingCell() {
+        return this._editingCell;
+    }
+    constructor(_notebookEditor, id, notebookViewZone, domNode, widgetContainer, inlineChatWidget, parentEditor, _languageService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this.id = id;
+        this.notebookViewZone = notebookViewZone;
+        this.domNode = domNode;
+        this.widgetContainer = widgetContainer;
+        this.inlineChatWidget = inlineChatWidget;
+        this.parentEditor = parentEditor;
+        this._languageService = _languageService;
+        this._editingCell = null;
+        this._register(inlineChatWidget.onDidChangeHeight(() => {
+            this.heightInPx = inlineChatWidget.getHeight() + WIDGET_MARGIN_BOTTOM;
+            this._notebookEditor.changeViewZones(accessor => {
+                accessor.layoutZone(id);
+            });
+            this._layoutWidget(inlineChatWidget, widgetContainer);
+        }));
+        this._layoutWidget(inlineChatWidget, widgetContainer);
+    }
+    focus() {
+        this.inlineChatWidget.focus();
+    }
+    getEditingCell() {
+        return this._editingCell;
+    }
+    async getOrCreateEditingCell() {
+        if (this._editingCell) {
+            await this._notebookEditor.focusNotebookCell(this._editingCell, 'editor');
+            if (this._notebookEditor.activeCodeEditor?.hasModel()) {
+                return {
+                    cell: this._editingCell,
+                    editor: this._notebookEditor.activeCodeEditor
+                };
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (!this._notebookEditor.hasModel()) {
+            return undefined;
+        }
+        this._editingCell = insertCell(this._languageService, this._notebookEditor, this.afterModelPosition, CellKind.Code, 'above');
+        if (!this._editingCell) {
+            return undefined;
+        }
+        await this._notebookEditor.focusNotebookCell(this._editingCell, 'editor', { revealBehavior: ScrollToRevealBehavior.firstLine });
+        if (this._notebookEditor.activeCodeEditor?.hasModel()) {
+            return {
+                cell: this._editingCell,
+                editor: this._notebookEditor.activeCodeEditor
+            };
+        }
+        return undefined;
+    }
+    async discardChange() {
+        if (this._notebookEditor.hasModel() && this._editingCell) {
+            runDeleteAction(this._notebookEditor, this._editingCell);
+        }
+    }
+    _layoutWidget(inlineChatWidget, widgetContainer) {
+        const layoutConfiguration = this._notebookEditor.notebookOptions.getLayoutConfiguration();
+        const rightMargin = layoutConfiguration.cellRightMargin;
+        const leftMargin = this._notebookEditor.notebookOptions.getCellEditorContainerLeftMargin();
+        const maxWidth = !inlineChatWidget.showsAnyPreview() ? 640 : Number.MAX_SAFE_INTEGER;
+        const width = Math.min(maxWidth, this._notebookEditor.getLayoutInfo().width - leftMargin - rightMargin);
+        inlineChatWidget.layout(( new Dimension(width, 80 + WIDGET_MARGIN_BOTTOM)));
+        inlineChatWidget.domNode.style.width = `${width}px`;
+        widgetContainer.style.left = `${leftMargin}px`;
+    }
+    dispose() {
+        this._notebookEditor.changeViewZones(accessor => {
+            accessor.removeZone(this.id);
+        });
+        this.domNode.remove();
+        super.dispose();
+    }
+}
+let NotebookChatController = class NotebookChatController extends Disposable {
+    static { NotebookChatController_1 = this; }
+    static { this.id = 'workbench.notebook.chatController'; }
+    static { this.counter = 0; }
+    static get(editor) {
+        return editor.getContribution(NotebookChatController_1.id);
+    }
+    constructor(_notebookEditor, _instantiationService, _inlineChatSessionService, _contextKeyService, _commandService, _editorWorkerService, _inlineChatSavingService, _modelService, _languageService, _executionStateService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._instantiationService = _instantiationService;
+        this._inlineChatSessionService = _inlineChatSessionService;
+        this._contextKeyService = _contextKeyService;
+        this._commandService = _commandService;
+        this._editorWorkerService = _editorWorkerService;
+        this._inlineChatSavingService = _inlineChatSavingService;
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._executionStateService = _executionStateService;
+        this._userEditingDisposables = this._register(( new DisposableStore()));
+        this._widgetDisposableStore = this._register(( new DisposableStore()));
+        this._ctxHasActiveRequest = CTX_NOTEBOOK_CHAT_HAS_ACTIVE_REQUEST.bindTo(this._contextKeyService);
+        this._ctxCellWidgetFocused = CTX_NOTEBOOK_CELL_CHAT_FOCUSED.bindTo(this._contextKeyService);
+        this._ctxLastResponseType = CTX_INLINE_CHAT_LAST_RESPONSE_TYPE.bindTo(this._contextKeyService);
+        this._ctxUserDidEdit = CTX_NOTEBOOK_CHAT_USER_DID_EDIT.bindTo(this._contextKeyService);
+        this._ctxOuterFocusPosition = CTX_NOTEBOOK_CHAT_OUTER_FOCUS_POSITION.bindTo(this._contextKeyService);
+        this._registerFocusTracker();
+    }
+    _registerFocusTracker() {
+        this._register(this._notebookEditor.onDidChangeFocus(() => {
+            if (!this._widget) {
+                this._ctxOuterFocusPosition.set('');
+                return;
+            }
+            const widgetIndex = this._widget.afterModelPosition;
+            const focus = this._notebookEditor.getFocus().start;
+            if (focus + 1 === widgetIndex) {
+                this._ctxOuterFocusPosition.set('above');
+            }
+            else if (focus === widgetIndex) {
+                this._ctxOuterFocusPosition.set('below');
+            }
+            else {
+                this._ctxOuterFocusPosition.set('');
+            }
+        }));
+    }
+    run(index, input, autoSend) {
+        if (this._widget) {
+            if (this._widget.afterModelPosition === index) ;
+            else {
+                const window = getWindow(this._widget.domNode);
+                this._widget.dispose();
+                this._widget = undefined;
+                this._widgetDisposableStore.clear();
+                scheduleAtNextAnimationFrame(window, () => {
+                    this._createWidget(index, input, autoSend);
+                });
+            }
+            return;
+        }
+        this._createWidget(index, input, autoSend);
+    }
+    _createWidget(index, input, autoSend) {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        this._widgetDisposableStore.clear();
+        const viewZoneContainer = document.createElement('div');
+        viewZoneContainer.classList.add('monaco-editor');
+        const widgetContainer = document.createElement('div');
+        widgetContainer.style.position = 'absolute';
+        viewZoneContainer.appendChild(widgetContainer);
+        this._focusTracker = this._widgetDisposableStore.add(trackFocus(viewZoneContainer));
+        this._widgetDisposableStore.add(this._focusTracker.onDidFocus(() => {
+            this._updateNotebookEditorFocusNSelections();
+        }));
+        const fakeParentEditorElement = document.createElement('div');
+        const fakeParentEditor = this._widgetDisposableStore.add(this._instantiationService.createInstance(CodeEditorWidget, fakeParentEditorElement, {}, { isSimpleWidget: true }));
+        const inputBoxFragment = `notebook-chat-input-${NotebookChatController_1.counter++}`;
+        const notebookUri = this._notebookEditor.textModel.uri;
+        const inputUri = notebookUri.with({ scheme: Schemas.untitled, fragment: inputBoxFragment });
+        const result = this._modelService.createModel('', null, inputUri, false);
+        fakeParentEditor.setModel(result);
+        const inlineChatWidget = this._widgetDisposableStore.add(this._instantiationService.createInstance(InlineChatWidget, fakeParentEditor, {
+            menuId: MENU_CELL_CHAT_INPUT,
+            widgetMenuId: MENU_CELL_CHAT_WIDGET,
+            statusMenuId: MENU_CELL_CHAT_WIDGET_STATUS,
+            feedbackMenuId: MENU_CELL_CHAT_WIDGET_FEEDBACK
+        }));
+        inlineChatWidget.placeholder = ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController',
+            'default.placeholder',
+            "Ask a question"
+        ));
+        inlineChatWidget.updateInfo(( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController',
+            'welcome.1',
+            "AI-generated code may be incorrect"
+        )));
+        widgetContainer.appendChild(inlineChatWidget.domNode);
+        this._widgetDisposableStore.add(inlineChatWidget.onDidChangeInput(() => {
+            this._warmupRequestCts?.dispose(true);
+            this._warmupRequestCts = undefined;
+        }));
+        this._notebookEditor.changeViewZones(accessor => {
+            const notebookViewZone = {
+                afterModelPosition: index,
+                heightInPx: 80 + WIDGET_MARGIN_BOTTOM,
+                domNode: viewZoneContainer
+            };
+            const id = accessor.addZone(notebookViewZone);
+            this._scrollWidgetIntoView(index);
+            this._widget = ( new NotebookChatWidget(
+                this._notebookEditor,
+                id,
+                notebookViewZone,
+                viewZoneContainer,
+                widgetContainer,
+                inlineChatWidget,
+                fakeParentEditor,
+                this._languageService
+            ));
+            this._ctxCellWidgetFocused.set(true);
+            disposableTimeout(() => {
+                this._focusWidget();
+            }, 0, this._store);
+            this._sessionCtor = createCancelablePromise(async (token) => {
+                if (fakeParentEditor.hasModel()) {
+                    await this._startSession(fakeParentEditor, token);
+                    this._warmupRequestCts = ( new CancellationTokenSource());
+                    this._startInitialFolowups(fakeParentEditor, this._warmupRequestCts.token);
+                    if (this._widget) {
+                        this._widget.inlineChatWidget.placeholder = this._activeSession?.session.placeholder ?? ( localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController',
+                            'default.placeholder',
+                            "Ask a question"
+                        ));
+                        this._widget.inlineChatWidget.updateInfo(this._activeSession?.session.message ?? ( localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController',
+                            'welcome.1',
+                            "AI-generated code may be incorrect"
+                        )));
+                        this._widget.inlineChatWidget.updateSlashCommands(this._activeSession?.session.slashCommands ?? []);
+                        this._focusWidget();
+                    }
+                    if (this._widget && input) {
+                        this._widget.inlineChatWidget.value = input;
+                        if (autoSend) {
+                            this.acceptInput();
+                        }
+                    }
+                }
+            });
+        });
+    }
+    _scrollWidgetIntoView(index) {
+        if (index === 0 || this._notebookEditor.getLength() === 0) {
+            this._notebookEditor.revealOffsetInCenterIfOutsideViewport(0);
+        }
+        else {
+            const previousCell = this._notebookEditor.cellAt(Math.min(index - 1, this._notebookEditor.getLength() - 1));
+            if (previousCell) {
+                const cellTop = this._notebookEditor.getAbsoluteTopOfElement(previousCell);
+                const cellHeight = this._notebookEditor.getHeightOfElement(previousCell);
+                this._notebookEditor.revealOffsetInCenterIfOutsideViewport(cellTop + cellHeight + 48 );
+            }
+        }
+    }
+    _focusWidget() {
+        if (!this._widget) {
+            return;
+        }
+        this._updateNotebookEditorFocusNSelections();
+        this._widget.focus();
+    }
+    _updateNotebookEditorFocusNSelections() {
+        if (!this._widget) {
+            return;
+        }
+        this._notebookEditor.focusContainer(true);
+        this._notebookEditor.setFocus({ start: this._widget.afterModelPosition, end: this._widget.afterModelPosition });
+        this._notebookEditor.setSelections([{
+                start: this._widget.afterModelPosition,
+                end: this._widget.afterModelPosition
+            }]);
+    }
+    async acceptInput() {
+        assertType(this._widget);
+        await this._sessionCtor;
+        assertType(this._activeSession);
+        this._warmupRequestCts?.dispose(true);
+        this._warmupRequestCts = undefined;
+        this._activeSession.addInput(( new SessionPrompt(this._widget.inlineChatWidget.value)));
+        assertType(this._activeSession.lastInput);
+        const value = this._activeSession.lastInput.value;
+        const editor = this._widget.parentEditor;
+        const model = editor.getModel();
+        if (!editor.hasModel() || !model) {
+            return;
+        }
+        if (this._widget.editingCell && this._widget.editingCell.textBuffer.getLength() > 0) {
+            const ref = await this._widget.editingCell.resolveTextModel();
+            ref.setValue('');
+        }
+        const editingCellIndex = this._widget.editingCell ? this._notebookEditor.getCellIndex(this._widget.editingCell) : undefined;
+        if (editingCellIndex !== undefined) {
+            this._notebookEditor.setSelections([{
+                    start: editingCellIndex,
+                    end: editingCellIndex + 1
+                }]);
+        }
+        else {
+            this._notebookEditor.setSelections([{
+                    start: this._widget.afterModelPosition,
+                    end: this._widget.afterModelPosition
+                }]);
+        }
+        this._ctxHasActiveRequest.set(true);
+        this._widget.inlineChatWidget.updateSlashCommands(this._activeSession.session.slashCommands ?? []);
+        this._widget?.inlineChatWidget.updateProgress(true);
+        const request = {
+            requestId: generateUuid(),
+            prompt: value,
+            attempt: this._activeSession.lastInput.attempt,
+            selection: { selectionStartLineNumber: 1, selectionStartColumn: 1, positionLineNumber: 1, positionColumn: 1 },
+            wholeRange: { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+            live: true,
+            previewDocument: model.uri,
+            withIntentDetection: true,
+        };
+        this._activeRequestCts?.cancel();
+        this._activeRequestCts = ( new CancellationTokenSource());
+        const progressEdits = [];
+        const progressiveEditsQueue = ( new Queue());
+        const progressiveEditsClock = StopWatch.create();
+        const progressiveEditsAvgDuration = ( new MovingAverage());
+        const progressiveEditsCts = ( new CancellationTokenSource(this._activeRequestCts.token));
+        let progressiveChatResponse;
+        const progress = ( new AsyncProgress(async (data) => {
+            if (this._activeRequestCts?.token.isCancellationRequested) {
+                return;
+            }
+            if (data.message) {
+                this._widget?.inlineChatWidget.updateToolbar(false);
+                this._widget?.inlineChatWidget.updateInfo(data.message);
+            }
+            if (data.edits?.length) {
+                if (!request.live) {
+                    throw new Error('Progress in NOT supported in non-live mode');
+                }
+                progressEdits.push(data.edits);
+                progressiveEditsAvgDuration.update(progressiveEditsClock.elapsed());
+                progressiveEditsClock.reset();
+                progressiveEditsQueue.queue(async () => {
+                    await this._makeChanges(data.edits, data.editsShouldBeInstant
+                        ? undefined
+                        : { duration: progressiveEditsAvgDuration.value, token: progressiveEditsCts.token });
+                });
+            }
+            if (data.markdownFragment) {
+                if (!progressiveChatResponse) {
+                    const message = {
+                        message: ( new MarkdownString(
+                            data.markdownFragment,
+                            { supportThemeIcons: true, supportHtml: true, isTrusted: false }
+                        )),
+                        providerId: this._activeSession.provider.debugName,
+                        requestId: request.requestId,
+                    };
+                    progressiveChatResponse = this._widget?.inlineChatWidget.updateChatMessage(message, true);
+                }
+                else {
+                    progressiveChatResponse.appendContent(data.markdownFragment);
+                }
+            }
+        }));
+        const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, this._activeRequestCts.token);
+        let response;
+        try {
+            this._widget?.inlineChatWidget.updateChatMessage(undefined);
+            this._widget?.inlineChatWidget.updateFollowUps(undefined);
+            this._widget?.inlineChatWidget.updateProgress(true);
+            this._widget?.inlineChatWidget.updateInfo(!this._activeSession.lastExchange ? ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/chat/notebookChatController',
+                'thinking',
+                "Thinking\u2026"
+            )) : '');
+            this._ctxHasActiveRequest.set(true);
+            const reply = await raceCancellationError(Promise.resolve(task), this._activeRequestCts.token);
+            if (progressiveEditsQueue.size > 0) {
+                await Event.toPromise(progressiveEditsQueue.onDrained);
+            }
+            await progress.drain();
+            if (!reply) {
+                response = ( new EmptyResponse());
+            }
+            else {
+                const markdownContents = ( new MarkdownString('', { supportThemeIcons: true, supportHtml: true, isTrusted: false }));
+                const replyResponse = response = this._instantiationService.createInstance(ReplyResponse, reply, markdownContents, this._activeSession.textModelN.uri, this._activeSession.textModelN.getAlternativeVersionId(), progressEdits, request.requestId);
+                for (let i = progressEdits.length; i < replyResponse.allLocalEdits.length; i++) {
+                    await this._makeChanges(replyResponse.allLocalEdits[i], undefined);
+                }
+                if (this._activeSession?.provider.provideFollowups) {
+                    const followupCts = ( new CancellationTokenSource());
+                    const followups = await this._activeSession.provider.provideFollowups(this._activeSession.session, replyResponse.raw, followupCts.token);
+                    if (followups && this._widget) {
+                        const widget = this._widget;
+                        widget.inlineChatWidget.updateFollowUps(followups, async (followup) => {
+                            if (followup.kind === 'reply') {
+                                widget.inlineChatWidget.value = followup.message;
+                                this.acceptInput();
+                            }
+                            else {
+                                await this.acceptSession();
+                                this._commandService.executeCommand(followup.commandId, ...(followup.args ?? []));
+                            }
+                        });
+                    }
+                }
+                this._userEditingDisposables.clear();
+                const editingCell = this._widget.getEditingCell();
+                if (editingCell) {
+                    this._userEditingDisposables.add(editingCell.model.onDidChangeContent(() => this._updateUserEditingState()));
+                    this._userEditingDisposables.add(editingCell.model.onDidChangeLanguage(() => this._updateUserEditingState()));
+                    this._userEditingDisposables.add(editingCell.model.onDidChangeMetadata(() => this._updateUserEditingState()));
+                    this._userEditingDisposables.add(editingCell.model.onDidChangeInternalMetadata(() => this._updateUserEditingState()));
+                    this._userEditingDisposables.add(editingCell.model.onDidChangeOutputs(() => this._updateUserEditingState()));
+                    this._userEditingDisposables.add(this._executionStateService.onDidChangeExecution(e => {
+                        if (e.type === NotebookExecutionType.cell && e.affectsCell(editingCell.uri)) {
+                            this._updateUserEditingState();
+                        }
+                    }));
+                }
+            }
+        }
+        catch (e) {
+            response = ( new ErrorResponse(e));
+        }
+        finally {
+            this._ctxHasActiveRequest.set(false);
+            this._widget?.inlineChatWidget.updateProgress(false);
+            this._widget?.inlineChatWidget.updateInfo('');
+            this._widget?.inlineChatWidget.updateToolbar(true);
+        }
+        this._ctxHasActiveRequest.set(false);
+        this._widget?.inlineChatWidget.updateProgress(false);
+        this._widget?.inlineChatWidget.updateInfo('');
+        this._widget?.inlineChatWidget.updateToolbar(true);
+        this._activeSession?.addExchange(( new SessionExchange(this._activeSession.lastInput, response)));
+        this._ctxLastResponseType.set(response instanceof ReplyResponse ? response.raw.type : undefined);
+    }
+    async _startSession(editor, token) {
+        if (this._activeSession) {
+            this._inlineChatSessionService.releaseSession(this._activeSession);
+        }
+        const session = await this._inlineChatSessionService.createSession(editor, { editMode: "live"  }, token);
+        if (!session) {
+            return;
+        }
+        this._activeSession = session;
+        this._strategy = ( new EditStrategy(session));
+    }
+    async _startInitialFolowups(editor, token) {
+        if (!this._activeSession || !this._activeSession.provider.provideFollowups) {
+            return;
+        }
+        const request = {
+            requestId: generateUuid(),
+            prompt: '',
+            attempt: 0,
+            selection: { selectionStartLineNumber: 1, selectionStartColumn: 1, positionLineNumber: 1, positionColumn: 1 },
+            wholeRange: { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 1 },
+            live: true,
+            previewDocument: editor.getModel().uri,
+            withIntentDetection: true
+        };
+        const progress = ( new AsyncProgress(async (data) => { }));
+        const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, token);
+        const reply = await raceCancellationError(Promise.resolve(task), token);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        if (!reply) {
+            return;
+        }
+        const markdownContents = ( new MarkdownString('', { supportThemeIcons: true, supportHtml: true, isTrusted: false }));
+        const response = this._instantiationService.createInstance(ReplyResponse, reply, markdownContents, this._activeSession.textModelN.uri, this._activeSession.textModelN.getAlternativeVersionId(), [], request.requestId);
+        const followups = await this._activeSession.provider.provideFollowups(this._activeSession.session, response.raw, token);
+        if (followups && this._widget) {
+            const widget = this._widget;
+            widget.inlineChatWidget.updateFollowUps(followups, async (followup) => {
+                if (followup.kind === 'reply') {
+                    widget.inlineChatWidget.value = followup.message;
+                    this.acceptInput();
+                }
+                else {
+                    await this.acceptSession();
+                    this._commandService.executeCommand(followup.commandId, ...(followup.args ?? []));
+                }
+            });
+        }
+    }
+    async _makeChanges(edits, opts) {
+        assertType(this._activeSession);
+        assertType(this._strategy);
+        assertType(this._widget);
+        const editingCell = await this._widget.getOrCreateEditingCell();
+        if (!editingCell) {
+            return;
+        }
+        const editor = editingCell.editor;
+        const moreMinimalEdits = await this._editorWorkerService.computeMoreMinimalEdits(editor.getModel().uri, edits);
+        if (moreMinimalEdits?.length === 0) {
+            return;
+        }
+        const actualEdits = !opts && moreMinimalEdits ? moreMinimalEdits : edits;
+        const editOperations = ( actualEdits.map(TextEdit.asEditOperation));
+        this._inlineChatSavingService.markChanged(this._activeSession);
+        try {
+            this._activeSession.wholeRange.trackEdits(editOperations);
+            if (opts) {
+                await this._strategy.makeProgressiveChanges(editor, editOperations, opts);
+            }
+            else {
+                await this._strategy.makeChanges(editor, editOperations);
+            }
+        }
+        finally {
+        }
+    }
+    _updateUserEditingState() {
+        this._ctxUserDidEdit.set(true);
+    }
+    async acceptSession() {
+        assertType(this._activeSession);
+        assertType(this._strategy);
+        const editor = this._widget?.parentEditor;
+        if (!editor?.hasModel()) {
+            return;
+        }
+        try {
+            await this._strategy.apply(editor);
+            this._inlineChatSessionService.releaseSession(this._activeSession);
+        }
+        catch (_err) { }
+        this.dismiss();
+    }
+    async focusAbove() {
+        if (!this._widget) {
+            return;
+        }
+        const index = this._widget.afterModelPosition;
+        const prev = index - 1;
+        if (prev < 0) {
+            return;
+        }
+        const cell = this._notebookEditor.cellAt(prev);
+        if (!cell) {
+            return;
+        }
+        await this._notebookEditor.focusNotebookCell(cell, 'editor');
+    }
+    async focusNext() {
+        if (!this._widget) {
+            return;
+        }
+        const index = this._widget.afterModelPosition;
+        const cell = this._notebookEditor.cellAt(index);
+        if (!cell) {
+            return;
+        }
+        await this._notebookEditor.focusNotebookCell(cell, 'editor');
+    }
+    focus() {
+        this._focusWidget();
+    }
+    focusNearestWidget(index, direction) {
+        switch (direction) {
+            case 'above':
+                if (this._widget?.afterModelPosition === index) {
+                    this._focusWidget();
+                }
+                break;
+            case 'below':
+                if (this._widget?.afterModelPosition === index + 1) {
+                    this._focusWidget();
+                }
+                break;
+        }
+    }
+    async cancelCurrentRequest(discard) {
+        if (discard) {
+            this._strategy?.cancel();
+        }
+        this._activeRequestCts?.cancel();
+    }
+    discard() {
+        this._strategy?.cancel();
+        this._activeRequestCts?.cancel();
+        this._widget?.discardChange();
+        this.dismiss();
+    }
+    async feedbackLast(kind) {
+        if (this._activeSession?.lastExchange && this._activeSession.lastExchange.response instanceof ReplyResponse) {
+            this._activeSession.provider.handleInlineChatResponseFeedback?.(this._activeSession.session, this._activeSession.lastExchange.response.raw, kind);
+            this._widget?.inlineChatWidget.updateStatus('Thank you for your feedback!', { resetAfter: 1250 });
+        }
+    }
+    dismiss() {
+        if (this._widget) {
+            const widgetIndex = this._widget.afterModelPosition;
+            const currentFocus = this._notebookEditor.getFocus();
+            if (currentFocus.start === widgetIndex && currentFocus.end === widgetIndex) {
+                if (widgetIndex === 0) {
+                    if (this._notebookEditor.getLength() > 0) {
+                        this._notebookEditor.focusNotebookCell(this._notebookEditor.cellAt(0), 'container');
+                    }
+                }
+                else {
+                    const cell = this._notebookEditor.cellAt(widgetIndex - 1);
+                    if (cell) {
+                        this._notebookEditor.focusNotebookCell(cell, 'container');
+                    }
+                }
+            }
+        }
+        this._ctxCellWidgetFocused.set(false);
+        this._ctxUserDidEdit.set(false);
+        this._sessionCtor?.cancel();
+        this._sessionCtor = undefined;
+        this._widget?.dispose();
+        this._widget = undefined;
+        this._widgetDisposableStore.clear();
+    }
+    dispose() {
+        this.dismiss();
+        super.dispose();
+    }
+};
+NotebookChatController = NotebookChatController_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IInlineChatSessionService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, ICommandService)),
+    ( __param(5, IEditorWorkerService)),
+    ( __param(6, IInlineChatSavingService)),
+    ( __param(7, IModelService)),
+    ( __param(8, ILanguageService)),
+    ( __param(9, INotebookExecutionStateService))
+], NotebookChatController));
+class EditStrategy {
+    constructor(_session) {
+        this._session = _session;
+        this._editCount = 0;
+    }
+    async makeProgressiveChanges(editor, edits, opts) {
+        if (++this._editCount === 1) {
+            editor.pushUndoStop();
+        }
+        const durationInSec = opts.duration / 1000;
+        for (const edit of edits) {
+            const wordCount = countWords(edit.text ?? '');
+            const speed = wordCount / durationInSec;
+            await performAsyncTextEdit(editor.getModel(), asProgressiveEdit(( new WindowIntervalTimer()), edit, speed, opts.token));
+        }
+    }
+    async makeChanges(editor, edits) {
+        const cursorStateComputerAndInlineDiffCollection = (undoEdits) => {
+            let last = null;
+            for (const edit of undoEdits) {
+                last = !last || last.isBefore(edit.range.getEndPosition()) ? edit.range.getEndPosition() : last;
+            }
+            return last && [Selection.fromPositions(last)];
+        };
+        if (++this._editCount === 1) {
+            editor.pushUndoStop();
+        }
+        editor.executeEdits('inline-chat-live', edits, cursorStateComputerAndInlineDiffCollection);
+    }
+    async apply(editor) {
+        if (this._editCount > 0) {
+            editor.pushUndoStop();
+        }
+        if (!(this._session.lastExchange?.response instanceof ReplyResponse)) {
+            return;
+        }
+        const { untitledTextModel } = this._session.lastExchange.response;
+        if (untitledTextModel && !untitledTextModel.isDisposed() && untitledTextModel.isDirty()) {
+            await untitledTextModel.save({ reason: 1  });
+        }
+    }
+    async cancel() {
+        const { textModelN: modelN, textModelNAltVersion, textModelNSnapshotAltVersion } = this._session;
+        if (modelN.isDisposed()) {
+            return;
+        }
+        const targetAltVersion = textModelNSnapshotAltVersion ?? textModelNAltVersion;
+        while (targetAltVersion < modelN.getAlternativeVersionId() && modelN.canUndo()) {
+            modelN.undo();
+        }
+    }
+    createSnapshot() {
+        if (this._session && !this._session.textModel0.equalsTextBuffer(this._session.textModelN.getTextBuffer())) {
+            this._session.createSnapshot();
+        }
+    }
+}
+registerNotebookContribution(NotebookChatController.id, NotebookChatController);
+
+export { EditStrategy, NotebookChatController };