@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,1442 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
+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, VersionedExtensionId } 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 { IMarkerDecorationsService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/markerDecorations.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 { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+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 { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.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 { 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 { 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 { IChatAttachmentResolveService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service';
+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 { ChatRequestRemovalReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { IDiagnosticVariableEntryFilterData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isILanguageModelChatSelector } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { isNotebookContainingCellEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.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 '../common/inlineChat.js';
+import { Session } from './inlineChatSession.js';
+import { moveToPanelChat } from './inlineChatSessionService.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 { 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 } 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';
+
+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) {
+        if (typeof options !== 'object' || options === null) {
+            return false;
+        }
+        const { initialSelection, initialRange, message, autoSend, position, existingSession, attachments, modelSelector, blockOnResponse } = 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))
+            || typeof modelSelector !== 'undefined' && !isILanguageModelChatSelector(modelSelector)
+            || typeof blockOnResponse !== 'undefined' && typeof blockOnResponse !== 'boolean') {
+            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, _notebookEditorService) {
+        this._notebookEditorService = _notebookEditorService;
+        const notebookAgent = observableConfigValue(InlineChatConfigKeys.notebookAgent, false, configurationService);
+        this._delegate = derived(r => {
+            const isNotebookCell = !!this._notebookEditorService.getNotebookForPossibleCell(editor);
+            if (!isNotebookCell || notebookAgent.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)),
+    ( __param(2, INotebookEditorService))
+], InlineChatController));
+function getEditorId(editor, model) {
+    return `${editor.getId()},${model.id}`;
+}
+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.EditorInline,
+                resolveData: () => {
+                    assertType(this._editor.hasModel());
+                    assertType(this._session);
+                    return {
+                        type: ChatAgentLocation.EditorInline,
+                        id: getEditorId(this._editor, this._session.textModelN),
+                        selection: this._editor.getSelection(),
+                        document: this._session.textModelN.uri,
+                        wholeRange: this._session?.wholeRange.trackedInitialRange,
+                        close: () => this.cancelSession(),
+                        delegateSessionResource: this._delegateSession?.chatSessionResource,
+                    };
+                }
+            };
+            const notebookEditor = notebookEditorService.getNotebookForPossibleCell(this._editor);
+            if (!!notebookEditor) {
+                location.location = ChatAgentLocation.Notebook;
+            }
+            const clear = async () => {
+                const r = this.joinCurrentRun();
+                this.cancelSession();
+                await r;
+                this.run();
+            };
+            const zone = _instaService.createInstance(InlineChatZoneWidget, location, undefined, { editor: this._editor, notebookEditor }, clear);
+            this._store.add(zone);
+            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(8300, "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(8301, "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);
+        }));
+        const filePartOfEditSessions = this._chatService.editingSessions.filter(session => ( session.entries.get().some(e => e.state.get() === ModifiedFileEntryState.Modified && ( e.modifiedURI.toString()) === ( this._session.textModelN.uri.toString()))));
+        const withinEditSession = filePartOfEditSessions.find(session => ( session.entries.get().some(
+            e => e.state.get() === ModifiedFileEntryState.Modified && e.hasModificationAt({
+                range: this._session.wholeRange.trackedInitialRange,
+                uri: this._session.textModelN.uri
+            })
+        )));
+        const chatWidget = this._ui.value.widget.chatWidget;
+        this._delegateSession = withinEditSession || filePartOfEditSessions[0];
+        chatWidget.input.setIsWithinEditSession(!!withinEditSession, filePartOfEditSessions.length > 0);
+        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.get()) {
+            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(this.chatWidget.onDidHide(() => 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.get());
+        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.sessionResource);
+            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.sessionResource);
+        }));
+        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) {
+            alert(response.result.errorDetails.message);
+        }
+        else if (response.response.value.length === 0) {
+            const status = ( localize(8302, "No results, please refine your input and try again"));
+            this._ui.value.widget.updateStatus(status, { classes: ['warn'] });
+            alert(status);
+        }
+        else {
+            this._ui.value.widget.updateStatus('');
+            alert(( localize(8303, "Response was empty")));
+        }
+        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(8304, "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(8305, "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 raceCancellation(this._editorWorkerService.computeMoreMinimalEdits(this._session.textModelN.uri, edits), opts?.token || CancellationToken.None);
+        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,
+        };
+        const metadata = this._getMetadata();
+        if (opts) {
+            await this._strategy.makeProgressiveChanges(editOperations, editsObserver, opts, undoStopBefore, metadata);
+        }
+        else {
+            await this._strategy.makeChanges(editOperations, editsObserver, undoStopBefore, metadata);
+        }
+    }
+    _getMetadata() {
+        const lastRequest = this._session?.chatModel.lastRequest;
+        return {
+            extensionId: VersionedExtensionId.tryCreate(this._session?.agent.extensionId.value, this._session?.agent.extensionVersion),
+            modelId: lastRequest?.modelId,
+            requestId: lastRequest?.id,
+        };
+    }
+    _updatePlaceholder() {
+        this._ui.value.widget.placeholder = this._session?.agent.description ?? ( localize(8306, '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, false);
+        this.cancelSession();
+    }
+    acceptSession() {
+        const response = this._session?.chatModel.getRequests().at(-1)?.response;
+        if (response) {
+            this._chatService.notifyUserAction({
+                sessionResource: response.session.sessionResource,
+                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({
+                sessionResource: response.session.sessionResource,
+                requestId: response.requestId,
+                agentId: response.agent?.id,
+                command: response.slashCommand?.name,
+                result: response.result,
+                action: {
+                    kind: 'inlineChat',
+                    action: 'discarded'
+                }
+            });
+        }
+        this._resetWidget();
+        this._messages.fire(Message.CANCEL_SESSION);
+    }
+    reportIssue() {
+        const response = this._session?.chatModel.lastRequest?.response;
+        if (response) {
+            this._chatService.notifyUserAction({
+                sessionResource: response.session.sessionResource,
+                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, _inlineChatSessionService, codeEditorService, contextKeyService, _webContentExtractorService, _fileService, _chatAttachmentResolveService, _editorService, _markerDecorationsService, _languageModelService, chatService) {
+        this._editor = _editor;
+        this._instaService = _instaService;
+        this._notebookEditorService = _notebookEditorService;
+        this._inlineChatSessionService = _inlineChatSessionService;
+        this._webContentExtractorService = _webContentExtractorService;
+        this._fileService = _fileService;
+        this._chatAttachmentResolveService = _chatAttachmentResolveService;
+        this._editorService = _editorService;
+        this._markerDecorationsService = _markerDecorationsService;
+        this._languageModelService = _languageModelService;
+        this._store = ( new DisposableStore());
+        this._isActiveController = observableValue(this, false);
+        const ctxInlineChatVisible = CTX_INLINE_CHAT_VISIBLE.bindTo(contextKeyService);
+        this._zone = ( new Lazy(() => {
+            const location = {
+                location: ChatAgentLocation.EditorInline,
+                resolveData: () => {
+                    assertType(this._editor.hasModel());
+                    const wholeRange = this._editor.getSelection();
+                    const document = this._editor.getModel().uri;
+                    return {
+                        type: ChatAgentLocation.EditorInline,
+                        id: getEditorId(this._editor, this._editor.getModel()),
+                        selection: this._editor.getSelection(),
+                        document,
+                        wholeRange,
+                        close: () => { },
+                        delegateSessionResource: chatService.editingSessions.find(session => ( session.entries.get().some(e => e.hasModificationAt({
+                            range: wholeRange,
+                            uri: document
+                        }))))?.chatSessionResource,
+                    };
+                }
+            };
+            const notebookEditor = this._notebookEditorService.getNotebookForPossibleCell(this._editor);
+            if (!!notebookEditor) {
+                location.location = ChatAgentLocation.Notebook;
+                location.resolveData = () => {
+                    assertType(this._editor.hasModel());
+                    return {
+                        type: ChatAgentLocation.Notebook,
+                        sessionInputUri: this._editor.getModel().uri,
+                    };
+                };
+            }
+            const result = this._instaService.createInstance(InlineChatZoneWidget, location, {
+                enableWorkingSet: 'implicit',
+                enableImplicitContext: false,
+                renderInputOnTop: false,
+                renderInputToolbarBelowInput: true,
+                filter: item => {
+                    if (!isResponseVM(item)) {
+                        return false;
+                    }
+                    return !!item.model.isPendingConfirmation.get();
+                },
+                menus: {
+                    telemetrySource: 'inlineChatWidget',
+                    executeToolbar: MenuId.ChatEditorInlineExecute,
+                    inputSideToolbar: MenuId.ChatEditorInlineInputSide
+                },
+                defaultMode: ChatMode.Ask
+            }, { editor: this._editor, notebookEditor }, () => Promise.resolve());
+            result.domNode.classList.add('inline-chat-2');
+            return result;
+        }));
+        const editorObs = observableCodeEditor(_editor);
+        const sessionsSignal = observableSignalFromEvent(this, _inlineChatSessionService.onDidChangeSessions);
+        this._currentSession = derived(r => {
+            sessionsSignal.read(r);
+            const model = editorObs.model.read(r);
+            const session = model && _inlineChatSessionService.getSession2(model.uri);
+            return session ?? undefined;
+        });
+        let lastSession = undefined;
+        this._store.add(autorun(r => {
+            const session = this._currentSession.read(r);
+            if (!session) {
+                this._isActiveController.set(false, undefined);
+                if (lastSession && !lastSession.chatModel.hasRequests) {
+                    const state = lastSession.chatModel.inputModel.state.read(undefined);
+                    if (!state || (!state.inputText && state.attachments.length === 0)) {
+                        lastSession.dispose();
+                        lastSession = undefined;
+                    }
+                }
+                return;
+            }
+            lastSession = session;
+            let foundOne = false;
+            for (const editor of codeEditorService.listCodeEditors()) {
+                if (Boolean(InlineChatController2_1.get(editor)?._isActiveController.read(undefined))) {
+                    foundOne = true;
+                    break;
+                }
+            }
+            if (!foundOne && editorObs.isFocused.read(r)) {
+                this._isActiveController.set(true, undefined);
+            }
+        }));
+        const visibleSessionObs = observableValue(this, undefined);
+        this._store.add(autorun(r => {
+            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);
+            }
+            else {
+                visibleSessionObs.set(session, undefined);
+            }
+        }));
+        const defaultPlaceholderObs = ( visibleSessionObs.map((session, r) => {
+            return session?.initialSelection.isEmpty()
+                ? ( localize(8307, "Generate code"))
+                : ( localize(8308, "Modify selected code"));
+        }));
+        this._store.add(autorun(r => {
+            const session = visibleSessionObs.read(r);
+            if (!session) {
+                this._zone.rawValue?.hide();
+                this._zone.rawValue?.widget.chatWidget.setModel(undefined);
+                _editor.focus();
+                ctxInlineChatVisible.reset();
+            }
+            else {
+                ctxInlineChatVisible.set(true);
+                this._zone.value.widget.chatWidget.setModel(session.chatModel);
+                if (!this._zone.value.position) {
+                    this._zone.value.widget.chatWidget.setInputPlaceholder(defaultPlaceholderObs.read(r));
+                    this._zone.value.widget.chatWidget.input.renderAttachedContext();
+                    this._zone.value.show(session.initialPosition);
+                }
+                this._zone.value.reveal(this._zone.value.position);
+                this._zone.value.widget.focus();
+            }
+        }));
+        this._store.add(autorun(r => {
+            const session = visibleSessionObs.read(r);
+            if (session) {
+                const entries = session.editingSession.entries.read(r);
+                const otherEntries = entries.filter(entry => !isEqual(entry.modifiedURI, session.uri));
+                for (const entry of otherEntries) {
+                    this._editorService.openEditor({ resource: entry.modifiedURI }, SIDE_GROUP).catch(onUnexpectedError);
+                }
+            }
+        }));
+        const lastResponseObs = ( visibleSessionObs.map((session, r) => {
+            if (!session) {
+                return;
+            }
+            const lastRequest = observableFromEvent(this, session.chatModel.onDidChange, () => session.chatModel.getRequests().at(-1)).read(r);
+            return lastRequest?.response;
+        }));
+        const lastResponseProgressObs = ( lastResponseObs.map((response, r) => {
+            if (!response) {
+                return;
+            }
+            return observableFromEvent(this, response.onDidChange, () => response.response.value.findLast(part => part.kind === 'progressMessage')).read(r);
+        }));
+        this._store.add(autorun(r => {
+            const response = lastResponseObs.read(r);
+            this._zone.rawValue?.widget.updateInfo('');
+            if (!response?.isInProgress.read(r)) {
+                if (response?.result?.errorDetails) {
+                    this._zone.rawValue?.widget.updateInfo(`$(error) ${response.result.errorDetails.message}`);
+                    alert(response.result.errorDetails.message);
+                }
+                this._zone.rawValue?.widget.domNode.classList.toggle('request-in-progress', false);
+                this._zone.rawValue?.widget.chatWidget.setInputPlaceholder(defaultPlaceholderObs.read(r));
+            }
+            else {
+                this._zone.rawValue?.widget.domNode.classList.toggle('request-in-progress', true);
+                let placeholder = response.request?.message.text;
+                const lastProgress = lastResponseProgressObs.read(r);
+                if (lastProgress) {
+                    placeholder = renderAsPlaintext(lastProgress.content);
+                }
+                this._zone.rawValue?.widget.chatWidget.setInputPlaceholder(placeholder || ( localize(8309, "Working...")));
+            }
+        }));
+        this._store.add(autorun(r => {
+            const session = visibleSessionObs.read(r);
+            if (!session) {
+                return;
+            }
+            const entry = session.editingSession.readEntry(session.uri, r);
+            if (entry?.state.read(r) === ModifiedFileEntryState.Modified) {
+                entry?.enableReviewModeUntilSettled();
+            }
+        }));
+        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);
+            }
+            if (entry?.diffInfo && this._zone.value.position) {
+                const { position } = this._zone.value;
+                const diff = entry.diffInfo.read(r);
+                for (const change of diff.changes) {
+                    if (change.modified.contains(position.lineNumber)) {
+                        this._zone.value.updatePositionAndHeight(( new Position(change.modified.startLineNumber - 1, 1)));
+                        break;
+                    }
+                }
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+    getWidgetPosition() {
+        return this._zone.rawValue?.position;
+    }
+    focus() {
+        this._zone.rawValue?.widget.focus();
+    }
+    async run(arg) {
+        assertType(this._editor.hasModel());
+        const uri = this._editor.getModel().uri;
+        const existingSession = this._inlineChatSessionService.getSession2(uri);
+        if (existingSession) {
+            await existingSession.editingSession.accept();
+            existingSession.dispose();
+        }
+        this._isActiveController.set(true, undefined);
+        const session = await this._inlineChatSessionService.createSession2(this._editor, uri, CancellationToken.None);
+        const entries = [];
+        for (const [range, marker] of this._markerDecorationsService.getLiveMarkers(uri)) {
+            if (range.intersectRanges(this._editor.getSelection())) {
+                const filter = IDiagnosticVariableEntryFilterData.fromMarker(marker);
+                entries.push(IDiagnosticVariableEntryFilterData.toEntry(filter));
+            }
+        }
+        if (entries.length > 0) {
+            this._zone.value.widget.chatWidget.attachmentModel.addContext(...entries);
+            this._zone.value.widget.chatWidget.input.setValue(entries.length > 1
+                ? ( localize(8310, "Fix the attached problems"))
+                : ( localize(8311, "Fix the attached problem")), true);
+            this._zone.value.widget.chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
+        }
+        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.modelSelector) {
+                const id = (await this._languageModelService.selectLanguageModels(arg.modelSelector, false)).sort().at(0);
+                if (!id) {
+                    throw ( new Error(
+                        `No language models found matching selector: ${JSON.stringify(arg.modelSelector)}.`
+                    ));
+                }
+                const model = this._languageModelService.lookupLanguageModel(id);
+                if (!model) {
+                    throw ( new Error(`Language model not loaded: ${id}.`));
+                }
+                this._zone.value.widget.chatWidget.input.setCurrentLanguageModel({ metadata: model, identifier: id });
+            }
+            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;
+    }
+    async acceptSession() {
+        const session = this._currentSession.get();
+        if (!session) {
+            return;
+        }
+        await session.editingSession.accept();
+        session.dispose();
+    }
+    async rejectSession() {
+        const session = this._currentSession.get();
+        if (!session) {
+            return;
+        }
+        await session.editingSession.reject();
+        session.dispose();
+    }
+    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, IMarkerDecorationsService)),
+    ( __param(11, ILanguageModelsService)),
+    ( __param(12, IChatService))
+], InlineChatController2));
+async function reviewEdits(accessor, editor, stream, token, applyCodeBlockSuggestionId) {
+    if (!editor.hasModel()) {
+        return false;
+    }
+    const chatService = accessor.get(IChatService);
+    const uri = editor.getModel().uri;
+    const chatModelRef = chatService.startSession(ChatAgentLocation.EditorInline);
+    const chatModel = chatModelRef.object;
+    chatModel.startEditingSession(true);
+    const store = ( new DisposableStore());
+    store.add(chatModelRef);
+    const chatRequest = chatModel?.addRequest({ text: '', parts: [] }, { variables: [] }, 0, {
+        kind: undefined,
+        modeId: 'applyCodeBlock',
+        modeInstructions: undefined,
+        isBuiltin: true,
+        applyCodeBlockSuggestionId,
+    });
+    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) {
+        chatRequest.response.complete();
+    }
+    const isSettled = derived(r => {
+        const entry = chatModel.editingSession?.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 chatModelRef = chatService.startSession(ChatAgentLocation.EditorInline);
+    const chatModel = chatModelRef.object;
+    chatModel.startEditingSession(true);
+    const store = ( new DisposableStore());
+    store.add(chatModelRef);
+    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 = chatModel.editingSession?.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;
+}
+
+export { InlineChatController, InlineChatController1, InlineChatController2, InlineChatRunOptions, State, reviewEdits, reviewNotebookEdits };