@codingame/monaco-vscode-api 8.0.3 → 9.0.0

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

@@ -1,21 +1,26 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { alert } from '../../../../base/browser/ui/aria/aria.js';
 import { Barrier, DeferredPromise, Queue } from '../../../../base/common/async.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { CancellationTokenSource, CancellationToken } from '../../../../base/common/cancellation.js';
 import { toErrorMessage } from '../../../../base/common/errorMessage.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
 import { Emitter, Event } from '../../../../base/common/event.js';
 import { Lazy } from '../../../../base/common/lazy.js';
 import { DisposableStore, MutableDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import { MovingAverage } from '../../../../base/common/numbers.js';
+import { isEqual } from '../../../../base/common/resources.js';
 import { StopWatch } from '../../../../base/common/stopwatch.js';
 import { assertType } from '../../../../base/common/types.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
 import { Position } from '../../../../editor/common/core/position.js';
 import { Range } from '../../../../editor/common/core/range.js';
-import { Selection } from '../../../../editor/common/core/selection.js';
+import { Selection, SelectionDirection } from '../../../../editor/common/core/selection.js';
 import { TextEdit } from '../../../../editor/common/languages.js';
 import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
-import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
+import { DefaultModelSHA1Computer } from '../../../../editor/common/services/modelService.js';
+import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.js';
+import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
 import { localize } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
@@ -23,30 +28,29 @@ import { IDialogService } from '../../../../platform/dialogs/common/dialogs.serv
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { showChatView } from '../../chat/browser/chat.js';
+import { ChatAgentLocation } from '../../chat/common/chatAgents.js';
+import { ChatRequestRemovalReason } from '../../chat/common/chatModel.js';
 import { IChatService } from '../../chat/common/chatService.service.js';
-import { IInlineChatSavingService } from './inlineChatSavingService.service.js';
-import { SessionPrompt, EmptyResponse, ErrorResponse, ReplyResponse, Session } from './inlineChatSession.js';
-import { IInlineChatSessionService } from './inlineChatSessionService.service.js';
-import { LiveStrategy, PreviewStrategy } from './inlineChatStrategies.js';
-import { InlineChatZoneWidget } from './inlineChatZoneWidget.js';
-import { INLINE_CHAT_ID, CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_USER_DID_EDIT, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, InlineChatConfigKeys, EditMode, InlineChatResponseType } from '../common/inlineChat.js';
 import { InlineChatContentWidget } from './inlineChatContentWidget.js';
-import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
-import { ChatRequestRemovalReason } from '../../chat/common/chatModel.js';
+import { HunkState, Session } from './inlineChatSession.js';
 import { InlineChatError } from './inlineChatSessionServiceImpl.js';
-import { IViewsService } from '../../../services/views/common/viewsService.service.js';
-import { DefaultModelSHA1Computer } from '../../../../editor/common/services/modelService.js';
-import { generateUuid } from '../../../../base/common/uuid.js';
-import { isEqual } from '../../../../base/common/resources.js';
-import { ChatAgentLocation } from '../../chat/common/chatAgents.js';
+import { LiveStrategy, PreviewStrategy, HunkAction } from './inlineChatStrategies.js';
+import { INLINE_CHAT_ID, CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_EDITING, CTX_INLINE_CHAT_USER_DID_EDIT, CTX_INLINE_CHAT_RESPONSE_TYPE, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, InlineChatConfigKeys, EditMode, InlineChatResponseType } from '../common/inlineChat.js';
 import { INotebookEditorService } from '../../notebook/browser/services/notebookEditorService.service.js';
+import { SIDE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { IViewsService } from '../../../services/views/common/viewsService.service.js';
+import { IInlineChatSavingService } from './inlineChatSavingService.service.js';
+import { IInlineChatSessionService } from './inlineChatSessionService.service.js';
+import { InlineChatZoneWidget } from './inlineChatZoneWidget.js';
+import { CONTEXT_RESPONSE, CONTEXT_RESPONSE_ERROR } from '../../chat/common/chatContextKeys.js';
+var InlineChatController_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["SHOW_RESPONSE"] = "SHOW_RESPONSE";
     State["PAUSE"] = "PAUSE";
     State["CANCEL"] = "CANCEL";
     State["ACCEPT"] = "DONE";
@@ -75,7 +79,7 @@ class InlineChatRunOptions {
         return true;
     }
 }
-let InlineChatController = class InlineChatController {
+let InlineChatController = InlineChatController_1 = class InlineChatController {
     static get(editor) {
         return editor.getContribution(INLINE_CHAT_ID);
     }
@@ -87,7 +91,7 @@ let InlineChatController = class InlineChatController {
             return this._ui.value.zone.widget.chatWidget;
         }
     }
-    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatService, notebookEditorService) {
+    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatService, _editorService, notebookEditorService) {
         this._editor = _editor;
         this._instaService = _instaService;
         this._inlineChatSessionService = _inlineChatSessionService;
@@ -97,18 +101,24 @@ let InlineChatController = class InlineChatController {
         this._configurationService = _configurationService;
         this._dialogService = _dialogService;
         this._chatService = _chatService;
+        this._editorService = _editorService;
         this._isDisposed = false;
         this._store = ( (new DisposableStore()));
         this._messages = this._store.add(( (new Emitter())));
+        this._onDidEnterState = this._store.add(( (new Emitter())));
+        this.onDidEnterState = this._onDidEnterState.event;
         this._onWillStartSession = this._store.add(( (new Emitter())));
         this.onWillStartSession = this._onWillStartSession.event;
         this._sessionStore = this._store.add(( (new DisposableStore())));
         this._stashedSession = this._store.add(( (new MutableDisposable())));
         this._forcedPlaceholder = undefined;
         this._ctxVisible = CTX_INLINE_CHAT_VISIBLE.bindTo(contextKeyService);
+        this._ctxEditing = CTX_INLINE_CHAT_EDITING.bindTo(contextKeyService);
         this._ctxUserDidEdit = CTX_INLINE_CHAT_USER_DID_EDIT.bindTo(contextKeyService);
         this._ctxResponseType = CTX_INLINE_CHAT_RESPONSE_TYPE.bindTo(contextKeyService);
         this._ctxRequestInProgress = CTX_INLINE_CHAT_REQUEST_IN_PROGRESS.bindTo(contextKeyService);
+        this._ctxResponse = CONTEXT_RESPONSE.bindTo(contextKeyService);
+        CONTEXT_RESPONSE_ERROR.bindTo(contextKeyService);
         this._ui = ( (new Lazy(() => {
             const location = {
                 location: ChatAgentLocation.Editor,
@@ -161,7 +171,7 @@ let InlineChatController = class InlineChatController {
                 await this.run({ existingSession: e.session });
             }
         }));
-        this._log('NEW controller');
+        this._log(`NEW controller`);
     }
     dispose() {
         if (this._currentRun) {
@@ -178,7 +188,7 @@ let InlineChatController = class InlineChatController {
             this._logService.error(message, ...more);
         }
         else {
-            this._logService.trace(`[IE] (editor:${this._editor.getId()})${message}`, ...more);
+            this._logService.trace(`[IE] (editor:${this._editor.getId()}) ${message}`, ...more);
         }
     }
     getMessage() {
@@ -208,6 +218,7 @@ let InlineChatController = class InlineChatController {
             await this._currentRun;
         }
         catch (error) {
+            this._log('error during run', error);
             onUnexpectedError(error);
             if (this._session) {
                 this._inlineChatSessionService.releaseSession(this._session);
@@ -222,7 +233,9 @@ let InlineChatController = class InlineChatController {
         let nextState = state;
         while (nextState && !this._isDisposed) {
             this._log('setState to ', nextState);
-            nextState = await this[nextState](options);
+            const p = this[nextState](options);
+            this._onDidEnterState.fire(nextState);
+            nextState = await p;
         }
     }
     async [State.CREATE_SESSION](options) {
@@ -234,15 +247,15 @@ let InlineChatController = class InlineChatController {
             initPosition = Position.lift(options.position).delta(-1);
             delete options.position;
         }
-        const widgetPosition = this._showWidget(true, initPosition);
-        let errorMessage = ( localize(7081, "Failed to start editor chat"));
+        const widgetPosition = this._showWidget(options.headless ?? session?.headless, true, initPosition);
+        let errorMessage = ( localize(7036, "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.zone.widget.updateInfo(( localize(7082, "Getting ready...")));
+                    this._ui.value.zone.widget.updateInfo(( localize(7037, "Getting ready...")));
                 }
                 else {
                     createSessionCts.cancel();
@@ -279,7 +292,7 @@ let InlineChatController = class InlineChatController {
                 break;
             case EditMode.Live:
             default:
-                this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._ui.value.zone);
+                this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._ui.value.zone, session.headless || this._configurationService.getValue(InlineChatConfigKeys.ZoneToolbar));
                 break;
         }
         this._session = session;
@@ -291,18 +304,25 @@ let InlineChatController = class InlineChatController {
         InlineCompletionsController.get(this._editor)?.hide();
         this._sessionStore.clear();
         const wholeRangeDecoration = this._editor.createDecorationsCollection();
-        const updateWholeRangeDecoration = () => {
+        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._sessionStore.add(this._session.wholeRange.onDidChange(updateWholeRangeDecoration));
-        updateWholeRangeDecoration();
+        this._sessionStore.add(toDisposable(() => {
+            wholeRangeDecoration.clear();
+            this._ctxEditing.reset();
+        }));
+        this._sessionStore.add(this._session.wholeRange.onDidChange(handleWholeRangeChange));
+        handleWholeRangeChange();
         this._sessionStore.add(this._ui.value.content.onDidBlur(() => this.cancelSession()));
         this._ui.value.content.setSession(this._session);
+        this._ui.value.zone.widget.setChatModel(this._session.chatModel);
         this._updatePlaceholder();
-        this._showWidget(!this._session.chatModel.hasRequests);
+        const isModelEmpty = !this._session.chatModel.hasRequests;
         this._ui.value.zone.widget.updateToolbar(true);
+        this._ui.value.zone.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
@@ -336,15 +356,38 @@ let InlineChatController = class InlineChatController {
                 await this._session.undoChangesUntil(e.requestId);
             }
         }));
-        if (!this._session.chatModel.hasRequests) {
-            return State.WAIT_FOR_INPUT;
+        const editState = this._createChatTextEditGroupState();
+        let didEdit = false;
+        for (const request of this._session.chatModel.getRequests()) {
+            if (!request.response) {
+                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();
         }
-        else if (options.isUnstashed) {
-            delete options.isUnstashed;
-            return State.SHOW_RESPONSE;
+        options.position = await this._strategy.renderChanges();
+        if (this._session.chatModel.requestInProgress) {
+            return State.SHOW_REQUEST;
         }
         else {
-            return State.SHOW_RESPONSE;
+            return State.WAIT_FOR_INPUT;
         }
     }
     async [State.WAIT_FOR_INPUT](options) {
@@ -355,7 +398,7 @@ let InlineChatController = class InlineChatController {
             this.updateInput(options.message);
             alert(options.message);
             delete options.message;
-            this._showWidget(false);
+            this._showWidget(this._session.headless, false);
         }
         let message = Message.NONE;
         let request;
@@ -377,7 +420,7 @@ let InlineChatController = class InlineChatController {
         }));
         if (options.autoSend) {
             delete options.autoSend;
-            this._showWidget(false);
+            this._showWidget(this._session.headless, false);
             this._ui.value.zone.widget.chatWidget.acceptInput();
         }
         await barrier.wait();
@@ -395,20 +438,21 @@ let InlineChatController = class InlineChatController {
         if (!request?.message.text) {
             return State.WAIT_FOR_INPUT;
         }
-        this._session.addInput(( (new SessionPrompt(request, this._editor.getModel().getAlternativeVersionId()))));
         return State.SHOW_REQUEST;
     }
-    async [State.SHOW_REQUEST]() {
+    async [State.SHOW_REQUEST](options) {
         assertType(this._session);
+        assertType(this._strategy);
         assertType(this._session.chatModel.requestInProgress);
         this._ctxRequestInProgress.set(true);
         const { chatModel } = this._session;
-        const request = chatModel.getRequests().at(-1);
+        const request = chatModel.lastRequest;
         assertType(request);
         assertType(request.response);
-        this._showWidget(false);
+        this._showWidget(this._session.headless, false);
         this._ui.value.zone.widget.selectAll(false);
         this._ui.value.zone.widget.updateInfo('');
+        this._ui.value.zone.widget.toggleStatus(true);
         const { response } = request;
         const responsePromise = ( (new DeferredPromise()));
         const store = ( (new DisposableStore()));
@@ -416,7 +460,7 @@ let InlineChatController = class InlineChatController {
         const progressiveEditsAvgDuration = ( (new MovingAverage()));
         const progressiveEditsClock = StopWatch.create();
         const progressiveEditsQueue = ( (new Queue()));
-        let next = State.SHOW_RESPONSE;
+        let next = State.WAIT_FOR_INPUT;
         store.add(Event.once(this._messages.event)(message => {
             this._log('state=_makeRequest) message received', message);
             this._chatService.cancelCurrentRequestForSession(chatModel.sessionId);
@@ -430,7 +474,7 @@ let InlineChatController = class InlineChatController {
                 next = State.ACCEPT;
             }
         }));
-        store.add(chatModel.onDidChange(e => {
+        store.add(chatModel.onDidChange(async (e) => {
             if (e.kind === 'removeRequest' && e.requestId === request.id) {
                 progressiveEditsCts.cancel();
                 responsePromise.complete();
@@ -440,6 +484,35 @@ let InlineChatController = class InlineChatController {
                 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, {
+                    editMode: this._getMode(),
+                    session: this._session,
+                }, CancellationToken.None);
+                InlineChatController_1.get(newEditor)?.run({ existingSession: newSession });
+                next = State.CANCEL;
+                responsePromise.complete();
+                return;
             }
         }));
         store.add(this._ui.value.zone.widget.chatWidget.inputEditor.onDidChangeModelContent(() => {
@@ -447,11 +520,7 @@ let InlineChatController = class InlineChatController {
         }));
         let lastLength = 0;
         let isFirstChange = true;
-        const sha1 = ( (new DefaultModelSHA1Computer()));
-        const textModel0Sha1 = sha1.canComputeSHA1(this._session.textModel0)
-            ? sha1.computeSHA1(this._session.textModel0)
-            : generateUuid();
-        const editState = { sha1: textModel0Sha1, applied: 0 };
+        const editState = this._createChatTextEditGroupState();
         let localEditGroup;
         const handleResponse = () => {
             this._updateCtxResponseType();
@@ -463,6 +532,7 @@ let InlineChatController = class InlineChatController {
                 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();
@@ -477,7 +547,7 @@ let InlineChatController = class InlineChatController {
                         }
                         const startNow = this._session.wholeRange.value.getStartPosition();
                         if (!startNow.equals(startThen) || !this._ui.value.zone.position?.equals(startNow)) {
-                            this._showWidget(false, startNow.delta(-1));
+                            this._showWidget(this._session.headless, false, startNow.delta(-1));
                         }
                     });
                 }
@@ -494,7 +564,7 @@ let InlineChatController = class InlineChatController {
         handleResponse();
         await responsePromise.p;
         await progressiveEditsQueue.whenIdle();
-        if (response.isCanceled) {
+        if (response.result?.errorDetails) {
             await this._session.undoChangesUntil(response.requestId);
         }
         store.dispose();
@@ -502,41 +572,29 @@ let InlineChatController = class InlineChatController {
         this._session.wholeRange.fixup(diff?.changes ?? []);
         await this._session.hunkData.recompute(editState, diff);
         this._ctxRequestInProgress.set(false);
-        return next;
-    }
-    async [State.SHOW_RESPONSE]() {
-        assertType(this._session);
-        assertType(this._strategy);
-        const { response } = this._session.lastExchange;
         let newPosition;
-        if (response instanceof EmptyResponse) {
-            const status = ( localize(7083, "No results, please refine your input and try again"));
+        if (response.result?.errorDetails) ;
+        else if (response.response.value.length === 0) {
+            const status = ( localize(7038, "No results, please refine your input and try again"));
             this._ui.value.zone.widget.updateStatus(status, { classes: ['warn'] });
-            return State.WAIT_FOR_INPUT;
         }
-        else if (response instanceof ErrorResponse) {
-            if (!response.isCancellation) {
-                this._ui.value.zone.widget.updateStatus(response.message, { classes: ['error'] });
-                this._strategy?.cancel();
-            }
-        }
-        else if (response instanceof ReplyResponse) {
+        else {
             this._ui.value.zone.widget.updateStatus('');
-            const position = await this._strategy.renderChanges();
-            if (position) {
-                const selection = this._editor.getSelection();
-                if (selection?.containsPosition(position)) {
-                    if (position.lineNumber - selection.startLineNumber > 8) {
-                        newPosition = position;
-                    }
-                }
-                else {
+        }
+        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(false, newPosition);
-        return State.WAIT_FOR_INPUT;
+        this._showWidget(this._session.headless, false, newPosition);
+        return next;
     }
     async [State.PAUSE]() {
         this._resetWidget();
@@ -551,7 +609,7 @@ let InlineChatController = class InlineChatController {
             await this._strategy.apply();
         }
         catch (err) {
-            this._dialogService.error(( localize(7084, "Failed to apply changes.", toErrorMessage(err))));
+            this._dialogService.error(( localize(7039, "Failed to apply changes.", toErrorMessage(err))));
             this._log('FAILED to apply changes');
             this._log(err);
         }
@@ -571,7 +629,7 @@ let InlineChatController = class InlineChatController {
                 undoCancelEdits = this._strategy.cancel();
             }
             catch (err) {
-                this._dialogService.error(( localize(7085, "Failed to discard changes.", toErrorMessage(err))));
+                this._dialogService.error(( localize(7040, "Failed to discard changes.", toErrorMessage(err))));
                 this._log('FAILED to discard changes');
                 this._log(err);
             }
@@ -588,7 +646,7 @@ let InlineChatController = class InlineChatController {
         this._strategy = undefined;
         this._session = undefined;
     }
-    _showWidget(initialRender = false, position) {
+    _showWidget(headless = false, initialRender = false, position) {
         assertType(this._editor.hasModel());
         this._ctxVisible.set(true);
         let widgetPosition;
@@ -607,21 +665,20 @@ let InlineChatController = class InlineChatController {
             widgetPosition = this._editor.getSelection().getStartPosition().delta(-1);
         }
         if (this._session && !position && (this._session.hasChangedText || this._session.chatModel.hasRequests)) {
-            widgetPosition = this._session.wholeRange.value.getStartPosition().delta(-1);
+            widgetPosition = this._session.wholeRange.trackedInitialRange.getStartPosition().delta(-1);
         }
-        if (this._ui.rawValue?.zone?.position) {
-            this._ui.value.zone.updatePositionAndHeight(widgetPosition);
-        }
-        else if (initialRender) {
-            const selection = this._editor.getSelection();
-            widgetPosition = selection.getStartPosition();
-            this._ui.value.content.show(widgetPosition);
-        }
-        else {
-            this._ui.value.content.hide();
-            this._ui.value.zone.show(widgetPosition);
-            if (this._session) {
-                this._ui.value.zone.widget.setChatModel(this._session.chatModel);
+        if (!headless) {
+            if (this._ui.rawValue?.zone?.position) {
+                this._ui.value.zone.updatePositionAndHeight(widgetPosition);
+            }
+            else if (initialRender && this._configurationService.getValue(InlineChatConfigKeys.StartWithOverlayWidget)) {
+                const selection = this._editor.getSelection();
+                widgetPosition = selection.getStartPosition();
+                this._ui.value.content.show(widgetPosition, selection.isEmpty());
+            }
+            else {
+                this._ui.value.content.hide();
+                this._ui.value.zone.show(widgetPosition);
             }
         }
         return widgetPosition;
@@ -650,7 +707,7 @@ let InlineChatController = class InlineChatController {
         };
         let responseType = InlineChatResponseType.None;
         for (const request of this._session.chatModel.getRequests()) {
-            if (!request.response) {
+            if (!request.response || request.response.isCanceled) {
                 continue;
             }
             responseType = InlineChatResponseType.Messages;
@@ -660,6 +717,18 @@ let InlineChatController = class InlineChatController {
             }
         }
         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);
@@ -690,8 +759,20 @@ let InlineChatController = class InlineChatController {
         return this._forcedPlaceholder ?? this._session?.agent.description ?? '';
     }
     showSaveHint() {
-        const status = ( localize(7086, "Accept or discard changes to continue saving"));
+        if (!this._session) {
+            return;
+        }
+        const status = ( localize(7041, "Accept or discard changes to continue saving."));
         this._ui.value.zone.widget.updateStatus(status, { classes: ['warn'] });
+        if (this._ui.value.zone.position) {
+            this._editor.revealLineInCenterIfOutsideViewport(this._ui.value.zone.position.lineNumber);
+        }
+        else {
+            const hunk = this._session.hunkData.getInfo().find(info => info.getState() === HunkState.Pending);
+            if (hunk) {
+                this._editor.revealLineInCenterIfOutsideViewport(hunk.getRangesN()[0].startLineNumber);
+            }
+        }
     }
     acceptInput() {
         return this.chatWidget.acceptInput();
@@ -723,10 +804,6 @@ let InlineChatController = class InlineChatController {
     hasFocus() {
         return this._ui.value.zone.widget.hasFocus();
     }
-    moveHunk(next) {
-        this.focus();
-        this._strategy?.move?.(next);
-    }
     async viewInChat() {
         if (!this._strategy || !this._session) {
             return;
@@ -750,13 +827,11 @@ let InlineChatController = class InlineChatController {
         if (someApplied) {
             assertType(lastEdit);
             lastEdit.edits = [doEdits];
+            lastEdit.state.applied = 0;
         }
         await this._instaService.invokeFunction(moveToPanelChat, this._session?.chatModel);
         this.cancelSession();
     }
-    toggleDiff() {
-        this._strategy?.toggleDiff?.();
-    }
     acceptSession() {
         const response = this._session?.chatModel.getRequests().at(-1)?.response;
         if (response) {
@@ -774,14 +849,21 @@ let InlineChatController = class InlineChatController {
         }
         this._messages.fire(Message.ACCEPT_SESSION);
     }
-    acceptHunk() {
-        return this._strategy?.acceptHunk();
+    acceptHunk(hunkInfo) {
+        return this._strategy?.performHunkAction(hunkInfo, HunkAction.Accept);
     }
-    discardHunk() {
-        return this._strategy?.discardHunk();
+    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.getRequests().at(-1)?.response;
+        const response = this._session?.chatModel.lastRequest?.response;
         if (response) {
             this._chatService.notifyUserAction({
                 sessionId: response.session.sessionId,
@@ -809,6 +891,19 @@ let InlineChatController = class InlineChatController {
             }
         }
     }
+    reportIssue() {
+        const response = this._session?.chatModel.lastRequest?.response;
+        if (response) {
+            this._chatService.notifyUserAction({
+                sessionId: response.session.sessionId,
+                requestId: response.requestId,
+                agentId: response.agent?.id,
+                command: response.slashCommand?.name,
+                result: response.result,
+                action: { kind: 'bug' }
+            });
+        }
+    }
     unstashLastSession() {
         const result = this._stashedSession.value?.unstash();
         if (result) {
@@ -819,8 +914,34 @@ let InlineChatController = class InlineChatController {
     joinCurrentRun() {
         return this._currentRun;
     }
+    async reviewEdits(anchor, stream, token) {
+        if (!this._editor.hasModel()) {
+            return false;
+        }
+        const session = await this._inlineChatSessionService.createSession(this._editor, { editMode: EditMode.Live, wholeRange: anchor, headless: true }, token);
+        if (!session) {
+            return false;
+        }
+        const request = session.chatModel.addRequest({ text: 'DUMMY', parts: [] }, { variables: [] }, 0);
+        const run = this.run({
+            existingSession: session,
+            headless: true
+        });
+        await Event.toPromise(Event.filter(this._onDidEnterState.event, candidate => candidate === State.SHOW_REQUEST));
+        for await (const chunk of stream) {
+            session.chatModel.acceptResponseProgress(request, { kind: 'textEdit', uri: this._editor.getModel().uri, edits: [chunk] });
+        }
+        if (token.isCancellationRequested) {
+            session.chatModel.cancelRequest(request);
+        }
+        else {
+            session.chatModel.completeResponse(request);
+        }
+        await run;
+        return true;
+    }
 };
-InlineChatController = ( (__decorate([
+InlineChatController = InlineChatController_1 = ( (__decorate([
     ( (__param(1, IInstantiationService))),
     ( (__param(2, IInlineChatSessionService))),
     ( (__param(3, IInlineChatSavingService))),
@@ -830,7 +951,8 @@ InlineChatController = ( (__decorate([
     ( (__param(7, IDialogService))),
     ( (__param(8, IContextKeyService))),
     ( (__param(9, IChatService))),
-    ( (__param(10, INotebookEditorService)))
+    ( (__param(10, IEditorService))),
+    ( (__param(11, INotebookEditorService)))
 ], InlineChatController)));
 async function moveToPanelChat(accessor, model) {
     const viewsService = accessor.get(IViewsService);