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

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

@@ -6,8 +6,10 @@ import { $, append, setVisibility, DisposableResizeObserver, getTotalWidth, addD
 import { DEFAULT_FONT_FAMILY } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/fonts';
 import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
 import { renderAsPlaintext, renderMarkdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
-import { ActionBar, ActionsOrientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { ActionsOrientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { WorkbenchActionBar } from '../../../../platform/actions/browser/actionbar.js';
 import { DomScrollableElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { ActionRunner } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
@@ -31,7 +33,6 @@ import { ChatEditingAcceptRejectActionViewItem } from '../../chat/browser/chatEd
 import { CTX_INLINE_CHAT_INPUT_HAS_TEXT, CTX_INLINE_CHAT_INPUT_WIDGET_FOCUSED } from '../common/inlineChat.js';
 import { StickyScrollController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/stickyScroll/browser/stickyScrollController';
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { getSimpleEditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
 import { PlaceholderTextContribution } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/placeholderText/browser/placeholderTextContribution';
@@ -45,38 +46,51 @@ import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/obse
 
 registerCss(inlineChatOverlayWidget);
 let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
+    #domNode;
+    #container;
+    #inputContainer;
+    #toolbarContainer;
+    #input;
+    #position;
+    #showStore;
+    #stickyScrollHeight;
+    #layoutData;
+    #anchorLineNumber;
+    #anchorLeft;
+    #anchorAbove;
+    #editorObs;
+    #historyService;
     constructor(
-        _editorObs,
-        _contextKeyService,
-        _menuService,
+        editorObs,
+        contextKeyService,
+        menuService,
         instantiationService,
         modelService,
         configurationService,
-        _historyService
+        historyService
     ) {
         super();
-        this._editorObs = _editorObs;
-        this._contextKeyService = _contextKeyService;
-        this._menuService = _menuService;
-        this._historyService = _historyService;
-        this._position = observableValue(this, null);
-        this.position = this._position;
-        this._showStore = this._store.add(( new DisposableStore()));
-        this._anchorLineNumber = 0;
-        this._anchorLeft = 0;
-        this._anchorAbove = false;
-        this._domNode = $(".inline-chat-gutter-menu");
-        this._container = append(this._domNode, $(".inline-chat-gutter-container"));
-        this._inputContainer = append(this._container, $(".input"));
-        this._toolbarContainer = append(this._container, $(".toolbar"));
-        const actionsContainer = append(this._domNode, $(".inline-chat-gutter-actions"));
-        const actionBar = this._store.add(( new ActionBar(actionsContainer, {
-            orientation: ActionsOrientation.VERTICAL,
-            preventLoopNavigation: true
-        })));
-        const actionsMenu = this._store.add(
-            this._menuService.createMenu(MenuId.ChatEditorInlineMenu, this._contextKeyService)
+        this.#position = observableValue(this, null);
+        this.position = this.#position;
+        this.#showStore = this._store.add(( new DisposableStore()));
+        this.#anchorLineNumber = 0;
+        this.#anchorLeft = 0;
+        this.#anchorAbove = false;
+        this.#editorObs = editorObs;
+        this.#historyService = historyService;
+        this.#domNode = $(".inline-chat-gutter-menu");
+        this.#container = append(this.#domNode, $(".inline-chat-gutter-container"));
+        this.#inputContainer = append(this.#container, $(".input"));
+        this.#toolbarContainer = append(this.#container, $(".toolbar"));
+        const actionsContainer = append(this.#domNode, $(".inline-chat-gutter-actions"));
+        const actionBar = this._store.add(
+            instantiationService.createInstance(WorkbenchActionBar, actionsContainer, {
+                orientation: ActionsOrientation.VERTICAL,
+                preventLoopNavigation: true,
+                telemetrySource: "inlineChatInput.actionBar"
+            })
         );
+        const actionsMenu = this._store.add(menuService.createMenu(MenuId.ChatEditorInlineMenu, contextKeyService));
         const updateActions = () => {
             const actions = getFlatActionBarActions(actionsMenu.getActions({
                 shouldForwardArgs: true
@@ -116,13 +130,13 @@ let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
             isSimpleWidget: true,
             contributions: EditorExtensionsRegistry.getSomeEditorContributions([PlaceholderTextContribution.ID])
         };
-        this._input = this._store.add(
-            instantiationService.createInstance(CodeEditorWidget, this._inputContainer, options, codeEditorWidgetOptions)
+        this.#input = this._store.add(
+            instantiationService.createInstance(CodeEditorWidget, this.#inputContainer, options, codeEditorWidgetOptions)
         );
         const model = this._store.add(modelService.createModel("", null, ( URI.parse(`gutter-input:${Date.now()}`)), true));
-        this._input.setModel(model);
+        this.#input.setModel(model);
         const toolbar = this._store.add(
-            instantiationService.createInstance(MenuWorkbenchToolBar, this._toolbarContainer, MenuId.InlineChatInput, {
+            instantiationService.createInstance(MenuWorkbenchToolBar, this.#toolbarContainer, MenuId.InlineChatInput, {
                 telemetrySource: "inlineChatInput.toolbar",
                 hiddenItemStrategy: HiddenItemStrategy.NoHide,
                 toolbarOptions: {
@@ -133,8 +147,8 @@ let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
                 }
             })
         );
-        const stickyScrollController = StickyScrollController.get(this._editorObs.editor);
-        this._stickyScrollHeight = stickyScrollController ? observableFromEvent(
+        const stickyScrollController = StickyScrollController.get(this.#editorObs.editor);
+        this.#stickyScrollHeight = stickyScrollController ? observableFromEvent(
             stickyScrollController.onDidChangeStickyScrollHeight,
             () => stickyScrollController.stickyScrollWidgetHeight
         ) : constObservable(0);
@@ -146,22 +160,22 @@ let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
         this._store.add(resizeObserver.observe(toolbar.getElement()));
         const contentWidth = observableFromEvent(
             this,
-            this._input.onDidChangeModelContent,
-            () => this._input.getContentWidth()
+            this.#input.onDidChangeModelContent,
+            () => this.#input.getContentWidth()
         );
         const contentHeight = observableFromEvent(
             this,
-            this._input.onDidContentSizeChange,
-            () => this._input.getContentHeight()
+            this.#input.onDidContentSizeChange,
+            () => this.#input.getContentHeight()
         );
-        this._layoutData = derived(r => {
+        this.#layoutData = derived(r => {
             const editorPad = 6;
             const totalWidth = contentWidth.read(r) + editorPad + toolbarWidth.read(r);
             const minWidth = 220;
             const maxWidth = 600;
             const midWidth = Math.round(maxWidth / 1.618);
             let clampedWidth;
-            if (this._input.getOption(EditorOption.wordWrap) === "on") {
+            if (this.#input.getOption(EditorOption.wordWrap) === "on") {
                 clampedWidth = maxWidth;
             } else if (totalWidth <= minWidth) {
                 clampedWidth = minWidth;
@@ -170,10 +184,10 @@ let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
             } else {
                 clampedWidth = maxWidth;
             }
-            const lineHeight = this._input.getOption(EditorOption.lineHeight);
+            const lineHeight = this.#input.getOption(EditorOption.lineHeight);
             const clampedHeight = Math.min(contentHeight.read(r), (3 * lineHeight));
             if (totalWidth > clampedWidth) {
-                this._input.updateOptions({
+                this.#input.updateOptions({
                     wordWrap: "on"
                 });
             }
@@ -190,47 +204,50 @@ let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
                 toolbarWidth,
                 totalWidth,
                 height
-            } = this._layoutData.read(r);
+            } = this.#layoutData.read(r);
             const inputWidth = totalWidth - toolbarWidth - editorPad;
-            this._container.style.width = `${totalWidth}px`;
-            this._inputContainer.style.width = `${inputWidth}px`;
-            this._input.layout({
+            this.#container.style.width = `${totalWidth}px`;
+            this.#inputContainer.style.width = `${inputWidth}px`;
+            this.#input.layout({
                 width: inputWidth,
                 height
             });
+            if (this.#position.read(undefined) !== null) {
+                this.#updatePosition();
+            }
         }));
         this._store.add(
-            this._input.onDidFocusEditorText(() => this._container.classList.add("focused"))
+            this.#input.onDidFocusEditorText(() => this.#container.classList.add("focused"))
         );
         this._store.add(
-            this._input.onDidBlurEditorText(() => this._container.classList.remove("focused"))
+            this.#input.onDidBlurEditorText(() => this.#container.classList.remove("focused"))
         );
-        this._store.add(this._input.onDidScrollChange(e => {
-            this._toolbarContainer.classList.toggle("fake-scroll-decoration", e.scrollTop > 0);
+        this._store.add(this.#input.onDidScrollChange(e => {
+            this.#toolbarContainer.classList.toggle("fake-scroll-decoration", e.scrollTop > 0);
         }));
-        const inputHasText = CTX_INLINE_CHAT_INPUT_HAS_TEXT.bindTo(this._contextKeyService);
-        this._store.add(this._input.onDidChangeModelContent(() => {
-            inputHasText.set(this._input.getModel().getValue().trim().length > 0);
+        const inputHasText = CTX_INLINE_CHAT_INPUT_HAS_TEXT.bindTo(contextKeyService);
+        this._store.add(this.#input.onDidChangeModelContent(() => {
+            inputHasText.set(this.#input.getModel().getValue().trim().length > 0);
         }));
         this._store.add(toDisposable(() => inputHasText.reset()));
-        const inputWidgetFocused = CTX_INLINE_CHAT_INPUT_WIDGET_FOCUSED.bindTo(this._contextKeyService);
-        this._store.add(this._input.onDidFocusEditorText(() => inputWidgetFocused.set(true)));
-        this._store.add(this._input.onDidBlurEditorText(() => inputWidgetFocused.set(false)));
+        const inputWidgetFocused = CTX_INLINE_CHAT_INPUT_WIDGET_FOCUSED.bindTo(contextKeyService);
+        this._store.add(this.#input.onDidFocusEditorText(() => inputWidgetFocused.set(true)));
+        this._store.add(this.#input.onDidBlurEditorText(() => inputWidgetFocused.set(false)));
         this._store.add(toDisposable(() => inputWidgetFocused.reset()));
-        this._store.add(this._input.onKeyDown(e => {
+        this._store.add(this.#input.onKeyDown(e => {
             if (e.keyCode === KeyCode.UpArrow) {
-                const position = this._input.getPosition();
+                const position = this.#input.getPosition();
                 if (position && position.lineNumber === 1) {
-                    this._showPreviousHistoryValue();
+                    this.#showPreviousHistoryValue();
                     e.preventDefault();
                     e.stopPropagation();
                 }
             } else if (e.keyCode === KeyCode.DownArrow) {
-                const model = this._input.getModel();
-                const position = this._input.getPosition();
+                const model = this.#input.getModel();
+                const position = this.#input.getPosition();
                 if (position && position.lineNumber === model.getLineCount()) {
-                    if (!this._historyService.isAtEnd()) {
-                        this._showNextHistoryValue();
+                    if (!this.#historyService.isAtEnd()) {
+                        this.#showNextHistoryValue();
                         e.preventDefault();
                         e.stopPropagation();
                     } else if (!actionBar.isEmpty()) {
@@ -252,160 +269,177 @@ let InlineChatInputWidget = class InlineChatInputWidget extends Disposable {
                 if (firstItem?.element && isAncestorOfActiveElement(firstItem.element)) {
                     event.preventDefault();
                     event.stopPropagation();
-                    this._input.focus();
+                    this.#input.focus();
                 }
             }
         }, true));
-        const focusTracker = this._store.add(trackFocus(this._domNode));
+        const focusTracker = this._store.add(trackFocus(this.#domNode));
         this._store.add(focusTracker.onDidBlur(() => this.hide()));
     }
     get value() {
-        return this._input.getModel().getValue().trim();
+        return this.#input.getModel().getValue().trim();
     }
     addToHistory(value) {
-        this._historyService.addToHistory(value);
+        this.#historyService.addToHistory(value);
     }
-    _showPreviousHistoryValue() {
-        if (this._historyService.isAtEnd()) {
-            this._historyService.replaceLast(this._input.getModel().getValue());
+    #showPreviousHistoryValue() {
+        if (this.#historyService.isAtEnd()) {
+            this.#historyService.replaceLast(this.#input.getModel().getValue());
         }
-        const value = this._historyService.previousValue();
+        const value = this.#historyService.previousValue();
         if (value !== undefined) {
-            this._input.getModel().setValue(value);
+            this.#input.getModel().setValue(value);
         }
     }
-    _showNextHistoryValue() {
-        if (this._historyService.isAtEnd()) {
+    #showNextHistoryValue() {
+        if (this.#historyService.isAtEnd()) {
             return;
         }
-        const value = this._historyService.nextValue();
+        const value = this.#historyService.nextValue();
         if (value !== undefined) {
-            this._input.getModel().setValue(value);
+            this.#input.getModel().setValue(value);
         }
     }
     show(lineNumber, left, anchorAbove, placeholder, value) {
-        this._showStore.clear();
-        this._historyService.resetCursor();
-        this._input.updateOptions({
+        this.#showStore.clear();
+        this.#historyService.resetCursor();
+        this.#input.updateOptions({
             wordWrap: "off",
             placeholder
         });
-        this._input.getModel().setValue(value ?? "");
-        this._anchorLineNumber = lineNumber;
-        this._anchorLeft = left;
-        this._anchorAbove = anchorAbove;
-        this._updatePosition();
-        this._showStore.add(this._editorObs.createOverlayWidget({
-            domNode: this._domNode,
-            position: this._position,
+        this.#input.getModel().setValue(value ?? "");
+        this.#anchorLineNumber = lineNumber;
+        this.#anchorLeft = left;
+        this.#anchorAbove = anchorAbove;
+        this.#updatePosition();
+        this.#showStore.add(this.#editorObs.createOverlayWidget({
+            domNode: this.#domNode,
+            position: this.#position,
             minContentWidthInPx: constObservable(0),
             allowEditorOverflow: true
         }));
-        if (anchorAbove) {
-            this._updatePosition();
-        }
-        this._showStore.add(this._editorObs.editor.onDidScrollChange(() => {
-            const visibleRanges = this._editorObs.editor.getVisibleRanges();
+        this.#updatePosition();
+        this.#showStore.add(this.#editorObs.editor.onDidScrollChange(() => {
+            const visibleRanges = this.#editorObs.editor.getVisibleRanges();
             const isLineVisible = ( visibleRanges.some(
-                range => this._anchorLineNumber >= range.startLineNumber && this._anchorLineNumber <= range.endLineNumber
+                range => this.#anchorLineNumber >= range.startLineNumber && this.#anchorLineNumber <= range.endLineNumber
             ));
-            const hasContent = !!this._input.getModel().getValue();
+            const hasContent = !!this.#input.getModel().getValue();
             if (!isLineVisible && !hasContent) {
                 this.hide();
             } else {
-                this._updatePosition();
+                this.#updatePosition();
             }
         }));
+        this.#showStore.add(this.#editorObs.editor.onDidLayoutChange(() => {
+            this.#updatePosition();
+        }));
         setTimeout(() => {
-            this._input.focus();
+            this.#input.focus();
             if (value) {
-                this._input.setSelection(this._input.getModel().getFullModelRange());
+                this.#input.setSelection(this.#input.getModel().getFullModelRange());
             }
         }, 0);
     }
-    _updatePosition() {
-        const editor = this._editorObs.editor;
+    #updatePosition() {
+        const editor = this.#editorObs.editor;
         const lineHeight = editor.getOption(EditorOption.lineHeight);
-        const top = editor.getTopForLineNumber(this._anchorLineNumber) - editor.getScrollTop();
+        const top = editor.getTopForLineNumber(this.#anchorLineNumber) - editor.getScrollTop();
         let adjustedTop = top;
-        if (this._anchorAbove) {
-            const widgetHeight = this._domNode.offsetHeight;
+        if (this.#anchorAbove) {
+            const widgetHeight = this.#domNode.offsetHeight;
             adjustedTop = top - widgetHeight;
         } else {
             adjustedTop = top + lineHeight;
         }
-        const stickyScrollHeight = this._stickyScrollHeight.get();
+        const stickyScrollHeight = this.#stickyScrollHeight.get();
         const layoutInfo = editor.getLayoutInfo();
-        const widgetHeight = this._domNode.offsetHeight;
+        const widgetHeight = this.#domNode.offsetHeight;
+        const widgetWidth = this.#domNode.offsetWidth;
         const minTop = stickyScrollHeight;
         const maxTop = layoutInfo.height - widgetHeight;
+        const padding = 8;
+        const maxLeft = layoutInfo.width - layoutInfo.verticalScrollbarWidth - layoutInfo.minimap.minimapWidth - widgetWidth - padding;
         const clampedTop = Math.max(minTop, Math.min(adjustedTop, maxTop));
-        const isClamped = clampedTop !== adjustedTop;
-        this._domNode.classList.toggle("clamped", isClamped);
-        this._position.set({
+        const clampedLeft = Math.max(0, Math.min(this.#anchorLeft, maxLeft));
+        const isClamped = clampedTop !== adjustedTop || clampedLeft !== this.#anchorLeft;
+        this.#domNode.classList.toggle("clamped", isClamped);
+        this.#position.set({
             preference: {
                 top: clampedTop,
-                left: this._anchorLeft
+                left: clampedLeft
             },
             stackOrdinal: 10000
         }, undefined);
     }
     hide() {
-        const editorDomNode = this._editorObs.editor.getDomNode();
+        const editorDomNode = this.#editorObs.editor.getDomNode();
         if (editorDomNode && isAncestorOfActiveElement(editorDomNode)) {
-            this._editorObs.editor.focus();
+            this.#editorObs.editor.focus();
         }
-        this._position.set(null, undefined);
-        this._input.getModel().setValue("");
-        this._showStore.clear();
+        this.#position.set(null, undefined);
+        this.#input.getModel().setValue("");
+        this.#showStore.clear();
     }
 };
 InlineChatInputWidget = ( __decorate([( __param(1, IContextKeyService)), ( __param(2, IMenuService)), ( __param(3, IInstantiationService)), ( __param(4, IModelService)), ( __param(5, IConfigurationService)), ( __param(6, IInlineChatHistoryService))], InlineChatInputWidget));
 let InlineChatSessionOverlayWidget = class InlineChatSessionOverlayWidget extends Disposable {
-    constructor(_editorObs, _instaService, _keybindingService, _logService) {
+    #domNode = createElement("div");
+    #container;
+    #markdownContainer;
+    #markdownMessage;
+    #markdownScrollable;
+    #contentRow;
+    #statusNode;
+    #icon;
+    #message;
+    #toolbarNode;
+    #showStore = this._store.add(( new DisposableStore()));
+    #position = observableValue(this, null);
+    #minContentWidthInPx = constObservable(0);
+    #stickyScrollHeight;
+    #editorObs;
+    #instaService;
+    #keybindingService;
+    constructor(editorObs, instaService, keybindingService) {
         super();
-        this._editorObs = _editorObs;
-        this._instaService = _instaService;
-        this._keybindingService = _keybindingService;
-        this._logService = _logService;
-        this._domNode = createElement("div");
-        this._showStore = this._store.add(( new DisposableStore()));
-        this._position = observableValue(this, null);
-        this._minContentWidthInPx = constObservable(0);
-        this._domNode.classList.add("inline-chat-session-overlay-widget");
-        this._container = createElement("div");
-        this._domNode.appendChild(this._container);
-        this._container.classList.add("inline-chat-session-overlay-container");
-        this._markdownContainer = createElement("div");
-        this._markdownContainer.classList.add("markdown-scroll-container");
-        this._markdownMessage = createElement("div");
-        this._markdownMessage.classList.add("markdown-message");
-        this._markdownContainer.appendChild(this._markdownMessage);
-        this._markdownScrollable = this._store.add(( new DomScrollableElement(this._markdownContainer, {
+        this.#editorObs = editorObs;
+        this.#instaService = instaService;
+        this.#keybindingService = keybindingService;
+        this.#domNode.classList.add("inline-chat-session-overlay-widget");
+        this.#container = createElement("div");
+        this.#domNode.appendChild(this.#container);
+        this.#container.classList.add("inline-chat-session-overlay-container");
+        this.#markdownContainer = createElement("div");
+        this.#markdownContainer.classList.add("markdown-scroll-container");
+        this.#markdownMessage = createElement("div");
+        this.#markdownMessage.classList.add("markdown-message");
+        this.#markdownContainer.appendChild(this.#markdownMessage);
+        this.#markdownScrollable = this._store.add(( new DomScrollableElement(this.#markdownContainer, {
             consumeMouseWheelIfScrollbarIsNeeded: true,
             horizontal: ScrollbarVisibility.Hidden,
             vertical: ScrollbarVisibility.Auto
         })));
-        this._container.appendChild(this._markdownScrollable.getDomNode());
-        this._contentRow = createElement("div");
-        this._contentRow.classList.add("content-row");
-        this._container.appendChild(this._contentRow);
-        this._statusNode = createElement("div");
-        this._statusNode.classList.add("status");
-        this._icon = append(this._statusNode, $("span"));
-        this._message = append(this._statusNode, $("span.message"));
-        this._contentRow.appendChild(this._statusNode);
-        this._toolbarNode = createElement("div");
-        this._toolbarNode.classList.add("toolbar");
-        const stickyScrollController = StickyScrollController.get(this._editorObs.editor);
-        this._stickyScrollHeight = stickyScrollController ? observableFromEvent(
+        this.#container.appendChild(this.#markdownScrollable.getDomNode());
+        this.#contentRow = createElement("div");
+        this.#contentRow.classList.add("content-row");
+        this.#container.appendChild(this.#contentRow);
+        this.#statusNode = createElement("div");
+        this.#statusNode.classList.add("status");
+        this.#icon = append(this.#statusNode, $("span"));
+        this.#message = append(this.#statusNode, $("span.message"));
+        this.#contentRow.appendChild(this.#statusNode);
+        this.#toolbarNode = createElement("div");
+        this.#toolbarNode.classList.add("toolbar");
+        const stickyScrollController = StickyScrollController.get(this.#editorObs.editor);
+        this.#stickyScrollHeight = stickyScrollController ? observableFromEvent(
             stickyScrollController.onDidChangeStickyScrollHeight,
             () => stickyScrollController.stickyScrollWidgetHeight
         ) : constObservable(0);
     }
     show(session) {
-        assertType(this._editorObs.editor.hasModel());
-        this._showStore.clear();
+        assertType(this.#editorObs.editor.hasModel());
+        this.#showStore.clear();
         const entry = derived(r => session.editingSession.readEntry(session.uri, r));
         const requestMessage = derived(r => {
             const chatModel = session?.chatModel;
@@ -422,7 +456,7 @@ let InlineChatSessionOverlayWidget = class InlineChatSessionOverlayWidget extend
             const response = chatModel.lastRequestObs.read(r)?.response;
             if (!response) {
                 return {
-                    message: ( localize(9960, "Working...")),
+                    message: ( localize(10098, "Working...")),
                     icon: ThemeIcon.modify(Codicon.loading, "spin")
                 };
             }
@@ -430,20 +464,20 @@ let InlineChatSessionOverlayWidget = class InlineChatSessionOverlayWidget extend
                 const result = response.result;
                 if (result?.errorDetails) {
                     return {
-                        message: ( localize(9961, "Sorry, your request failed")),
+                        message: ( localize(10099, "Sorry, your request failed")),
                         icon: Codicon.error
                     };
                 }
                 const changes = entry.read(r)?.changesCount.read(r) ?? 0;
                 return {
-                    message: changes === 0 ? ( localize(9962, "Done")) : changes === 1 ? ( localize(9963, "Done, 1 change")) : ( localize(9964, "Done, {0} changes", changes)),
+                    message: changes === 0 ? ( localize(10100, "Done")) : changes === 1 ? ( localize(10101, "Done, 1 change")) : ( localize(10102, "Done, {0} changes", changes)),
                     icon: Codicon.check
                 };
             }
             const pendingConfirmation = response.isPendingConfirmation.read(r);
             if (pendingConfirmation) {
                 return {
-                    message: ( localize(9965, "Sorry, but an expected error happened")),
+                    message: ( localize(10103, "Sorry, but an unexpected error happened")),
                     icon: Codicon.error
                 };
             }
@@ -462,62 +496,62 @@ let InlineChatSessionOverlayWidget = class InlineChatSessionOverlayWidget extend
                 };
             } else {
                 return {
-                    message: ( localize(9960, "Working...")),
+                    message: ( localize(10098, "Working...")),
                     icon: ThemeIcon.modify(Codicon.loading, "spin")
                 };
             }
         });
-        const markdownStore = this._showStore.add(( new DisposableStore()));
-        this._showStore.add(autorun(r => {
+        const markdownStore = this.#showStore.add(( new DisposableStore()));
+        this.#showStore.add(autorun(r => {
             const value = requestMessage.read(r);
             if (value) {
                 if (value.message && value.icon) {
-                    this._message.innerText = renderAsPlaintext(value.message);
-                    this._icon.className = "";
-                    this._icon.classList.add(...ThemeIcon.asClassNameArray(value.icon));
-                    this._statusNode.classList.remove("hidden");
-                    this._contentRow.classList.remove("status-hidden");
+                    this.#message.innerText = renderAsPlaintext(value.message);
+                    this.#icon.className = "";
+                    this.#icon.classList.add(...ThemeIcon.asClassNameArray(value.icon));
+                    this.#statusNode.classList.remove("hidden");
+                    this.#contentRow.classList.remove("status-hidden");
                 } else {
-                    this._message.innerText = "";
-                    this._icon.className = "";
-                    this._statusNode.classList.add("hidden");
-                    this._contentRow.classList.add("status-hidden");
+                    this.#message.innerText = "";
+                    this.#icon.className = "";
+                    this.#statusNode.classList.add("hidden");
+                    this.#contentRow.classList.add("status-hidden");
                 }
                 markdownStore.clear();
-                this._markdownMessage.replaceChildren();
+                this.#markdownMessage.replaceChildren();
                 if (value.markdown) {
-                    this._markdownScrollable.getDomNode().classList.remove("hidden");
+                    this.#markdownScrollable.getDomNode().classList.remove("hidden");
                     const markdown = typeof value.markdown === "string" ? ( new MarkdownString(value.markdown)) : value.markdown;
                     const rendered = markdownStore.add(renderMarkdown(markdown));
-                    this._markdownMessage.appendChild(rendered.element);
-                    this._markdownScrollable.scanDomNode();
+                    this.#markdownMessage.appendChild(rendered.element);
+                    this.#markdownScrollable.scanDomNode();
                 } else {
-                    this._markdownScrollable.getDomNode().classList.add("hidden");
+                    this.#markdownScrollable.getDomNode().classList.add("hidden");
                 }
             } else {
-                this._message.innerText = "";
-                this._icon.className = "";
-                this._statusNode.classList.add("hidden");
-                this._contentRow.classList.add("status-hidden");
+                this.#message.innerText = "";
+                this.#icon.className = "";
+                this.#statusNode.classList.add("hidden");
+                this.#contentRow.classList.add("status-hidden");
                 markdownStore.clear();
-                this._markdownMessage.replaceChildren();
-                this._markdownScrollable.getDomNode().classList.add("hidden");
-            }
-        }));
-        this._showStore.add(autorun(r => {
-            const response = session.chatModel.lastRequestObs.read(r)?.response;
-            const pending = response?.isPendingConfirmation.read(r);
-            if (pending) {
-                this._logService.info(`[InlineChat] UNEXPECTED approval needed: ${pending.detail ?? "unknown"}`);
+                this.#markdownMessage.replaceChildren();
+                this.#markdownScrollable.getDomNode().classList.add("hidden");
             }
         }));
-        this._contentRow.appendChild(this._toolbarNode);
-        this._showStore.add(toDisposable(() => this._toolbarNode.remove()));
+        this.#contentRow.appendChild(this.#toolbarNode);
+        this.#showStore.add(toDisposable(() => this.#toolbarNode.remove()));
         const that = this;
-        this._showStore.add(
-            this._instaService.createInstance(MenuWorkbenchToolBar, this._toolbarNode, MenuId.ChatEditorInlineExecute, {
+        const actionRunner = this.#showStore.add(new (class extends ActionRunner {
+            async runAction(action, context) {
+                that.#editorObs.editor.focus();
+                return super.runAction(action, context);
+            }
+        })());
+        this.#showStore.add(
+            this.#instaService.createInstance(MenuWorkbenchToolBar, this.#toolbarNode, MenuId.ChatEditorInlineExecute, {
                 telemetrySource: "inlineChatProgress.overlayToolbar",
                 hiddenItemStrategy: HiddenItemStrategy.Ignore,
+                actionRunner,
                 toolbarOptions: {
                     primaryGroup: () => true,
                     useSeparatorsInPrimaryActions: true
@@ -534,31 +568,31 @@ let InlineChatSessionOverlayWidget = class InlineChatSessionOverlayWidget extend
                     return ( new ChatEditingAcceptRejectActionViewItem(action, {
                         ...options,
                         keybinding: undefined
-                    }, entry, undefined, that._keybindingService, primaryActions));
+                    }, entry, undefined, that.#keybindingService, primaryActions));
                 }
             })
         );
-        const lineHeight = this._editorObs.getOption(EditorOption.lineHeight);
+        const lineHeight = this.#editorObs.getOption(EditorOption.lineHeight);
         const widgetWidth = observableValue(this, 0);
         const resizeObserver = new DisposableResizeObserver(() => {
-            widgetWidth.set(this._domNode.offsetWidth, undefined);
+            widgetWidth.set(this.#domNode.offsetWidth, undefined);
         });
-        this._showStore.add(resizeObserver);
-        this._showStore.add(resizeObserver.observe(this._domNode));
-        this._showStore.add(autorun(r => {
-            const layoutInfo = this._editorObs.layoutInfo.read(r);
-            const stickyScrollHeight = this._stickyScrollHeight.read(r);
+        this.#showStore.add(resizeObserver);
+        this.#showStore.add(resizeObserver.observe(this.#domNode));
+        this.#showStore.add(autorun(r => {
+            const layoutInfo = this.#editorObs.layoutInfo.read(r);
+            const stickyScrollHeight = this.#stickyScrollHeight.read(r);
             const width = widgetWidth.read(r);
             const padding = Math.round(lineHeight.read(r) * 2 / 3);
             const maxWidth = Math.min(400, layoutInfo.contentWidth - 2 * padding);
             const maxHeight = Math.min(150, Math.floor(layoutInfo.height / 3));
-            this._domNode.style.maxWidth = `${maxWidth}px`;
-            this._markdownScrollable.getDomNode().style.maxHeight = `${maxHeight}px`;
-            this._markdownContainer.style.maxHeight = `${maxHeight}px`;
-            this._markdownScrollable.scanDomNode();
+            this.#domNode.style.maxWidth = `${maxWidth}px`;
+            this.#markdownScrollable.getDomNode().style.maxHeight = `${maxHeight}px`;
+            this.#markdownContainer.style.maxHeight = `${maxHeight}px`;
+            this.#markdownScrollable.scanDomNode();
             const top = stickyScrollHeight + padding;
             const left = layoutInfo.width - width - layoutInfo.verticalScrollbarWidth - layoutInfo.minimap.minimapWidth - padding;
-            this._position.set({
+            this.#position.set({
                 preference: {
                     top,
                     left
@@ -566,18 +600,18 @@ let InlineChatSessionOverlayWidget = class InlineChatSessionOverlayWidget extend
                 stackOrdinal: 10000
             }, undefined);
         }));
-        this._showStore.add(this._editorObs.createOverlayWidget({
-            domNode: this._domNode,
-            position: this._position,
-            minContentWidthInPx: this._minContentWidthInPx,
+        this.#showStore.add(this.#editorObs.createOverlayWidget({
+            domNode: this.#domNode,
+            position: this.#position,
+            minContentWidthInPx: this.#minContentWidthInPx,
             allowEditorOverflow: false
         }));
     }
     hide() {
-        this._position.set(null, undefined);
-        this._showStore.clear();
+        this.#position.set(null, undefined);
+        this.#showStore.clear();
     }
 };
-InlineChatSessionOverlayWidget = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IKeybindingService)), ( __param(3, ILogService))], InlineChatSessionOverlayWidget));
+InlineChatSessionOverlayWidget = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IKeybindingService))], InlineChatSessionOverlayWidget));
 
 export { InlineChatInputWidget, InlineChatSessionOverlayWidget };