@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -1,18 +1,15 @@
 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 { raceCancellationError, raceCancellation, Barrier, Queue } from '../../../../base/common/async.js';
+import { raceCancellation, 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';
 import { Emitter, Event } from '../../../../base/common/event.js';
-import { MarkdownString } from '../../../../base/common/htmlContent.js';
 import { Lazy } from '../../../../base/common/lazy.js';
 import { DisposableStore, MutableDisposable, toDisposable } from '../../../../base/common/lifecycle.js';
 import { MovingAverage } from '../../../../base/common/numbers.js';
 import { StopWatch } from '../../../../base/common/stopwatch.js';
 import { assertType } from '../../../../base/common/types.js';
-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';
@@ -26,44 +23,44 @@ import { IContextKeyService } from '../../../../platform/contextkey/common/conte
 import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../platform/log/common/log.js';
-import { Progress } from '../../../../platform/progress/common/progress.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { IChatWidgetService, IChatAccessibilityService } from '../../chat/browser/chat.js';
-import { IChatAgentService } from '../../chat/common/chatAgents.js';
-import { chatSubcommandLeader, chatAgentLeader } from '../../chat/common/chatParserTypes.js';
+import { IChatWidgetService } from '../../chat/browser/chat.js';
+import { ChatAgentLocation, IChatAgentService } from '../../chat/common/chatAgents.js';
+import { ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, chatAgentLeader } from '../../chat/common/chatParserTypes.js';
 import { IChatService } from '../../chat/common/chatService.js';
 import { IInlineChatSavingService } from './inlineChatSavingService.js';
-import { ReplyResponse, SessionPrompt, SessionExchange, EmptyResponse, ErrorResponse, ExpansionState, Session } from './inlineChatSession.js';
+import { SessionPrompt, ReplyResponse, EmptyResponse, ErrorResponse, Session } from './inlineChatSession.js';
 import { IInlineChatSessionService } from './inlineChatSessionService.js';
-import { LiveStrategy, LivePreviewStrategy, PreviewStrategy } 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_FEEDBACK, CTX_INLINE_CHAT_SUPPORT_ISSUE_REPORTING } from '../common/inlineChat.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.js';
+import { InlineChatContentWidget } from './inlineChatContentWidget.js';
+import { MessageController } from '../../../../editor/contrib/message/browser/messageController.js';
+import { tail } from '../../../../base/common/arrays.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 { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var InlineChatController_1;
 class InlineChatRunOptions {
     static isInteractiveEditorOptions(options) {
-        const { initialSelection, initialRange, message, autoSend, position, existingExchange, existingSession } = options;
+        const { initialSelection, initialRange, message, autoSend, position, existingSession } = options;
         if (typeof message !== 'undefined' && typeof message !== 'string'
             || typeof autoSend !== 'undefined' && typeof autoSend !== 'boolean'
             || typeof initialRange !== 'undefined' && !Range.isIRange(initialRange)
             || typeof initialSelection !== 'undefined' && !Selection.isISelection(initialSelection)
             || typeof position !== 'undefined' && !Position.isIPosition(position)
-            || typeof existingSession !== 'undefined' && !(existingSession instanceof Session)
-            || typeof existingExchange !== 'undefined' && typeof existingExchange !== 'object') {
+            || typeof existingSession !== 'undefined' && !(existingSession instanceof Session)) {
             return false;
         }
         return true;
     }
 }
 let InlineChatController = class InlineChatController {
-    static { InlineChatController_1 = this; }
     static get(editor) {
         return editor.getContribution(INLINE_CHAT_ID);
     }
-    static { this._storageKey = 'inline-chat-history'; }
-    static { this._promptHistory = []; }
-    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatAccessibilityService, _chatAgentService, _bulkEditService, _storageService, _commandService) {
+    constructor(_editor, _instaService, _inlineChatSessionService, _inlineChatSavingService, _editorWorkerService, _logService, _configurationService, _dialogService, contextKeyService, _chatAgentService, _chatService, _bulkEditService, _commandService, _languageFeatureService, _chatWidgetService) {
         this._editor = _editor;
         this._instaService = _instaService;
         this._inlineChatSessionService = _inlineChatSessionService;
@@ -72,13 +69,12 @@ let InlineChatController = class InlineChatController {
         this._logService = _logService;
         this._configurationService = _configurationService;
         this._dialogService = _dialogService;
-        this._chatAccessibilityService = _chatAccessibilityService;
         this._chatAgentService = _chatAgentService;
+        this._chatService = _chatService;
         this._bulkEditService = _bulkEditService;
-        this._storageService = _storageService;
         this._commandService = _commandService;
-        this._historyOffset = -1;
-        this._historyCandidate = '';
+        this._languageFeatureService = _languageFeatureService;
+        this._chatWidgetService = _chatWidgetService;
         this._isDisposed = false;
         this._store = ( new DisposableStore());
         this._messages = this._store.add(( new Emitter()));
@@ -88,13 +84,18 @@ 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._nextAttempt = 0;
+        this._nextWithIntentDetection = true;
         this._forcedPlaceholder = undefined;
-        this._ctxHasActiveRequest = CTX_INLINE_CHAT_HAS_ACTIVE_REQUEST.bindTo(contextKeyService);
+        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))
         ));
@@ -125,17 +126,6 @@ let InlineChatController = class InlineChatController {
             }
         }));
         this._log('NEW controller');
-        InlineChatController_1._promptHistory = JSON.parse(_storageService.get(InlineChatController_1._storageKey, 0 , '[]'));
-        this._historyUpdate = (prompt) => {
-            const idx = InlineChatController_1._promptHistory.indexOf(prompt);
-            if (idx >= 0) {
-                InlineChatController_1._promptHistory.splice(idx, 1);
-            }
-            InlineChatController_1._promptHistory.unshift(prompt);
-            this._historyOffset = -1;
-            this._historyCandidate = '';
-            this._storageService.store(InlineChatController_1._storageKey, JSON.stringify(InlineChatController_1._promptHistory), 0 , 0 );
-        };
     }
     dispose() {
         if (this._currentRun) {
@@ -174,8 +164,6 @@ let InlineChatController = class InlineChatController {
             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);
@@ -208,8 +196,12 @@ let InlineChatController = class InlineChatController {
             initPosition = Position.lift(options.position).delta(-1);
             delete options.position;
         }
-        this._showWidget(true, initPosition);
-        this._updatePlaceholder();
+        const widgetPosition = this._showWidget(true, initPosition);
+        let errorMessage = ( localizeWithPath(
+            'vs/workbench/contrib/inlineChat/browser/inlineChatController',
+            'create.fail',
+            "Failed to start editor chat"
+        ));
         if (!session) {
             const createSessionCts = ( new CancellationTokenSource());
             const msgListener = Event.once(this._messages.event)(m => {
@@ -227,7 +219,14 @@ let InlineChatController = class InlineChatController {
                     createSessionCts.cancel();
                 }
             });
-            session = await this._inlineChatSessionService.createSession(this._editor, { editMode: this._getMode(), wholeRange: options.initialRange }, createSessionCts.token);
+            try {
+                session = await this._inlineChatSessionService.createSession(this._editor, { editMode: this._getMode(), wholeRange: options.initialRange }, createSessionCts.token);
+            }
+            catch (error) {
+                if (error instanceof InlineChatError || error?.name === InlineChatError.code) {
+                    errorMessage = error.message;
+                }
+            }
             createSessionCts.dispose();
             msgListener.dispose();
             if (createSessionCts.token.isCancellationRequested) {
@@ -240,29 +239,22 @@ let InlineChatController = class InlineChatController {
         delete options.initialRange;
         delete options.existingSession;
         if (!session) {
-            this._dialogService.info(( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                'create.fail',
-                "Failed to start editor chat"
-            )), ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                'create.fail.detail',
-                "Please consult the error log and try again later."
-            )));
+            MessageController.get(this._editor)?.showMessage(errorMessage, widgetPosition);
+            this._log('Failed to start editor chat');
             return "CANCEL" ;
         }
         switch (session.editMode) {
             case "preview" :
                 this._strategy = this._instaService.createInstance(PreviewStrategy, session, this._editor, this._zone.value);
                 break;
-            case "livePreview" :
-                this._strategy = this._instaService.createInstance(LivePreviewStrategy, session, this._editor, this._zone.value);
-                break;
             case "live" :
             default:
                 this._strategy = this._instaService.createInstance(LiveStrategy, session, this._editor, this._zone.value);
                 break;
         }
+        if (session.session.input) {
+            options.message = session.session.input;
+        }
         this._session = session;
         return "INIT_UI" ;
     }
@@ -271,10 +263,6 @@ let InlineChatController = class InlineChatController {
         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 newDecorations = this._strategy?.getWholeRangeDecoration() ?? [];
@@ -283,19 +271,16 @@ let InlineChatController = class InlineChatController {
         this._sessionStore.add(toDisposable(() => wholeRangeDecoration.clear()));
         this._sessionStore.add(this._session.wholeRange.onDidChange(updateWholeRangeDecoration));
         updateWholeRangeDecoration();
-        this._zone.value.widget.updateSlashCommands(this._session.session.slashCommands ?? []);
+        this._sessionStore.add(this._input.value.onDidBlur(() => this.cancelSession()));
+        this._input.value.setSession(this._session);
         this._updatePlaceholder();
-        this._zone.value.widget.updateInfo(this._session.session.message ?? ( localizeWithPath(
+        const message = 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._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._zone.value.widget.updateInfo(message);
+        this._showWidget(!this._session.lastExchange);
         this._sessionStore.add(this._editor.onDidChangeModel((e) => {
             const msg = this._session?.lastExchange
                 ? 4
@@ -324,7 +309,89 @@ let InlineChatController = class InlineChatController {
                 this.finishExistingSession();
             }
         }));
+        this._sessionStore.add(this._session.chatModel.onDidChange(e => {
+            if (e.kind === 'addRequest' && e.request.response) {
+                this._zone.value.widget.updateProgress(true);
+                const listener = e.request.response.onDidChange(() => {
+                    if (e.request.response?.isCanceled || e.request.response?.isComplete) {
+                        this._zone.value.widget.updateProgress(false);
+                        listener.dispose();
+                    }
+                });
+            }
+        }));
         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: ['/'],
+            provideCompletionItems: (model, position, context, token) => {
+                if (position.lineNumber !== 1) {
+                    return undefined;
+                }
+                if (!this._session || !this._session.session.slashCommands) {
+                    return undefined;
+                }
+                const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
+                if (widget !== this._zone.value.widget.chatWidget && widget !== this._input.value.chatWidget) {
+                    return undefined;
+                }
+                const result = { suggestions: [], incomplete: false };
+                for (const command of this._session.session.slashCommands) {
+                    const withSlash = `/${command.command}`;
+                    result.suggestions.push({
+                        label: { label: withSlash, description: command.detail ?? '' },
+                        kind: 18 ,
+                        insertText: withSlash,
+                        range: Range.fromPositions(( new Position(1, 1)), position),
+                        command: command.executeImmediately ? { id: 'workbench.action.chat.acceptInput', title: withSlash } : undefined
+                    });
+                }
+                return result;
+            }
+        }));
+        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}`;
+                const firstLine = model.getLineContent(1);
+                if (firstLine.startsWith(withSlash)) {
+                    newDecorations.push({
+                        range: ( new Range(1, 1, 1, withSlash.length + 1)),
+                        options: {
+                            description: 'inline-chat-slash-command',
+                            inlineClassName: 'inline-chat-slash-command',
+                            after: {
+                                content: ' '
+                            }
+                        }
+                    });
+                    if (firstLine.trim() === `/${command.command}`) {
+                        newDecorations.push({
+                            range: ( new Range(1, withSlash.length, 1, withSlash.length)),
+                            options: {
+                                description: 'inline-chat-slash-command-detail',
+                                after: {
+                                    content: `${command.detail}`,
+                                    inlineClassName: 'inline-chat-slash-command-detail'
+                                }
+                            }
+                        });
+                    }
+                    break;
+                }
+            }
+            collection.set(newDecorations);
+        };
+        const inputInputEditor = this._input.value.chatWidget.inputEditor;
+        const zoneInputEditor = this._zone.value.widget.chatWidget.inputEditor;
+        const inputDecorations = inputInputEditor.createDecorationsCollection();
+        const zoneDecorations = zoneInputEditor.createDecorationsCollection();
+        this._sessionStore.add(inputInputEditor.onDidChangeModelContent(() => updateSlashDecorations(inputDecorations, inputInputEditor.getModel())));
+        this._sessionStore.add(zoneInputEditor.onDidChangeModelContent(() => updateSlashDecorations(zoneDecorations, zoneInputEditor.getModel())));
+        this._sessionStore.add(toDisposable(() => {
+            inputDecorations.clear();
+            zoneDecorations.clear();
+        }));
         if (!this._session.lastExchange) {
             return "WAIT_FOR_INPUT" ;
         }
@@ -340,33 +407,37 @@ let InlineChatController = class InlineChatController {
         assertType(this._session);
         assertType(this._strategy);
         this._updatePlaceholder();
-        if (options.existingExchange) {
-            options.message = options.existingExchange.prompt;
-            options.autoSend = true;
-        }
         if (options.message) {
             this.updateInput(options.message);
             alert(options.message);
             delete options.message;
+            this._showWidget(false);
         }
         let message = 0 ;
+        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 ;
+                barrier.open();
+            }
+        }));
+        store.add(this._strategy.onDidAccept(() => this.acceptSession()));
+        store.add(this._strategy.onDidDiscard(() => this.cancelSession()));
+        store.add(Event.once(this._messages.event)(m => {
+            this._log('state=_waitForInput) message received', m);
+            message = m;
+            barrier.open();
+        }));
         if (options.autoSend) {
-            message = 32 ;
             delete options.autoSend;
+            this._showWidget(false);
+            this._zone.value.widget.chatWidget.acceptInput();
         }
-        else {
-            const barrier = ( new Barrier());
-            const store = ( new DisposableStore());
-            store.add(this._strategy.onDidAccept(() => this.acceptSession()));
-            store.add(this._strategy.onDidDiscard(() => this.cancelSession()));
-            store.add(Event.once(this._messages.event)(m => {
-                this._log('state=_waitForInput) message received', m);
-                message = m;
-                barrier.open();
-            }));
-            await barrier.wait();
-            store.dispose();
-        }
+        await barrier.wait();
+        store.dispose();
         if (message & ((16  | 2) )) {
             return "CANCEL" ;
         }
@@ -377,220 +448,108 @@ let InlineChatController = class InlineChatController {
             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._session.hunkData.ignoreTextModelNChanges = true;
-                    await this._strategy.undoChanges(lastExchange.response.modelAltVersionId);
+        if (!request?.message.text) {
+            return "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;
                 }
-                finally {
-                    this._session.hunkData.ignoreTextModelNChanges = false;
+                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 "MAKE_REQUEST" ;
-        }
-        if (!this.getInput()) {
-            return "WAIT_FOR_INPUT" ;
-        }
-        const input = this.getInput();
-        this._historyUpdate(input);
-        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._session.provider.debugName);
+            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;
-            if (input.startsWith(chatSubcommandLeader)) {
-                const withoutSubCommandLeader = input.slice(1);
-                const cts = ( new CancellationTokenSource());
-                this._sessionStore.add(cts);
-                for (const agent of this._chatAgentService.getAgents()) {
-                    const commands = await agent.provideSlashCommands(undefined, [], cts.token);
+            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.id} ${input}`;
+                        massagedInput = `${chatAgentLeader}${agent.name} ${slashCommandLike.text}`;
                         break;
                     }
                 }
             }
-            this._instaService.invokeFunction(sendRequest, massagedInput);
-            if (!this._session.lastExchange) {
-                return "DONE" ;
-            }
-            return "WAIT_FOR_INPUT" ;
+            await this._instaService.invokeFunction(sendRequest, massagedInput);
+            return "DONE" ;
         }
-        this._session.addInput(( new SessionPrompt(input)));
-        return "MAKE_REQUEST" ;
+        this._session.addInput(( new SessionPrompt(input, this._nextAttempt, this._nextWithIntentDetection)));
+        this._nextAttempt = 0;
+        this._nextWithIntentDetection = true;
+        return "SHOW_REQUEST" ;
     }
-    async ["MAKE_REQUEST" ](options) {
-        assertType(this._editor.hasModel());
+    async ["SHOW_REQUEST" ](options) {
         assertType(this._session);
-        assertType(this._strategy);
         assertType(this._session.lastInput);
-        const requestCts = ( new CancellationTokenSource());
-        let message = 0 ;
-        const msgListener = Event.once(this._messages.event)(m => {
-            this._log('state=_makeRequest) message received', m);
-            message = m;
-            requestCts.cancel();
-        });
-        const typeListener = this._zone.value.widget.onDidChangeInput(() => requestCts.cancel());
-        const requestClock = StopWatch.create();
-        const request = {
-            requestId: generateUuid(),
-            prompt: this._session.lastInput.value,
-            attempt: this._session.lastInput.attempt,
-            selection: this._editor.getSelection(),
-            wholeRange: this._session.wholeRange.trackedInitialRange,
-            live: this._session.editMode !== "preview" ,
-            previewDocument: this._session.textModelN.uri,
-            withIntentDetection: options.withIntentDetection ?? true ,
-        };
-        delete options.withIntentDetection;
-        const modelAltVersionIdNow = this._session.textModelN.getAlternativeVersionId();
-        const progressEdits = [];
+        const request = tail(this._session.chatModel.getRequests());
+        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('');
+        const { response } = request;
+        const responsePromise = ( new DeferredPromise());
+        const store = ( new DisposableStore());
+        const progressiveEditsCts = store.add(( new CancellationTokenSource()));
         const progressiveEditsAvgDuration = ( new MovingAverage());
-        const progressiveEditsCts = ( new CancellationTokenSource(requestCts.token));
         const progressiveEditsClock = StopWatch.create();
         const progressiveEditsQueue = ( new Queue());
-        let progressiveChatResponse;
-        const progress = ( new Progress(data => {
-            this._log('received chunk', data, request);
-            if (requestCts.token.isCancellationRequested) {
+        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);
+        }));
+        store.add(response.onDidChange(() => {
+            if (response.isCanceled) {
+                progressiveEditsCts.cancel();
+                responsePromise.complete();
                 return;
             }
-            if (data.message) {
-                this._zone.value.widget.updateToolbar(false);
-                this._zone.value.widget.updateInfo(data.message);
-            }
-            if (data.slashCommand) {
-                const valueNow = this.getInput();
-                if (!valueNow.startsWith('/')) {
-                    this._zone.value.widget.updateSlashCommandUsed(data.slashCommand);
-                }
+            if (response.isComplete) {
+                responsePromise.complete();
+                return;
             }
-            if (data.edits?.length) {
-                if (!request.live) {
-                    throw new Error('Progress in NOT supported in non-live mode');
-                }
-                progressEdits.push(data.edits);
-                progressiveEditsAvgDuration.update(progressiveEditsClock.elapsed());
-                progressiveEditsClock.reset();
-                progressiveEditsQueue.queue(async () => {
-                    const startThen = this._session.wholeRange.value.getStartPosition();
-                    await this._makeChanges(data.edits, data.editsShouldBeInstant
-                        ? undefined
-                        : { 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));
-                    }
-                });
+            const edits = response.edits.get(this._session.textModelN.uri) ?? [];
+            const newEdits = edits.slice(lastLength);
+            if (newEdits.length === 0) {
+                return;
             }
-            if (data.markdownFragment) {
-                if (!progressiveChatResponse) {
-                    const message = {
-                        message: ( new MarkdownString(
-                            data.markdownFragment,
-                            { supportThemeIcons: true, supportHtml: true, isTrusted: false }
-                        )),
-                        providerId: this._session.provider.debugName,
-                        requestId: request.requestId,
-                    };
-                    progressiveChatResponse = this._zone.value.widget.updateChatMessage(message, true);
+            lastLength = edits.length;
+            progressiveEditsAvgDuration.update(progressiveEditsClock.elapsed());
+            progressiveEditsClock.reset();
+            progressiveEditsQueue.queue(async () => {
+                const startThen = this._session.wholeRange.value.getStartPosition();
+                await this._makeChanges(newEdits, { 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));
                 }
-                else {
-                    progressiveChatResponse.appendContent(data.markdownFragment);
-                }
-            }
+            });
         }));
-        let a11yResponse;
-        const a11yVerboseInlineChat = this._configurationService.getValue('accessibility.verbosity.inlineChat') === true;
-        const requestId = this._chatAccessibilityService.acceptRequest();
-        let task;
-        if (options.existingExchange) {
-            task = options.existingExchange.response;
-            delete options.existingExchange;
-            this._log('using READY-response', this._session.provider.debugName, this._session.session);
-        }
-        else {
-            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._session.lastExchange ? ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                'thinking',
-                "Thinking\u2026"
-            )) : '');
-            this._ctxHasActiveRequest.set(true);
-            reply = await raceCancellationError(Promise.resolve(task), requestCts.token);
-            await progressiveEditsQueue.whenIdle();
-            if (progressiveChatResponse) {
-                progressiveChatResponse.cancel();
-            }
-            if (!reply) {
-                response = ( new EmptyResponse());
-                a11yResponse = ( localizeWithPath(
-                    'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                    'empty',
-                    "No results, please refine your input and try again"
-                ));
-            }
-            else {
-                const markdownContents = reply.message ?? ( new MarkdownString('', { supportThemeIcons: true, supportHtml: true, isTrusted: false }));
-                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);
-                }
-                const a11yMessageResponse = renderMarkdownAsPlaintext(replyResponse.mdContent);
-                a11yResponse = a11yVerboseInlineChat
-                    ? a11yMessageResponse ? ( localizeWithPath(
-                    'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                    'editResponseMessage2',
-                    "{0}, also review proposed changes in the diff editor.",
-                    a11yMessageResponse
-                )) : ( localizeWithPath(
-                    'vs/workbench/contrib/inlineChat/browser/inlineChatController',
-                    'editResponseMessage',
-                    "Review proposed changes in the diff editor."
-                ))
-                    : a11yMessageResponse;
-            }
-        }
-        catch (e) {
-            progressiveEditsQueue.clear();
-            response = ( new ErrorResponse(e));
-            a11yResponse = response.message;
-        }
-        finally {
-            this._ctxHasActiveRequest.set(false);
-            this._zone.value.widget.updateProgress(false);
-            this._zone.value.widget.updateInfo('');
-            this._zone.value.widget.updateToolbar(true);
-            this._log('request took', requestClock.elapsed(), this._session.provider.debugName);
-            this._chatAccessibilityService.acceptResponse(a11yResponse, requestId);
-        }
+        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 ?? []);
-        progressiveEditsCts.dispose(true);
-        requestCts.dispose();
-        msgListener.dispose();
-        typeListener.dispose();
-        if (response instanceof ReplyResponse) {
-            await this._session.hunkData.recompute();
-        }
-        else if (request.live) {
-            this._strategy?.undoChanges(modelAltVersionIdNow);
-        }
-        this._session.addExchange(( new SessionExchange(this._session.lastInput, response)));
+        await this._session.hunkData.recompute();
+        this._zone.value.widget.updateToolbar(true);
         if (message & 2 ) {
             return "CANCEL" ;
         }
@@ -600,9 +559,6 @@ let InlineChatController = class InlineChatController {
         else if (message & 1 ) {
             return "DONE" ;
         }
-        else if (message & ((32  | 64) )) {
-            return "MAKE_REQUEST" ;
-        }
         else {
             return "APPLY_RESPONSE" ;
         }
@@ -653,9 +609,6 @@ let InlineChatController = class InlineChatController {
         }
         else if (response instanceof ReplyResponse) {
             this._zone.value.widget.updateStatus('');
-            const message = { message: response.mdContent, providerId: this._session.provider.debugName, requestId: response.requestId };
-            this._zone.value.widget.updateChatMessage(message);
-            this._session.lastExpansionState = this._zone.value.widget.expansionState;
             this._zone.value.widget.updateToolbar(true);
             newPosition = await this._strategy.renderChanges(response);
             if (this._session.provider.provideFollowups) {
@@ -664,10 +617,10 @@ let InlineChatController = class InlineChatController {
                     followupCts.cancel();
                 });
                 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);
+                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.debugName, this._session.session, followupReply);
+                        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);
@@ -753,41 +706,49 @@ let InlineChatController = class InlineChatController {
         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 if (this._zone.rawValue?.position) {
+            if (this._zone.rawValue.position.lineNumber === 1) {
+                widgetPosition = this._zone.rawValue.position.delta(-1);
             }
             else {
-                widgetPosition = this._zone.value.position;
+                widgetPosition = this._zone.rawValue.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.rawValue?.position) {
+            this._zone.value.updatePositionAndHeight(widgetPosition);
         }
-        if (!this._zone.value.position) {
-            this._zone.value.setWidgetMargins(widgetPosition);
-            this._zone.value.show(widgetPosition);
+        else if (initialRender) {
+            const selection = this._editor.getSelection();
+            widgetPosition = selection.getStartPosition();
+            this._input.value.show(widgetPosition);
         }
         else {
-            this._zone.value.setWidgetMargins(widgetPosition);
-            this._zone.value.updatePositionAndHeight(widgetPosition);
+            this._input.value.hide();
+            this._zone.value.show(widgetPosition);
+            if (this._session && this._zone.value.widget.chatWidget.viewModel?.model !== this._session.chatModel) {
+                this._zone.value.widget.setChatModel(this._session.chatModel);
+            }
+        }
+        if (this._session && this._zone.rawValue) {
+            this._zone.rawValue.updateBackgroundColor(widgetPosition, this._session.wholeRange.value);
         }
+        this._ctxVisible.set(true);
+        return widgetPosition;
     }
     _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();
         if (this._editor.hasWidgetFocus()) {
             this._editor.focus();
@@ -797,7 +758,7 @@ let InlineChatController = class InlineChatController {
         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);
+        this._log('edits from PROVIDER and after making them MORE MINIMAL', this._session.provider.extensionId, edits, moreMinimalEdits);
         if (moreMinimalEdits?.length === 0) {
             return;
         }
@@ -840,19 +801,52 @@ let InlineChatController = class InlineChatController {
         this._updatePlaceholder();
     }
     acceptInput() {
-        this._messages.fire(32 );
+        if (this._input.value.isVisible) {
+            this._input.value.chatWidget.acceptInput();
+        }
+        else {
+            this._zone.value.widget.chatWidget.acceptInput();
+        }
     }
     updateInput(text, selectAll = true) {
-        this._zone.value.widget.value = text;
+        this._input.value.chatWidget.setInput(text);
+        this._zone.value.widget.chatWidget.setInput(text);
         if (selectAll) {
-            this._zone.value.widget.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);
         }
     }
     getInput() {
-        return this._zone.value.widget.value;
+        return this._input.value.isVisible
+            ? this._input.value.value
+            : this._zone.value.widget.value;
     }
-    regenerate() {
-        this._messages.fire(64 );
+    async rerun(opts) {
+        if (this._session?.lastExchange && this._strategy) {
+            const { lastExchange } = this._session;
+            const request = tail(this._session.chatModel.getRequests());
+            if (!request || !request.response?.isComplete) {
+                return;
+            }
+            this._session.chatModel.removeRequest(request.id);
+            if (lastExchange.response instanceof ReplyResponse) {
+                try {
+                    this._session.hunkData.ignoreTextModelNChanges = true;
+                    await this._strategy.undoChanges(lastExchange.response.modelAltVersionId);
+                }
+                finally {
+                    this._session.hunkData.ignoreTextModelNChanges = false;
+                }
+            }
+            if (opts.retry) {
+                this._nextAttempt = lastExchange.prompt.attempt + 1;
+            }
+            if (opts.withoutIntentDetection) {
+                this._nextWithIntentDetection = false;
+            }
+            this._zone.value.widget.chatWidget.acceptInput(request.message.text);
+        }
     }
     cancelCurrentRequest() {
         this._messages.fire(16  | 8 );
@@ -876,42 +870,11 @@ let InlineChatController = class InlineChatController {
         this.focus();
         this._strategy?.move?.(next);
     }
-    populateHistory(up) {
-        const len = InlineChatController_1._promptHistory.length;
-        if (len === 0) {
-            return;
-        }
-        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();
-    }
     viewInChat() {
         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._session) {
-            const expansionState = expand ? ExpansionState.EXPANDED : ExpansionState.CROPPED;
-            this._zone.value.widget.updateChatMessageExpansionState(expansionState);
-            this._session.lastExpansionState = expansionState;
-        }
-    }
     toggleDiff() {
         this._strategy?.toggleDiff?.();
     }
@@ -981,7 +944,7 @@ let InlineChatController = class InlineChatController {
         return this._currentRun;
     }
 };
-InlineChatController = InlineChatController_1 = ( __decorate([
+InlineChatController = ( __decorate([
     ( __param(1, IInstantiationService)),
     ( __param(2, IInlineChatSessionService)),
     ( __param(3, IInlineChatSavingService)),
@@ -990,30 +953,39 @@ InlineChatController = InlineChatController_1 = ( __decorate([
     ( __param(6, IConfigurationService)),
     ( __param(7, IDialogService)),
     ( __param(8, IContextKeyService)),
-    ( __param(9, IChatAccessibilityService)),
-    ( __param(10, IChatAgentService)),
+    ( __param(9, IChatAgentService)),
+    ( __param(10, IChatService)),
     ( __param(11, IBulkEditService)),
-    ( __param(12, IStorageService)),
-    ( __param(13, ICommandService))
+    ( __param(12, ICommandService)),
+    ( __param(13, ILanguageFeaturesService)),
+    ( __param(14, IChatWidgetService))
 ], InlineChatController));
 async function showMessageResponse(accessor, query, response) {
     const chatService = accessor.get(IChatService);
-    const providerId = chatService.getProviderInfos()[0]?.id;
+    const chatAgentService = accessor.get(IChatAgentService);
+    const agent = chatAgentService.getActivatedAgents().find(agent => agent.locations.includes(ChatAgentLocation.Panel) && agent.isDefault);
+    if (!agent) {
+        return;
+    }
     const chatWidgetService = accessor.get(IChatWidgetService);
-    const widget = await chatWidgetService.revealViewForProvider(providerId);
+    const widget = await chatWidgetService.revealViewForProvider(agent.name);
     if (widget && widget.viewModel) {
         chatService.addCompleteRequest(widget.viewModel.sessionId, query, undefined, { message: response });
         widget.focusLastMessage();
     }
 }
 async function sendRequest(accessor, query) {
-    const chatService = accessor.get(IChatService);
     const widgetService = accessor.get(IChatWidgetService);
-    const providerId = chatService.getProviderInfos()[0]?.id;
-    const widget = await widgetService.revealViewForProvider(providerId);
+    const chatAgentService = accessor.get(IChatAgentService);
+    const agent = chatAgentService.getActivatedAgents().find(agent => agent.locations.includes(ChatAgentLocation.Panel) && agent.isDefault);
+    if (!agent) {
+        return;
+    }
+    const widget = await widgetService.revealViewForProvider(agent.name);
     if (!widget) {
         return;
     }
+    widget.focusInput();
     widget.acceptInput(query);
 }
 export { InlineChatController, InlineChatRunOptions };