@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

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

@@ -1,7 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { renderMarkdownAsPlaintext } from '../../../../base/browser/markdownRenderer.js';
 import { alert } from '../../../../base/browser/ui/aria/aria.js';
-import { coalesceInPlace } from '../../../../base/common/arrays.js';
 import { raceCancellationError, raceCancellation, Barrier, Queue } from '../../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { toErrorMessage } from '../../../../base/common/errorMessage.js';
@@ -17,9 +16,7 @@ import { generateUuid } from '../../../../base/common/uuid.js';
 import { IBulkEditService } from '../../../../editor/browser/services/bulkEditService.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 { TextEdit } from '../../../../editor/common/languages.js';
-import { ModelDecorationOptions } from '../../../../editor/common/model/textModel.js';
 import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
 import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
 import { localizeWithPath } from '../../../../nls.js';
@@ -35,42 +32,27 @@ import { IChatWidgetService, IChatAccessibilityService } from '../../chat/browse
 import { IChatAgentService } from '../../chat/common/chatAgents.js';
 import { chatSubcommandLeader, chatAgentLeader } from '../../chat/common/chatParserTypes.js';
 import { IChatService } from '../../chat/common/chatService.js';
-import { ReplyResponse, SessionPrompt, SessionExchange, EmptyResponse, ErrorResponse, ExpansionState, IInlineChatSessionService } from './inlineChatSession.js';
-import { LivePreviewStrategy, PreviewStrategy, LiveStrategy3, LiveStrategy } from './inlineChatStrategies.js';
+import { IInlineChatSavingService } from './inlineChatSavingService.js';
+import { ReplyResponse, SessionPrompt, SessionExchange, EmptyResponse, ErrorResponse, ExpansionState } from './inlineChatSession.js';
+import { IInlineChatSessionService } from './inlineChatSessionService.js';
+import { LivePreviewStrategy, PreviewStrategy, LiveStrategy } from './inlineChatStrategies.js';
 import { InlineChatZoneWidget } from './inlineChatWidget.js';
-import { INLINE_CHAT_ID, CTX_INLINE_CHAT_HAS_ACTIVE_REQUEST, CTX_INLINE_CHAT_DID_EDIT, CTX_INLINE_CHAT_USER_DID_EDIT, CTX_INLINE_CHAT_RESPONSE_TYPES, CTX_INLINE_CHAT_LAST_RESPONSE_TYPE, CTX_INLINE_CHAT_LAST_FEEDBACK, CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING, CTX_INLINE_CHAT_HAS_STASHED_SESSION } from '../common/inlineChat.js';
+import { INLINE_CHAT_ID, CTX_INLINE_CHAT_HAS_ACTIVE_REQUEST, CTX_INLINE_CHAT_DID_EDIT, CTX_INLINE_CHAT_USER_DID_EDIT, CTX_INLINE_CHAT_RESPONSE_TYPES, CTX_INLINE_CHAT_LAST_FEEDBACK, CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING } from '../common/inlineChat.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.js';
 import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
 var InlineChatController_1;
-class InlineChatRunOptions {
-    static isInteractiveEditorOptions(options) {
-        const { initialSelection, initialRange, message, autoSend, position } = 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)) {
-            return false;
-        }
-        return true;
-    }
-}
 let InlineChatController = class InlineChatController {
     static { InlineChatController_1 = this; }
     static get(editor) {
         return editor.getContribution(INLINE_CHAT_ID);
     }
-    static { this._decoBlock = ModelDecorationOptions.register({
-        description: 'inline-chat',
-        showIfCollapsed: false,
-        isWholeLine: true,
-        className: 'inline-chat-block-selection',
-    }); }
     static { this._storageKey = 'inline-chat-history'; }
     static { this._promptHistory = []; }
-    constructor(_editor, _instaService, _inlineChatSessionService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _accessibilityService, _chatAccessibilityService, _chatAgentService, _bulkEditService, _storageService) {
+    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _accessibilityService, _chatAccessibilityService, _chatAgentService, _bulkEditService, _storageService, _commandService) {
         this._editor = _editor;
         this._instaService = _instaService;
         this._inlineChatSessionService = _inlineChatSessionService;
+        this._inlineChatSavingService = _inlineChatSavingService;
         this._editorWorkerService = _editorWorkerService;
         this._logService = _logService;
         this._configurationService = _configurationService;
@@ -80,7 +62,10 @@ let InlineChatController = class InlineChatController {
         this._chatAgentService = _chatAgentService;
         this._bulkEditService = _bulkEditService;
         this._storageService = _storageService;
+        this._commandService = _commandService;
         this._historyOffset = -1;
+        this._historyCandidate = '';
+        this._isDisposed = false;
         this._store = ( new DisposableStore());
         this._messages = this._store.add(( new Emitter()));
         this._onWillStartSession = this._store.add(( new Emitter()));
@@ -89,29 +74,32 @@ let InlineChatController = class InlineChatController {
         this.onDidCancelInput = Event.filter(this._messages.event, m => m === 16  || m === 2 , this._store);
         this._sessionStore = this._store.add(( new DisposableStore()));
         this._stashedSession = this._store.add(( new MutableDisposable()));
-        this._ignoreModelContentChanged = false;
         this._forcedPlaceholder = undefined;
         this._ctxHasActiveRequest = CTX_INLINE_CHAT_HAS_ACTIVE_REQUEST.bindTo(contextKeyService);
         this._ctxDidEdit = CTX_INLINE_CHAT_DID_EDIT.bindTo(contextKeyService);
         this._ctxUserDidEdit = CTX_INLINE_CHAT_USER_DID_EDIT.bindTo(contextKeyService);
         this._ctxResponseTypes = CTX_INLINE_CHAT_RESPONSE_TYPES.bindTo(contextKeyService);
-        this._ctxLastResponseType = CTX_INLINE_CHAT_LAST_RESPONSE_TYPE.bindTo(contextKeyService);
         this._ctxLastFeedbackKind = CTX_INLINE_CHAT_LAST_FEEDBACK.bindTo(contextKeyService);
         this._ctxSupportIssueReporting = CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING.bindTo(contextKeyService);
         this._zone = ( new Lazy(
             () => this._store.add(_instaService.createInstance(InlineChatZoneWidget, this._editor))
         ));
         this._store.add(this._editor.onDidChangeModel(async (e) => {
-            if (this._activeSession || !e.newModelUrl) {
+            if (this._session || !e.newModelUrl) {
                 return;
             }
             const existingSession = this._inlineChatSessionService.getSession(this._editor, e.newModelUrl);
             if (!existingSession) {
                 return;
             }
-            this._log('session RESUMING', e);
+            this._log('session RESUMING after model change', e);
             await this.run({ existingSession });
-            this._log('session done or paused');
+        }));
+        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');
         InlineChatController_1._promptHistory = JSON.parse(_storageService.get(InlineChatController_1._storageKey, 0 , '[]'));
@@ -122,17 +110,17 @@ let InlineChatController = class InlineChatController {
             }
             InlineChatController_1._promptHistory.unshift(prompt);
             this._historyOffset = -1;
+            this._historyCandidate = '';
             this._storageService.store(InlineChatController_1._storageKey, JSON.stringify(InlineChatController_1._promptHistory), 0 , 0 );
         };
     }
     dispose() {
-        this._strategy?.dispose();
-        this._stashedSession.clear();
-        if (this._activeSession) {
-            this._inlineChatSessionService.releaseSession(this._activeSession);
+        if (this._currentRun) {
+            this._messages.fire(((this._session?.lastExchange ? 4  : 2) ));
         }
         this._store.dispose();
-        this._log('controller disposed');
+        this._isDisposed = true;
+        this._log('DISPOSED controller');
     }
     _log(message, ...more) {
         if (message instanceof Error) {
@@ -149,7 +137,7 @@ let InlineChatController = class InlineChatController {
         return INLINE_CHAT_ID;
     }
     _getMode() {
-        const editMode = this._configurationService.inspect('inlineChat.mode');
+        const editMode = this._configurationService.inspect("inlineChat.mode" );
         let editModeValue = editMode.value;
         if (this._accessibilityService.isScreenReaderOptimized() && editModeValue === editMode.defaultValue) {
             editModeValue = "preview" ;
@@ -165,18 +153,20 @@ let InlineChatController = class InlineChatController {
             if (this._currentRun) {
                 await this._currentRun;
             }
-            this._stashedSession.clear();
             if (options.initialSelection) {
                 this._editor.setSelection(options.initialSelection);
             }
+            this._historyOffset = -1;
+            this._historyCandidate = '';
+            this._stashedSession.clear();
             this._onWillStartSession.fire();
             this._currentRun = this._nextState("CREATE_SESSION" , options);
             await this._currentRun;
         }
         catch (error) {
             onUnexpectedError(error);
-            if (this._activeSession) {
-                this._inlineChatSessionService.releaseSession(this._activeSession);
+            if (this._session) {
+                this._inlineChatSessionService.releaseSession(this._session);
             }
             this["PAUSE" ]();
         }
@@ -184,56 +174,15 @@ let InlineChatController = class InlineChatController {
             this._currentRun = undefined;
         }
     }
-    joinCurrentRun() {
-        return this._currentRun;
-    }
-    _showWidget(initialRender = false, position) {
-        assertType(this._editor.hasModel());
-        let widgetPosition;
-        if (position) {
-            widgetPosition = position;
-        }
-        else if (this._zone.value.position) {
-            if (this._zone.value.position.lineNumber === 1) {
-                widgetPosition = this._zone.value.position.delta(-1);
-            }
-            else {
-                widgetPosition = this._zone.value.position;
-            }
-        }
-        else {
-            widgetPosition = this._editor.getSelection().getStartPosition().delta(-1);
-        }
-        let needsMargin = false;
-        if (initialRender) {
-            this._zone.value.setContainerMargins();
-        }
-        if (this._activeSession && !position && (this._activeSession.hasChangedText || this._activeSession.lastExchange)) {
-            widgetPosition = this._activeSession.wholeRange.value.getStartPosition().delta(-1);
-        }
-        if (this._activeSession) {
-            this._zone.value.updateBackgroundColor(widgetPosition, this._activeSession.wholeRange.value);
-        }
-        if (this._strategy) {
-            needsMargin = this._strategy.needsMargin();
-        }
-        if (!this._zone.value.position) {
-            this._zone.value.setWidgetMargins(widgetPosition, !needsMargin ? 0 : undefined);
-            this._zone.value.show(widgetPosition);
-        }
-        else {
-            this._zone.value.updatePositionAndHeight(widgetPosition);
-        }
-    }
     async _nextState(state, options) {
         let nextState = state;
-        while (nextState) {
+        while (nextState && !this._isDisposed) {
             this._log('setState to ', nextState);
             nextState = await this[nextState](options);
         }
     }
     async ["CREATE_SESSION" ](options) {
-        assertType(this._activeSession === undefined);
+        assertType(this._session === undefined);
         assertType(this._editor.hasModel());
         let session = options.existingSession;
         let initPosition;
@@ -242,11 +191,6 @@ let InlineChatController = class InlineChatController {
             delete options.position;
         }
         this._showWidget(true, initPosition);
-        this._zone.value.widget.updateInfo(( localizeWithPath(
-            'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-            'welcome.1',
-            "AI-generated code may be incorrect"
-        )));
         this._updatePlaceholder();
         if (!session) {
             const createSessionCts = ( new CancellationTokenSource());
@@ -269,7 +213,10 @@ let InlineChatController = class InlineChatController {
             createSessionCts.dispose();
             msgListener.dispose();
             if (createSessionCts.token.isCancellationRequested) {
-                return "PAUSE" ;
+                if (session) {
+                    this._inlineChatSessionService.releaseSession(session);
+                }
+                return "CANCEL" ;
             }
         }
         delete options.initialRange;
@@ -290,52 +237,49 @@ let InlineChatController = class InlineChatController {
             case "live" :
                 this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._zone.value);
                 break;
-            case "live3" :
-                this._strategy = this._instaService.createInstance(LiveStrategy3, session, this._editor, this._zone.value);
-                break;
             case "preview" :
-                this._strategy = this._instaService.createInstance(PreviewStrategy, session, this._zone.value);
+                this._strategy = this._instaService.createInstance(PreviewStrategy, session, this._editor, this._zone.value);
                 break;
             case "livePreview" :
             default:
                 this._strategy = this._instaService.createInstance(LivePreviewStrategy, session, this._editor, this._zone.value);
                 break;
         }
-        this._activeSession = session;
+        this._session = session;
         return "INIT_UI" ;
     }
     async ["INIT_UI" ](options) {
-        assertType(this._activeSession);
+        assertType(this._session);
         assertType(this._strategy);
         InlineCompletionsController.get(this._editor)?.hide();
         this._sessionStore.clear();
+        this._sessionStore.add(this._zone.value.widget.onRequestWithoutIntentDetection(async () => {
+            options.withIntentDetection = false;
+            this.regenerate();
+        }));
         const wholeRangeDecoration = this._editor.createDecorationsCollection();
         const updateWholeRangeDecoration = () => {
-            const ranges = [this._activeSession.wholeRange.value];
-            const newDecorations = ( ranges.map(
-                range => range.isEmpty() ? undefined : ({ range, options: InlineChatController_1._decoBlock })
-            ));
-            coalesceInPlace(newDecorations);
+            const newDecorations = this._strategy?.getWholeRangeDecoration() ?? [];
             wholeRangeDecoration.set(newDecorations);
         };
         this._sessionStore.add(toDisposable(() => wholeRangeDecoration.clear()));
-        this._sessionStore.add(this._activeSession.wholeRange.onDidChange(updateWholeRangeDecoration));
+        this._sessionStore.add(this._session.wholeRange.onDidChange(updateWholeRangeDecoration));
         updateWholeRangeDecoration();
-        this._zone.value.widget.updateSlashCommands(this._activeSession.session.slashCommands ?? []);
+        this._zone.value.widget.updateSlashCommands(this._session.session.slashCommands ?? []);
         this._updatePlaceholder();
-        this._zone.value.widget.updateInfo(this._activeSession.session.message ?? ( localizeWithPath(
+        this._zone.value.widget.updateInfo(this._session.session.message ?? ( localizeWithPath(
             'vs/workbench/contrib/inlineChat/browser/inlineChatController',
             'welcome.1',
             "AI-generated code may be incorrect"
         )));
-        this._zone.value.widget.preferredExpansionState = this._activeSession.lastExpansionState;
-        this._zone.value.widget.value = this._activeSession.session.input ?? this._activeSession.lastInput?.value ?? this._zone.value.widget.value;
-        if (this._activeSession.session.input) {
+        this._zone.value.widget.preferredExpansionState = this._session.lastExpansionState;
+        this._zone.value.widget.value = this._session.session.input ?? this._session.lastInput?.value ?? this._zone.value.widget.value;
+        if (this._session.session.input) {
             this._zone.value.widget.selectAll();
         }
         this._showWidget(true);
         this._sessionStore.add(this._editor.onDidChangeModel((e) => {
-            const msg = this._activeSession?.lastExchange
+            const msg = this._session?.lastExchange
                 ? 4
                 : 2 ;
             this._log('model changed, pause or cancel session', msg, e);
@@ -343,25 +287,27 @@ let InlineChatController = class InlineChatController {
         }));
         const altVersionNow = this._editor.getModel()?.getAlternativeVersionId();
         this._sessionStore.add(this._editor.onDidChangeModelContent(e => {
-            if (!this._ignoreModelContentChanged && this._strategy?.hasFocus()) {
+            if (!this._session?.hunkData.ignoreTextModelNChanges) {
                 this._ctxUserDidEdit.set(altVersionNow !== this._editor.getModel()?.getAlternativeVersionId());
             }
-            if (this._ignoreModelContentChanged || this._strategy?.hasFocus()) {
+            if (this._session?.hunkData.ignoreTextModelNChanges || this._strategy?.hasFocus()) {
                 return;
             }
-            const wholeRange = this._activeSession.wholeRange;
-            let editIsOutsideOfWholeRange = false;
-            for (const { range } of e.changes) {
-                editIsOutsideOfWholeRange = !Range.areIntersectingOrTouching(range, wholeRange.value);
+            const wholeRange = this._session.wholeRange;
+            let shouldFinishSession = false;
+            if (this._configurationService.getValue("inlineChat.finishOnType" )) {
+                for (const { range } of e.changes) {
+                    shouldFinishSession = !Range.areIntersectingOrTouching(range, wholeRange.value);
+                }
             }
-            this._activeSession.recordExternalEditOccurred(editIsOutsideOfWholeRange);
-            if (editIsOutsideOfWholeRange) {
+            this._session.recordExternalEditOccurred(shouldFinishSession);
+            if (shouldFinishSession) {
                 this._log('text changed outside of whole range, FINISH session');
                 this.finishExistingSession();
             }
         }));
-        this._ctxSupportIssueReporting.set(this._activeSession.provider.supportIssueReporting ?? false);
-        if (!this._activeSession.lastExchange) {
+        this._ctxSupportIssueReporting.set(this._session.provider.supportIssueReporting ?? false);
+        if (!this._session.lastExchange) {
             return "WAIT_FOR_INPUT" ;
         }
         else if (options.isUnstashed) {
@@ -372,26 +318,8 @@ let InlineChatController = class InlineChatController {
             return "SHOW_RESPONSE" ;
         }
     }
-    setPlaceholder(text) {
-        this._forcedPlaceholder = text;
-        this._updatePlaceholder();
-    }
-    resetPlaceholder() {
-        this._forcedPlaceholder = undefined;
-        this._updatePlaceholder();
-    }
-    _updatePlaceholder() {
-        this._zone.value.widget.placeholder = this._getPlaceholderText();
-    }
-    _getPlaceholderText() {
-        return this._forcedPlaceholder ?? this._activeSession?.session.placeholder ?? ( localizeWithPath(
-            'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-            'default.placeholder',
-            "Ask a question"
-        ));
-    }
     async ["WAIT_FOR_INPUT" ](options) {
-        assertType(this._activeSession);
+        assertType(this._session);
         assertType(this._strategy);
         this._updatePlaceholder();
         if (options.message) {
@@ -417,26 +345,28 @@ let InlineChatController = class InlineChatController {
             await barrier.wait();
             store.dispose();
         }
-        this._zone.value.widget.selectAll(false);
         if (message & ((16  | 2) )) {
             return "CANCEL" ;
         }
-        if (message & 1 ) {
-            return "DONE" ;
-        }
         if (message & 4 ) {
             return "PAUSE" ;
         }
-        if (message & 64  && this._activeSession.lastExchange) {
-            const { lastExchange } = this._activeSession;
-            this._activeSession.addInput(lastExchange.prompt.retry());
+        if (message & 1 ) {
+            this._zone.value.widget.selectAll(false);
+            return "DONE" ;
+        }
+        if (message & 64  && this._session.lastExchange) {
+            const { lastExchange } = this._session;
+            if (options.withIntentDetection === undefined) {
+                this._session.addInput(lastExchange.prompt.retry());
+            }
             if (lastExchange.response instanceof ReplyResponse) {
                 try {
-                    this._ignoreModelContentChanged = true;
+                    this._session.hunkData.ignoreTextModelNChanges = true;
                     await this._strategy.undoChanges(lastExchange.response.modelAltVersionId);
                 }
                 finally {
-                    this._ignoreModelContentChanged = false;
+                    this._session.hunkData.ignoreTextModelNChanges = false;
                 }
             }
             return "MAKE_REQUEST" ;
@@ -446,10 +376,10 @@ let InlineChatController = class InlineChatController {
         }
         const input = this.getInput();
         this._historyUpdate(input);
-        const refer = this._activeSession.session.slashCommands?.some(value => value.refer && input.startsWith(`/${value.command}`));
+        const refer = this._session.session.slashCommands?.some(value => value.refer && input.startsWith(`/${value.command}`));
         if (refer) {
-            this._log('[IE] seeing refer command, continuing outside editor', this._activeSession.provider.debugName);
-            this._editor.setSelection(this._activeSession.wholeRange.value);
+            this._log('[IE] seeing refer command, continuing outside editor', this._session.provider.debugName);
+            this._editor.setSelection(this._session.wholeRange.value);
             let massagedInput = input;
             if (input.startsWith(chatSubcommandLeader)) {
                 const withoutSubCommandLeader = input.slice(1);
@@ -464,19 +394,19 @@ let InlineChatController = class InlineChatController {
                 }
             }
             this._instaService.invokeFunction(sendRequest, massagedInput);
-            if (!this._activeSession.lastExchange) {
+            if (!this._session.lastExchange) {
                 return "DONE" ;
             }
             return "WAIT_FOR_INPUT" ;
         }
-        this._activeSession.addInput(( new SessionPrompt(input)));
+        this._session.addInput(( new SessionPrompt(input)));
         return "MAKE_REQUEST" ;
     }
-    async ["MAKE_REQUEST" ]() {
+    async ["MAKE_REQUEST" ](options) {
         assertType(this._editor.hasModel());
-        assertType(this._activeSession);
+        assertType(this._session);
         assertType(this._strategy);
-        assertType(this._activeSession.lastInput);
+        assertType(this._session.lastInput);
         const requestCts = ( new CancellationTokenSource());
         let message = 0 ;
         const msgListener = Event.once(this._messages.event)(m => {
@@ -488,13 +418,15 @@ let InlineChatController = class InlineChatController {
         const requestClock = StopWatch.create();
         const request = {
             requestId: generateUuid(),
-            prompt: this._activeSession.lastInput.value,
-            attempt: this._activeSession.lastInput.attempt,
+            prompt: this._session.lastInput.value,
+            attempt: this._session.lastInput.attempt,
             selection: this._editor.getSelection(),
-            wholeRange: this._activeSession.wholeRange.value,
-            live: this._activeSession.editMode !== "preview"
+            wholeRange: this._session.wholeRange.trackedInitialRange,
+            live: this._session.editMode !== "preview" ,
+            withIntentDetection: options.withIntentDetection ?? true ,
         };
-        const modelAltVersionIdNow = this._activeSession.textModelN.getAlternativeVersionId();
+        delete options.withIntentDetection;
+        const modelAltVersionIdNow = this._session.textModelN.getAlternativeVersionId();
         const progressEdits = [];
         const progressiveEditsAvgDuration = ( new MovingAverage());
         const progressiveEditsCts = ( new CancellationTokenSource(requestCts.token));
@@ -524,11 +456,11 @@ let InlineChatController = class InlineChatController {
                 progressiveEditsAvgDuration.update(progressiveEditsClock.elapsed());
                 progressiveEditsClock.reset();
                 progressiveEditsQueue.queue(async () => {
-                    const startThen = this._activeSession.wholeRange.value.getStartPosition();
+                    const startThen = this._session.wholeRange.value.getStartPosition();
                     await this._makeChanges(data.edits, data.editsShouldBeInstant
                         ? undefined
                         : { duration: progressiveEditsAvgDuration.value, token: progressiveEditsCts.token });
-                    const startNow = this._activeSession.wholeRange.value.getStartPosition();
+                    const startNow = this._session.wholeRange.value.getStartPosition();
                     if (!startNow.equals(startThen) || !this._zone.value.position?.equals(startNow)) {
                         this._showWidget(false, startNow.delta(-1));
                     }
@@ -541,7 +473,7 @@ let InlineChatController = class InlineChatController {
                             data.markdownFragment,
                             { supportThemeIcons: true, supportHtml: true, isTrusted: false }
                         )),
-                        providerId: this._activeSession.provider.debugName,
+                        providerId: this._session.provider.debugName,
                         requestId: request.requestId,
                     };
                     progressiveChatResponse = this._zone.value.widget.updateChatMessage(message, true);
@@ -554,25 +486,22 @@ let InlineChatController = class InlineChatController {
         let a11yResponse;
         const a11yVerboseInlineChat = this._configurationService.getValue('accessibility.verbosity.inlineChat') === true;
         const requestId = this._chatAccessibilityService.acceptRequest();
-        const task = this._activeSession.provider.provideResponse(this._activeSession.session, request, progress, requestCts.token);
-        this._log('request started', this._activeSession.provider.debugName, this._activeSession.session, request);
+        const task = this._session.provider.provideResponse(this._session.session, request, progress, requestCts.token);
+        this._log('request started', this._session.provider.debugName, this._session.session, request);
         let response;
         let reply;
         try {
             this._zone.value.widget.updateChatMessage(undefined);
             this._zone.value.widget.updateFollowUps(undefined);
             this._zone.value.widget.updateProgress(true);
-            this._zone.value.widget.updateInfo(!this._activeSession.lastExchange ? ( localizeWithPath(
+            this._zone.value.widget.updateInfo(!this._session.lastExchange ? ( localizeWithPath(
                 'vs/workbench/contrib/inlineChat/browser/inlineChatController',
                 'thinking',
                 "Thinking\u2026"
             )) : '');
-            await this._strategy.start();
             this._ctxHasActiveRequest.set(true);
             reply = await raceCancellationError(Promise.resolve(task), requestCts.token);
-            if (progressiveEditsQueue.size > 0) {
-                await Event.toPromise(progressiveEditsQueue.onDrained);
-            }
+            await progressiveEditsQueue.whenIdle();
             if (progressiveChatResponse) {
                 progressiveChatResponse.cancel();
             }
@@ -586,7 +515,7 @@ let InlineChatController = class InlineChatController {
             }
             else {
                 const markdownContents = reply.message ?? ( new MarkdownString('', { supportThemeIcons: true, supportHtml: true, isTrusted: false }));
-                const replyResponse = response = this._instaService.createInstance(ReplyResponse, reply, markdownContents, this._activeSession.textModelN.uri, modelAltVersionIdNow, progressEdits, request.requestId);
+                const replyResponse = response = this._instaService.createInstance(ReplyResponse, reply, markdownContents, this._session.textModelN.uri, modelAltVersionIdNow, progressEdits, request.requestId);
                 for (let i = progressEdits.length; i < replyResponse.allLocalEdits.length; i++) {
                     await this._makeChanges(replyResponse.allLocalEdits[i], undefined);
                 }
@@ -606,6 +535,7 @@ let InlineChatController = class InlineChatController {
             }
         }
         catch (e) {
+            progressiveEditsQueue.clear();
             response = ( new ErrorResponse(e));
             a11yResponse = response.message;
         }
@@ -614,19 +544,22 @@ let InlineChatController = class InlineChatController {
             this._zone.value.widget.updateProgress(false);
             this._zone.value.widget.updateInfo('');
             this._zone.value.widget.updateToolbar(true);
-            this._log('request took', requestClock.elapsed(), this._activeSession.provider.debugName);
+            this._log('request took', requestClock.elapsed(), this._session.provider.debugName);
             this._chatAccessibilityService.acceptResponse(a11yResponse, requestId);
         }
-        const diff = await this._editorWorkerService.computeDiff(this._activeSession.textModel0.uri, this._activeSession.textModelN.uri, { computeMoves: false, maxComputationTimeMs: Number.MAX_SAFE_INTEGER, ignoreTrimWhitespace: false }, 'advanced');
-        this._activeSession.wholeRange.fixup(diff?.changes ?? []);
+        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 ?? []);
         progressiveEditsCts.dispose(true);
         requestCts.dispose();
         msgListener.dispose();
         typeListener.dispose();
-        if (request.live && !(response instanceof ReplyResponse)) {
+        if (response instanceof ReplyResponse) {
+            await this._session.hunkData.recompute();
+        }
+        else if (request.live) {
             this._strategy?.undoChanges(modelAltVersionIdNow);
         }
-        this._activeSession.addExchange(( new SessionExchange(this._activeSession.lastInput, response)));
+        this._session.addExchange(( new SessionExchange(this._session.lastInput, response)));
         if (message & 2 ) {
             return "CANCEL" ;
         }
@@ -636,52 +569,29 @@ let InlineChatController = class InlineChatController {
         else if (message & 1 ) {
             return "DONE" ;
         }
+        else if (message & ((32  | 64) )) {
+            return "MAKE_REQUEST" ;
+        }
         else {
             return "APPLY_RESPONSE" ;
         }
     }
     async ["APPLY_RESPONSE" ]() {
-        assertType(this._activeSession);
+        assertType(this._session);
         assertType(this._strategy);
-        const { response } = this._activeSession.lastExchange;
+        const { response } = this._session.lastExchange;
         if (response instanceof ReplyResponse && response.workspaceEdit) {
             this._bulkEditService.apply(response.workspaceEdit, { showPreview: true });
             return "CANCEL" ;
         }
         return "SHOW_RESPONSE" ;
     }
-    async _makeChanges(edits, opts) {
-        assertType(this._activeSession);
-        assertType(this._strategy);
-        const moreMinimalEdits = await this._editorWorkerService.computeMoreMinimalEdits(this._activeSession.textModelN.uri, edits);
-        this._log('edits from PROVIDER and after making them MORE MINIMAL', this._activeSession.provider.debugName, edits, moreMinimalEdits);
-        if (moreMinimalEdits?.length === 0) {
-            return;
-        }
-        const actualEdits = !opts && moreMinimalEdits ? moreMinimalEdits : edits;
-        const editOperations = ( actualEdits.map(TextEdit.asEditOperation));
-        try {
-            this._ignoreModelContentChanged = true;
-            this._activeSession.wholeRange.trackEdits(editOperations);
-            if (opts) {
-                await this._strategy.makeProgressiveChanges(editOperations, opts);
-            }
-            else {
-                await this._strategy.makeChanges(editOperations);
-            }
-            this._ctxDidEdit.set(this._activeSession.hasChangedText);
-        }
-        finally {
-            this._ignoreModelContentChanged = false;
-        }
-    }
     async ["SHOW_RESPONSE" ]() {
-        assertType(this._activeSession);
+        assertType(this._session);
         assertType(this._strategy);
-        const { response } = this._activeSession.lastExchange;
-        this._ctxLastResponseType.set(response instanceof ReplyResponse ? response.raw.type : undefined);
+        const { response } = this._session.lastExchange;
         let responseTypes;
-        for (const { response } of this._activeSession.exchanges) {
+        for (const { response } of this._session.exchanges) {
             const thisType = response instanceof ReplyResponse
                 ? response.responseType
                 : undefined;
@@ -694,7 +604,7 @@ let InlineChatController = class InlineChatController {
             }
         }
         this._ctxResponseTypes.set(responseTypes);
-        this._ctxDidEdit.set(this._activeSession.hasChangedText);
+        this._ctxDidEdit.set(this._session.hasChangedText);
         let newPosition;
         if (response instanceof EmptyResponse) {
             const status = ( localizeWithPath(
@@ -712,24 +622,29 @@ let InlineChatController = class InlineChatController {
         }
         else if (response instanceof ReplyResponse) {
             this._zone.value.widget.updateStatus('');
-            const message = { message: response.mdContent, providerId: this._activeSession.provider.debugName, requestId: response.requestId };
+            const message = { message: response.mdContent, providerId: this._session.provider.debugName, requestId: response.requestId };
             this._zone.value.widget.updateChatMessage(message);
-            this._activeSession.lastExpansionState = this._zone.value.widget.expansionState;
+            this._session.lastExpansionState = this._zone.value.widget.expansionState;
             this._zone.value.widget.updateToolbar(true);
             newPosition = await this._strategy.renderChanges(response);
-            if (this._activeSession.provider.provideFollowups) {
+            if (this._session.provider.provideFollowups) {
                 const followupCts = ( new CancellationTokenSource());
                 const msgListener = Event.once(this._messages.event)(() => {
                     followupCts.cancel();
                 });
-                const followupTask = this._activeSession.provider.provideFollowups(this._activeSession.session, response.raw, followupCts.token);
-                this._log('followup request started', this._activeSession.provider.debugName, this._activeSession.session, response.raw);
+                const followupTask = this._session.provider.provideFollowups(this._session.session, response.raw, followupCts.token);
+                this._log('followup request started', this._session.provider.debugName, this._session.session, response.raw);
                 raceCancellation(Promise.resolve(followupTask), followupCts.token).then(followupReply => {
-                    if (followupReply && this._activeSession) {
-                        this._log('followup request received', this._activeSession.provider.debugName, this._activeSession.session, followupReply);
+                    if (followupReply && this._session) {
+                        this._log('followup request received', this._session.provider.debugName, this._session.session, followupReply);
                         this._zone.value.widget.updateFollowUps(followupReply, followup => {
-                            this.updateInput(followup.message);
-                            this.acceptInput();
+                            if (followup.kind === 'reply') {
+                                this.updateInput(followup.message);
+                                this.acceptInput();
+                            }
+                            else {
+                                this._commandService.executeCommand(followup.commandId, ...(followup.args ?? []));
+                            }
                         });
                     }
                 }).finally(() => {
@@ -742,21 +657,12 @@ let InlineChatController = class InlineChatController {
         return "WAIT_FOR_INPUT" ;
     }
     async ["PAUSE" ]() {
-        this._ctxDidEdit.reset();
-        this._ctxUserDidEdit.reset();
-        this._ctxLastResponseType.reset();
-        this._ctxLastFeedbackKind.reset();
-        this._ctxSupportIssueReporting.reset();
-        this._zone.value.hide();
-        if (this._editor.hasWidgetFocus()) {
-            this._editor.focus();
-        }
-        this._strategy?.dispose();
-        this._strategy = undefined;
-        this._activeSession = undefined;
+        this._resetWidget();
+        this._strategy?.dispose?.();
+        this._session = undefined;
     }
     async ["DONE" ]() {
-        assertType(this._activeSession);
+        assertType(this._session);
         assertType(this._strategy);
         this._sessionStore.clear();
         try {
@@ -772,35 +678,134 @@ let InlineChatController = class InlineChatController {
             this._log('FAILED to apply changes');
             this._log(err);
         }
-        this._inlineChatSessionService.releaseSession(this._activeSession);
-        this["PAUSE" ]();
+        this._inlineChatSessionService.releaseSession(this._session);
+        this._resetWidget();
+        this._strategy?.dispose();
+        this._strategy = undefined;
+        this._session = undefined;
     }
     async ["CANCEL" ]() {
-        assertType(this._activeSession);
-        assertType(this._strategy);
+        if (this._session) {
+            assertType(this._strategy);
+            this._sessionStore.clear();
+            const shouldStash = !this._session.isUnstashed && !!this._session.lastExchange && this._session.hunkData.size === this._session.hunkData.pending;
+            let undoCancelEdits = [];
+            try {
+                undoCancelEdits = this._strategy.cancel();
+            }
+            catch (err) {
+                this._dialogService.error(( localizeWithPath(
+                    'vs/workbench/contrib/inlineChat/browser/inlineChatController',
+                    'err.discard',
+                    "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._resetWidget();
+        this._strategy?.dispose();
+        this._strategy = undefined;
+        this._session = undefined;
+    }
+    _showWidget(initialRender = false, position) {
+        assertType(this._editor.hasModel());
+        let widgetPosition;
+        if (position) {
+            widgetPosition = position;
+        }
+        else if (this._zone.value.position) {
+            if (this._zone.value.position.lineNumber === 1) {
+                widgetPosition = this._zone.value.position.delta(-1);
+            }
+            else {
+                widgetPosition = this._zone.value.position;
+            }
+        }
+        else {
+            widgetPosition = this._editor.getSelection().getStartPosition().delta(-1);
+        }
+        if (initialRender) {
+            this._zone.value.setContainerMargins();
+        }
+        if (this._session && !position && (this._session.hasChangedText || this._session.lastExchange)) {
+            widgetPosition = this._session.wholeRange.value.getStartPosition().delta(-1);
+        }
+        if (this._session) {
+            this._zone.value.updateBackgroundColor(widgetPosition, this._session.wholeRange.value);
+        }
+        if (!this._zone.value.position) {
+            this._zone.value.setWidgetMargins(widgetPosition);
+            this._zone.value.show(widgetPosition);
+        }
+        else {
+            this._zone.value.updatePositionAndHeight(widgetPosition);
+        }
+    }
+    _resetWidget() {
         this._sessionStore.clear();
-        const mySession = this._activeSession;
-        try {
-            await this._strategy.cancel();
+        this._ctxDidEdit.reset();
+        this._ctxUserDidEdit.reset();
+        this._ctxLastFeedbackKind.reset();
+        this._ctxSupportIssueReporting.reset();
+        this._zone.value.hide();
+        if (this._editor.hasWidgetFocus()) {
+            this._editor.focus();
         }
-        catch (err) {
-            this._dialogService.error(( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                'err.discard',
-                "Failed to discard changes.",
-                toErrorMessage(err)
-            )));
-            this._log('FAILED to discard changes');
-            this._log(err);
+    }
+    async _makeChanges(edits, opts) {
+        assertType(this._session);
+        assertType(this._strategy);
+        const moreMinimalEdits = await this._editorWorkerService.computeMoreMinimalEdits(this._session.textModelN.uri, edits);
+        this._log('edits from PROVIDER and after making them MORE MINIMAL', this._session.provider.debugName, edits, moreMinimalEdits);
+        if (moreMinimalEdits?.length === 0) {
+            return;
         }
-        this["PAUSE" ]();
-        this._stashedSession.clear();
-        if (!mySession.isUnstashed && mySession.lastExchange) {
-            this._stashedSession.value = this._instaService.createInstance(StashedSession, this._editor, mySession);
+        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,
+        };
+        this._inlineChatSavingService.markChanged(this._session);
+        this._session.wholeRange.trackEdits(editOperations);
+        if (opts) {
+            await this._strategy.makeProgressiveChanges(editOperations, editsObserver, opts);
         }
         else {
-            this._inlineChatSessionService.releaseSession(mySession);
+            await this._strategy.makeChanges(editOperations, editsObserver);
         }
+        this._ctxDidEdit.set(this._session.hasChangedText);
+    }
+    _updatePlaceholder() {
+        this._zone.value.widget.placeholder = this._getPlaceholderText();
+    }
+    _getPlaceholderText() {
+        return this._forcedPlaceholder ?? this._session?.session.placeholder ?? '';
+    }
+    showSaveHint() {
+        const status = ( localizeWithPath(
+            'vs/workbench/contrib/inlineChat/browser/inlineChatController',
+            'savehint',
+            "Accept or discard changes to continue saving"
+        ));
+        this._zone.value.widget.updateStatus(status, { classes: ['warn'] });
+    }
+    setPlaceholder(text) {
+        this._forcedPlaceholder = text;
+        this._updatePlaceholder();
+    }
+    resetPlaceholder() {
+        this._forcedPlaceholder = undefined;
+        this._updatePlaceholder();
     }
     acceptInput() {
         this._messages.fire(32 );
@@ -840,30 +845,43 @@ let InlineChatController = class InlineChatController {
         if (len === 0) {
             return;
         }
-        const pos = (len + this._historyOffset + (up ? 1 : -1)) % len;
-        const entry = InlineChatController_1._promptHistory[pos];
+        if (this._historyOffset === -1) {
+            this._historyCandidate = this._zone.value.widget.value;
+        }
+        const newIdx = this._historyOffset + (up ? 1 : -1);
+        if (newIdx >= len) {
+            return;
+        }
+        let entry;
+        if (newIdx < 0) {
+            entry = this._historyCandidate;
+            this._historyOffset = -1;
+        }
+        else {
+            entry = InlineChatController_1._promptHistory[newIdx];
+            this._historyOffset = newIdx;
+        }
         this._zone.value.widget.value = entry;
         this._zone.value.widget.selectAll();
-        this._historyOffset = pos;
     }
     viewInChat() {
-        if (this._activeSession?.lastExchange?.response instanceof ReplyResponse) {
-            this._instaService.invokeFunction(showMessageResponse, this._activeSession.lastExchange.prompt.value, this._activeSession.lastExchange.response.mdContent.value);
+        if (this._session?.lastExchange?.response instanceof ReplyResponse) {
+            this._instaService.invokeFunction(showMessageResponse, this._session.lastExchange.prompt.value, this._session.lastExchange.response.mdContent.value);
         }
     }
     updateExpansionState(expand) {
-        if (this._activeSession) {
+        if (this._session) {
             const expansionState = expand ? ExpansionState.EXPANDED : ExpansionState.CROPPED;
             this._zone.value.widget.updateChatMessageExpansionState(expansionState);
-            this._activeSession.lastExpansionState = expansionState;
+            this._session.lastExpansionState = expansionState;
         }
     }
     toggleDiff() {
         this._strategy?.toggleDiff?.();
     }
     feedbackLast(kind) {
-        if (this._activeSession?.lastExchange && this._activeSession.lastExchange.response instanceof ReplyResponse) {
-            this._activeSession.provider.handleInlineChatResponseFeedback?.(this._activeSession.session, this._activeSession.lastExchange.response.raw, kind);
+        if (this._session?.lastExchange && this._session.lastExchange.response instanceof ReplyResponse) {
+            this._session.provider.handleInlineChatResponseFeedback?.(this._session.session, this._session.lastExchange.response.raw, kind);
             switch (kind) {
                 case 1 :
                     this._ctxLastFeedbackKind.set('helpful');
@@ -876,102 +894,80 @@ let InlineChatController = class InlineChatController {
         }
     }
     createSnapshot() {
-        if (this._activeSession && !this._activeSession.textModel0.equalsTextBuffer(this._activeSession.textModelN.getTextBuffer())) {
-            this._activeSession.createSnapshot();
+        if (this._session && !this._session.textModel0.equalsTextBuffer(this._session.textModelN.getTextBuffer())) {
+            this._session.createSnapshot();
         }
     }
     acceptSession() {
-        if (this._activeSession?.lastExchange && this._activeSession.lastExchange.response instanceof ReplyResponse) {
-            this._activeSession.provider.handleInlineChatResponseFeedback?.(this._activeSession.session, this._activeSession.lastExchange.response.raw, 3 );
+        if (this._session?.lastExchange && this._session.lastExchange.response instanceof ReplyResponse) {
+            this._session.provider.handleInlineChatResponseFeedback?.(this._session.session, this._session.lastExchange.response.raw, 3 );
         }
         this._messages.fire(1 );
     }
+    acceptHunk() {
+        return this._strategy?.acceptHunk();
+    }
+    discardHunk() {
+        return this._strategy?.discardHunk();
+    }
     async cancelSession() {
         let result;
-        if (this._activeSession) {
-            const diff = await this._editorWorkerService.computeDiff(this._activeSession.textModel0.uri, this._activeSession.textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: 5000, computeMoves: false }, 'advanced');
-            result = this._activeSession.asChangedText(diff?.changes ?? []);
-            if (this._activeSession.lastExchange && this._activeSession.lastExchange.response instanceof ReplyResponse) {
-                this._activeSession.provider.handleInlineChatResponseFeedback?.(this._activeSession.session, this._activeSession.lastExchange.response.raw, 2 );
+        if (this._session) {
+            const diff = await this._editorWorkerService.computeDiff(this._session.textModel0.uri, this._session.textModelN.uri, { ignoreTrimWhitespace: false, maxComputationTimeMs: 5000, computeMoves: false }, 'advanced');
+            result = this._session.asChangedText(diff?.changes ?? []);
+            if (this._session.lastExchange && this._session.lastExchange.response instanceof ReplyResponse) {
+                this._session.provider.handleInlineChatResponseFeedback?.(this._session.session, this._session.lastExchange.response.raw, 2 );
             }
         }
         this._messages.fire(2 );
         return result;
     }
     finishExistingSession() {
-        if (this._activeSession) {
-            if (this._activeSession.editMode === "preview" ) {
-                this._log('finishing existing session, using CANCEL', this._activeSession.editMode);
+        if (this._session) {
+            if (this._session.editMode === "preview" ) {
+                this._log('finishing existing session, using CANCEL', this._session.editMode);
                 this.cancelSession();
             }
             else {
-                this._log('finishing existing session, using APPLY', this._activeSession.editMode);
+                this._log('finishing existing session, using APPLY', this._session.editMode);
                 this.acceptSession();
             }
         }
     }
     unstashLastSession() {
-        return this._stashedSession.value?.unstash();
+        const result = this._stashedSession.value?.unstash();
+        if (result) {
+            this._inlineChatSavingService.markChanged(result);
+        }
+        return result;
+    }
+    joinCurrentRun() {
+        return this._currentRun;
     }
 };
 InlineChatController = InlineChatController_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, IAccessibilityService)),
-    ( __param(9, IChatAccessibilityService)),
-    ( __param(10, IChatAgentService)),
-    ( __param(11, IBulkEditService)),
-    ( __param(12, IStorageService))
+    ( __param(3, IInlineChatSavingService)),
+    ( __param(4, IEditorWorkerService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IConfigurationService)),
+    ( __param(7, IDialogService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IAccessibilityService)),
+    ( __param(10, IChatAccessibilityService)),
+    ( __param(11, IChatAgentService)),
+    ( __param(12, IBulkEditService)),
+    ( __param(13, IStorageService)),
+    ( __param(14, ICommandService))
 ], InlineChatController));
-let StashedSession = class StashedSession {
-    constructor(editor, session, contextKeyService, _sessionService, _logService) {
-        this._sessionService = _sessionService;
-        this._logService = _logService;
-        this._ctxHasStashedSession = CTX_INLINE_CHAT_HAS_STASHED_SESSION.bindTo(contextKeyService);
-        this._session = session;
-        this._ctxHasStashedSession.set(true);
-        this._listener = Event.once(Event.any(editor.onDidChangeCursorSelection, editor.onDidChangeModelContent, editor.onDidChangeModel))(() => {
-            this._session = undefined;
-            this._sessionService.releaseSession(session);
-            this._ctxHasStashedSession.reset();
-        });
-    }
-    dispose() {
-        this._listener.dispose();
-        this._ctxHasStashedSession.reset();
-        if (this._session) {
-            this._sessionService.releaseSession(this._session);
-        }
-    }
-    unstash() {
-        if (!this._session) {
-            return undefined;
-        }
-        this._listener.dispose();
-        const result = this._session;
-        result.markUnstashed();
-        this._session = undefined;
-        this._logService.debug('[IE] Unstashed session');
-        return result;
-    }
-};
-StashedSession = ( __decorate([
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IInlineChatSessionService)),
-    ( __param(4, ILogService))
-], StashedSession));
 async function showMessageResponse(accessor, query, response) {
     const chatService = accessor.get(IChatService);
     const providerId = chatService.getProviderInfos()[0]?.id;
     const chatWidgetService = accessor.get(IChatWidgetService);
     const widget = await chatWidgetService.revealViewForProvider(providerId);
     if (widget && widget.viewModel) {
-        chatService.addCompleteRequest(widget.viewModel.sessionId, query, { message: response });
+        chatService.addCompleteRequest(widget.viewModel.sessionId, query, undefined, { message: response });
         widget.focusLastMessage();
     }
 }
@@ -985,4 +981,4 @@ async function sendRequest(accessor, query) {
     }
     widget.acceptInput(query);
 }
-export { InlineChatController, InlineChatRunOptions };
+export { InlineChatController };