@codingame/monaco-vscode-notebook-service-override 3.2.2 → 4.0.0

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

@@ -1,744 +0,0 @@
-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 };