@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common 20.0.0

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

@@ -0,0 +1,1318 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { alert } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { Barrier, DeferredPromise, Queue, raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { DisposableStore, MutableDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { MovingAverage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/numbers';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { observableCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/observableCodeEditor';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { Selection, SelectionDirection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
+import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { DefaultModelSHA1Computer } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/modelService';
+import { InlineCompletionsController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController';
+import { MessageController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/message/browser/messageController';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+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 { SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { showChatView } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatRequestRemovalReason } from '@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { InlineChatConfigKeys, INLINE_CHAT_ID, CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_EDITING, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, InlineChatResponseType } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { Session } from './inlineChatSession.js';
+import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
+import { InlineChatError } from './inlineChatSessionServiceImpl.js';
+import { LiveStrategy, HunkAction } from './inlineChatStrategies.js';
+import { InlineChatZoneWidget } from './inlineChatZoneWidget.js';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { ISharedWebContentExtractorService } from '@codingame/monaco-vscode-api/vscode/vs/platform/webContentExtractor/common/webContentExtractor.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IChatAttachmentResolveService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { isNotebookContainingCellEditor } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun, autorunWithStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { waitForState } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utilsCancellation';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var InlineChatController_1, InlineChatController1_1, InlineChatController2_1;
+var State;
+(function (State) {
+    State["CREATE_SESSION"] = "CREATE_SESSION";
+    State["INIT_UI"] = "INIT_UI";
+    State["WAIT_FOR_INPUT"] = "WAIT_FOR_INPUT";
+    State["SHOW_REQUEST"] = "SHOW_REQUEST";
+    State["PAUSE"] = "PAUSE";
+    State["CANCEL"] = "CANCEL";
+    State["ACCEPT"] = "DONE";
+})(State || (State = {}));
+var Message;
+(function (Message) {
+    Message[Message["NONE"] = 0] = "NONE";
+    Message[Message["ACCEPT_SESSION"] = 1] = "ACCEPT_SESSION";
+    Message[Message["CANCEL_SESSION"] = 2] = "CANCEL_SESSION";
+    Message[Message["PAUSE_SESSION"] = 4] = "PAUSE_SESSION";
+    Message[Message["CANCEL_REQUEST"] = 8] = "CANCEL_REQUEST";
+    Message[Message["CANCEL_INPUT"] = 16] = "CANCEL_INPUT";
+    Message[Message["ACCEPT_INPUT"] = 32] = "ACCEPT_INPUT";
+})(Message || (Message = {}));
+class InlineChatRunOptions {
+    static isInlineChatRunOptions(options) {
+        const { initialSelection, initialRange, message, autoSend, position, existingSession, attachments: attachments } = options;
+        if (typeof message !== 'undefined' && typeof message !== 'string'
+            || typeof autoSend !== 'undefined' && typeof autoSend !== 'boolean'
+            || typeof initialRange !== 'undefined' && !Range.isIRange(initialRange)
+            || typeof initialSelection !== 'undefined' && !Selection.isISelection(initialSelection)
+            || typeof position !== 'undefined' && !Position.isIPosition(position)
+            || typeof existingSession !== 'undefined' && !(existingSession instanceof Session)
+            || typeof attachments !== 'undefined' && (!Array.isArray(attachments) || !attachments.every(item => item instanceof URI))) {
+            return false;
+        }
+        return true;
+    }
+}
+let InlineChatController = class InlineChatController {
+    static { InlineChatController_1 = this; }
+    static { this.ID = 'editor.contrib.inlineChatController'; }
+    static get(editor) {
+        return editor.getContribution(InlineChatController_1.ID);
+    }
+    constructor(editor, configurationService) {
+        const inlineChat2 = observableConfigValue(InlineChatConfigKeys.EnableV2, false, configurationService);
+        this._delegate = derived(r => {
+            if (inlineChat2.read(r)) {
+                return InlineChatController2.get(editor);
+            }
+            else {
+                return InlineChatController1.get(editor);
+            }
+        });
+    }
+    dispose() {
+    }
+    get isActive() {
+        return this._delegate.get().isActive;
+    }
+    async run(arg) {
+        return this._delegate.get().run(arg);
+    }
+    focus() {
+        return this._delegate.get().focus();
+    }
+    get widget() {
+        return this._delegate.get().widget;
+    }
+    getWidgetPosition() {
+        return this._delegate.get().getWidgetPosition();
+    }
+    acceptSession() {
+        return this._delegate.get().acceptSession();
+    }
+};
+InlineChatController = InlineChatController_1 = ( __decorate([
+    ( __param(1, IConfigurationService))
+], InlineChatController));
+let InlineChatController1 = InlineChatController1_1 = class InlineChatController1 {
+    static get(editor) {
+        return editor.getContribution(INLINE_CHAT_ID);
+    }
+    get chatWidget() {
+        return this._ui.value.widget.chatWidget;
+    }
+    constructor(_editor, _instaService, _inlineChatSessionService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatService, _editorService, notebookEditorService, _webContentExtractorService, _fileService, _chatAttachmentResolveService) {
+        this._editor = _editor;
+        this._instaService = _instaService;
+        this._inlineChatSessionService = _inlineChatSessionService;
+        this._editorWorkerService = _editorWorkerService;
+        this._logService = _logService;
+        this._configurationService = _configurationService;
+        this._dialogService = _dialogService;
+        this._chatService = _chatService;
+        this._editorService = _editorService;
+        this._webContentExtractorService = _webContentExtractorService;
+        this._fileService = _fileService;
+        this._chatAttachmentResolveService = _chatAttachmentResolveService;
+        this._isDisposed = false;
+        this._store = ( new DisposableStore());
+        this._messages = this._store.add(( new Emitter()));
+        this._onDidEnterState = this._store.add(( new Emitter()));
+        this._sessionStore = this._store.add(( new DisposableStore()));
+        this._stashedSession = this._store.add(( new MutableDisposable()));
+        this._ctxVisible = CTX_INLINE_CHAT_VISIBLE.bindTo(contextKeyService);
+        this._ctxEditing = CTX_INLINE_CHAT_EDITING.bindTo(contextKeyService);
+        this._ctxResponseType = CTX_INLINE_CHAT_RESPONSE_TYPE.bindTo(contextKeyService);
+        this._ctxRequestInProgress = CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.bindTo(contextKeyService);
+        this._ctxResponse = ChatContextKeys.isResponse.bindTo(contextKeyService);
+        ChatContextKeys.responseHasError.bindTo(contextKeyService);
+        this._ui = ( new Lazy(() => {
+            const location = {
+                location: ChatAgentLocation.Editor,
+                resolveData: () => {
+                    assertType(this._editor.hasModel());
+                    assertType(this._session);
+                    return {
+                        type: ChatAgentLocation.Editor,
+                        selection: this._editor.getSelection(),
+                        document: this._session.textModelN.uri,
+                        wholeRange: this._session?.wholeRange.trackedInitialRange,
+                    };
+                }
+            };
+            let notebookEditor;
+            for (const editor of notebookEditorService.listNotebookEditors()) {
+                for (const [, codeEditor] of editor.codeEditors) {
+                    if (codeEditor === this._editor) {
+                        notebookEditor = editor;
+                        location.location = ChatAgentLocation.Notebook;
+                        break;
+                    }
+                }
+            }
+            const zone = _instaService.createInstance(InlineChatZoneWidget, location, undefined, { editor: this._editor, notebookEditor });
+            this._store.add(zone);
+            this._store.add(zone.widget.chatWidget.onDidClear(async () => {
+                const r = this.joinCurrentRun();
+                this.cancelSession();
+                await r;
+                this.run();
+            }));
+            return zone;
+        }));
+        this._store.add(this._editor.onDidChangeModel(async (e) => {
+            if (this._session || !e.newModelUrl) {
+                return;
+            }
+            const existingSession = this._inlineChatSessionService.getSession(this._editor, e.newModelUrl);
+            if (!existingSession) {
+                return;
+            }
+            this._log('session RESUMING after model change', e);
+            await this.run({ existingSession });
+        }));
+        this._store.add(this._inlineChatSessionService.onDidEndSession(e => {
+            if (e.session === this._session && e.endedByExternalCause) {
+                this._log('session ENDED by external cause');
+                this.acceptSession();
+            }
+        }));
+        this._store.add(this._inlineChatSessionService.onDidMoveSession(async (e) => {
+            if (e.editor === this._editor) {
+                this._log('session RESUMING after move', e);
+                await this.run({ existingSession: e.session });
+            }
+        }));
+        this._log(`NEW controller`);
+    }
+    dispose() {
+        if (this._currentRun) {
+            this._messages.fire(this._session?.chatModel.hasRequests
+                ? Message.PAUSE_SESSION
+                : Message.CANCEL_SESSION);
+        }
+        this._store.dispose();
+        this._isDisposed = true;
+        this._log('DISPOSED controller');
+    }
+    _log(message, ...more) {
+        if (message instanceof Error) {
+            this._logService.error(message, ...more);
+        }
+        else {
+            this._logService.trace(`[IE] (editor:${this._editor.getId()}) ${message}`, ...more);
+        }
+    }
+    get widget() {
+        return this._ui.value.widget;
+    }
+    getId() {
+        return INLINE_CHAT_ID;
+    }
+    getWidgetPosition() {
+        return this._ui.value.position;
+    }
+    async run(options = {}) {
+        let lastState;
+        const d = this._onDidEnterState.event(e => lastState = e);
+        try {
+            this.acceptSession();
+            if (this._currentRun) {
+                await this._currentRun;
+            }
+            if (options.initialSelection) {
+                this._editor.setSelection(options.initialSelection);
+            }
+            this._stashedSession.clear();
+            this._currentRun = this._nextState(State.CREATE_SESSION, options);
+            await this._currentRun;
+        }
+        catch (error) {
+            this._log('error during run', error);
+            onUnexpectedError(error);
+            if (this._session) {
+                this._inlineChatSessionService.releaseSession(this._session);
+            }
+            this[State.PAUSE]();
+        }
+        finally {
+            this._currentRun = undefined;
+            d.dispose();
+        }
+        return lastState !== State.CANCEL;
+    }
+    async _nextState(state, options) {
+        let nextState = state;
+        while (nextState && !this._isDisposed) {
+            this._log('setState to ', nextState);
+            const p = this[nextState](options);
+            this._onDidEnterState.fire(nextState);
+            nextState = await p;
+        }
+    }
+    async [State.CREATE_SESSION](options) {
+        assertType(this._session === undefined);
+        assertType(this._editor.hasModel());
+        let session = options.existingSession;
+        let initPosition;
+        if (options.position) {
+            initPosition = Position.lift(options.position).delta(-1);
+            delete options.position;
+        }
+        const widgetPosition = this._showWidget(session?.headless, true, initPosition);
+        let errorMessage = ( localize(7676, "Failed to start editor chat"));
+        if (!session) {
+            const createSessionCts = ( new CancellationTokenSource());
+            const msgListener = Event.once(this._messages.event)(m => {
+                this._log('state=_createSession) message received', m);
+                if (m === Message.ACCEPT_INPUT) {
+                    options.autoSend = true;
+                    this._ui.value.widget.updateInfo(( localize(7677, "Getting ready...")));
+                }
+                else {
+                    createSessionCts.cancel();
+                }
+            });
+            try {
+                session = await this._inlineChatSessionService.createSession(this._editor, { wholeRange: options.initialRange }, createSessionCts.token);
+            }
+            catch (error) {
+                if (error instanceof InlineChatError || error?.name === InlineChatError.code) {
+                    errorMessage = error.message;
+                }
+            }
+            createSessionCts.dispose();
+            msgListener.dispose();
+            if (createSessionCts.token.isCancellationRequested) {
+                if (session) {
+                    this._inlineChatSessionService.releaseSession(session);
+                }
+                return State.CANCEL;
+            }
+        }
+        delete options.initialRange;
+        delete options.existingSession;
+        if (!session) {
+            MessageController.get(this._editor)?.showMessage(errorMessage, widgetPosition);
+            this._log('Failed to start editor chat');
+            return State.CANCEL;
+        }
+        this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._ui.value, session.headless);
+        this._session = session;
+        return State.INIT_UI;
+    }
+    async [State.INIT_UI](options) {
+        assertType(this._session);
+        assertType(this._strategy);
+        InlineCompletionsController.get(this._editor)?.reject();
+        this._sessionStore.clear();
+        const wholeRangeDecoration = this._editor.createDecorationsCollection();
+        const handleWholeRangeChange = () => {
+            const newDecorations = this._strategy?.getWholeRangeDecoration() ?? [];
+            wholeRangeDecoration.set(newDecorations);
+            this._ctxEditing.set(!this._session?.wholeRange.trackedInitialRange.isEmpty());
+        };
+        this._sessionStore.add(toDisposable(() => {
+            wholeRangeDecoration.clear();
+            this._ctxEditing.reset();
+        }));
+        this._sessionStore.add(this._session.wholeRange.onDidChange(handleWholeRangeChange));
+        handleWholeRangeChange();
+        this._ui.value.widget.setChatModel(this._session.chatModel);
+        this._updatePlaceholder();
+        const isModelEmpty = !this._session.chatModel.hasRequests;
+        this._ui.value.widget.updateToolbar(true);
+        this._ui.value.widget.toggleStatus(!isModelEmpty);
+        this._showWidget(this._session.headless, isModelEmpty);
+        this._sessionStore.add(this._editor.onDidChangeModel((e) => {
+            const msg = this._session?.chatModel.hasRequests
+                ? Message.PAUSE_SESSION
+                : Message.CANCEL_SESSION;
+            this._log('model changed, pause or cancel session', msg, e);
+            this._messages.fire(msg);
+        }));
+        this._sessionStore.add(this._editor.onDidChangeModelContent(e => {
+            if (this._session?.hunkData.ignoreTextModelNChanges || this._ui.value.widget.hasFocus()) {
+                return;
+            }
+            const wholeRange = this._session.wholeRange;
+            let shouldFinishSession = false;
+            if (this._configurationService.getValue(InlineChatConfigKeys.FinishOnType)) {
+                for (const { range } of e.changes) {
+                    shouldFinishSession = !Range.areIntersectingOrTouching(range, wholeRange.value);
+                }
+            }
+            this._session.recordExternalEditOccurred(shouldFinishSession);
+            if (shouldFinishSession) {
+                this._log('text changed outside of whole range, FINISH session');
+                this.acceptSession();
+            }
+        }));
+        this._sessionStore.add(this._session.chatModel.onDidChange(async (e) => {
+            if (e.kind === 'removeRequest') {
+                await this._session.undoChangesUntil(e.requestId);
+            }
+        }));
+        const editState = this._createChatTextEditGroupState();
+        let didEdit = false;
+        for (const request of this._session.chatModel.getRequests()) {
+            if (!request.response || request.response.result?.errorDetails) {
+                break;
+            }
+            for (const part of request.response.response.value) {
+                if (part.kind !== 'textEditGroup' || !isEqual(part.uri, this._session.textModelN.uri)) {
+                    continue;
+                }
+                if (part.state?.applied) {
+                    continue;
+                }
+                for (const edit of part.edits) {
+                    this._makeChanges(edit, undefined, !didEdit);
+                    didEdit = true;
+                }
+                part.state ??= editState;
+            }
+        }
+        if (didEdit) {
+            const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { computeMoves: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER, ignoreTrimWhitespace: false }, 'advanced');
+            this._session.wholeRange.fixup(diff?.changes ?? []);
+            await this._session.hunkData.recompute(editState, diff);
+            this._updateCtxResponseType();
+        }
+        options.position = await this._strategy.renderChanges();
+        if (this._session.chatModel.requestInProgress) {
+            return State.SHOW_REQUEST;
+        }
+        else {
+            return State.WAIT_FOR_INPUT;
+        }
+    }
+    async [State.WAIT_FOR_INPUT](options) {
+        assertType(this._session);
+        assertType(this._strategy);
+        this._updatePlaceholder();
+        if (options.message) {
+            this._updateInput(options.message);
+            alert(options.message);
+            delete options.message;
+            this._showWidget(this._session.headless, false);
+        }
+        let message = Message.NONE;
+        let request;
+        const barrier = ( new Barrier());
+        const store = ( new DisposableStore());
+        store.add(this._session.chatModel.onDidChange(e => {
+            if (e.kind === 'addRequest') {
+                request = e.request;
+                message = Message.ACCEPT_INPUT;
+                barrier.open();
+            }
+        }));
+        store.add(this._strategy.onDidAccept(() => this.acceptSession()));
+        store.add(this._strategy.onDidDiscard(() => this.cancelSession()));
+        store.add(Event.once(this._messages.event)(m => {
+            this._log('state=_waitForInput) message received', m);
+            message = m;
+            barrier.open();
+        }));
+        if (options.attachments) {
+            await Promise.all(( options.attachments.map(async (attachment) => {
+                await this._ui.value.widget.chatWidget.attachmentModel.addFile(attachment);
+            })));
+            delete options.attachments;
+        }
+        if (options.autoSend) {
+            delete options.autoSend;
+            this._showWidget(this._session.headless, false);
+            this._ui.value.widget.chatWidget.acceptInput();
+        }
+        await barrier.wait();
+        store.dispose();
+        if (message & (Message.CANCEL_INPUT | Message.CANCEL_SESSION)) {
+            return State.CANCEL;
+        }
+        if (message & Message.PAUSE_SESSION) {
+            return State.PAUSE;
+        }
+        if (message & Message.ACCEPT_SESSION) {
+            this._ui.value.widget.selectAll();
+            return State.ACCEPT;
+        }
+        if (!request?.message.text) {
+            return State.WAIT_FOR_INPUT;
+        }
+        return State.SHOW_REQUEST;
+    }
+    async [State.SHOW_REQUEST](options) {
+        assertType(this._session);
+        assertType(this._strategy);
+        assertType(this._session.chatModel.requestInProgress);
+        this._ctxRequestInProgress.set(true);
+        const { chatModel } = this._session;
+        const request = chatModel.lastRequest;
+        assertType(request);
+        assertType(request.response);
+        this._showWidget(this._session.headless, false);
+        this._ui.value.widget.selectAll();
+        this._ui.value.widget.updateInfo('');
+        this._ui.value.widget.toggleStatus(true);
+        const { response } = request;
+        const responsePromise = ( new DeferredPromise());
+        const store = ( new DisposableStore());
+        const progressiveEditsCts = store.add(( new CancellationTokenSource()));
+        const progressiveEditsAvgDuration = ( new MovingAverage());
+        const progressiveEditsClock = StopWatch.create();
+        const progressiveEditsQueue = ( new Queue());
+        const origDeco = this._editor.getOption(EditorOption.renderValidationDecorations);
+        this._editor.updateOptions({
+            renderValidationDecorations: 'off'
+        });
+        store.add(toDisposable(() => {
+            this._editor.updateOptions({
+                renderValidationDecorations: origDeco
+            });
+        }));
+        let next = State.WAIT_FOR_INPUT;
+        store.add(Event.once(this._messages.event)(message => {
+            this._log('state=_makeRequest) message received', message);
+            this._chatService.cancelCurrentRequestForSession(chatModel.sessionId);
+            if (message & Message.CANCEL_SESSION) {
+                next = State.CANCEL;
+            }
+            else if (message & Message.PAUSE_SESSION) {
+                next = State.PAUSE;
+            }
+            else if (message & Message.ACCEPT_SESSION) {
+                next = State.ACCEPT;
+            }
+        }));
+        store.add(chatModel.onDidChange(async (e) => {
+            if (e.kind === 'removeRequest' && e.requestId === request.id) {
+                progressiveEditsCts.cancel();
+                responsePromise.complete();
+                if (e.reason === ChatRequestRemovalReason.Resend) {
+                    next = State.SHOW_REQUEST;
+                }
+                else {
+                    next = State.CANCEL;
+                }
+                return;
+            }
+            if (e.kind === 'move') {
+                assertType(this._session);
+                const log = (msg, ...args) => this._log('state=_showRequest) moving inline chat', msg, ...args);
+                log('move was requested', e.target, e.range);
+                const initialSelection = Selection.fromRange(Range.lift(e.range), SelectionDirection.LTR);
+                const editorPane = await this._editorService.openEditor({ resource: e.target, options: { selection: initialSelection } }, SIDE_GROUP);
+                if (!editorPane) {
+                    log('opening editor failed');
+                    return;
+                }
+                const newEditor = editorPane.getControl();
+                if (!isCodeEditor(newEditor) || !newEditor.hasModel()) {
+                    log('new editor is either missing or not a code editor or does not have a model');
+                    return;
+                }
+                if (this._inlineChatSessionService.getSession(newEditor, e.target)) {
+                    log('new editor ALREADY has a session');
+                    return;
+                }
+                const newSession = await this._inlineChatSessionService.createSession(newEditor, {
+                    session: this._session,
+                }, CancellationToken.None);
+                InlineChatController1_1.get(newEditor)?.run({ existingSession: newSession });
+                next = State.CANCEL;
+                responsePromise.complete();
+                return;
+            }
+        }));
+        store.add(this._ui.value.widget.chatWidget.inputEditor.onDidChangeModelContent(() => {
+            this._chatService.cancelCurrentRequestForSession(chatModel.sessionId);
+        }));
+        let lastLength = 0;
+        let isFirstChange = true;
+        const editState = this._createChatTextEditGroupState();
+        let localEditGroup;
+        const handleResponse = () => {
+            this._updateCtxResponseType();
+            if (!localEditGroup) {
+                localEditGroup = response.response.value.find(part => part.kind === 'textEditGroup' && isEqual(part.uri, this._session?.textModelN.uri));
+            }
+            if (localEditGroup) {
+                localEditGroup.state ??= editState;
+                const edits = localEditGroup.edits;
+                const newEdits = edits.slice(lastLength);
+                if (newEdits.length > 0) {
+                    this._log(`${this._session?.textModelN.uri.toString()} received ${newEdits.length} edits`);
+                    lastLength = edits.length;
+                    progressiveEditsAvgDuration.update(progressiveEditsClock.elapsed());
+                    progressiveEditsClock.reset();
+                    progressiveEditsQueue.queue(async () => {
+                        const startThen = this._session.wholeRange.value.getStartPosition();
+                        for (const edits of newEdits) {
+                            await this._makeChanges(edits, {
+                                duration: progressiveEditsAvgDuration.value,
+                                token: progressiveEditsCts.token
+                            }, isFirstChange);
+                            isFirstChange = false;
+                        }
+                        const startNow = this._session.wholeRange.value.getStartPosition();
+                        if (!startNow.equals(startThen) || !this._ui.value.position?.equals(startNow)) {
+                            this._showWidget(this._session.headless, false, startNow.delta(-1));
+                        }
+                    });
+                }
+            }
+            if (response.isCanceled) {
+                progressiveEditsCts.cancel();
+                responsePromise.complete();
+            }
+            else if (response.isComplete) {
+                responsePromise.complete();
+            }
+        };
+        store.add(response.onDidChange(handleResponse));
+        handleResponse();
+        await responsePromise.p;
+        await progressiveEditsQueue.whenIdle();
+        if (response.result?.errorDetails && !response.result.errorDetails.responseIsFiltered) {
+            await this._session.undoChangesUntil(response.requestId);
+        }
+        store.dispose();
+        const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { computeMoves: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER, ignoreTrimWhitespace: false }, 'advanced');
+        this._session.wholeRange.fixup(diff?.changes ?? []);
+        await this._session.hunkData.recompute(editState, diff);
+        this._ctxRequestInProgress.set(false);
+        let newPosition;
+        if (response.result?.errorDetails) ;
+        else if (response.response.value.length === 0) {
+            const status = ( localize(7678, "No results, please refine your input and try again"));
+            this._ui.value.widget.updateStatus(status, { classes: ['warn'] });
+        }
+        else {
+            this._ui.value.widget.updateStatus('');
+        }
+        const position = await this._strategy.renderChanges();
+        if (position) {
+            const selection = this._editor.getSelection();
+            if (selection?.containsPosition(position)) {
+                if (position.lineNumber - selection.startLineNumber > 8) {
+                    newPosition = position;
+                }
+            }
+            else {
+                newPosition = position;
+            }
+        }
+        this._showWidget(this._session.headless, false, newPosition);
+        return next;
+    }
+    async [State.PAUSE]() {
+        this._resetWidget();
+        this._strategy?.dispose?.();
+        this._session = undefined;
+    }
+    async [State.ACCEPT]() {
+        assertType(this._session);
+        assertType(this._strategy);
+        this._sessionStore.clear();
+        try {
+            await this._strategy.apply();
+        }
+        catch (err) {
+            this._dialogService.error(( localize(7679, "Failed to apply changes.", toErrorMessage(err))));
+            this._log('FAILED to apply changes');
+            this._log(err);
+        }
+        this._resetWidget();
+        this._inlineChatSessionService.releaseSession(this._session);
+        this._strategy?.dispose();
+        this._strategy = undefined;
+        this._session = undefined;
+    }
+    async [State.CANCEL]() {
+        this._resetWidget();
+        if (this._session) {
+            assertType(this._strategy);
+            this._sessionStore.clear();
+            const shouldStash = !this._session.isUnstashed && this._session.chatModel.hasRequests && this._session.hunkData.size === this._session.hunkData.pending;
+            let undoCancelEdits = [];
+            try {
+                undoCancelEdits = this._strategy.cancel();
+            }
+            catch (err) {
+                this._dialogService.error(( localize(7680, "Failed to discard changes.", toErrorMessage(err))));
+                this._log('FAILED to discard changes');
+                this._log(err);
+            }
+            this._stashedSession.clear();
+            if (shouldStash) {
+                this._stashedSession.value = this._inlineChatSessionService.stashSession(this._session, this._editor, undoCancelEdits);
+            }
+            else {
+                this._inlineChatSessionService.releaseSession(this._session);
+            }
+        }
+        this._strategy?.dispose();
+        this._strategy = undefined;
+        this._session = undefined;
+    }
+    _showWidget(headless = false, initialRender = false, position) {
+        assertType(this._editor.hasModel());
+        this._ctxVisible.set(true);
+        let widgetPosition;
+        if (position) {
+            widgetPosition = position;
+        }
+        else if (this._ui.rawValue?.position) {
+            if (this._ui.rawValue?.position.lineNumber === 1) {
+                widgetPosition = this._ui.rawValue?.position.delta(-1);
+            }
+            else {
+                widgetPosition = this._ui.rawValue?.position;
+            }
+        }
+        else {
+            widgetPosition = this._editor.getSelection().getStartPosition().delta(-1);
+        }
+        if (this._session && !position && (this._session.hasChangedText || this._session.chatModel.hasRequests)) {
+            widgetPosition = this._session.wholeRange.trackedInitialRange.getStartPosition().delta(-1);
+        }
+        if (initialRender && (this._editor.getOption(EditorOption.stickyScroll)).enabled) {
+            this._editor.revealLine(widgetPosition.lineNumber);
+        }
+        if (!headless) {
+            if (this._ui.rawValue?.position) {
+                this._ui.value.updatePositionAndHeight(widgetPosition);
+            }
+            else {
+                this._ui.value.show(widgetPosition);
+            }
+        }
+        return widgetPosition;
+    }
+    _resetWidget() {
+        this._sessionStore.clear();
+        this._ctxVisible.reset();
+        this._ui.rawValue?.hide();
+        if (this._editor.hasWidgetFocus()) {
+            this._editor.focus();
+        }
+    }
+    _updateCtxResponseType() {
+        if (!this._session) {
+            this._ctxResponseType.set(InlineChatResponseType.None);
+            return;
+        }
+        const hasLocalEdit = (response) => {
+            return ( response.value.some(
+                part => part.kind === 'textEditGroup' && isEqual(part.uri, this._session?.textModelN.uri)
+            ));
+        };
+        let responseType = InlineChatResponseType.None;
+        for (const request of this._session.chatModel.getRequests()) {
+            if (!request.response) {
+                continue;
+            }
+            responseType = InlineChatResponseType.Messages;
+            if (hasLocalEdit(request.response.response)) {
+                responseType = InlineChatResponseType.MessagesAndEdits;
+                break;
+            }
+        }
+        this._ctxResponseType.set(responseType);
+        this._ctxResponse.set(responseType !== InlineChatResponseType.None);
+    }
+    _createChatTextEditGroupState() {
+        assertType(this._session);
+        const sha1 = ( new DefaultModelSHA1Computer());
+        const textModel0Sha1 = sha1.canComputeSHA1(this._session.textModel0)
+            ? sha1.computeSHA1(this._session.textModel0)
+            : generateUuid();
+        return {
+            sha1: textModel0Sha1,
+            applied: 0
+        };
+    }
+    async _makeChanges(edits, opts, undoStopBefore) {
+        assertType(this._session);
+        assertType(this._strategy);
+        const moreMinimalEdits = await this._editorWorkerService.computeMoreMinimalEdits(this._session.textModelN.uri, edits);
+        this._log('edits from PROVIDER and after making them MORE MINIMAL', this._session.agent.extensionId, edits, moreMinimalEdits);
+        if (moreMinimalEdits?.length === 0) {
+            return;
+        }
+        const actualEdits = !opts && moreMinimalEdits ? moreMinimalEdits : edits;
+        const editOperations = ( actualEdits.map(TextEdit.asEditOperation));
+        const editsObserver = {
+            start: () => this._session.hunkData.ignoreTextModelNChanges = true,
+            stop: () => this._session.hunkData.ignoreTextModelNChanges = false,
+        };
+        if (opts) {
+            await this._strategy.makeProgressiveChanges(editOperations, editsObserver, opts, undoStopBefore);
+        }
+        else {
+            await this._strategy.makeChanges(editOperations, editsObserver, undoStopBefore);
+        }
+    }
+    _updatePlaceholder() {
+        this._ui.value.widget.placeholder = this._session?.agent.description ?? ( localize(7681, 'Ask or edit in context'));
+    }
+    _updateInput(text, selectAll = true) {
+        this._ui.value.widget.chatWidget.setInput(text);
+        if (selectAll) {
+            const newSelection = ( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1));
+            this._ui.value.widget.chatWidget.inputEditor.setSelection(newSelection);
+        }
+    }
+    arrowOut(up) {
+        if (this._ui.value.position && this._editor.hasModel()) {
+            const { column } = this._editor.getPosition();
+            const { lineNumber } = this._ui.value.position;
+            const newLine = up ? lineNumber : lineNumber + 1;
+            this._editor.setPosition({ lineNumber: newLine, column });
+            this._editor.focus();
+        }
+    }
+    focus() {
+        this._ui.value.widget.focus();
+    }
+    async viewInChat() {
+        if (!this._strategy || !this._session) {
+            return;
+        }
+        let someApplied = false;
+        let lastEdit;
+        const uri = this._editor.getModel()?.uri;
+        const requests = this._session.chatModel.getRequests();
+        for (const request of requests) {
+            if (!request.response) {
+                continue;
+            }
+            for (const part of request.response.response.value) {
+                if (part.kind === 'textEditGroup' && isEqual(part.uri, uri)) {
+                    someApplied = someApplied || Boolean(part.state?.applied);
+                    lastEdit = part;
+                    part.edits = [];
+                    part.state = undefined;
+                }
+            }
+        }
+        const doEdits = this._strategy.cancel();
+        if (someApplied) {
+            assertType(lastEdit);
+            lastEdit.edits = [doEdits];
+        }
+        await this._instaService.invokeFunction(moveToPanelChat, this._session?.chatModel);
+        this.cancelSession();
+    }
+    acceptSession() {
+        const response = this._session?.chatModel.getRequests().at(-1)?.response;
+        if (response) {
+            this._chatService.notifyUserAction({
+                sessionId: response.session.sessionId,
+                requestId: response.requestId,
+                agentId: response.agent?.id,
+                command: response.slashCommand?.name,
+                result: response.result,
+                action: {
+                    kind: 'inlineChat',
+                    action: 'accepted'
+                }
+            });
+        }
+        this._messages.fire(Message.ACCEPT_SESSION);
+    }
+    acceptHunk(hunkInfo) {
+        return this._strategy?.performHunkAction(hunkInfo, HunkAction.Accept);
+    }
+    discardHunk(hunkInfo) {
+        return this._strategy?.performHunkAction(hunkInfo, HunkAction.Discard);
+    }
+    toggleDiff(hunkInfo) {
+        return this._strategy?.performHunkAction(hunkInfo, HunkAction.ToggleDiff);
+    }
+    moveHunk(next) {
+        this.focus();
+        this._strategy?.performHunkAction(undefined, next ? HunkAction.MoveNext : HunkAction.MovePrev);
+    }
+    async cancelSession() {
+        const response = this._session?.chatModel.lastRequest?.response;
+        if (response) {
+            this._chatService.notifyUserAction({
+                sessionId: response.session.sessionId,
+                requestId: response.requestId,
+                agentId: response.agent?.id,
+                command: response.slashCommand?.name,
+                result: response.result,
+                action: {
+                    kind: 'inlineChat',
+                    action: 'discarded'
+                }
+            });
+        }
+        this._messages.fire(Message.CANCEL_SESSION);
+    }
+    reportIssue() {
+        const response = this._session?.chatModel.lastRequest?.response;
+        if (response) {
+            this._chatService.notifyUserAction({
+                sessionId: response.session.sessionId,
+                requestId: response.requestId,
+                agentId: response.agent?.id,
+                command: response.slashCommand?.name,
+                result: response.result,
+                action: { kind: 'bug' }
+            });
+        }
+    }
+    unstashLastSession() {
+        const result = this._stashedSession.value?.unstash();
+        return result;
+    }
+    joinCurrentRun() {
+        return this._currentRun;
+    }
+    get isActive() {
+        return Boolean(this._currentRun);
+    }
+    async createImageAttachment(attachment) {
+        if (attachment.scheme === Schemas.file) {
+            if (await this._fileService.canHandleResource(attachment)) {
+                return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment);
+            }
+        }
+        else if (attachment.scheme === Schemas.http || attachment.scheme === Schemas.https) {
+            const extractedImages = await this._webContentExtractorService.readImage(attachment, CancellationToken.None);
+            if (extractedImages) {
+                return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment, extractedImages);
+            }
+        }
+        return undefined;
+    }
+};
+InlineChatController1 = InlineChatController1_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IInlineChatSessionService)),
+    ( __param(3, IEditorWorkerService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IDialogService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IChatService)),
+    ( __param(9, IEditorService)),
+    ( __param(10, INotebookEditorService)),
+    ( __param(11, ISharedWebContentExtractorService)),
+    ( __param(12, IFileService)),
+    ( __param(13, IChatAttachmentResolveService))
+], InlineChatController1));
+let InlineChatController2 = class InlineChatController2 {
+    static { InlineChatController2_1 = this; }
+    static { this.ID = 'editor.contrib.inlineChatController2'; }
+    static get(editor) {
+        return editor.getContribution(InlineChatController2_1.ID) ?? undefined;
+    }
+    get widget() {
+        return this._zone.value.widget;
+    }
+    get isActive() {
+        return Boolean(this._currentSession.get());
+    }
+    constructor(_editor, _instaService, _notebookEditorService, _inlineChatSessions, codeEditorService, contextKeyService, _webContentExtractorService, _fileService, _chatAttachmentResolveService, _editorService, inlineChatService, configurationService) {
+        this._editor = _editor;
+        this._instaService = _instaService;
+        this._notebookEditorService = _notebookEditorService;
+        this._inlineChatSessions = _inlineChatSessions;
+        this._webContentExtractorService = _webContentExtractorService;
+        this._fileService = _fileService;
+        this._chatAttachmentResolveService = _chatAttachmentResolveService;
+        this._editorService = _editorService;
+        this._store = ( new DisposableStore());
+        this._showWidgetOverrideObs = observableValue(this, false);
+        this._isActiveController = observableValue(this, false);
+        const ctxInlineChatVisible = CTX_INLINE_CHAT_VISIBLE.bindTo(contextKeyService);
+        this._zone = ( new Lazy(() => {
+            const location = {
+                location: ChatAgentLocation.Editor,
+                resolveData: () => {
+                    assertType(this._editor.hasModel());
+                    return {
+                        type: ChatAgentLocation.Editor,
+                        selection: this._editor.getSelection(),
+                        document: this._editor.getModel().uri,
+                        wholeRange: this._editor.getSelection(),
+                    };
+                }
+            };
+            let notebookEditor;
+            for (const editor of this._notebookEditorService.listNotebookEditors()) {
+                for (const [, codeEditor] of editor.codeEditors) {
+                    if (codeEditor === this._editor) {
+                        location.location = ChatAgentLocation.Notebook;
+                        notebookEditor = editor;
+                        if (configurationService.getValue(InlineChatConfigKeys.notebookAgent)) {
+                            location.resolveData = () => {
+                                assertType(this._editor.hasModel());
+                                return {
+                                    type: ChatAgentLocation.Notebook,
+                                    sessionInputUri: this._editor.getModel().uri,
+                                };
+                            };
+                        }
+                        break;
+                    }
+                }
+            }
+            const result = this._instaService.createInstance(InlineChatZoneWidget, location, {
+                enableWorkingSet: 'implicit',
+                rendererOptions: {
+                    renderTextEditsAsSummary: _uri => true
+                }
+            }, { editor: this._editor, notebookEditor });
+            result.domNode.classList.add('inline-chat-2');
+            return result;
+        }));
+        const editorObs = observableCodeEditor(_editor);
+        const sessionsSignal = observableSignalFromEvent(this, _inlineChatSessions.onDidChangeSessions);
+        this._currentSession = derived(r => {
+            sessionsSignal.read(r);
+            const model = editorObs.model.read(r);
+            const value = model && _inlineChatSessions.getSession2(model.uri);
+            return value ?? undefined;
+        });
+        this._store.add(autorun(r => {
+            const session = this._currentSession.read(r);
+            if (!session) {
+                this._isActiveController.set(false, undefined);
+                return;
+            }
+            let foundOne = false;
+            for (const editor of codeEditorService.listCodeEditors()) {
+                if (Boolean(InlineChatController2_1.get(editor)?._isActiveController.get())) {
+                    foundOne = true;
+                    break;
+                }
+            }
+            if (!foundOne && editorObs.isFocused.read(r)) {
+                this._isActiveController.set(true, undefined);
+            }
+        }));
+        const visibleSessionObs = observableValue(this, undefined);
+        this._store.add(autorunWithStore((r, store) => {
+            const model = editorObs.model.read(r);
+            const session = this._currentSession.read(r);
+            const isActive = this._isActiveController.read(r);
+            if (!session || !isActive || !model) {
+                visibleSessionObs.set(undefined, undefined);
+                return;
+            }
+            const { chatModel } = session;
+            const showShowUntil = this._showWidgetOverrideObs.read(r);
+            const hasNoRequests = chatModel.getRequests().length === 0;
+            const hideOnRequest = inlineChatService.hideOnRequest.read(r);
+            const responseListener = store.add(( new MutableDisposable()));
+            if (hideOnRequest) {
+                store.add(chatModel.onDidChange(e => {
+                    if (e.kind === 'addRequest') {
+                        transaction(tx => {
+                            this._showWidgetOverrideObs.set(false, tx);
+                            visibleSessionObs.set(undefined, tx);
+                        });
+                        const { response } = e.request;
+                        if (!response) {
+                            return;
+                        }
+                        responseListener.value = response.onDidChange(async (e) => {
+                            if (!response.isComplete) {
+                                return;
+                            }
+                            const shouldShow = response.isCanceled
+                                || response.result?.errorDetails
+                                || !response.response.value.find(part => part.kind === 'textEditGroup'
+                                    && part.edits.length > 0
+                                    && isEqual(part.uri, model.uri));
+                            if (shouldShow) {
+                                visibleSessionObs.set(session, undefined);
+                            }
+                        });
+                    }
+                }));
+            }
+            if (showShowUntil || hasNoRequests || !hideOnRequest) {
+                visibleSessionObs.set(session, undefined);
+            }
+            else {
+                visibleSessionObs.set(undefined, undefined);
+            }
+        }));
+        this._store.add(autorun(r => {
+            const session = visibleSessionObs.read(r);
+            if (!session) {
+                this._zone.rawValue?.hide();
+                _editor.focus();
+                ctxInlineChatVisible.reset();
+            }
+            else {
+                ctxInlineChatVisible.set(true);
+                this._zone.value.widget.setChatModel(session.chatModel);
+                if (!this._zone.value.position) {
+                    this._zone.value.show(session.initialPosition);
+                }
+                this._zone.value.reveal(this._zone.value.position);
+                this._zone.value.widget.focus();
+                this._zone.value.widget.updateToolbar(true);
+                const entry = session.editingSession.getEntry(session.uri);
+                entry?.autoAcceptController.get()?.cancel();
+                const requestCount = observableFromEvent(this, session.chatModel.onDidChange, () => session.chatModel.getRequests().length).read(r);
+                this._zone.value.widget.updateToolbar(requestCount > 0);
+            }
+        }));
+        this._store.add(autorun(r => {
+            const session = visibleSessionObs.read(r);
+            const entry = session?.editingSession.readEntry(session.uri, r);
+            const pane = this._editorService.visibleEditorPanes.find(candidate => candidate.getControl() === this._editor || isNotebookContainingCellEditor(candidate, this._editor));
+            if (pane && entry) {
+                entry?.getEditorIntegration(pane);
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+    toggleWidgetUntilNextRequest() {
+        const value = this._showWidgetOverrideObs.get();
+        this._showWidgetOverrideObs.set(!value, undefined);
+    }
+    getWidgetPosition() {
+        return this._zone.rawValue?.position;
+    }
+    focus() {
+        this._zone.rawValue?.widget.focus();
+    }
+    markActiveController() {
+        this._isActiveController.set(true, undefined);
+    }
+    async run(arg) {
+        assertType(this._editor.hasModel());
+        this.markActiveController();
+        const uri = this._editor.getModel().uri;
+        const session = this._inlineChatSessions.getSession2(uri)
+            ?? (await this._inlineChatSessions.createSession2(this._editor, uri, CancellationToken.None));
+        if (arg && InlineChatRunOptions.isInlineChatRunOptions(arg)) {
+            if (arg.initialRange) {
+                this._editor.revealRange(arg.initialRange);
+            }
+            if (arg.initialSelection) {
+                this._editor.setSelection(arg.initialSelection);
+            }
+            if (arg.attachments) {
+                await Promise.all(( arg.attachments.map(async (attachment) => {
+                    await this._zone.value.widget.chatWidget.attachmentModel.addFile(attachment);
+                })));
+                delete arg.attachments;
+            }
+            if (arg.message) {
+                this._zone.value.widget.chatWidget.setInput(arg.message);
+                if (arg.autoSend) {
+                    await this._zone.value.widget.chatWidget.acceptInput();
+                }
+            }
+        }
+        await Event.toPromise(session.editingSession.onDidDispose);
+        const rejected = session.editingSession.getEntry(uri)?.state.get() === ModifiedFileEntryState.Rejected;
+        return !rejected;
+    }
+    acceptSession() {
+        const value = this._currentSession.get();
+        value?.editingSession.accept();
+    }
+    async createImageAttachment(attachment) {
+        const value = this._currentSession.get();
+        if (!value) {
+            return undefined;
+        }
+        if (attachment.scheme === Schemas.file) {
+            if (await this._fileService.canHandleResource(attachment)) {
+                return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment);
+            }
+        }
+        else if (attachment.scheme === Schemas.http || attachment.scheme === Schemas.https) {
+            const extractedImages = await this._webContentExtractorService.readImage(attachment, CancellationToken.None);
+            if (extractedImages) {
+                return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment, extractedImages);
+            }
+        }
+        return undefined;
+    }
+};
+InlineChatController2 = InlineChatController2_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, INotebookEditorService)),
+    ( __param(3, IInlineChatSessionService)),
+    ( __param(4, ICodeEditorService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, ISharedWebContentExtractorService)),
+    ( __param(7, IFileService)),
+    ( __param(8, IChatAttachmentResolveService)),
+    ( __param(9, IEditorService)),
+    ( __param(10, IInlineChatSessionService)),
+    ( __param(11, IConfigurationService))
+], InlineChatController2));
+async function reviewEdits(accessor, editor, stream, token) {
+    if (!editor.hasModel()) {
+        return false;
+    }
+    const chatService = accessor.get(IChatService);
+    const uri = editor.getModel().uri;
+    const chatModel = chatService.startSession(ChatAgentLocation.Editor, token, false);
+    chatModel.startEditingSession(true);
+    const editSession = await chatModel.editingSessionObs?.promise;
+    const store = ( new DisposableStore());
+    store.add(chatModel);
+    const chatRequest = chatModel?.addRequest({ text: '', parts: [] }, { variables: [] }, 0);
+    assertType(chatRequest.response);
+    chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: [], done: false });
+    for await (const chunk of stream) {
+        if (token.isCancellationRequested) {
+            chatRequest.response.cancel();
+            break;
+        }
+        chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: chunk, done: false });
+    }
+    chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: [], done: true });
+    if (!token.isCancellationRequested) {
+        chatModel.completeResponse(chatRequest);
+    }
+    const isSettled = derived(r => {
+        const entry = editSession?.readEntry(uri, r);
+        if (!entry) {
+            return false;
+        }
+        const state = entry.state.read(r);
+        return state === ModifiedFileEntryState.Accepted || state === ModifiedFileEntryState.Rejected;
+    });
+    const whenDecided = waitForState(isSettled, Boolean);
+    await raceCancellation(whenDecided, token);
+    store.dispose();
+    return true;
+}
+async function reviewNotebookEdits(accessor, uri, stream, token) {
+    const chatService = accessor.get(IChatService);
+    const notebookService = accessor.get(INotebookService);
+    const isNotebook = notebookService.hasSupportedNotebooks(uri);
+    const chatModel = chatService.startSession(ChatAgentLocation.Editor, token, false);
+    chatModel.startEditingSession(true);
+    const editSession = await chatModel.editingSessionObs?.promise;
+    const store = ( new DisposableStore());
+    store.add(chatModel);
+    const chatRequest = chatModel?.addRequest({ text: '', parts: [] }, { variables: [] }, 0);
+    assertType(chatRequest.response);
+    if (isNotebook) {
+        chatRequest.response.updateContent({ kind: 'notebookEdit', uri, edits: [], done: false });
+    }
+    else {
+        chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: [], done: false });
+    }
+    for await (const chunk of stream) {
+        if (token.isCancellationRequested) {
+            chatRequest.response.cancel();
+            break;
+        }
+        if (chunk.every(isCellEditOperation)) {
+            chatRequest.response.updateContent({ kind: 'notebookEdit', uri, edits: chunk, done: false });
+        }
+        else {
+            chatRequest.response.updateContent({ kind: 'textEdit', uri: chunk[0], edits: chunk[1], done: false });
+        }
+    }
+    if (isNotebook) {
+        chatRequest.response.updateContent({ kind: 'notebookEdit', uri, edits: [], done: true });
+    }
+    else {
+        chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: [], done: true });
+    }
+    if (!token.isCancellationRequested) {
+        chatRequest.response.complete();
+    }
+    const isSettled = derived(r => {
+        const entry = editSession?.readEntry(uri, r);
+        if (!entry) {
+            return false;
+        }
+        const state = entry.state.read(r);
+        return state === ModifiedFileEntryState.Accepted || state === ModifiedFileEntryState.Rejected;
+    });
+    const whenDecided = waitForState(isSettled, Boolean);
+    await raceCancellation(whenDecided, token);
+    store.dispose();
+    return true;
+}
+function isCellEditOperation(edit) {
+    if (URI.isUri(edit)) {
+        return false;
+    }
+    if (Array.isArray(edit)) {
+        return false;
+    }
+    return true;
+}
+async function moveToPanelChat(accessor, model) {
+    const viewsService = accessor.get(IViewsService);
+    const chatService = accessor.get(IChatService);
+    const widget = await showChatView(viewsService);
+    if (widget && widget.viewModel && model) {
+        for (const request of model.getRequests().slice()) {
+            await chatService.adoptRequest(widget.viewModel.model.sessionId, request);
+        }
+        widget.focusLastMessage();
+    }
+}
+
+export { InlineChatController, InlineChatController1, InlineChatController2, InlineChatRunOptions, State, reviewEdits, reviewNotebookEdits };