@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.1

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

@@ -34,10 +34,11 @@ import { IChatAttachmentResolveService } from '@codingame/monaco-vscode-api/vsco
 import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
 import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
 import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { IDiagnosticVariableEntryFilterData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { isILanguageModelChatSelector, ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
 import { isNotebookContainingCellEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditor';
@@ -47,7 +48,7 @@ import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workben
 import { CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_FILE_BELONGS_TO_CHAT, CTX_INLINE_CHAT_PENDING_CONFIRMATION, CTX_INLINE_CHAT_TERMINATED, InlineChatConfigKeys } from '../common/inlineChat.js';
 import { InlineChatAffordance } from './inlineChatAffordance.js';
 import { InlineChatInputWidget, InlineChatSessionOverlayWidget } from './inlineChatOverlayWidget.js';
-import { continueInPanelChat } from './inlineChatSessionService.js';
+import { continueInPanelChat, rephraseInlineChat } from './inlineChatSessionService.js';
 import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
 import { InlineChatZoneWidget } from './inlineChatZoneWidget.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
@@ -93,63 +94,82 @@ let InlineChatController = class InlineChatController {
     static get(editor) {
         return editor.getContribution(InlineChatController_1.ID) ?? undefined;
     }
+    static #userSelectedModel;
+    #store = ( new DisposableStore());
+    #isActiveController = observableValue(this, false);
+    #renderMode;
+    #zone;
+    #inputWidget;
+    #currentSession;
+    #editor;
+    #instaService;
+    #notebookEditorService;
+    #inlineChatSessionService;
+    #configurationService;
+    #webContentExtractorService;
+    #fileService;
+    #chatAttachmentResolveService;
+    #editorService;
+    #markerDecorationsService;
+    #languageModelService;
+    #logService;
+    #chatEditingService;
+    #chatService;
     get widget() {
-        return this._zone.value.widget;
+        return this.#zone.value.widget;
     }
     get isActive() {
-        return Boolean(this._currentSession.get());
+        return Boolean(this.#currentSession.get());
     }
     get inputWidget() {
-        return this._inputWidget;
+        return this.#inputWidget;
     }
     constructor(
-        _editor,
-        _instaService,
-        _notebookEditorService,
-        _inlineChatSessionService,
+        editor,
+        instaService,
+        notebookEditorService,
+        inlineChatSessionService,
         codeEditorService,
         contextKeyService,
-        _configurationService,
-        _webContentExtractorService,
-        _fileService,
-        _chatAttachmentResolveService,
-        _editorService,
-        _markerDecorationsService,
-        _languageModelService,
-        _logService,
-        _chatEditingService,
-        _chatService
+        configurationService,
+        webContentExtractorService,
+        fileService,
+        chatAttachmentResolveService,
+        editorService,
+        markerDecorationsService,
+        languageModelService,
+        logService,
+        chatEditingService,
+        chatService
     ) {
-        this._editor = _editor;
-        this._instaService = _instaService;
-        this._notebookEditorService = _notebookEditorService;
-        this._inlineChatSessionService = _inlineChatSessionService;
-        this._configurationService = _configurationService;
-        this._webContentExtractorService = _webContentExtractorService;
-        this._fileService = _fileService;
-        this._chatAttachmentResolveService = _chatAttachmentResolveService;
-        this._editorService = _editorService;
-        this._markerDecorationsService = _markerDecorationsService;
-        this._languageModelService = _languageModelService;
-        this._logService = _logService;
-        this._chatEditingService = _chatEditingService;
-        this._chatService = _chatService;
-        this._store = ( new DisposableStore());
-        this._isActiveController = observableValue(this, false);
-        const editorObs = observableCodeEditor(_editor);
+        this.#editor = editor;
+        this.#instaService = instaService;
+        this.#notebookEditorService = notebookEditorService;
+        this.#inlineChatSessionService = inlineChatSessionService;
+        this.#configurationService = configurationService;
+        this.#webContentExtractorService = webContentExtractorService;
+        this.#fileService = fileService;
+        this.#chatAttachmentResolveService = chatAttachmentResolveService;
+        this.#editorService = editorService;
+        this.#markerDecorationsService = markerDecorationsService;
+        this.#languageModelService = languageModelService;
+        this.#logService = logService;
+        this.#chatEditingService = chatEditingService;
+        this.#chatService = chatService;
+        const editorObs = observableCodeEditor(editor);
         const ctxInlineChatVisible = CTX_INLINE_CHAT_VISIBLE.bindTo(contextKeyService);
         const ctxFileBelongsToChat = CTX_INLINE_CHAT_FILE_BELONGS_TO_CHAT.bindTo(contextKeyService);
         const ctxPendingConfirmation = CTX_INLINE_CHAT_PENDING_CONFIRMATION.bindTo(contextKeyService);
         const ctxTerminated = CTX_INLINE_CHAT_TERMINATED.bindTo(contextKeyService);
-        const notebookAgentConfig = observableConfigValue(InlineChatConfigKeys.notebookAgent, false, this._configurationService);
-        this._renderMode = observableConfigValue(InlineChatConfigKeys.RenderMode, "zone", this._configurationService);
-        this._store.add(autorun(r => {
+        const notebookAgentConfig = observableConfigValue(InlineChatConfigKeys.notebookAgent, false, this.#configurationService);
+        this.#renderMode = observableConfigValue(InlineChatConfigKeys.RenderMode, "zone", this.#configurationService);
+        this.#store.add(autorun(r => {
             const model = editorObs.model.read(r);
             if (!model) {
                 ctxFileBelongsToChat.set(false);
                 return;
             }
-            const sessions = this._chatEditingService.editingSessionsObs.read(r);
+            const sessions = this.#chatEditingService.editingSessionsObs.read(r);
             let hasEdits = false;
             for (const session of sessions) {
                 const entries = session.entries.read(r);
@@ -165,47 +185,47 @@ let InlineChatController = class InlineChatController {
             }
             ctxFileBelongsToChat.set(hasEdits);
         }));
-        const overlayWidget = this._inputWidget = this._store.add(this._instaService.createInstance(InlineChatInputWidget, editorObs));
-        const sessionOverlayWidget = this._store.add(
-            this._instaService.createInstance(InlineChatSessionOverlayWidget, editorObs)
+        const overlayWidget = this.#inputWidget = this.#store.add(this.#instaService.createInstance(InlineChatInputWidget, editorObs));
+        const sessionOverlayWidget = this.#store.add(
+            this.#instaService.createInstance(InlineChatSessionOverlayWidget, editorObs)
         );
-        this.inputOverlayWidget = this._store.add(
-            this._instaService.createInstance(InlineChatAffordance, this._editor, overlayWidget)
+        this.inputOverlayWidget = this.#store.add(
+            this.#instaService.createInstance(InlineChatAffordance, this.#editor, overlayWidget)
         );
-        this._zone = ( new Lazy(() => {
+        this.#zone = ( new Lazy(() => {
             assertType(
-                this._editor.hasModel(),
+                this.#editor.hasModel(),
                 "[Illegal State] widget should only be created when the editor has a model"
             );
             const location = {
                 location: ChatAgentLocation.EditorInline,
                 resolveData: () => {
-                    assertType(this._editor.hasModel());
-                    const wholeRange = this._editor.getSelection();
-                    const document = this._editor.getModel().uri;
+                    assertType(this.#editor.hasModel());
+                    const wholeRange = this.#editor.getSelection();
+                    const document = this.#editor.getModel().uri;
                     return {
                         type: ChatAgentLocation.EditorInline,
-                        id: getEditorId(this._editor, this._editor.getModel()),
-                        selection: this._editor.getSelection(),
+                        id: getEditorId(this.#editor, this.#editor.getModel()),
+                        selection: this.#editor.getSelection(),
                         document,
                         wholeRange
                     };
                 }
             };
-            const notebookEditor = this._notebookEditorService.getNotebookForPossibleCell(this._editor);
+            const notebookEditor = this.#notebookEditorService.getNotebookForPossibleCell(this.#editor);
             if (!!notebookEditor) {
                 location.location = ChatAgentLocation.Notebook;
                 if (notebookAgentConfig.get()) {
                     location.resolveData = () => {
-                        assertType(this._editor.hasModel());
+                        assertType(this.#editor.hasModel());
                         return {
                             type: ChatAgentLocation.Notebook,
-                            sessionInputUri: this._editor.getModel().uri
+                            sessionInputUri: this.#editor.getModel().uri
                         };
                     };
                 }
             }
-            const result = this._instaService.createInstance(InlineChatZoneWidget, location, {
+            const result = this.#instaService.createInstance(InlineChatZoneWidget, location, {
                 enableWorkingSet: "implicit",
                 enableImplicitContext: false,
                 renderInputOnTop: false,
@@ -223,25 +243,25 @@ let InlineChatController = class InlineChatController {
                 },
                 defaultMode: ChatMode.Ask
             }, {
-                editor: this._editor,
+                editor: this.#editor,
                 notebookEditor
             }, () => Promise.resolve());
-            this._store.add(result);
+            this.#store.add(result);
             result.domNode.classList.add("inline-chat-2");
             return result;
         }));
-        const sessionsSignal = observableSignalFromEvent(this, _inlineChatSessionService.onDidChangeSessions);
-        this._currentSession = derived(r => {
+        const sessionsSignal = observableSignalFromEvent(this, inlineChatSessionService.onDidChangeSessions);
+        this.#currentSession = derived(r => {
             sessionsSignal.read(r);
             const model = editorObs.model.read(r);
-            const session = model && _inlineChatSessionService.getSessionByTextModel(model.uri);
+            const session = model && inlineChatSessionService.getSessionByTextModel(model.uri);
             return session ?? undefined;
         });
         let lastSession = undefined;
-        this._store.add(autorun(r => {
-            const session = this._currentSession.read(r);
+        this.#store.add(autorun(r => {
+            const session = this.#currentSession.read(r);
             if (!session) {
-                this._isActiveController.set(false, undefined);
+                this.#isActiveController.set(false, undefined);
                 if (lastSession && !lastSession.chatModel.hasRequests) {
                     const state = lastSession.chatModel.inputModel.state.read(undefined);
                     if (!state || (!state.inputText && state.attachments.length === 0)) {
@@ -254,20 +274,21 @@ let InlineChatController = class InlineChatController {
             lastSession = session;
             let foundOne = false;
             for (const editor of codeEditorService.listCodeEditors()) {
-                if (Boolean(InlineChatController_1.get(editor)?._isActiveController.read(undefined))) {
+                const ctrl = InlineChatController_1.get(editor);
+                if (ctrl && ctrl.#isActiveController.read(undefined)) {
                     foundOne = true;
                     break;
                 }
             }
             if (!foundOne && editorObs.isFocused.read(r)) {
-                this._isActiveController.set(true, undefined);
+                this.#isActiveController.set(true, undefined);
             }
         }));
         const visibleSessionObs = observableValue(this, undefined);
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const model = editorObs.model.read(r);
-            const session = this._currentSession.read(r);
-            const isActive = this._isActiveController.read(r);
+            const session = this.#currentSession.read(r);
+            const isActive = this.#isActiveController.read(r);
             if (!session || !isActive || !model) {
                 visibleSessionObs.set(undefined, undefined);
             } else {
@@ -275,39 +296,37 @@ let InlineChatController = class InlineChatController {
             }
         }));
         const defaultPlaceholderObs = ( visibleSessionObs.map((session, r) => {
-            return session?.initialSelection.isEmpty() ? ( localize(9951, "Generate code")) : ( localize(9952, "Modify selected code"));
+            return session?.initialSelection.isEmpty() ? ( localize(10089, "Generate code")) : ( localize(10090, "Modify selected code"));
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
             ctxTerminated.set(!!session?.terminationState.read(r));
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
-            const renderMode = this._renderMode.read(r);
+            const renderMode = this.#renderMode.read(r);
             if (!session) {
-                this._zone.rawValue?.hide();
-                this._zone.rawValue?.widget.chatWidget.setModel(undefined);
-                _editor.focus();
+                this.#zone.rawValue?.hide();
+                this.#zone.rawValue?.widget.chatWidget.setModel(undefined);
+                editor.focus();
                 ctxInlineChatVisible.reset();
             } else if (renderMode === "hover") {
-                this._zone.value.widget.chatWidget.setModel(session.chatModel);
-                this._zone.rawValue?.hide();
                 ctxInlineChatVisible.set(true);
             } else {
                 ctxInlineChatVisible.set(true);
-                this._zone.value.widget.chatWidget.setModel(session.chatModel);
-                if (!this._zone.value.position) {
-                    this._zone.value.widget.chatWidget.setInputPlaceholder(defaultPlaceholderObs.read(r));
-                    this._zone.value.widget.chatWidget.input.renderAttachedContext();
-                    this._zone.value.show(session.initialPosition);
+                this.#zone.value.widget.chatWidget.setModel(session.chatModel);
+                if (!this.#zone.value.position) {
+                    this.#zone.value.widget.chatWidget.setInputPlaceholder(defaultPlaceholderObs.read(r));
+                    this.#zone.value.widget.chatWidget.input.renderAttachedContext();
+                    this.#zone.value.show(session.initialPosition);
                 }
-                this._zone.value.reveal(this._zone.value.position);
-                this._zone.value.widget.focus();
+                this.#zone.value.reveal(this.#zone.value.position);
+                this.#zone.value.widget.focus();
             }
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
-            const renderMode = this._renderMode.read(r);
+            const renderMode = this.#renderMode.read(r);
             if (!session || renderMode !== "hover") {
                 ctxPendingConfirmation.set(false);
                 sessionOverlayWidget.hide();
@@ -327,7 +346,27 @@ let InlineChatController = class InlineChatController {
                 sessionOverlayWidget.hide();
             }
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
+            const session = this.#currentSession.read(r);
+            if (!session) {
+                return;
+            }
+            const lastRequest = session.chatModel.lastRequestObs.read(r);
+            const response = lastRequest?.response;
+            const pending = response?.isPendingConfirmation.read(r);
+            if (pending) {
+                this.#logService.info(`[InlineChat] auto-approving: ${pending.detail ?? "unknown"}`);
+                for (const part of response.response.value) {
+                    if (part.kind === "toolInvocation") {
+                        IChatToolInvocation.confirmWith(part, {
+                            type: ToolConfirmKind.ConfirmationNotNeeded,
+                            reason: "inlineChat"
+                        });
+                    }
+                }
+            }
+        }));
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
             if (session) {
                 const entries = session.editingSession.entries.read(r);
@@ -342,7 +381,7 @@ let InlineChatController = class InlineChatController {
                     return true;
                 });
                 for (const entry of otherEntries) {
-                    this._editorService.openEditor({
+                    this.#editorService.openEditor({
                         resource: entry.modifiedURI
                     }, SIDE_GROUP).catch(onUnexpectedError);
                 }
@@ -369,31 +408,37 @@ let InlineChatController = class InlineChatController {
                 () => response.response.value.findLast(part => part.kind === "progressMessage")
             ).read(r);
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
             const response = lastResponseObs.read(r);
             const terminationState = session?.terminationState.read(r);
-            this._zone.rawValue?.widget.updateInfo("");
+            const renderMode = this.#renderMode.read(r);
+            this.#zone.rawValue?.widget.updateInfo("");
             if (!response?.isInProgress.read(r)) {
                 if (response?.result?.errorDetails) {
-                    this._zone.rawValue?.widget.updateInfo(`$(error) ${response.result.errorDetails.message}`);
+                    this.#zone.rawValue?.widget.updateInfo(`$(error) ${response.result.errorDetails.message}`);
                     alert(response.result.errorDetails.message);
+                } else if (terminationState && renderMode === "zone") {
+                    this.#zone.rawValue?.showTerminationCard(terminationState, this.#instaService);
                 } else if (terminationState) {
-                    this._zone.rawValue?.widget.updateInfo(`$(info) ${renderAsPlaintext(terminationState)}`);
+                    this.#zone.rawValue?.widget.updateInfo(`$(info) ${renderAsPlaintext(terminationState)}`);
+                }
+                if (!terminationState || renderMode !== "zone") {
+                    this.#zone.rawValue?.hideTerminationCard();
                 }
-                this._zone.rawValue?.widget.domNode.classList.toggle("request-in-progress", false);
-                this._zone.rawValue?.widget.chatWidget.setInputPlaceholder(defaultPlaceholderObs.read(r));
+                this.#zone.rawValue?.widget.domNode.classList.toggle("request-in-progress", false);
+                this.#zone.rawValue?.widget.chatWidget.setInputPlaceholder(defaultPlaceholderObs.read(r));
             } else {
-                this._zone.rawValue?.widget.domNode.classList.toggle("request-in-progress", true);
+                this.#zone.rawValue?.widget.domNode.classList.toggle("request-in-progress", true);
                 let placeholder = response.request?.message.text;
                 const lastProgress = lastResponseProgressObs.read(r);
                 if (lastProgress) {
                     placeholder = renderAsPlaintext(lastProgress.content);
                 }
-                this._zone.rawValue?.widget.chatWidget.setInputPlaceholder(placeholder || ( localize(9953, "Working...")));
+                this.#zone.rawValue?.widget.chatWidget.setInputPlaceholder(placeholder || ( localize(10091, "Working...")));
             }
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
             if (!session) {
                 return;
@@ -403,23 +448,23 @@ let InlineChatController = class InlineChatController {
                 entry?.enableReviewModeUntilSettled();
             }
         }));
-        this._store.add(autorun(r => {
+        this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
             const entry = session?.editingSession.readEntry(session.uri, r);
-            const pane = this._editorService.visibleEditorPanes.find(
-                candidate => candidate.getControl() === this._editor || isNotebookContainingCellEditor(candidate, this._editor)
+            const pane = this.#editorService.visibleEditorPanes.find(
+                candidate => candidate.getControl() === this.#editor || isNotebookContainingCellEditor(candidate, this.#editor)
             );
             if (pane && entry) {
                 entry?.getEditorIntegration(pane);
             }
-            if (entry?.diffInfo && this._zone.value.position) {
+            if (entry?.diffInfo && this.#zone.rawValue?.position) {
                 const {
                     position
-                } = this._zone.value;
+                } = this.#zone.rawValue;
                 const diff = entry.diffInfo.read(r);
                 for (const change of diff.changes) {
                     if (change.modified.contains(position.lineNumber)) {
-                        this._zone.value.updatePositionAndHeight(( new Position(change.modified.startLineNumber - 1, 1)));
+                        this.#zone.rawValue?.updatePositionAndHeight(( new Position(change.modified.startLineNumber - 1, 1)));
                         break;
                     }
                 }
@@ -427,79 +472,162 @@ let InlineChatController = class InlineChatController {
         }));
     }
     dispose() {
-        this._store.dispose();
+        this.#store.dispose();
     }
     getWidgetPosition() {
-        return this._zone.rawValue?.position;
+        return this.#zone.rawValue?.position;
     }
     focus() {
-        this._zone.rawValue?.widget.focus();
+        this.#zone.rawValue?.widget.focus();
     }
     async run(arg) {
-        assertType(this._editor.hasModel());
-        const uri = this._editor.getModel().uri;
-        const existingSession = this._inlineChatSessionService.getSessionByTextModel(uri);
+        assertType(this.#editor.hasModel());
+        const uri = this.#editor.getModel().uri;
+        const existingSession = this.#inlineChatSessionService.getSessionByTextModel(uri);
         if (existingSession) {
             await existingSession.editingSession.accept();
             existingSession.dispose();
         }
-        this._isActiveController.set(true, undefined);
-        const session = this._inlineChatSessionService.createSession(this._editor);
+        this.#isActiveController.set(true, undefined);
+        const session = this.#inlineChatSessionService.createSession(this.#editor);
+        if (this.#renderMode.get() === "hover") {
+            return this.#runHover(session, arg);
+        } else {
+            return this.#runZone(session, arg);
+        }
+    }
+    async #runHover(session, arg) {
+        assertType(this.#editor.hasModel());
+        const uri = this.#editor.getModel().uri;
+        if (arg && InlineChatRunOptions.isInlineChatRunOptions(arg)) {
+            if (arg.initialRange) {
+                this.#editor.revealRange(arg.initialRange);
+            }
+            if (arg.initialSelection) {
+                this.#editor.setSelection(arg.initialSelection);
+            }
+        }
+        const {
+            location,
+            locationData
+        } = this.#buildLocationData();
+        let userSelectedModelId;
+        if (arg?.modelSelector) {
+            userSelectedModelId = (await this.#languageModelService.selectLanguageModels(arg.modelSelector)).sort().at(0);
+            if (!userSelectedModelId) {
+                throw ( new Error(
+                    `No language models found matching selector: ${JSON.stringify(arg.modelSelector)}.`
+                ));
+            }
+        } else {
+            userSelectedModelId = await this.#resolveModelId(location);
+        }
+        const attachedContext = [];
+        if (arg?.attachments) {
+            for (const attachment of arg.attachments) {
+                const resolved = await this.#chatAttachmentResolveService.resolveImageEditorAttachContext(attachment);
+                if (resolved) {
+                    attachedContext.push(resolved);
+                }
+            }
+        }
+        if (arg?.attachDiagnostics) {
+            for (const [range, marker] of this.#markerDecorationsService.getLiveMarkers(uri)) {
+                if (range.intersectRanges(this.#editor.getSelection())) {
+                    const filter = IDiagnosticVariableEntryFilterData.fromMarker(marker);
+                    attachedContext.push(IDiagnosticVariableEntryFilterData.toEntry(filter));
+                }
+            }
+            if (attachedContext.length > 0 && !arg.message) {
+                arg.message = attachedContext.length > 1 ? ( localize(10092, "Fix the attached problems")) : ( localize(10093, "Fix the attached problem"));
+            }
+        }
+        if (arg?.message && arg.autoSend) {
+            await this.#chatService.sendRequest(session.chatModel.sessionResource, arg.message, {
+                userSelectedModelId,
+                location,
+                locationData,
+                attachedContext: attachedContext.length > 0 ? attachedContext : undefined,
+                modeInfo: {
+                    kind: ChatModeKind.Ask,
+                    isBuiltin: true,
+                    modeInstructions: undefined,
+                    modeId: "ask",
+                    applyCodeBlockSuggestionId: undefined
+                }
+            });
+        }
+        if (!arg?.resolveOnResponse) {
+            await Event.toPromise(session.editingSession.onDidDispose);
+            const rejected = session.editingSession.getEntry(uri)?.state.get() === ModifiedFileEntryState.Rejected;
+            return !rejected;
+        } else {
+            const modifiedObs = derived(r => {
+                const entry = session.editingSession.readEntry(uri, r);
+                return entry?.state.read(r) === ModifiedFileEntryState.Modified && !entry?.isCurrentlyBeingModifiedBy.read(r);
+            });
+            await waitForState(modifiedObs, state => state === true);
+            return true;
+        }
+    }
+    async #runZone(session, arg) {
+        assertType(this.#editor.hasModel());
+        const uri = this.#editor.getModel().uri;
         const sessionStore = ( new DisposableStore());
         try {
-            await this._applyModelDefaults(session, sessionStore);
+            await this.#applyModelDefaults(session, sessionStore);
             if (arg) {
-                arg.attachDiagnostics ??= this._configurationService.getValue(InlineChatConfigKeys.RenderMode) === "zone";
+                arg.attachDiagnostics ??= true;
             }
             if (arg?.attachDiagnostics) {
                 const entries = [];
-                for (const [range, marker] of this._markerDecorationsService.getLiveMarkers(uri)) {
-                    if (range.intersectRanges(this._editor.getSelection())) {
+                for (const [range, marker] of this.#markerDecorationsService.getLiveMarkers(uri)) {
+                    if (range.intersectRanges(this.#editor.getSelection())) {
                         const filter = IDiagnosticVariableEntryFilterData.fromMarker(marker);
                         entries.push(IDiagnosticVariableEntryFilterData.toEntry(filter));
                     }
                 }
                 if (entries.length > 0) {
-                    this._zone.value.widget.chatWidget.attachmentModel.addContext(...entries);
-                    const msg = entries.length > 1 ? ( localize(9954, "Fix the attached problems")) : ( localize(9955, "Fix the attached problem"));
-                    this._zone.value.widget.chatWidget.input.setValue(msg, true);
+                    this.#zone.value.widget.chatWidget.attachmentModel.addContext(...entries);
+                    const msg = entries.length > 1 ? ( localize(10092, "Fix the attached problems")) : ( localize(10093, "Fix the attached problem"));
+                    this.#zone.value.widget.chatWidget.input.setValue(msg, true);
                     arg.message = msg;
-                    this._zone.value.widget.chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
+                    this.#zone.value.widget.chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
                 }
             }
             if (arg && InlineChatRunOptions.isInlineChatRunOptions(arg)) {
                 if (arg.initialRange) {
-                    this._editor.revealRange(arg.initialRange);
+                    this.#editor.revealRange(arg.initialRange);
                 }
                 if (arg.initialSelection) {
-                    this._editor.setSelection(arg.initialSelection);
+                    this.#editor.setSelection(arg.initialSelection);
                 }
                 if (arg.attachments) {
                     await Promise.all(( arg.attachments.map(async attachment => {
-                        await this._zone.value.widget.chatWidget.attachmentModel.addFile(attachment);
+                        await this.#zone.value.widget.chatWidget.attachmentModel.addFile(attachment);
                     })));
                     delete arg.attachments;
                 }
                 if (arg.modelSelector) {
-                    const id = (await this._languageModelService.selectLanguageModels(arg.modelSelector)).sort().at(0);
+                    const id = (await this.#languageModelService.selectLanguageModels(arg.modelSelector)).sort().at(0);
                     if (!id) {
                         throw ( new Error(
                             `No language models found matching selector: ${JSON.stringify(arg.modelSelector)}.`
                         ));
                     }
-                    const model = this._languageModelService.lookupLanguageModel(id);
+                    const model = this.#languageModelService.lookupLanguageModel(id);
                     if (!model) {
                         throw ( new Error(`Language model not loaded: ${id}.`));
                     }
-                    this._zone.value.widget.chatWidget.input.setCurrentLanguageModel({
+                    this.#zone.value.widget.chatWidget.input.setCurrentLanguageModel({
                         metadata: model,
                         identifier: id
                     });
                 }
                 if (arg.message) {
-                    this._zone.value.widget.chatWidget.setInput(arg.message);
+                    this.#zone.value.widget.chatWidget.setInput(arg.message);
                     if (arg.autoSend) {
-                        await this._zone.value.widget.chatWidget.acceptInput();
+                        await this.#zone.value.widget.chatWidget.acceptInput();
                     }
                 }
             }
@@ -520,7 +648,7 @@ let InlineChatController = class InlineChatController {
         }
     }
     async acceptSession() {
-        const session = this._currentSession.get();
+        const session = this.#currentSession.get();
         if (!session) {
             return;
         }
@@ -528,45 +656,53 @@ let InlineChatController = class InlineChatController {
         session.dispose();
     }
     async rejectSession() {
-        const session = this._currentSession.get();
+        const session = this.#currentSession.get();
         if (!session) {
             return;
         }
-        await this._chatService.cancelCurrentRequestForSession(session.chatModel.sessionResource, "inlineChatReject");
+        await this.#chatService.cancelCurrentRequestForSession(session.chatModel.sessionResource, "inlineChatReject");
         await session.editingSession.reject();
         session.dispose();
     }
     async continueSessionInChat() {
-        const session = this._currentSession.get();
+        const session = this.#currentSession.get();
         if (!session) {
             return;
         }
-        await this._instaService.invokeFunction(continueInPanelChat, session);
+        await this.#instaService.invokeFunction(continueInPanelChat, session);
     }
     async rephraseSession() {
-        const session = this._currentSession.get();
+        const session = this.#currentSession.get();
         if (!session) {
             return;
         }
+        if (this.#renderMode.get() === "zone") {
+            const requestText = this.#instaService.invokeFunction(rephraseInlineChat, session);
+            if (requestText) {
+                this.#zone.rawValue?.widget.chatWidget.setInput(requestText);
+            }
+            this.#zone.rawValue?.widget.focus();
+            return;
+        }
         const requestText = session.chatModel.getRequests().at(-1)?.message.text;
         session.dispose();
         if (!requestText) {
             return;
         }
-        const selection = this._editor.getSelection();
-        const placeholder = selection && !selection.isEmpty() ? ( localize(9956, "Describe how to change this")) : ( localize(9957, "Describe what to generate"));
+        const selection = this.#editor.getSelection();
+        const placeholder = selection && !selection.isEmpty() ? ( localize(10094, "Describe how to change this")) : ( localize(10095, "Describe what to generate"));
         await this.inputOverlayWidget.showMenuAtSelection(placeholder, requestText);
     }
-    async _selectVendorDefaultModel(session) {
-        const model = this._zone.value.widget.chatWidget.input.selectedLanguageModel.get();
+    async #selectVendorDefaultModel(session) {
+        const model = this.#zone.value.widget.chatWidget.input.selectedLanguageModel.get();
         if (model && !model.metadata.isDefaultForLocation[session.chatModel.initialLocation]) {
-            const ids = await this._languageModelService.selectLanguageModels({
+            const ids = await this.#languageModelService.selectLanguageModels({
                 vendor: model.metadata.vendor
             });
             for (const identifier of ids) {
-                const candidate = this._languageModelService.lookupLanguageModel(identifier);
+                const candidate = this.#languageModelService.lookupLanguageModel(identifier);
                 if (candidate?.isDefaultForLocation[session.chatModel.initialLocation]) {
-                    this._zone.value.widget.chatWidget.input.setCurrentLanguageModel({
+                    this.#zone.value.widget.chatWidget.input.setCurrentLanguageModel({
                         metadata: candidate,
                         identifier
                     });
@@ -575,30 +711,93 @@ let InlineChatController = class InlineChatController {
             }
         }
     }
-    async _applyModelDefaults(session, sessionStore) {
-        const userSelectedModel = InlineChatController_1._userSelectedModel;
-        const defaultModelSetting = this._configurationService.getValue(InlineChatConfigKeys.DefaultModel);
+    async #resolveModelId(location) {
+        const userSelectedModel = InlineChatController_1.#userSelectedModel;
+        const defaultModelSetting = this.#configurationService.getValue(InlineChatConfigKeys.DefaultModel);
+        if (userSelectedModel) {
+            const match = this.#languageModelService.lookupLanguageModelByQualifiedName(userSelectedModel);
+            if (match) {
+                return match.identifier;
+            }
+            InlineChatController_1.#userSelectedModel = undefined;
+        }
+        if (defaultModelSetting) {
+            const match = this.#languageModelService.lookupLanguageModelByQualifiedName(defaultModelSetting);
+            if (match) {
+                return match.identifier;
+            }
+            this.#logService.warn(
+                `inlineChat.defaultModel setting value '${defaultModelSetting}' did not match any available model. Falling back to vendor default.`
+            );
+        }
+        for (const id of this.#languageModelService.getLanguageModelIds()) {
+            const metadata = this.#languageModelService.lookupLanguageModel(id);
+            if (metadata?.isDefaultForLocation[location]) {
+                return id;
+            }
+        }
+        return undefined;
+    }
+    #buildLocationData() {
+        assertType(this.#editor.hasModel());
+        const notebookEditor = this.#notebookEditorService.getNotebookForPossibleCell(this.#editor);
+        if (notebookEditor) {
+            const useNotebookAgent = this.#configurationService.getValue(InlineChatConfigKeys.notebookAgent);
+            if (useNotebookAgent) {
+                return {
+                    location: ChatAgentLocation.Notebook,
+                    locationData: {
+                        type: ChatAgentLocation.Notebook,
+                        sessionInputUri: this.#editor.getModel().uri
+                    }
+                };
+            }
+            return {
+                location: ChatAgentLocation.Notebook,
+                locationData: {
+                    type: ChatAgentLocation.EditorInline,
+                    id: getEditorId(this.#editor, this.#editor.getModel()),
+                    selection: this.#editor.getSelection(),
+                    document: this.#editor.getModel().uri,
+                    wholeRange: this.#editor.getSelection()
+                }
+            };
+        }
+        return {
+            location: ChatAgentLocation.EditorInline,
+            locationData: {
+                type: ChatAgentLocation.EditorInline,
+                id: getEditorId(this.#editor, this.#editor.getModel()),
+                selection: this.#editor.getSelection(),
+                document: this.#editor.getModel().uri,
+                wholeRange: this.#editor.getSelection()
+            }
+        };
+    }
+    async #applyModelDefaults(session, sessionStore) {
+        const userSelectedModel = InlineChatController_1.#userSelectedModel;
+        const defaultModelSetting = this.#configurationService.getValue(InlineChatConfigKeys.DefaultModel);
         let modelApplied = false;
         if (userSelectedModel) {
-            modelApplied = this._zone.value.widget.chatWidget.input.switchModelByQualifiedName([userSelectedModel]);
+            modelApplied = this.#zone.value.widget.chatWidget.input.switchModelByQualifiedName([userSelectedModel]);
             if (!modelApplied) {
-                InlineChatController_1._userSelectedModel = undefined;
+                InlineChatController_1.#userSelectedModel = undefined;
             }
         }
         if (!modelApplied && defaultModelSetting) {
-            modelApplied = this._zone.value.widget.chatWidget.input.switchModelByQualifiedName([defaultModelSetting]);
+            modelApplied = this.#zone.value.widget.chatWidget.input.switchModelByQualifiedName([defaultModelSetting]);
             if (!modelApplied) {
-                this._logService.warn(
+                this.#logService.warn(
                     `inlineChat.defaultModel setting value '${defaultModelSetting}' did not match any available model. Falling back to vendor default.`
                 );
             }
         }
         if (!modelApplied) {
-            await this._selectVendorDefaultModel(session);
+            await this.#selectVendorDefaultModel(session);
         }
         let initialModelId;
         sessionStore.add(autorun(r => {
-            const newModel = this._zone.value.widget.chatWidget.input.selectedLanguageModel.read(r);
+            const newModel = this.#zone.value.widget.chatWidget.input.selectedLanguageModel.read(r);
             if (!newModel) {
                 return;
             }
@@ -607,24 +806,24 @@ let InlineChatController = class InlineChatController {
                 return;
             }
             if (initialModelId !== newModel.identifier) {
-                InlineChatController_1._userSelectedModel = ILanguageModelChatMetadata.asQualifiedName(newModel.metadata);
+                InlineChatController_1.#userSelectedModel = ILanguageModelChatMetadata.asQualifiedName(newModel.metadata);
                 initialModelId = newModel.identifier;
             }
         }));
     }
     async createImageAttachment(attachment) {
-        const value = this._currentSession.get();
+        const value = this.#currentSession.get();
         if (!value) {
             return undefined;
         }
         if (attachment.scheme === Schemas.file) {
-            if (await this._fileService.canHandleResource(attachment)) {
-                return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment);
+            if (await this.#fileService.canHandleResource(attachment)) {
+                return await this.#chatAttachmentResolveService.resolveImageEditorAttachContext(attachment);
             }
         } else if (attachment.scheme === Schemas.http || attachment.scheme === Schemas.https) {
-            const extractedImages = await this._webContentExtractorService.readImage(attachment, CancellationToken.None);
+            const extractedImages = await this.#webContentExtractorService.readImage(attachment, CancellationToken.None);
             if (extractedImages) {
-                return await this._chatAttachmentResolveService.resolveImageEditorAttachContext(attachment, extractedImages);
+                return await this.#chatAttachmentResolveService.resolveImageEditorAttachContext(attachment, extractedImages);
             }
         }
         return undefined;