@codingame/monaco-vscode-api 5.3.0 → 6.0.1

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { alert } from '../../../../base/browser/ui/aria/aria.js';
-import { raceCancellation, Barrier, DeferredPromise, Queue } from '../../../../base/common/async.js';
+import { Barrier, DeferredPromise, Queue } from '../../../../base/common/async.js';
 import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { toErrorMessage } from '../../../../base/common/errorMessage.js';
 import { onUnexpectedError } from '../../../../base/common/errors.js';
@@ -13,7 +13,7 @@ import { assertType } from '../../../../base/common/types.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 { CompletionItemKind, TextEdit } from '../../../../editor/common/languages.js';
 import { IEditorWorkerService } from '../../../../editor/common/services/editorWorker.js';
 import { InlineCompletionsController } from '../../../../editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
 import { localizeWithPath } from '../../../../nls.js';
@@ -24,27 +24,47 @@ import { IInstantiationService } from '../../../../platform/instantiation/common
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { showChatView } from '../../chat/browser/chat.js';
 import { IChatWidgetService } from '../../chat/browser/chat.service.js';
-import { ChatAgentLocation } from '../../chat/common/chatAgents.js';
-import { IChatAgentService } from '../../chat/common/chatAgents.service.js';
-import { ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, chatAgentLeader } from '../../chat/common/chatParserTypes.js';
 import { IChatService } from '../../chat/common/chatService.service.js';
 import { IInlineChatSavingService } from './inlineChatSavingService.service.js';
-import { ReplyResponse, SessionPrompt, EmptyResponse, ErrorResponse, Session } from './inlineChatSession.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_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.service.js';
+import { INLINE_CHAT_ID, CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_USER_DID_EDIT, CTX_INLINE_CHAT_RESPONSE_TYPES, InlineChatConfigKeys, EditMode, InlineChatResponseTypes } from '../common/inlineChat.js';
 import { InlineChatContentWidget } from './inlineChatContentWidget.js';
 import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
-import { tail } from '../../../../base/common/arrays.js';
+import { ChatRequestRemovalReason } from '../../chat/common/chatModel.js';
 import { InlineChatError } from './inlineChatSessionServiceImpl.js';
 import { ILanguageFeaturesService } from '../../../../editor/common/services/languageFeatures.js';
 import { ChatInputPart } from '../../chat/browser/chatInputPart.js';
-import { OffsetRange } from '../../../../editor/common/core/offsetRange.js';
-import { isEqual } from '../../../../base/common/resources.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 { INotebookEditorService } from '../../notebook/browser/services/notebookEditorService.service.js';
 const _moduleId = "vs/workbench/contrib/inlineChat/browser/inlineChatController";
+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";
+})(State || (State = {}))));
+var Message;
+( ((function(Message) {
+    Message[Message["NONE"] = 0] = "NONE";
+    Message[Message["ACCEPT_SESSION"] = 1] = "ACCEPT_SESSION";
+    Message[Message["CANCEL_SESSION"] = 2] = "CANCEL_SESSION";
+    Message[Message["PAUSE_SESSION"] = 4] = "PAUSE_SESSION";
+    Message[Message["CANCEL_REQUEST"] = 8] = "CANCEL_REQUEST";
+    Message[Message["CANCEL_INPUT"] = 16] = "CANCEL_INPUT";
+    Message[Message["ACCEPT_INPUT"] = 32] = "ACCEPT_INPUT";
+})(Message || (Message = {}))));
 class InlineChatRunOptions {
     static isInteractiveEditorOptions(options) {
         const { initialSelection, initialRange, message, autoSend, position, existingSession } = options;
@@ -63,7 +83,15 @@ let InlineChatController = class InlineChatController {
     static get(editor) {
         return editor.getContribution(INLINE_CHAT_ID);
     }
-    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatAgentService, _chatService, _commandService, _languageFeatureService, _chatWidgetService) {
+    get chatWidget() {
+        if (this._ui.value.content.isVisible) {
+            return this._ui.value.content.chatWidget;
+        }
+        else {
+            return this._ui.value.zone.widget.chatWidget;
+        }
+    }
+    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatService, _languageFeatureService, _chatWidgetService, notebookEditorService) {
         this._editor = _editor;
         this._instaService = _instaService;
         this._inlineChatSessionService = _inlineChatSessionService;
@@ -72,9 +100,7 @@ let InlineChatController = class InlineChatController {
         this._logService = _logService;
         this._configurationService = _configurationService;
         this._dialogService = _dialogService;
-        this._chatAgentService = _chatAgentService;
         this._chatService = _chatService;
-        this._commandService = _commandService;
         this._languageFeatureService = _languageFeatureService;
         this._chatWidgetService = _chatWidgetService;
         this._isDisposed = false;
@@ -82,23 +108,26 @@ let InlineChatController = class InlineChatController {
         this._messages = this._store.add(( (new Emitter())));
         this._onWillStartSession = this._store.add(( (new Emitter())));
         this.onWillStartSession = this._onWillStartSession.event;
-        this.onDidAcceptInput = Event.filter(this._messages.event, m => m === 32 , this._store);
-        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._forcedPlaceholder = undefined;
         this._ctxVisible = CTX_INLINE_CHAT_VISIBLE.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._ctxLastFeedbackKind = CTX_INLINE_CHAT_LAST_FEEDBACK.bindTo(contextKeyService);
-        this._ctxSupportIssueReporting = CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING.bindTo(contextKeyService);
-        this._input = ( (new Lazy(
-            () => this._store.add(_instaService.createInstance(InlineChatContentWidget, this._editor))
-        )));
-        this._zone = ( (new Lazy(
-            () => this._store.add(_instaService.createInstance(InlineChatZoneWidget, this._editor))
-        )));
+        this._ui = ( (new Lazy(() => {
+            let location = ChatAgentLocation.Editor;
+            for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
+                for (const [, codeEditor] of notebookEditor.codeEditors) {
+                    if (codeEditor === this._editor) {
+                        location = ChatAgentLocation.Notebook;
+                        break;
+                    }
+                }
+            }
+            const content = this._store.add(_instaService.createInstance(InlineChatContentWidget, location, this._editor));
+            const zone = this._store.add(_instaService.createInstance(InlineChatZoneWidget, location, this._editor));
+            return { content, zone };
+        })));
         this._store.add(this._editor.onDidChangeModel(async (e) => {
             if (this._session || !e.newModelUrl) {
                 return;
@@ -130,8 +159,8 @@ let InlineChatController = class InlineChatController {
     dispose() {
         if (this._currentRun) {
             this._messages.fire(this._session?.chatModel.hasRequests
-                ? 4
-                : 2 );
+                ? Message.PAUSE_SESSION
+                : Message.CANCEL_SESSION);
         }
         this._store.dispose();
         this._isDisposed = true;
@@ -146,16 +175,16 @@ let InlineChatController = class InlineChatController {
         }
     }
     getMessage() {
-        return this._zone.value.widget.responseContent;
+        return this._ui.value.zone.widget.responseContent;
     }
     getId() {
         return INLINE_CHAT_ID;
     }
     _getMode() {
-        return this._configurationService.getValue("inlineChat.mode" );
+        return this._configurationService.getValue(InlineChatConfigKeys.Mode);
     }
     getWidgetPosition() {
-        return this._zone.value.position;
+        return this._ui.value.zone.position;
     }
     async run(options = {}) {
         try {
@@ -168,7 +197,7 @@ let InlineChatController = class InlineChatController {
             }
             this._stashedSession.clear();
             this._onWillStartSession.fire();
-            this._currentRun = this._nextState("CREATE_SESSION" , options);
+            this._currentRun = this._nextState(State.CREATE_SESSION, options);
             await this._currentRun;
         }
         catch (error) {
@@ -176,7 +205,7 @@ let InlineChatController = class InlineChatController {
             if (this._session) {
                 this._inlineChatSessionService.releaseSession(this._session);
             }
-            this["PAUSE" ]();
+            this[State.PAUSE]();
         }
         finally {
             this._currentRun = undefined;
@@ -189,7 +218,7 @@ let InlineChatController = class InlineChatController {
             nextState = await this[nextState](options);
         }
     }
-    async ["CREATE_SESSION" ](options) {
+    async [State.CREATE_SESSION](options) {
         assertType(this._session === undefined);
         assertType(this._editor.hasModel());
         let session = options.existingSession;
@@ -204,10 +233,10 @@ let InlineChatController = class InlineChatController {
             const createSessionCts = ( (new CancellationTokenSource()));
             const msgListener = Event.once(this._messages.event)(m => {
                 this._log('state=_createSession) message received', m);
-                if (m === 32 ) {
+                if (m === Message.ACCEPT_INPUT) {
                     options.autoSend = true;
-                    this._zone.value.widget.updateProgress(true);
-                    this._zone.value.widget.updateInfo(( localizeWithPath(_moduleId, 1, "Getting ready...")));
+                    this._ui.value.zone.widget.updateProgress(true);
+                    this._ui.value.zone.widget.updateInfo(( localizeWithPath(_moduleId, 1, "Getting ready...")));
                 }
                 else {
                     createSessionCts.cancel();
@@ -227,7 +256,7 @@ let InlineChatController = class InlineChatController {
                 if (session) {
                     this._inlineChatSessionService.releaseSession(session);
                 }
-                return "CANCEL" ;
+                return State.CANCEL;
             }
         }
         delete options.initialRange;
@@ -235,22 +264,22 @@ let InlineChatController = class InlineChatController {
         if (!session) {
             MessageController.get(this._editor)?.showMessage(errorMessage, widgetPosition);
             this._log('Failed to start editor chat');
-            return "CANCEL" ;
+            return State.CANCEL;
         }
         await session.chatModel.waitForInitialization();
         switch (session.editMode) {
-            case "preview" :
-                this._strategy = this._instaService.createInstance(PreviewStrategy, session, this._editor, this._zone.value);
+            case EditMode.Preview:
+                this._strategy = this._instaService.createInstance(PreviewStrategy, session, this._editor, this._ui.value.zone);
                 break;
-            case "live" :
+            case EditMode.Live:
             default:
-                this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._zone.value);
+                this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._ui.value.zone);
                 break;
         }
         this._session = session;
-        return "INIT_UI" ;
+        return State.INIT_UI;
     }
-    async ["INIT_UI" ](options) {
+    async [State.INIT_UI](options) {
         assertType(this._session);
         assertType(this._strategy);
         InlineCompletionsController.get(this._editor)?.hide();
@@ -263,16 +292,16 @@ let InlineChatController = class InlineChatController {
         this._sessionStore.add(toDisposable(() => wholeRangeDecoration.clear()));
         this._sessionStore.add(this._session.wholeRange.onDidChange(updateWholeRangeDecoration));
         updateWholeRangeDecoration();
-        this._sessionStore.add(this._input.value.onDidBlur(() => this.cancelSession()));
-        this._input.value.setSession(this._session);
+        this._sessionStore.add(this._ui.value.content.onDidBlur(() => this.cancelSession()));
+        this._ui.value.content.setSession(this._session);
         this._updatePlaceholder();
         const message = this._session.session.message ?? ( localizeWithPath(_moduleId, 2, "AI-generated code may be incorrect"));
-        this._zone.value.widget.updateInfo(message);
+        this._ui.value.zone.widget.updateInfo(message);
         this._showWidget(!this._session.chatModel.hasRequests);
         this._sessionStore.add(this._editor.onDidChangeModel((e) => {
             const msg = this._session?.chatModel.hasRequests
-                ? 4
-                : 2 ;
+                ? Message.PAUSE_SESSION
+                : Message.CANCEL_SESSION;
             this._log('model changed, pause or cancel session', msg, e);
             this._messages.fire(msg);
         }));
@@ -286,7 +315,7 @@ let InlineChatController = class InlineChatController {
             }
             const wholeRange = this._session.wholeRange;
             let shouldFinishSession = false;
-            if (this._configurationService.getValue("inlineChat.finishOnType" )) {
+            if (this._configurationService.getValue(InlineChatConfigKeys.FinishOnType)) {
                 for (const { range } of e.changes) {
                     shouldFinishSession = !Range.areIntersectingOrTouching(range, wholeRange.value);
                 }
@@ -299,19 +328,24 @@ let InlineChatController = class InlineChatController {
         }));
         this._sessionStore.add(this._session.chatModel.onDidChange(async (e) => {
             if (e.kind === 'addRequest' && e.request.response) {
-                this._zone.value.widget.updateProgress(true);
+                this._ui.value.zone.widget.updateProgress(true);
                 const listener = e.request.response.onDidChange(() => {
                     if (e.request.response?.isCanceled || e.request.response?.isComplete) {
-                        this._zone.value.widget.updateProgress(false);
+                        this._ui.value.zone.widget.updateProgress(false);
                         listener.dispose();
                     }
                 });
             }
             else if (e.kind === 'removeRequest') {
-                if (this._session.lastExchange?.response instanceof ReplyResponse) {
+                const exchange = this._session.exchanges.find(candidate => candidate.prompt.request.id === e.requestId);
+                if (exchange && this._editor.hasModel()) {
+                    this._session.hunkData.ignoreTextModelNChanges = true;
                     try {
-                        this._session.hunkData.ignoreTextModelNChanges = true;
-                        await this._strategy.undoChanges(this._session.lastExchange.response.modelAltVersionId);
+                        const model = this._editor.getModel();
+                        const targetAltVersion = exchange.prompt.modelAltVersionId;
+                        while (targetAltVersion < model.getAlternativeVersionId() && model.canUndo()) {
+                            await model.undo();
+                        }
                     }
                     finally {
                         this._session.hunkData.ignoreTextModelNChanges = false;
@@ -319,7 +353,6 @@ let InlineChatController = class InlineChatController {
                 }
             }
         }));
-        this._ctxSupportIssueReporting.set(this._session.provider.supportIssueReporting ?? false);
         this._sessionStore.add(this._languageFeatureService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
             _debugDisplayName: 'inline chat commands',
             triggerCharacters: ['/'],
@@ -331,18 +364,17 @@ let InlineChatController = class InlineChatController {
                     return undefined;
                 }
                 const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
-                if (widget !== this._zone.value.widget.chatWidget && widget !== this._input.value.chatWidget) {
+                if (widget !== this._ui.value.zone.widget.chatWidget && widget !== this._ui.value.content.chatWidget) {
                     return undefined;
                 }
                 const result = { suggestions: [], incomplete: false };
                 for (const command of this._session.session.slashCommands) {
-                    const withSlash = `/${command.command}`;
+                    const withSlash = `/${command.name}`;
                     result.suggestions.push({
-                        label: { label: withSlash, description: command.detail ?? '' },
-                        kind: 18 ,
+                        label: { label: withSlash, description: command.description ?? '' },
+                        kind: CompletionItemKind.Text,
                         insertText: withSlash,
                         range: Range.fromPositions(( (new Position(1, 1))), position),
-                        command: command.executeImmediately ? { id: 'workbench.action.chat.acceptInput', title: withSlash } : undefined
                     });
                 }
                 return result;
@@ -350,8 +382,8 @@ let InlineChatController = class InlineChatController {
         }));
         const updateSlashDecorations = (collection, model) => {
             const newDecorations = [];
-            for (const command of (this._session?.session.slashCommands ?? []).sort((a, b) => b.command.length - a.command.length)) {
-                const withSlash = `/${command.command}`;
+            for (const command of (this._session?.session.slashCommands ?? []).sort((a, b) => b.name.length - a.name.length)) {
+                const withSlash = `/${command.name}`;
                 const firstLine = model.getLineContent(1);
                 if (firstLine.startsWith(withSlash)) {
                     newDecorations.push({
@@ -364,13 +396,13 @@ let InlineChatController = class InlineChatController {
                             }
                         }
                     });
-                    if (firstLine.trim() === `/${command.command}`) {
+                    if (firstLine.trim() === `/${command.name}`) {
                         newDecorations.push({
                             range: ( (new Range(1, withSlash.length, 1, withSlash.length))),
                             options: {
                                 description: 'inline-chat-slash-command-detail',
                                 after: {
-                                    content: `${command.detail}`,
+                                    content: `${command.description}`,
                                     inlineClassName: 'inline-chat-slash-command-detail'
                                 }
                             }
@@ -381,8 +413,8 @@ let InlineChatController = class InlineChatController {
             }
             collection.set(newDecorations);
         };
-        const inputInputEditor = this._input.value.chatWidget.inputEditor;
-        const zoneInputEditor = this._zone.value.widget.chatWidget.inputEditor;
+        const inputInputEditor = this._ui.value.content.chatWidget.inputEditor;
+        const zoneInputEditor = this._ui.value.zone.widget.chatWidget.inputEditor;
         const inputDecorations = inputInputEditor.createDecorationsCollection();
         const zoneDecorations = zoneInputEditor.createDecorationsCollection();
         this._sessionStore.add(inputInputEditor.onDidChangeModelContent(() => updateSlashDecorations(inputDecorations, inputInputEditor.getModel())));
@@ -392,17 +424,17 @@ let InlineChatController = class InlineChatController {
             zoneDecorations.clear();
         }));
         if (!this._session.chatModel.hasRequests) {
-            return "WAIT_FOR_INPUT" ;
+            return State.WAIT_FOR_INPUT;
         }
         else if (options.isUnstashed) {
             delete options.isUnstashed;
-            return "SHOW_RESPONSE" ;
+            return State.SHOW_RESPONSE;
         }
         else {
-            return "SHOW_RESPONSE" ;
+            return State.SHOW_RESPONSE;
         }
     }
-    async ["WAIT_FOR_INPUT" ](options) {
+    async [State.WAIT_FOR_INPUT](options) {
         assertType(this._session);
         assertType(this._strategy);
         this._updatePlaceholder();
@@ -412,14 +444,14 @@ let InlineChatController = class InlineChatController {
             delete options.message;
             this._showWidget(false);
         }
-        let message = 0 ;
+        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 = 32 ;
+                message = Message.ACCEPT_INPUT;
                 barrier.open();
             }
         }));
@@ -433,73 +465,39 @@ let InlineChatController = class InlineChatController {
         if (options.autoSend) {
             delete options.autoSend;
             this._showWidget(false);
-            this._zone.value.widget.chatWidget.acceptInput();
+            this._ui.value.zone.widget.chatWidget.acceptInput();
         }
         await barrier.wait();
         store.dispose();
-        if (message & ((16  | 2) )) {
-            return "CANCEL" ;
+        if (message & (Message.CANCEL_INPUT | Message.CANCEL_SESSION)) {
+            return State.CANCEL;
         }
-        if (message & 4 ) {
-            return "PAUSE" ;
+        if (message & Message.PAUSE_SESSION) {
+            return State.PAUSE;
         }
-        if (message & 1 ) {
-            this._zone.value.widget.selectAll(false);
-            return "DONE" ;
+        if (message & Message.ACCEPT_SESSION) {
+            this._ui.value.zone.widget.selectAll(false);
+            return State.ACCEPT;
         }
         if (!request?.message.text) {
-            return "WAIT_FOR_INPUT" ;
+            return State.WAIT_FOR_INPUT;
         }
         const input = request.message.text;
-        this._zone.value.widget.value = input;
-        let slashCommandLike = request.message.parts.find(part => part instanceof ChatRequestAgentSubcommandPart || part instanceof ChatRequestSlashCommandPart);
-        const refer = this._session.session.slashCommands?.some(value => {
-            if (value.refer) {
-                if (slashCommandLike?.text === `/${value.command}`) {
-                    return true;
-                }
-                if (request?.message.text.startsWith(`/${value.command}`)) {
-                    slashCommandLike = ( (new ChatRequestSlashCommandPart(
-                         (new OffsetRange(0, 1)),
-                         (new Range(1, 1, 1, 1)),
-                        { command: value.command, detail: value.detail ?? '' }
-                    )));
-                    return true;
-                }
-            }
-            return false;
-        });
-        if (refer && slashCommandLike && !this._session.lastExchange) {
-            this._log('[IE] seeing refer command, continuing outside editor', this._session.provider.extensionId);
-            this._chatService.cancelCurrentRequestForSession(request.session.sessionId);
-            this._editor.setSelection(this._session.wholeRange.value);
-            let massagedInput = input;
-            const withoutSubCommandLeader = slashCommandLike.text.slice(1);
-            for (const agent of this._chatAgentService.getActivatedAgents()) {
-                if (agent.locations.includes(ChatAgentLocation.Panel)) {
-                    const commands = agent.slashCommands;
-                    if (commands.find((command) => withoutSubCommandLeader.startsWith(command.name))) {
-                        massagedInput = `${chatAgentLeader}${agent.name} ${slashCommandLike.text}`;
-                        break;
-                    }
-                }
-            }
-            await this._instaService.invokeFunction(sendRequest, massagedInput);
-            return "DONE" ;
-        }
-        this._session.addInput(( (new SessionPrompt(input))));
-        return "SHOW_REQUEST" ;
+        this._ui.value.zone.widget.value = input;
+        this._session.addInput(( (new SessionPrompt(request, this._editor.getModel().getAlternativeVersionId()))));
+        return State.SHOW_REQUEST;
     }
-    async ["SHOW_REQUEST" ]() {
+    async [State.SHOW_REQUEST]() {
         assertType(this._session);
         assertType(this._session.chatModel.requestInProgress);
-        const request = tail(this._session.chatModel.getRequests());
+        const { chatModel } = this._session;
+        const request = chatModel.getRequests().at(-1);
         assertType(request);
         assertType(request.response);
         this._showWidget(false);
-        this._zone.value.widget.value = request.message.text;
-        this._zone.value.widget.selectAll(false);
-        this._zone.value.widget.updateInfo('');
+        this._ui.value.zone.widget.value = request.message.text;
+        this._ui.value.zone.widget.selectAll(false);
+        this._ui.value.zone.widget.updateInfo('');
         const { response } = request;
         const responsePromise = ( (new DeferredPromise()));
         const store = ( (new DisposableStore()));
@@ -507,73 +505,92 @@ let InlineChatController = class InlineChatController {
         const progressiveEditsAvgDuration = ( (new MovingAverage()));
         const progressiveEditsClock = StopWatch.create();
         const progressiveEditsQueue = ( (new Queue()));
-        let lastLength = 0;
-        let message = 0 ;
-        store.add(Event.once(this._messages.event)(m => {
-            this._log('state=_makeRequest) message received', m);
-            this._chatService.cancelCurrentRequestForSession(request.session.sessionId);
-            message = m;
-        }));
-        store.add(this._zone.value.widget.chatWidget.inputEditor.onDidChangeModelContent(() => {
-            this._chatService.cancelCurrentRequestForSession(request.session.sessionId);
+        let next = State.SHOW_RESPONSE;
+        store.add(Event.once(this._messages.event)(message => {
+            this._log('state=_makeRequest) message received', message);
+            this._chatService.cancelCurrentRequestForSession(chatModel.sessionId);
+            if (message & Message.CANCEL_SESSION) {
+                next = State.CANCEL;
+            }
+            else if (message & Message.PAUSE_SESSION) {
+                next = State.PAUSE;
+            }
+            else if (message & Message.ACCEPT_SESSION) {
+                next = State.ACCEPT;
+            }
         }));
-        store.add(response.onDidChange(() => {
-            if (response.isCanceled) {
+        store.add(chatModel.onDidChange(e => {
+            if (e.kind === 'removeRequest' && e.requestId === request.id) {
                 progressiveEditsCts.cancel();
                 responsePromise.complete();
-                return;
-            }
-            if (response.isComplete) {
-                responsePromise.complete();
-                return;
-            }
-            const edits = ( (response.response.value.map(part => {
-                if (part.kind === 'textEditGroup' && isEqual(part.uri, this._session?.textModelN.uri)) {
-                    return part.edits;
+                if (e.reason === ChatRequestRemovalReason.Resend) {
+                    next = State.SHOW_REQUEST;
                 }
                 else {
-                    return [];
+                    next = State.CANCEL;
                 }
-            }))).flat();
-            const newEdits = edits.slice(lastLength);
-            if (newEdits.length === 0) {
-                return;
             }
-            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 });
-                }
-                const startNow = this._session.wholeRange.value.getStartPosition();
-                if (!startNow.equals(startThen) || !this._zone.value.position?.equals(startNow)) {
-                    this._showWidget(false, startNow.delta(-1));
-                }
-            });
         }));
+        store.add(this._ui.value.zone.widget.chatWidget.inputEditor.onDidChangeModelContent(() => {
+            this._chatService.cancelCurrentRequestForSession(chatModel.sessionId);
+        }));
+        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 };
+        let localEditGroup;
+        const handleResponse = () => {
+            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) {
+                    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.zone.position?.equals(startNow)) {
+                            this._showWidget(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();
         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();
-        this._zone.value.widget.updateToolbar(true);
-        if (message & 2 ) {
-            return "CANCEL" ;
-        }
-        else if (message & 4 ) {
-            return "PAUSE" ;
-        }
-        else if (message & 1 ) {
-            return "DONE" ;
-        }
-        else {
-            return "SHOW_RESPONSE" ;
-        }
+        await this._session.hunkData.recompute(editState);
+        this._ui.value.zone.widget.updateToolbar(true);
+        this._ui.value.zone.widget.updateProgress(false);
+        return next;
     }
-    async ["SHOW_RESPONSE" ]() {
+    async [State.SHOW_RESPONSE]() {
         assertType(this._session);
         assertType(this._strategy);
         const { response } = this._session.lastExchange;
@@ -587,63 +604,37 @@ let InlineChatController = class InlineChatController {
                 responseTypes = thisType;
             }
             else if (responseTypes !== thisType) {
-                responseTypes = "mixed" ;
+                responseTypes = InlineChatResponseTypes.Mixed;
                 break;
             }
         }
         this._ctxResponseTypes.set(responseTypes);
-        this._ctxDidEdit.set(this._session.hasChangedText);
         let newPosition;
         if (response instanceof EmptyResponse) {
             const status = ( localizeWithPath(_moduleId, 3, "No results, please refine your input and try again"));
-            this._zone.value.widget.updateStatus(status, { classes: ['warn'] });
-            return "WAIT_FOR_INPUT" ;
+            this._ui.value.zone.widget.updateStatus(status, { classes: ['warn'] });
+            return State.WAIT_FOR_INPUT;
         }
         else if (response instanceof ErrorResponse) {
             if (!response.isCancellation) {
-                this._zone.value.widget.updateStatus(response.message, { classes: ['error'] });
+                this._ui.value.zone.widget.updateStatus(response.message, { classes: ['error'] });
                 this._strategy?.cancel();
             }
         }
         else if (response instanceof ReplyResponse) {
-            this._zone.value.widget.updateStatus('');
-            this._zone.value.widget.updateToolbar(true);
+            this._ui.value.zone.widget.updateStatus('');
+            this._ui.value.zone.widget.updateToolbar(true);
             newPosition = await this._strategy.renderChanges(response);
-            if (this._session.provider.provideFollowups) {
-                const followupCts = ( (new CancellationTokenSource()));
-                const msgListener = Event.once(this._messages.event)(() => {
-                    followupCts.cancel();
-                });
-                const followupTask = this._session.provider.provideFollowups(this._session.session, response.raw, followupCts.token);
-                this._log('followup request started', this._session.provider.extensionId, this._session.session, response.raw);
-                raceCancellation(Promise.resolve(followupTask), followupCts.token).then(followupReply => {
-                    if (followupReply && this._session) {
-                        this._log('followup request received', this._session.provider.extensionId, this._session.session, followupReply);
-                        this._zone.value.widget.updateFollowUps(followupReply, followup => {
-                            if (followup.kind === 'reply') {
-                                this.updateInput(followup.message);
-                                this.acceptInput();
-                            }
-                            else {
-                                this._commandService.executeCommand(followup.commandId, ...(followup.args ?? []));
-                            }
-                        });
-                    }
-                }).finally(() => {
-                    msgListener.dispose();
-                    followupCts.dispose();
-                });
-            }
         }
         this._showWidget(false, newPosition);
-        return "WAIT_FOR_INPUT" ;
+        return State.WAIT_FOR_INPUT;
     }
-    async ["PAUSE" ]() {
+    async [State.PAUSE]() {
         this._resetWidget();
         this._strategy?.dispose?.();
         this._session = undefined;
     }
-    async ["DONE" ]() {
+    async [State.ACCEPT]() {
         assertType(this._session);
         assertType(this._strategy);
         this._sessionStore.clear();
@@ -661,7 +652,7 @@ let InlineChatController = class InlineChatController {
         this._strategy = undefined;
         this._session = undefined;
     }
-    async ["CANCEL" ]() {
+    async [State.CANCEL]() {
         if (this._session) {
             assertType(this._strategy);
             this._sessionStore.clear();
@@ -694,12 +685,12 @@ let InlineChatController = class InlineChatController {
         if (position) {
             widgetPosition = position;
         }
-        else if (this._zone.rawValue?.position) {
-            if (this._zone.rawValue.position.lineNumber === 1) {
-                widgetPosition = this._zone.rawValue.position.delta(-1);
+        else if (this._ui.rawValue?.zone?.position) {
+            if (this._ui.rawValue?.zone.position.lineNumber === 1) {
+                widgetPosition = this._ui.rawValue?.zone.position.delta(-1);
             }
             else {
-                widgetPosition = this._zone.rawValue.position;
+                widgetPosition = this._ui.rawValue?.zone.position;
             }
         }
         else {
@@ -708,23 +699,23 @@ let InlineChatController = class InlineChatController {
         if (this._session && !position && (this._session.hasChangedText || this._session.lastExchange)) {
             widgetPosition = this._session.wholeRange.value.getStartPosition().delta(-1);
         }
-        if (this._zone.rawValue?.position) {
-            this._zone.value.updatePositionAndHeight(widgetPosition);
+        if (this._ui.rawValue?.zone?.position) {
+            this._ui.value.zone.updatePositionAndHeight(widgetPosition);
         }
         else if (initialRender) {
             const selection = this._editor.getSelection();
             widgetPosition = selection.getStartPosition();
-            this._input.value.show(widgetPosition);
+            this._ui.value.content.show(widgetPosition);
         }
         else {
-            this._input.value.hide();
-            this._zone.value.show(widgetPosition);
+            this._ui.value.content.hide();
+            this._ui.value.zone.show(widgetPosition);
             if (this._session) {
-                this._zone.value.widget.setChatModel(this._session.chatModel);
+                this._ui.value.zone.widget.setChatModel(this._session.chatModel);
             }
         }
-        if (this._session && this._zone.rawValue) {
-            this._zone.rawValue.updateBackgroundColor(widgetPosition, this._session.wholeRange.value);
+        if (this._session && this._ui.rawValue?.zone) {
+            this._ui.rawValue?.zone.updateBackgroundColor(widgetPosition, this._session.wholeRange.value);
         }
         this._ctxVisible.set(true);
         return widgetPosition;
@@ -732,21 +723,18 @@ let InlineChatController = class InlineChatController {
     _resetWidget() {
         this._sessionStore.clear();
         this._ctxVisible.reset();
-        this._ctxDidEdit.reset();
         this._ctxUserDidEdit.reset();
-        this._ctxLastFeedbackKind.reset();
-        this._ctxSupportIssueReporting.reset();
-        this._input.rawValue?.hide();
-        this._zone.rawValue?.hide();
+        this._ui.rawValue?.content.hide();
+        this._ui.rawValue?.zone?.hide();
         if (this._editor.hasWidgetFocus()) {
             this._editor.focus();
         }
     }
-    async _makeChanges(edits, opts) {
+    async _makeChanges(edits, opts, undoStopBefore) {
         assertType(this._session);
         assertType(this._strategy);
         const moreMinimalEdits = await this._editorWorkerService.computeMoreMinimalEdits(this._session.textModelN.uri, edits);
-        this._log('edits from PROVIDER and after making them MORE MINIMAL', this._session.provider.extensionId, edits, moreMinimalEdits);
+        this._log('edits from PROVIDER and after making them MORE MINIMAL', this._session.agent.extensionId, edits, moreMinimalEdits);
         if (moreMinimalEdits?.length === 0) {
             return;
         }
@@ -759,93 +747,91 @@ let InlineChatController = class InlineChatController {
         this._inlineChatSavingService.markChanged(this._session);
         this._session.wholeRange.trackEdits(editOperations);
         if (opts) {
-            await this._strategy.makeProgressiveChanges(editOperations, editsObserver, opts);
+            await this._strategy.makeProgressiveChanges(editOperations, editsObserver, opts, undoStopBefore);
         }
         else {
-            await this._strategy.makeChanges(editOperations, editsObserver);
+            await this._strategy.makeChanges(editOperations, editsObserver, undoStopBefore);
         }
-        this._ctxDidEdit.set(this._session.hasChangedText);
     }
     _updatePlaceholder() {
-        this._zone.value.widget.placeholder = this._getPlaceholderText();
+        this._ui.value.zone.widget.placeholder = this._getPlaceholderText();
     }
     _getPlaceholderText() {
         return this._forcedPlaceholder ?? this._session?.session.placeholder ?? '';
     }
     showSaveHint() {
         const status = ( localizeWithPath(_moduleId, 6, "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();
+        this._ui.value.zone.widget.updateStatus(status, { classes: ['warn'] });
     }
     acceptInput() {
-        if (this._input.value.isVisible) {
-            this._input.value.chatWidget.acceptInput();
-        }
-        else {
-            this._zone.value.widget.chatWidget.acceptInput();
-        }
+        return this.chatWidget.acceptInput();
     }
     updateInput(text, selectAll = true) {
-        this._input.value.chatWidget.setInput(text);
-        this._zone.value.widget.chatWidget.setInput(text);
+        this._ui.value.content.chatWidget.setInput(text);
+        this._ui.value.zone.widget.chatWidget.setInput(text);
         if (selectAll) {
             const newSelection = ( (new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
-            this._input.value.chatWidget.inputEditor.setSelection(newSelection);
-            this._zone.value.widget.chatWidget.inputEditor.setSelection(newSelection);
+            this._ui.value.content.chatWidget.inputEditor.setSelection(newSelection);
+            this._ui.value.zone.widget.chatWidget.inputEditor.setSelection(newSelection);
         }
     }
-    getInput() {
-        return this._input.value.isVisible
-            ? this._input.value.value
-            : this._zone.value.widget.value;
-    }
     cancelCurrentRequest() {
-        this._messages.fire(16  | 8 );
+        this._messages.fire(Message.CANCEL_INPUT | Message.CANCEL_REQUEST);
     }
     arrowOut(up) {
-        if (this._zone.value.position && this._editor.hasModel()) {
+        if (this._ui.value.zone.position && this._editor.hasModel()) {
             const { column } = this._editor.getPosition();
-            const { lineNumber } = this._zone.value.position;
+            const { lineNumber } = this._ui.value.zone.position;
             const newLine = up ? lineNumber : lineNumber + 1;
             this._editor.setPosition({ lineNumber: newLine, column });
             this._editor.focus();
         }
     }
     focus() {
-        this._zone.value.widget.focus();
+        this._ui.value.zone.widget.focus();
     }
     hasFocus() {
-        return this._zone.value.widget.hasFocus();
+        return this._ui.value.zone.widget.hasFocus();
     }
     moveHunk(next) {
         this.focus();
         this._strategy?.move?.(next);
     }
-    viewInChat() {
-        if (this._session?.lastExchange?.response instanceof ReplyResponse) {
-            this._instaService.invokeFunction(showMessageResponse, this._session.lastExchange.prompt.value, this._session.lastExchange.response.mdContent.value);
+    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;
+                }
+            }
+        }
+        const doEdits = this._strategy.cancel();
+        if (someApplied) {
+            assertType(lastEdit);
+            lastEdit.edits = [doEdits];
         }
+        await this._instaService.invokeFunction(moveToPanelChat, this._session?.chatModel);
+        this.cancelSession();
     }
     toggleDiff() {
         this._strategy?.toggleDiff?.();
     }
-    createSnapshot() {
-        if (this._session && !this._session.textModel0.equalsTextBuffer(this._session.textModelN.getTextBuffer())) {
-            this._session.createSnapshot();
-        }
-    }
     acceptSession() {
         if (this._session?.lastExchange?.response instanceof ReplyResponse && this._session?.lastExchange?.response.chatResponse) {
             const response = this._session?.lastExchange?.response.chatResponse;
             this._chatService.notifyUserAction({
-                sessionId: response.session.sessionId,
+                sessionId: this._session.chatModel.sessionId,
                 requestId: response.requestId,
                 agentId: response.agent?.id,
                 result: response.result,
@@ -855,7 +841,7 @@ let InlineChatController = class InlineChatController {
                 }
             });
         }
-        this._messages.fire(1 );
+        this._messages.fire(Message.ACCEPT_SESSION);
     }
     acceptHunk() {
         return this._strategy?.acceptHunk();
@@ -864,30 +850,24 @@ let InlineChatController = class InlineChatController {
         return this._strategy?.discardHunk();
     }
     async cancelSession() {
-        let result;
-        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?.response instanceof ReplyResponse && this._session?.lastExchange?.response.chatResponse) {
-                const response = this._session?.lastExchange?.response.chatResponse;
-                this._chatService.notifyUserAction({
-                    sessionId: response.session.sessionId,
-                    requestId: response.requestId,
-                    agentId: response.agent?.id,
-                    result: response.result,
-                    action: {
-                        kind: 'inlineChat',
-                        action: 'discarded'
-                    }
-                });
-            }
+        if (this._session?.lastExchange?.response instanceof ReplyResponse && this._session?.lastExchange?.response.chatResponse) {
+            const response = this._session?.lastExchange?.response.chatResponse;
+            this._chatService.notifyUserAction({
+                sessionId: this._session.chatModel.sessionId,
+                requestId: response.requestId,
+                agentId: response.agent?.id,
+                result: response.result,
+                action: {
+                    kind: 'inlineChat',
+                    action: 'discarded'
+                }
+            });
         }
-        this._messages.fire(2 );
-        return result;
+        this._messages.fire(Message.CANCEL_SESSION);
     }
     finishExistingSession() {
         if (this._session) {
-            if (this._session.editMode === "preview" ) {
+            if (this._session.editMode === EditMode.Preview) {
                 this._log('finishing existing session, using CANCEL', this._session.editMode);
                 this.cancelSession();
             }
@@ -917,58 +897,42 @@ InlineChatController = ( (__decorate([
     ( (__param(6, IConfigurationService))),
     ( (__param(7, IDialogService))),
     ( (__param(8, IContextKeyService))),
-    ( (__param(9, IChatAgentService))),
-    ( (__param(10, IChatService))),
-    ( (__param(11, ICommandService))),
-    ( (__param(12, ILanguageFeaturesService))),
-    ( (__param(13, IChatWidgetService)))
+    ( (__param(9, IChatService))),
+    ( (__param(10, ILanguageFeaturesService))),
+    ( (__param(11, IChatWidgetService))),
+    ( (__param(12, INotebookEditorService)))
 ], InlineChatController)));
-async function showMessageResponse(accessor, query, response) {
+async function moveToPanelChat(accessor, model) {
+    const viewsService = accessor.get(IViewsService);
     const chatService = accessor.get(IChatService);
-    const chatAgentService = accessor.get(IChatAgentService);
-    const agent = chatAgentService.getActivatedAgents().find(agent => agent.locations.includes(ChatAgentLocation.Panel) && agent.isDefault);
-    if (!agent) {
-        return;
-    }
-    const widget = await showChatView(accessor.get(IViewsService));
-    if (widget && widget.viewModel) {
-        chatService.addCompleteRequest(widget.viewModel.sessionId, query, undefined, 0, { message: response });
+    const widget = await showChatView(viewsService);
+    if (widget && widget.viewModel && model) {
+        for (const request of model.getRequests().slice()) {
+            await chatService.adoptRequest(widget.viewModel.model.sessionId, request);
+        }
         widget.focusLastMessage();
     }
 }
-async function sendRequest(accessor, query) {
-    const chatAgentService = accessor.get(IChatAgentService);
-    const agent = chatAgentService.getActivatedAgents().find(agent => agent.locations.includes(ChatAgentLocation.Panel) && agent.isDefault);
-    if (!agent) {
-        return;
-    }
-    const widget = await showChatView(accessor.get(IViewsService));
-    if (!widget) {
-        return;
-    }
-    widget.focusInput();
-    widget.acceptInput(query);
-}
 function asInlineChatResponseType(response) {
     let result;
     for (const item of response.value) {
         let thisType;
         switch (item.kind) {
             case 'textEditGroup':
-                thisType = "onlyEdits" ;
+                thisType = InlineChatResponseTypes.OnlyEdits;
                 break;
             case 'markdownContent':
             default:
-                thisType = "onlyMessages" ;
+                thisType = InlineChatResponseTypes.OnlyMessages;
                 break;
         }
         if (result === undefined) {
             result = thisType;
         }
         else if (result !== thisType) {
-            return "mixed" ;
+            return InlineChatResponseTypes.Mixed;
         }
     }
-    return result ?? "empty" ;
+    return result ?? InlineChatResponseTypes.Empty;
 }
-export { InlineChatController, InlineChatRunOptions };
+export { InlineChatController, InlineChatRunOptions, State };