@codingame/monaco-vscode-katex-common 25.1.1 → 26.0.0

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

@@ -2,39 +2,27 @@
 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 { raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 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 { 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 { DisposableStore } 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 { Selection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
 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';
@@ -43,946 +31,64 @@ import { ISharedWebContentExtractorService } from '@codingame/monaco-vscode-api/
 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/attachments/chatAttachmentResolveService.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
-import { ChatRequestRemovalReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/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/chatService.service';
 import { IDiagnosticVariableEntryFilterData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/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 { isILanguageModelChatSelector, ILanguageModelChatMetadata } 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 { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { INLINE_CHAT_ID, CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_EDITING, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, InlineChatConfigKeys, InlineChatResponseType } from '../common/inlineChat.js';
-import { Session } from './inlineChatSession.js';
-import { moveToPanelChat } from './inlineChatSessionService.js';
+import { CTX_INLINE_CHAT_VISIBLE, InlineChatConfigKeys } from '../common/inlineChat.js';
+import { InlineChatAffordance } from './inlineChatAffordance.js';
+import { InlineChatInputWidget, InlineChatSessionOverlayWidget } from './inlineChatOverlayWidget.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 { 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 { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 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';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 
-var 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 = {}));
+var InlineChatController_1;
 class InlineChatRunOptions {
     static isInlineChatRunOptions(options) {
-        if (typeof options !== 'object' || options === null) {
+        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') {
+        const {
+            initialSelection,
+            initialRange,
+            message,
+            autoSend,
+            position,
+            attachments,
+            modelSelector,
+            resolveOnResponse
+        } = 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 attachments !== "undefined" && (!Array.isArray(attachments) || !attachments.every(item => item instanceof URI)) || typeof modelSelector !== "undefined" && !isILanguageModelChatSelector(modelSelector) || typeof resolveOnResponse !== "undefined" && typeof resolveOnResponse !== "boolean") {
             return false;
         }
         return true;
     }
 }
-class InlineChatController {
-    static { this.ID = 'editor.contrib.inlineChatController'; }
-    static get(editor) {
-        return editor.getContribution(InlineChatController.ID);
-    }
-    constructor(editor) {
-        this._delegate = InlineChatController2.get(editor);
-    }
-    dispose() {
-    }
-    get isActive() {
-        return this._delegate.isActive;
-    }
-    async run(arg) {
-        return this._delegate.run(arg);
-    }
-    focus() {
-        return this._delegate.focus();
-    }
-    get widget() {
-        return this._delegate.widget;
-    }
-    getWidgetPosition() {
-        return this._delegate.getWidgetPosition();
-    }
-    acceptSession() {
-        return this._delegate.acceptSession();
-    }
-}
 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;
-        }
+let InlineChatController = class InlineChatController {
+    static {
+        InlineChatController_1 = this;
     }
-    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(8330, "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(8331, "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;
+    static {
+        this.ID = "editor.contrib.inlineChatController";
     }
-    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(8332, "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(8333, "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(8334, "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(8335, "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(8336, '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;
+        return editor.getContribution(InlineChatController_1.ID) ?? undefined;
     }
     get widget() {
         return this._zone.value.widget;
@@ -990,23 +96,52 @@ let InlineChatController2 = class InlineChatController2 {
     get isActive() {
         return Boolean(this._currentSession.get());
     }
-    constructor(_editor, _instaService, _notebookEditorService, _inlineChatSessionService, codeEditorService, contextKeyService, configurationService, _webContentExtractorService, _fileService, _chatAttachmentResolveService, _editorService, _markerDecorationsService, _languageModelService, chatService) {
+    constructor(
+        _editor,
+        _instaService,
+        _notebookEditorService,
+        _inlineChatSessionService,
+        codeEditorService,
+        contextKeyService,
+        _configurationService,
+        _webContentExtractorService,
+        _fileService,
+        _chatAttachmentResolveService,
+        _editorService,
+        _markerDecorationsService,
+        _languageModelService,
+        _logService
+    ) {
         this._editor = _editor;
         this._instaService = _instaService;
         this._notebookEditorService = _notebookEditorService;
         this._inlineChatSessionService = _inlineChatSessionService;
+        this._configurationService = _configurationService;
         this._webContentExtractorService = _webContentExtractorService;
         this._fileService = _fileService;
         this._chatAttachmentResolveService = _chatAttachmentResolveService;
         this._editorService = _editorService;
         this._markerDecorationsService = _markerDecorationsService;
         this._languageModelService = _languageModelService;
+        this._logService = _logService;
         this._store = ( new DisposableStore());
         this._isActiveController = observableValue(this, false);
+        const editorObs = observableCodeEditor(_editor);
         const ctxInlineChatVisible = CTX_INLINE_CHAT_VISIBLE.bindTo(contextKeyService);
-        const notebookAgentConfig = observableConfigValue(InlineChatConfigKeys.notebookAgent, false, configurationService);
+        const notebookAgentConfig = observableConfigValue(InlineChatConfigKeys.notebookAgent, false, this._configurationService);
+        this._renderMode = observableConfigValue(InlineChatConfigKeys.RenderMode, "zone", this._configurationService);
+        const overlayWidget = this._store.add(this._instaService.createInstance(InlineChatInputWidget, editorObs));
+        const sessionOverlayWidget = this._store.add(
+            this._instaService.createInstance(InlineChatSessionOverlayWidget, editorObs)
+        );
+        this._gutterIndicator = this._store.add(
+            this._instaService.createInstance(InlineChatAffordance, this._editor, overlayWidget)
+        );
         this._zone = ( new Lazy(() => {
-            assertType(this._editor.hasModel(), '[Illegal State] widget should only be created when the editor has a model');
+            assertType(
+                this._editor.hasModel(),
+                "[Illegal State] widget should only be created when the editor has a model"
+            );
             const location = {
                 location: ChatAgentLocation.EditorInline,
                 resolveData: () => {
@@ -1018,12 +153,7 @@ let InlineChatController2 = class InlineChatController2 {
                         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,
+                        wholeRange
                     };
                 }
             };
@@ -1035,13 +165,13 @@ let InlineChatController2 = class InlineChatController2 {
                         assertType(this._editor.hasModel());
                         return {
                             type: ChatAgentLocation.Notebook,
-                            sessionInputUri: this._editor.getModel().uri,
+                            sessionInputUri: this._editor.getModel().uri
                         };
                     };
                 }
             }
             const result = this._instaService.createInstance(InlineChatZoneWidget, location, {
-                enableWorkingSet: 'implicit',
+                enableWorkingSet: "implicit",
                 enableImplicitContext: false,
                 renderInputOnTop: false,
                 renderInputToolbarBelowInput: true,
@@ -1052,21 +182,24 @@ let InlineChatController2 = class InlineChatController2 {
                     return !!item.model.isPendingConfirmation.get();
                 },
                 menus: {
-                    telemetrySource: 'inlineChatWidget',
+                    telemetrySource: "inlineChatWidget",
                     executeToolbar: MenuId.ChatEditorInlineExecute,
                     inputSideToolbar: MenuId.ChatEditorInlineInputSide
                 },
                 defaultMode: ChatMode.Ask
-            }, { editor: this._editor, notebookEditor }, () => Promise.resolve());
-            result.domNode.classList.add('inline-chat-2');
+            }, {
+                editor: this._editor,
+                notebookEditor
+            }, () => Promise.resolve());
+            this._store.add(result);
+            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);
+            const session = model && _inlineChatSessionService.getSessionByTextModel(model.uri);
             return session ?? undefined;
         });
         let lastSession = undefined;
@@ -1086,7 +219,7 @@ let InlineChatController2 = class InlineChatController2 {
             lastSession = session;
             let foundOne = false;
             for (const editor of codeEditorService.listCodeEditors()) {
-                if (Boolean(InlineChatController2_1.get(editor)?._isActiveController.read(undefined))) {
+                if (Boolean(InlineChatController_1.get(editor)?._isActiveController.read(undefined))) {
                     foundOne = true;
                     break;
                 }
@@ -1102,25 +235,26 @@ let InlineChatController2 = class InlineChatController2 {
             const isActive = this._isActiveController.read(r);
             if (!session || !isActive || !model) {
                 visibleSessionObs.set(undefined, undefined);
-            }
-            else {
+            } else {
                 visibleSessionObs.set(session, undefined);
             }
         }));
         const defaultPlaceholderObs = ( visibleSessionObs.map((session, r) => {
-            return session?.initialSelection.isEmpty()
-                ? ( localize(8337, "Generate code"))
-                : ( localize(8338, "Modify selected code"));
+            return session?.initialSelection.isEmpty() ? ( localize(8630, "Generate code")) : ( localize(8631, "Modify selected code"));
         }));
         this._store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
+            const renderMode = this._renderMode.read(r);
             if (!session) {
                 this._zone.rawValue?.hide();
                 this._zone.rawValue?.widget.chatWidget.setModel(undefined);
                 _editor.focus();
                 ctxInlineChatVisible.reset();
-            }
-            else {
+            } else if (renderMode === "hover") {
+                this._zone.value.widget.chatWidget.setModel(session.chatModel);
+                this._zone.rawValue?.hide();
+                ctxInlineChatVisible.set(true);
+            } else {
                 ctxInlineChatVisible.set(true);
                 this._zone.value.widget.chatWidget.setModel(session.chatModel);
                 if (!this._zone.value.position) {
@@ -1132,6 +266,23 @@ let InlineChatController2 = class InlineChatController2 {
                 this._zone.value.widget.focus();
             }
         }));
+        this._store.add(autorun(r => {
+            const session = visibleSessionObs.read(r);
+            const renderMode = this._renderMode.read(r);
+            if (!session || renderMode !== "hover") {
+                sessionOverlayWidget.hide();
+                return;
+            }
+            const lastRequest = session.chatModel.lastRequestObs.read(r);
+            const isInProgress = lastRequest?.response?.isInProgress.read(r);
+            const entry = session.editingSession.readEntry(session.uri, r);
+            const isNotSettled = entry ? entry.state.read(r) === ModifiedFileEntryState.Modified : false;
+            if (isInProgress || isNotSettled) {
+                sessionOverlayWidget.show(session);
+            } else {
+                sessionOverlayWidget.hide();
+            }
+        }));
         this._store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
             if (session) {
@@ -1147,7 +298,9 @@ let InlineChatController2 = class InlineChatController2 {
                     return true;
                 });
                 for (const entry of otherEntries) {
-                    this._editorService.openEditor({ resource: entry.modifiedURI }, SIDE_GROUP).catch(onUnexpectedError);
+                    this._editorService.openEditor({
+                        resource: entry.modifiedURI
+                    }, SIDE_GROUP).catch(onUnexpectedError);
                 }
             }
         }));
@@ -1155,34 +308,41 @@ let InlineChatController2 = class InlineChatController2 {
             if (!session) {
                 return;
             }
-            const lastRequest = observableFromEvent(this, session.chatModel.onDidChange, () => session.chatModel.getRequests().at(-1)).read(r);
+            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);
+            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('');
+            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.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);
+            } 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(8339, "Working...")));
+                this._zone.rawValue?.widget.chatWidget.setInputPlaceholder(placeholder || ( localize(8632, "Working...")));
             }
         }));
         this._store.add(autorun(r => {
@@ -1198,12 +358,16 @@ let InlineChatController2 = class InlineChatController2 {
         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));
+            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 {
+                    position
+                } = this._zone.value;
                 const diff = entry.diffInfo.read(r);
                 for (const change of diff.changes) {
                     if (change.modified.contains(position.lineNumber)) {
@@ -1226,63 +390,83 @@ let InlineChatController2 = class InlineChatController2 {
     async run(arg) {
         assertType(this._editor.hasModel());
         const uri = this._editor.getModel().uri;
-        const existingSession = this._inlineChatSessionService.getSession2(uri);
+        const existingSession = this._inlineChatSessionService.getSessionByTextModel(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(8340, "Fix the attached problems"))
-                : ( localize(8341, "Fix the attached problem")), true);
-            this._zone.value.widget.chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
+        if (!arg?.message && this._configurationService.getValue(InlineChatConfigKeys.RenderMode) === "hover") {
+            await this._gutterIndicator.showMenuAtSelection();
+            return true;
         }
-        if (arg && InlineChatRunOptions.isInlineChatRunOptions(arg)) {
-            if (arg.initialRange) {
-                this._editor.revealRange(arg.initialRange);
-            }
-            if (arg.initialSelection) {
-                this._editor.setSelection(arg.initialSelection);
+        this._isActiveController.set(true, undefined);
+        const session = this._inlineChatSessionService.createSession(this._editor);
+        const sessionStore = ( new DisposableStore());
+        try {
+            await this._applyModelDefaults(session, sessionStore);
+            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 (arg.attachments) {
-                await Promise.all(( arg.attachments.map(async (attachment) => {
-                    await this._zone.value.widget.chatWidget.attachmentModel.addFile(attachment);
-                })));
-                delete arg.attachments;
+            if (entries.length > 0) {
+                this._zone.value.widget.chatWidget.attachmentModel.addContext(...entries);
+                this._zone.value.widget.chatWidget.input.setValue(entries.length > 1 ? ( localize(8633, "Fix the attached problems")) : ( localize(8634, "Fix the attached problem")), true);
+                this._zone.value.widget.chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
             }
-            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)}.`
-                    ));
+            if (arg && InlineChatRunOptions.isInlineChatRunOptions(arg)) {
+                if (arg.initialRange) {
+                    this._editor.revealRange(arg.initialRange);
                 }
-                const model = this._languageModelService.lookupLanguageModel(id);
-                if (!model) {
-                    throw ( new Error(`Language model not loaded: ${id}.`));
+                if (arg.initialSelection) {
+                    this._editor.setSelection(arg.initialSelection);
                 }
-                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();
+                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)).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();
+                    }
+                }
+            }
+            if (!arg?.resolveOnResponse) {
+                await Event.toPromise(session.editingSession.onDidDispose);
+                const rejected = session.editingSession.getEntry(uri)?.state.get() === ModifiedFileEntryState.Rejected;
+                return !rejected;
+            } else {
+                const modifiedObs = derived(r => {
+                    const entry = session.editingSession.readEntry(uri, r);
+                    return entry?.state.read(r) === ModifiedFileEntryState.Modified && !entry?.isCurrentlyBeingModifiedBy.read(r);
+                });
+                await waitForState(modifiedObs, state => state === true);
+                return true;
             }
+        } finally {
+            sessionStore.dispose();
         }
-        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();
@@ -1300,6 +484,61 @@ let InlineChatController2 = class InlineChatController2 {
         await session.editingSession.reject();
         session.dispose();
     }
+    async _selectVendorDefaultModel(session) {
+        const model = this._zone.value.widget.chatWidget.input.selectedLanguageModel.get();
+        if (model && !model.metadata.isDefaultForLocation[session.chatModel.initialLocation]) {
+            const ids = await this._languageModelService.selectLanguageModels({
+                vendor: model.metadata.vendor
+            });
+            for (const identifier of ids) {
+                const candidate = this._languageModelService.lookupLanguageModel(identifier);
+                if (candidate?.isDefaultForLocation[session.chatModel.initialLocation]) {
+                    this._zone.value.widget.chatWidget.input.setCurrentLanguageModel({
+                        metadata: candidate,
+                        identifier
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    async _applyModelDefaults(session, sessionStore) {
+        const userSelectedModel = InlineChatController_1._userSelectedModel;
+        const defaultModelSetting = this._configurationService.getValue(InlineChatConfigKeys.DefaultModel);
+        let modelApplied = false;
+        if (userSelectedModel) {
+            modelApplied = this._zone.value.widget.chatWidget.input.switchModelByQualifiedName([userSelectedModel]);
+            if (!modelApplied) {
+                InlineChatController_1._userSelectedModel = undefined;
+            }
+        }
+        if (!modelApplied && defaultModelSetting) {
+            modelApplied = this._zone.value.widget.chatWidget.input.switchModelByQualifiedName([defaultModelSetting]);
+            if (!modelApplied) {
+                this._logService.warn(
+                    `inlineChat.defaultModel setting value '${defaultModelSetting}' did not match any available model. Falling back to vendor default.`
+                );
+            }
+        }
+        if (!modelApplied) {
+            await this._selectVendorDefaultModel(session);
+        }
+        let initialModelId;
+        sessionStore.add(autorun(r => {
+            const newModel = this._zone.value.widget.chatWidget.input.selectedLanguageModel.read(r);
+            if (!newModel) {
+                return;
+            }
+            if (!initialModelId) {
+                initialModelId = newModel.identifier;
+                return;
+            }
+            if (initialModelId !== newModel.identifier) {
+                InlineChatController_1._userSelectedModel = ILanguageModelChatMetadata.asQualifiedName(newModel.metadata);
+                initialModelId = newModel.identifier;
+            }
+        }));
+    }
     async createImageAttachment(attachment) {
         const value = this._currentSession.get();
         if (!value) {
@@ -1309,8 +548,7 @@ let InlineChatController2 = class InlineChatController2 {
             if (await this._fileService.canHandleResource(attachment)) {
                 return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment);
             }
-        }
-        else if (attachment.scheme === Schemas.http || attachment.scheme === Schemas.https) {
+        } 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);
@@ -1319,21 +557,7 @@ let InlineChatController2 = class InlineChatController2 {
         return undefined;
     }
 };
-InlineChatController2 = InlineChatController2_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, INotebookEditorService)),
-    ( __param(3, IInlineChatSessionService)),
-    ( __param(4, ICodeEditorService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IConfigurationService)),
-    ( __param(7, ISharedWebContentExtractorService)),
-    ( __param(8, IFileService)),
-    ( __param(9, IChatAttachmentResolveService)),
-    ( __param(10, IEditorService)),
-    ( __param(11, IMarkerDecorationsService)),
-    ( __param(12, ILanguageModelsService)),
-    ( __param(13, IChatService))
-], InlineChatController2));
+InlineChatController = InlineChatController_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, INotebookEditorService)), ( __param(3, IInlineChatSessionService)), ( __param(4, ICodeEditorService)), ( __param(5, IContextKeyService)), ( __param(6, IConfigurationService)), ( __param(7, ISharedWebContentExtractorService)), ( __param(8, IFileService)), ( __param(9, IChatAttachmentResolveService)), ( __param(10, IEditorService)), ( __param(11, IMarkerDecorationsService)), ( __param(12, ILanguageModelsService)), ( __param(13, ILogService))], InlineChatController));
 async function reviewEdits(accessor, editor, stream, token, applyCodeBlockSuggestionId) {
     if (!editor.hasModel()) {
         return false;
@@ -1345,23 +569,43 @@ async function reviewEdits(accessor, editor, stream, token, applyCodeBlockSugges
     chatModel.startEditingSession(true);
     const store = ( new DisposableStore());
     store.add(chatModelRef);
-    const chatRequest = chatModel?.addRequest({ text: '', parts: [] }, { variables: [] }, 0, {
+    const chatRequest = chatModel?.addRequest({
+        text: "",
+        parts: []
+    }, {
+        variables: []
+    }, 0, {
         kind: undefined,
-        modeId: 'applyCodeBlock',
+        modeId: "applyCodeBlock",
         modeInstructions: undefined,
         isBuiltin: true,
-        applyCodeBlockSuggestionId,
+        applyCodeBlockSuggestionId
     });
     assertType(chatRequest.response);
-    chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: [], done: false });
+    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: chunk,
+            done: false
+        });
     }
-    chatRequest.response.updateContent({ kind: 'textEdit', uri, edits: [], done: true });
+    chatRequest.response.updateContent({
+        kind: "textEdit",
+        uri,
+        edits: [],
+        done: true
+    });
     if (!token.isCancellationRequested) {
         chatRequest.response.complete();
     }
@@ -1387,13 +631,27 @@ async function reviewNotebookEdits(accessor, uri, stream, token) {
     chatModel.startEditingSession(true);
     const store = ( new DisposableStore());
     store.add(chatModelRef);
-    const chatRequest = chatModel?.addRequest({ text: '', parts: [] }, { variables: [] }, 0);
+    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 });
+        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) {
@@ -1401,17 +659,35 @@ async function reviewNotebookEdits(accessor, uri, stream, token) {
             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 });
+            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 });
+        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();
@@ -1439,4 +715,4 @@ function isCellEditOperation(edit) {
     return true;
 }
 
-export { InlineChatController, InlineChatController1, InlineChatController2, InlineChatRunOptions, State, reviewEdits, reviewNotebookEdits };
+export { InlineChatController, InlineChatRunOptions, reviewEdits, reviewNotebookEdits };