@codingame/monaco-vscode-api 9.0.2 → 10.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatInputPart.js

@@ -1,35 +1,43 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { append, clearNode, setVisibility, isKeyboardEvent, Dimension, getTotalWidth, $ as $$1 } from '../../../../base/browser/dom.js';
+import { h, append, addStandardDisposableListener, clearNode, setVisibility, $ as $$1, isKeyboardEvent, Dimension, getTotalWidth, addDisposableListener, reset, EventType } from '../../../../base/browser/dom.js';
 import { DEFAULT_FONT_FAMILY } from '../../../../base/browser/fonts.js';
 import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
 import { status } from '../../../../base/browser/ui/aria/aria.js';
 import { Button } from '../../../../base/browser/ui/button/button.js';
+import { createInstantHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { renderLabelWithIcons } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { ProgressBar } from '../../../../base/browser/ui/progressbar/progressbar.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { HistoryNavigator2 } from '../../../../base/common/history.js';
-import { KeyCode } from '../../../../base/common/keyCodes.js';
-import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { Disposable, DisposableStore, MutableDisposable } from '../../../../base/common/lifecycle.js';
 import { basename, dirname } from '../../../../base/common/path.js';
 import { isMacintosh } from '../../../../base/common/platform.js';
 import { URI } from '../../../../base/common/uri.js';
 import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
 import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { EditorOptions } from '../../../../editor/common/config/editorOptions.js';
 import { Range } from '../../../../editor/common/core/range.js';
 import { IModelService } from '../../../../editor/common/services/model.js';
-import { ContentHoverController } from '../../../../editor/contrib/hover/browser/contentHoverController2.js';
-import { MarginHoverController } from '../../../../editor/contrib/hover/browser/marginHoverController.js';
+import { CopyPasteController } from '../../../../editor/contrib/dropOrPasteInto/browser/copyPasteController.js';
+import { ContentHoverController } from '../../../../editor/contrib/hover/browser/contentHoverController.js';
+import { GlyphHoverController } from '../../../../editor/contrib/hover/browser/glyphHoverController.js';
+import { SuggestController } from '../../../../editor/contrib/suggest/browser/suggestController.js';
 import { localize } from '../../../../nls.js';
 import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
 import { DropdownWithPrimaryActionViewItem } from '../../../../platform/actions/browser/dropdownWithPrimaryActionViewItem.js';
-import { createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
-import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../platform/actions/browser/toolbar.js';
-import { MenuItemAction, MenuId } from '../../../../platform/actions/common/actions.js';
+import { MenuEntryActionViewItem, createAndFillInActionBarActions } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction } from '../../../../platform/actions/common/actions.js';
 import { IMenuService } from '../../../../platform/actions/common/actions.service.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
 import { FileKind } from '../../../../platform/files/common/files.js';
+import { IFileService } from '../../../../platform/files/common/files.service.js';
 import { registerAndCreateHistoryNavigationContext } from '../../../../platform/history/browser/contextScopedHistoryWidget.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
@@ -37,15 +45,17 @@ import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
 import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
 import { ResourceLabels } from '../../../browser/labels.js';
-import { AccessibilityVerbositySettingId } from '../../accessibility/browser/accessibilityConfiguration.js';
-import { AccessibilityCommandId } from '../../accessibility/common/accessibilityCommands.js';
-import { SubmitAction, CancelAction, ChatSubmitSecondaryAgentAction } from './actions/chatExecuteActions.js';
-import { ChatFollowups } from './chatFollowups.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { getSimpleEditorOptions, getSimpleCodeEditorWidgetOptions, setupSimpleEditorSelectionStyling } from '../../codeEditor/browser/simpleEditorOptions.js';
 import { ChatAgentLocation } from '../common/chatAgents.js';
 import { IChatAgentService } from '../common/chatAgents.service.js';
 import { CONTEXT_CHAT_INPUT_HAS_TEXT, CONTEXT_CHAT_INPUT_CURSOR_AT_TOP, CONTEXT_CHAT_INPUT_HAS_FOCUS, CONTEXT_IN_CHAT_INPUT } from '../common/chatContextKeys.js';
 import { IChatWidgetHistoryService } from '../common/chatWidgetHistoryService.service.js';
-import { getSimpleEditorOptions, getSimpleCodeEditorWidgetOptions, setupSimpleEditorSelectionStyling } from '../../codeEditor/browser/simpleEditorOptions.js';
+import { ILanguageModelsService } from '../common/languageModels.service.js';
+import { SubmitAction, CancelAction, ChatModelPickerActionId, ChatSubmitSecondaryAgentAction } from './actions/chatExecuteActions.js';
+import { CollapsibleListPool } from './chatContentParts/chatReferencesContentPart.js';
+import { ChatEditingShowChangesAction, ChatEditingDiscardAllAction, ChatEditingAcceptAllAction } from './chatEditingService.js';
+import { ChatFollowups } from './chatFollowups.js';
 var ChatInputPart_1;
 const $ = $$1;
 const INPUT_EDITOR_MAX_HEIGHT = 250;
@@ -59,11 +69,28 @@ let ChatInputPart = class ChatInputPart extends Disposable {
     get inputPartHeight() {
         return this._inputPartHeight;
     }
+    get followupsHeight() {
+        return this._followupsHeight;
+    }
     get inputEditor() {
         return this._inputEditor;
     }
+    get currentLanguageModel() {
+        return this._currentLanguageModel;
+    }
+    get selectedElements() {
+        const edits = [];
+        const editsList = this._chatEditList?.object;
+        const selectedElements = editsList?.getSelectedElements() ?? [];
+        for (const element of selectedElements) {
+            if (element.kind === 'reference' && URI.isUri(element.reference)) {
+                edits.push(element.reference);
+            }
+        }
+        return edits;
+    }
     constructor(
-    location, options, getInputState, historyService, modelService, instantiationService, contextKeyService, configurationService, keybindingService, accessibilityService, logService) {
+    location, options, getInputState, historyService, modelService, instantiationService, contextKeyService, configurationService, keybindingService, accessibilityService, languageModelsService, logService, hoverService, fileService, commandService, editorService) {
         super();
         this.location = location;
         this.options = options;
@@ -75,7 +102,12 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         this.configurationService = configurationService;
         this.keybindingService = keybindingService;
         this.accessibilityService = accessibilityService;
+        this.languageModelsService = languageModelsService;
         this.logService = logService;
+        this.hoverService = hoverService;
+        this.fileService = fileService;
+        this.commandService = commandService;
+        this.editorService = editorService;
         this._onDidLoadInputState = this._register(( (new Emitter())));
         this.onDidLoadInputState = this._onDidLoadInputState.event;
         this._onDidChangeHeight = this._register(( (new Emitter())));
@@ -96,8 +128,13 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         this.followupsDisposables = this._register(( (new DisposableStore())));
         this.attachedContextDisposables = this._register(( (new DisposableStore())));
         this._inputPartHeight = 0;
+        this._followupsHeight = 0;
         this.inHistoryNavigation = false;
+        this._waitForPersistedLanguageModel = this._register(( (new MutableDisposable())));
+        this._onDidChangeCurrentLanguageModel = ( (new Emitter()));
         this.inputUri = ( (URI.parse(`${ChatInputPart_1.INPUT_SCHEME}:input-${ChatInputPart_1._counter++}`)));
+        this._chatEditsActionsDisposables = this._register(( (new DisposableStore())));
+        this._chatEditsDisposables = this._register(( (new DisposableStore())));
         this.inputEditorMaxHeight = this.options.renderStyle === 'compact' ? INPUT_EDITOR_MAX_HEIGHT / 3 : INPUT_EDITOR_MAX_HEIGHT;
         this.inputEditorHasText = CONTEXT_CHAT_INPUT_HAS_TEXT.bindTo(contextKeyService);
         this.chatCursorAtTop = CONTEXT_CHAT_INPUT_CURSOR_AT_TOP.bindTo(contextKeyService);
@@ -105,10 +142,26 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         this.history = this.loadHistory();
         this._register(this.historyService.onDidClearHistory(() => this.history = ( (new HistoryNavigator2([{ text: '' }], 50, historyKeyFn)))));
         this._register(this.configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(AccessibilityVerbositySettingId.Chat)) {
+            if (e.affectsConfiguration("accessibility.verbosity.panelChat" )) {
                 this.inputEditor.updateOptions({ ariaLabel: this._getAriaLabel() });
             }
         }));
+        this._chatEditsListPool = this._register(this.instantiationService.createInstance(CollapsibleListPool, this._onDidChangeVisibility.event, MenuId.ChatEditingSessionWidgetToolbar, { enableFileDecorations: true }));
+    }
+    setCurrentLanguageModelToDefault() {
+        const defaultLanguageModel = this.languageModelsService.getLanguageModelIds().find(id => this.languageModelsService.lookupLanguageModel(id)?.isDefault);
+        const hasUserSelectableLanguageModels = this.languageModelsService.getLanguageModelIds().find(id => {
+            const model = this.languageModelsService.lookupLanguageModel(id);
+            return model?.isUserSelectable && !model.isDefault;
+        });
+        this._currentLanguageModel = hasUserSelectableLanguageModels ? defaultLanguageModel : undefined;
+    }
+    setCurrentLanguageModelByUser(modelId) {
+        this._currentLanguageModel = modelId;
+        this._waitForPersistedLanguageModel.clear();
+        if (this.cachedDimensions) {
+            this.layout(this.cachedDimensions.height, this.cachedDimensions.width);
+        }
     }
     loadHistory() {
         const history = this.historyService.getHistory(this.location);
@@ -120,19 +173,19 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         );
     }
     _getAriaLabel() {
-        const verbose = this.configurationService.getValue(AccessibilityVerbositySettingId.Chat);
+        const verbose = this.configurationService.getValue("accessibility.verbosity.panelChat" );
         if (verbose) {
-            const kbLabel = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+            const kbLabel = this.keybindingService.lookupKeybinding("editor.action.accessibilityHelp" )?.getLabel();
             return kbLabel ? ( localize(
-                6989,
+                7175,
                 "Chat Input,  Type to ask questions or type / for topics, press enter to send out the request. Use {0} for Chat Accessibility Help.",
                 kbLabel
             )) : ( localize(
-                6990,
+                7176,
                 "Chat Input,  Type code here and press Enter to run. Use the Chat Accessibility Help command for more information."
             ));
         }
-        return ( localize(6991, "Chat Input"));
+        return ( localize(7177, "Chat Input"));
     }
     updateState(inputState) {
         if (this.inHistoryNavigation) {
@@ -147,11 +200,33 @@ let ChatInputPart = class ChatInputPart extends Disposable {
             this.history.resetCursor();
         }
     }
-    initForNewChatModel(inputValue, inputState) {
+    initForNewChatModel(state) {
         this.history = this.loadHistory();
-        this.history.add({ text: inputValue ?? this.history.current().text, state: inputState });
-        if (inputValue) {
-            this.setValue(inputValue, false);
+        this.history.add({
+            text: state.inputValue ?? this.history.current().text,
+            state: state.inputState ?? this.getInputState()
+        });
+        if (state.inputValue) {
+            this.setValue(state.inputValue, false);
+        }
+        if (state.selectedLanguageModelId) {
+            const model = this.languageModelsService.lookupLanguageModel(state.selectedLanguageModelId);
+            if (model) {
+                this._currentLanguageModel = state.selectedLanguageModelId;
+                this._onDidChangeCurrentLanguageModel.fire(this._currentLanguageModel);
+            }
+            else {
+                this._waitForPersistedLanguageModel.value = this.languageModelsService.onDidChangeLanguageModels(e => {
+                    const persistedModel = e.added?.find(m => m.identifier === state.selectedLanguageModelId);
+                    if (persistedModel) {
+                        this._waitForPersistedLanguageModel.clear();
+                        if (persistedModel.metadata.isUserSelectable) {
+                            this._currentLanguageModel = state.selectedLanguageModelId;
+                            this._onDidChangeCurrentLanguageModel.fire(this._currentLanguageModel);
+                        }
+                    }
+                });
+            }
         }
     }
     logInputHistory() {
@@ -198,14 +273,21 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         this.setValue(historyEntry.text, true);
         this.inHistoryNavigation = false;
         this._onDidLoadInputState.fire(historyEntry.state);
+        const model = this._inputEditor.getModel();
+        if (!model) {
+            return;
+        }
         if (previous) {
-            this._inputEditor.setPosition({ lineNumber: 1, column: 1 });
+            const endOfFirstViewLine = this._inputEditor._getViewModel()?.getLineLength(1) ?? 1;
+            const endOfFirstModelLine = model.getLineLength(1);
+            if (endOfFirstViewLine === endOfFirstModelLine) {
+                this._inputEditor.setPosition({ lineNumber: 1, column: endOfFirstViewLine + 1 });
+            }
+            else {
+                this._inputEditor.setPosition({ lineNumber: 1, column: endOfFirstViewLine });
+            }
         }
         else {
-            const model = this._inputEditor.getModel();
-            if (!model) {
-                return;
-            }
             this._inputEditor.setPosition(getLastPosition(model));
         }
     }
@@ -272,23 +354,47 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         }
     }
     render(container, initialValue, widget) {
-        this.container = append(container, $('.interactive-input-part'));
-        this.container.classList.toggle('compact', this.options.renderStyle === 'compact');
-        let inputContainer;
-        let inputAndSideToolbar;
+        let elements;
         if (this.options.renderStyle === 'compact') {
-            inputAndSideToolbar = append(this.container, $('.interactive-input-and-side-toolbar'));
-            this.followupsContainer = append(this.container, $('.interactive-input-followups'));
-            inputContainer = append(inputAndSideToolbar, $('.interactive-input-and-execute-toolbar'));
-            this.attachedContextContainer = append(this.container, $('.chat-attached-context'));
+            elements = h('.interactive-input-part', [
+                h('.interactive-input-and-edit-session', [
+                    h('.chat-editing-session@chatEditingSessionWidgetContainer'),
+                    h('.interactive-input-and-side-toolbar@inputAndSideToolbar', [
+                        h('.chat-input-container@inputContainer', [
+                            h('.chat-editor-container@editorContainer'),
+                            h('.chat-input-toolbars@inputToolbars'),
+                        ]),
+                    ]),
+                    h('.chat-attached-context@attachedContextContainer'),
+                    h('.interactive-input-followups@followupsContainer'),
+                ])
+            ]);
         }
         else {
-            this.followupsContainer = append(this.container, $('.interactive-input-followups'));
-            this.attachedContextContainer = append(this.container, $('.chat-attached-context'));
-            inputAndSideToolbar = append(this.container, $('.interactive-input-and-side-toolbar'));
-            inputContainer = append(inputAndSideToolbar, $('.interactive-input-and-execute-toolbar'));
+            elements = h('.interactive-input-part', [
+                h('.interactive-input-followups@followupsContainer'),
+                h('.chat-editing-session@chatEditingSessionWidgetContainer'),
+                h('.interactive-input-and-side-toolbar@inputAndSideToolbar', [
+                    h('.chat-input-container@inputContainer', [
+                        h('.chat-editor-container@editorContainer'),
+                        h('.chat-attached-context@attachedContextContainer'),
+                        h('.chat-input-toolbars@inputToolbars'),
+                    ]),
+                ]),
+            ]);
         }
+        this.container = elements.root;
+        container.append(this.container);
+        this.container.classList.toggle('compact', this.options.renderStyle === 'compact');
+        this.followupsContainer = elements.followupsContainer;
+        const inputAndSideToolbar = elements.inputAndSideToolbar;
+        const inputContainer = elements.inputContainer;
+        const editorContainer = elements.editorContainer;
+        this.attachedContextContainer = elements.attachedContextContainer;
+        const toolbarsContainer = elements.inputToolbars;
+        this.chatEditingSessionWidgetContainer = elements.chatEditingSessionWidgetContainer;
         this.initAttachedContext(this.attachedContextContainer);
+        this.renderChatEditingSessionState(null);
         const inputScopedContextKeyService = this._register(this.contextKeyService.createScoped(inputContainer));
         CONTEXT_IN_CHAT_INPUT.bindTo(inputScopedContextKeyService).set(true);
         const scopedInstantiationService = this._register(this.instantiationService.createChild(( (new ServiceCollection([IContextKeyService, inputScopedContextKeyService])))));
@@ -297,6 +403,7 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         this.historyNavigationForewardsEnablement = historyNavigationForwardsEnablement;
         const options = getSimpleEditorOptions(this.configurationService);
         options.overflowWidgetsDomNode = this.options.editorOverflowWidgetsDomNode;
+        options.pasteAs = EditorOptions.pasteAs.defaultValue;
         options.readOnly = false;
         options.ariaLabel = this._getAriaLabel();
         options.fontFamily = DEFAULT_FONT_FAMILY;
@@ -315,10 +422,11 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         };
         options.scrollbar = { ...(options.scrollbar ?? {}), vertical: 'hidden' };
         options.stickyScroll = { enabled: false };
-        this._inputEditorElement = append(inputContainer, $(chatInputEditorContainerSelector));
+        this._inputEditorElement = append(editorContainer, $(chatInputEditorContainerSelector));
         const editorOptions = getSimpleCodeEditorWidgetOptions();
-        editorOptions.contributions?.push(...EditorExtensionsRegistry.getSomeEditorContributions([ContentHoverController.ID, MarginHoverController.ID]));
+        editorOptions.contributions?.push(...EditorExtensionsRegistry.getSomeEditorContributions([ContentHoverController.ID, GlyphHoverController.ID, CopyPasteController.ID]));
         this._inputEditor = this._register(scopedInstantiationService.createInstance(CodeEditorWidget, this._inputEditorElement, options, editorOptions));
+        SuggestController.get(this._inputEditor)?.forceRenderingAbove();
         this._register(this._inputEditor.onDidChangeModelContent(() => {
             const currentHeight = Math.min(this._inputEditor.getContentHeight(), this.inputEditorMaxHeight);
             if (currentHeight !== this.inputEditorHeight) {
@@ -339,26 +447,54 @@ let ChatInputPart = class ChatInputPart extends Disposable {
             inputContainer.classList.toggle('focused', false);
             this._onDidBlur.fire();
         }));
-        this.toolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, inputContainer, this.options.menus.executeToolbar, {
+        const hoverDelegate = this._register(createInstantHoverDelegate());
+        this._register(addStandardDisposableListener(toolbarsContainer, EventType.CLICK, e => this.inputEditor.focus()));
+        this.inputActionsToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, toolbarsContainer, MenuId.ChatInput, {
+            telemetrySource: this.options.menus.telemetrySource,
+            menuOptions: { shouldForwardArgs: true },
+            hiddenItemStrategy: 0 ,
+            hoverDelegate
+        }));
+        this.inputActionsToolbar.context = { widget };
+        this._register(this.inputActionsToolbar.onDidChangeMenuItems(() => {
+            if (this.cachedDimensions && typeof this.cachedInputToolbarWidth === 'number' && this.cachedInputToolbarWidth !== this.inputActionsToolbar.getItemsWidth()) {
+                this.layout(this.cachedDimensions.height, this.cachedDimensions.width);
+            }
+        }));
+        this.executeToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, toolbarsContainer, this.options.menus.executeToolbar, {
             telemetrySource: this.options.menus.telemetrySource,
             menuOptions: {
                 shouldForwardArgs: true
             },
-            hiddenItemStrategy: HiddenItemStrategy.Ignore,
+            hoverDelegate,
+            hiddenItemStrategy: 0 ,
             actionViewItemProvider: (action, options) => {
                 if (this.location === ChatAgentLocation.Panel) {
                     if ((action.id === SubmitAction.ID || action.id === CancelAction.ID) && action instanceof MenuItemAction) {
-                        const dropdownAction = this.instantiationService.createInstance(MenuItemAction, { id: 'chat.moreExecuteActions', title: ( localize(6992, "More...")), icon: Codicon.chevronDown }, undefined, undefined, undefined, undefined);
-                        return this.instantiationService.createInstance(ChatSubmitDropdownActionItem, action, dropdownAction);
+                        const dropdownAction = this.instantiationService.createInstance(MenuItemAction, { id: 'chat.moreExecuteActions', title: ( localize(7178, "More...")), icon: Codicon.chevronDown }, undefined, undefined, undefined, undefined);
+                        return this.instantiationService.createInstance(ChatSubmitDropdownActionItem, action, dropdownAction, options);
+                    }
+                }
+                if (action.id === ChatModelPickerActionId && action instanceof MenuItemAction) {
+                    if (!this._currentLanguageModel) {
+                        this.setCurrentLanguageModelToDefault();
+                    }
+                    if (this._currentLanguageModel) {
+                        const itemDelegate = {
+                            onDidChangeModel: this._onDidChangeCurrentLanguageModel.event,
+                            setModel: (modelId) => {
+                                this.setCurrentLanguageModelByUser(modelId);
+                            }
+                        };
+                        return this.instantiationService.createInstance(ModelPickerActionViewItem, action, this._currentLanguageModel, itemDelegate, { hoverDelegate: options.hoverDelegate, keybinding: options.keybinding ?? undefined });
                     }
                 }
                 return undefined;
             }
         }));
-        this.toolbar.getElement().classList.add('interactive-execute-toolbar');
-        this.toolbar.context = { widget };
-        this._register(this.toolbar.onDidChangeMenuItems(() => {
-            if (this.cachedDimensions && typeof this.cachedToolbarWidth === 'number' && this.cachedToolbarWidth !== this.toolbar.getItemsWidth()) {
+        this.executeToolbar.context = { widget };
+        this._register(this.executeToolbar.onDidChangeMenuItems(() => {
+            if (this.cachedDimensions && typeof this.cachedExecuteToolbarWidth === 'number' && this.cachedExecuteToolbarWidth !== this.executeToolbar.getItemsWidth()) {
                 this.layout(this.cachedDimensions.height, this.cachedDimensions.width);
             }
         }));
@@ -367,7 +503,8 @@ let ChatInputPart = class ChatInputPart extends Disposable {
                 telemetrySource: this.options.menus.telemetrySource,
                 menuOptions: {
                     shouldForwardArgs: true
-                }
+                },
+                hoverDelegate
             }));
             this.inputSideToolbarContainer = toolbarSide.getElement();
             toolbarSide.getElement().classList.add('chat-side-toolbar');
@@ -395,7 +532,7 @@ let ChatInputPart = class ChatInputPart extends Disposable {
             if (!position) {
                 return;
             }
-            const atTop = position.column === 1 && position.lineNumber === 1;
+            const atTop = position.lineNumber === 1 && position.column - 1 <= (this._inputEditor._getViewModel()?.getLineLength(1) ?? 0);
             this.chatCursorAtTop.set(atTop);
             this.historyNavigationBackwardsEnablement.set(atTop);
             this.historyNavigationForewardsEnablement.set(position.equals(getLastPosition(model)));
@@ -407,65 +544,213 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         const oldHeight = container.offsetHeight;
         clearNode(container);
         this.attachedContextDisposables.clear();
+        const hoverDelegate = this.attachedContextDisposables.add(createInstantHoverDelegate());
         setVisibility(Boolean(this.attachedContext.size), this.attachedContextContainer);
         if (!this.attachedContext.size) {
             this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
         }
-        [...( (this.attachedContext.values()))].forEach((attachment, index) => {
+        [...( (this.attachedContext.values()))].forEach(async (attachment, index) => {
             const widget = append(container, $('.chat-attached-context-attachment.show-file-icons'));
-            const label = this._contextResourceLabels.create(widget, { supportIcons: true });
+            const label = this._contextResourceLabels.create(widget, { supportIcons: true, hoverDelegate });
+            let hoverElement;
+            let ariaLabel;
             const file = URI.isUri(attachment.value) ? attachment.value : attachment.value && typeof attachment.value === 'object' && 'uri' in attachment.value && URI.isUri(attachment.value.uri) ? attachment.value.uri : undefined;
             const range = attachment.value && typeof attachment.value === 'object' && 'range' in attachment.value && Range.isIRange(attachment.value.range) ? attachment.value.range : undefined;
             if (file && attachment.isFile) {
                 const fileBasename = basename(file.path);
                 const fileDirname = dirname(file.path);
                 const friendlyName = `${fileBasename} ${fileDirname}`;
-                const ariaLabel = range ? ( localize(
-                    6993,
+                ariaLabel = range ? ( localize(
+                    7179,
                     "Attached file, {0}, line {1} to line {2}",
                     friendlyName,
                     range.startLineNumber,
                     range.endLineNumber
-                )) : ( localize(6994, "Attached file, {0}", friendlyName));
+                )) : ( localize(7180, "Attached file, {0}", friendlyName));
+                hoverElement = file.fsPath;
                 label.setFile(file, {
                     fileKind: FileKind.FILE,
                     hidePath: true,
                     range,
                 });
-                widget.ariaLabel = ariaLabel;
-                widget.tabIndex = 0;
+                this.attachButtonAndDisposables(widget, index, attachment, hoverDelegate);
+            }
+            else if (attachment.isImage) {
+                ariaLabel = ( localize(7181, "Attached image, {0}", attachment.name));
+                hoverElement = $$1('div.chat-attached-context-hover');
+                hoverElement.setAttribute('aria-label', ariaLabel);
+                const pillIcon = $$1('div.chat-attached-context-pill', {}, $$1('span.codicon.codicon-file-media'));
+                const textLabel = $$1('span.chat-attached-context-custom-text', {}, attachment.name);
+                widget.appendChild(pillIcon);
+                widget.appendChild(textLabel);
+                let buffer;
+                try {
+                    if (attachment.value instanceof URI) {
+                        this.attachButtonAndDisposables(widget, index, attachment, hoverDelegate);
+                        const readFile = await this.fileService.readFile(attachment.value);
+                        buffer = readFile.value.buffer;
+                    }
+                    else {
+                        buffer = attachment.value;
+                        this.attachButtonAndDisposables(widget, index, attachment, hoverDelegate);
+                    }
+                    this.createImageElements(buffer, widget, hoverElement);
+                }
+                catch (error) {
+                    console.error('Error processing attachment:', error);
+                }
+                widget.style.position = 'relative';
             }
             else {
                 const attachmentLabel = attachment.fullName ?? attachment.name;
                 const withIcon = attachment.icon?.id ? `$(${attachment.icon.id}) ${attachmentLabel}` : attachmentLabel;
                 label.setLabel(withIcon, undefined);
-                widget.ariaLabel = ( localize(6995, "Attached context, {0}", attachment.name));
-                widget.tabIndex = 0;
+                ariaLabel = ( localize(7182, "Attached context, {0}", attachment.name));
+                hoverElement = attachmentLabel;
+                this.attachButtonAndDisposables(widget, index, attachment, hoverDelegate);
             }
-            const clearButton = ( (new Button(widget, { supportIcons: true })));
-            if (index === Math.min(this._indexOfLastAttachedContextDeletedWithKeyboard, this.attachedContext.size - 1)) {
-                clearButton.focus();
+            widget.tabIndex = 0;
+            widget.ariaLabel = ariaLabel;
+            if (!this.attachedContextDisposables.isDisposed) {
+                this.attachedContextDisposables.add(this.hoverService.setupManagedHover(hoverDelegate, widget, hoverElement, { trapFocus: false }));
             }
-            this.attachedContextDisposables.add(clearButton);
-            clearButton.icon = Codicon.close;
-            const disp = clearButton.onDidClick((e) => {
-                this._attachedContext.delete(attachment);
-                disp.dispose();
-                if (isKeyboardEvent(e)) {
-                    const event = ( (new StandardKeyboardEvent(e)));
-                    if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
-                        this._indexOfLastAttachedContextDeletedWithKeyboard = index;
-                    }
-                }
-                this._onDidChangeHeight.fire();
-                this._onDidChangeContext.fire({ removed: [attachment] });
-            });
-            this.attachedContextDisposables.add(disp);
         });
         if (oldHeight !== container.offsetHeight && !isLayout) {
             this._onDidChangeHeight.fire();
         }
     }
+    attachButtonAndDisposables(widget, index, attachment, hoverDelegate) {
+        const clearButton = ( (new Button(widget, { supportIcons: true, hoverDelegate, title: ( localize(7183, 'Remove')) })));
+        if (index === Math.min(this._indexOfLastAttachedContextDeletedWithKeyboard, this.attachedContext.size - 1)) {
+            clearButton.focus();
+        }
+        this.attachedContextDisposables.add(clearButton);
+        clearButton.icon = Codicon.close;
+        const disp = clearButton.onDidClick((e) => {
+            this._attachedContext.delete(attachment);
+            disp.dispose();
+            if (isKeyboardEvent(e)) {
+                const event = ( (new StandardKeyboardEvent(e)));
+                if (event.equals(3 ) || event.equals(10 )) {
+                    this._indexOfLastAttachedContextDeletedWithKeyboard = index;
+                }
+            }
+            if (this._attachedContext.size === 0) {
+                this.focus();
+            }
+            this._onDidChangeHeight.fire();
+            this._onDidChangeContext.fire({ removed: [attachment] });
+        });
+        this.attachedContextDisposables.add(disp);
+    }
+    createImageElements(buffer, widget, hoverElement) {
+        const blob = ( (new Blob([buffer], { type: 'image/png' })));
+        const url = URL.createObjectURL(blob);
+        const img = $$1('img.chat-attached-context-image', { src: url, alt: '' });
+        const pillImg = $$1('img.chat-attached-context-pill-image', { src: url, alt: '' });
+        const pill = $$1('div.chat-attached-context-pill', {}, pillImg);
+        const existingPill = widget.querySelector('.chat-attached-context-pill');
+        if (existingPill) {
+            existingPill.replaceWith(pill);
+        }
+        hoverElement.appendChild(img);
+    }
+    async renderChatEditingSessionState(chatEditingSession) {
+        setVisibility(Boolean(chatEditingSession), this.chatEditingSessionWidgetContainer);
+        if (!chatEditingSession) {
+            clearNode(this.chatEditingSessionWidgetContainer);
+            this._chatEditsDisposables.clear();
+            this._chatEditList = undefined;
+            this._chatEditsProgress?.dispose();
+            this._chatEditsProgress = undefined;
+            return;
+        }
+        if (this._chatEditList && chatEditingSession.state.get() === 2 ) {
+            this._chatEditsProgress?.stop();
+            this._chatEditsProgress?.dispose();
+            this._chatEditsProgress = undefined;
+        }
+        const innerContainer = this.chatEditingSessionWidgetContainer.querySelector('.chat-editing-session-container.show-file-icons') ?? append(this.chatEditingSessionWidgetContainer, $('.chat-editing-session-container.show-file-icons'));
+        const numberOfEditedEntries = chatEditingSession.entries.get().length;
+        const overviewRegion = innerContainer.querySelector('.chat-editing-session-overview') ?? append(innerContainer, $('.chat-editing-session-overview'));
+        if (numberOfEditedEntries !== this._chatEditList?.object.length) {
+            const overviewText = overviewRegion.querySelector('span') ?? append(overviewRegion, $('span'));
+            overviewText.textContent = numberOfEditedEntries === 1
+                ? ( localize(7184, "1 file changed"))
+                : ( localize(7185, "{0} files changed", numberOfEditedEntries));
+        }
+        {
+            const actionsContainer = overviewRegion.querySelector('.chat-editing-session-actions') ?? append(overviewRegion, $('.chat-editing-session-actions'));
+            this._chatEditsActionsDisposables.clear();
+            clearNode(actionsContainer);
+            if (chatEditingSession.entries.get().find((e) => e.state.get() === 0 )) {
+                const actions = [];
+                actions.push({
+                    command: ChatEditingShowChangesAction.ID,
+                    label: ChatEditingShowChangesAction.LABEL,
+                    isSecondary: true
+                }, {
+                    command: ChatEditingDiscardAllAction.ID,
+                    label: ChatEditingDiscardAllAction.LABEL,
+                    isSecondary: true
+                }, {
+                    command: ChatEditingAcceptAllAction.ID,
+                    label: ChatEditingAcceptAllAction.LABEL,
+                    isSecondary: false
+                });
+                for (const action of actions) {
+                    const button = this._chatEditsActionsDisposables.add(( (new Button(actionsContainer, {
+                        supportIcons: false,
+                        secondary: action.isSecondary
+                    }))));
+                    button.label = action.label;
+                    this._chatEditsActionsDisposables.add(button.onDidClick(() => {
+                        this.commandService.executeCommand(action.command);
+                    }));
+                    append(actionsContainer, button.element);
+                }
+            }
+            const clearButton = this._chatEditsActionsDisposables.add(( (new Button(actionsContainer, { supportIcons: true }))));
+            clearButton.icon = Codicon.close;
+            this._chatEditsActionsDisposables.add(clearButton.onDidClick((e) => {
+                void chatEditingSession.stop();
+            }));
+            append(actionsContainer, clearButton.element);
+        }
+        if (!this._chatEditsProgress && chatEditingSession.state.get() === 1 ) {
+            this._chatEditsProgress = ( (new ProgressBar(innerContainer)));
+            this._chatEditsProgress.infinite().show(500);
+        }
+        if (!this._chatEditList) {
+            this._chatEditList = this._chatEditsListPool.get();
+            const list = this._chatEditList.object;
+            this._chatEditsDisposables.add(this._chatEditList);
+            this._chatEditsDisposables.add(list.onDidOpen((e) => {
+                if (e.element?.kind === 'reference' && URI.isUri(e.element.reference)) {
+                    const modifiedFileUri = e.element.reference;
+                    const editedFile = chatEditingSession.entries.get().find((e) => ( (e.modifiedURI.toString())) === ( (modifiedFileUri.toString())));
+                    if (editedFile) {
+                        void this.editorService.openEditor({
+                            original: { resource: ( (URI.from(editedFile.originalURI, true))) },
+                            modified: { resource: ( (URI.from(editedFile.modifiedURI, true))) },
+                        });
+                    }
+                }
+            }));
+            append(innerContainer, list.getHTMLElement());
+        }
+        const maxItemsShown = 6;
+        const itemsShown = Math.min(numberOfEditedEntries, maxItemsShown);
+        const height = itemsShown * 22;
+        const list = this._chatEditList.object;
+        list.layout(height);
+        list.getHTMLElement().style.height = `${height}px`;
+        const entries = ( (chatEditingSession.entries.get().map((entry) => ({
+            reference: entry.modifiedURI,
+            kind: 'reference',
+        }))));
+        list.splice(0, list.length, entries);
+    }
     async renderFollowups(items, response) {
         if (!this.options.renderFollowups) {
             return;
@@ -479,7 +764,7 @@ let ChatInputPart = class ChatInputPart extends Disposable {
     }
     get contentHeight() {
         const data = this.getLayoutData();
-        return data.followupsHeight + data.inputPartEditorHeight + data.inputPartVerticalPadding + data.inputEditorBorder + data.implicitContextHeight;
+        return data.followupsHeight + data.inputPartEditorHeight + data.inputPartVerticalPadding + data.inputEditorBorder + data.attachmentsHeight + data.toolbarsHeight + data.chatEditingStateHeight;
     }
     layout(height, width) {
         this.cachedDimensions = new Dimension(width, height);
@@ -488,12 +773,13 @@ let ChatInputPart = class ChatInputPart extends Disposable {
     _layout(height, width, allowRecurse = true) {
         this.initAttachedContext(this.attachedContextContainer, true);
         const data = this.getLayoutData();
-        const inputEditorHeight = Math.min(data.inputPartEditorHeight, height - data.followupsHeight - data.inputPartVerticalPadding);
+        const inputEditorHeight = Math.min(data.inputPartEditorHeight, height - data.followupsHeight - data.attachmentsHeight - data.inputPartVerticalPadding - data.toolbarsHeight);
         const followupsWidth = width - data.inputPartHorizontalPadding;
         this.followupsContainer.style.width = `${followupsWidth}px`;
-        this._inputPartHeight = data.followupsHeight + inputEditorHeight + data.inputPartVerticalPadding + data.inputEditorBorder + data.implicitContextHeight;
+        this._inputPartHeight = data.inputPartVerticalPadding + data.followupsHeight + inputEditorHeight + data.inputEditorBorder + data.attachmentsHeight + data.toolbarsHeight + data.chatEditingStateHeight;
+        this._followupsHeight = data.followupsHeight;
         const initialEditorScrollWidth = this._inputEditor.getScrollWidth();
-        const newEditorWidth = width - data.inputPartHorizontalPadding - data.editorBorder - data.editorPadding - data.executeToolbarWidth - data.sideToolbarWidth - data.toolbarPadding;
+        const newEditorWidth = width - data.inputPartHorizontalPadding - data.editorBorder - data.inputPartHorizontalPaddingInside - data.toolbarsWidth - data.sideToolbarWidth;
         const newDimension = { width: newEditorWidth, height: inputEditorHeight };
         if (!this.previousInputEditorDimension || (this.previousInputEditorDimension.width !== newDimension.width || this.previousInputEditorDimension.height !== newDimension.height)) {
             this._inputEditor.layout(newDimension);
@@ -504,17 +790,22 @@ let ChatInputPart = class ChatInputPart extends Disposable {
         }
     }
     getLayoutData() {
+        const executeToolbarWidth = this.cachedExecuteToolbarWidth = this.executeToolbar.getItemsWidth();
+        const inputToolbarWidth = this.cachedInputToolbarWidth = this.inputActionsToolbar.getItemsWidth();
+        const executeToolbarPadding = (this.executeToolbar.getItemsLength() - 1) * 4;
+        const inputToolbarPadding = this.inputActionsToolbar.getItemsLength() ? (this.inputActionsToolbar.getItemsLength() - 1) * 4 : 0;
         return {
             inputEditorBorder: 2,
             followupsHeight: this.followupsContainer.offsetHeight,
             inputPartEditorHeight: Math.min(this._inputEditor.getContentHeight(), this.inputEditorMaxHeight),
-            inputPartHorizontalPadding: this.options.renderStyle === 'compact' ? 12 : 40,
-            inputPartVerticalPadding: this.options.renderStyle === 'compact' ? 12 : 24,
-            implicitContextHeight: this.attachedContextContainer.offsetHeight,
+            inputPartHorizontalPadding: this.options.renderStyle === 'compact' ? 16 : 32,
+            inputPartVerticalPadding: this.options.renderStyle === 'compact' ? 12 : 28,
+            attachmentsHeight: this.attachedContextContainer.offsetHeight,
             editorBorder: 2,
-            editorPadding: 12,
-            toolbarPadding: (this.toolbar.getItemsLength() - 1) * 4,
-            executeToolbarWidth: this.cachedToolbarWidth = this.toolbar.getItemsWidth(),
+            inputPartHorizontalPaddingInside: 12,
+            toolbarsWidth: this.options.renderStyle === 'compact' ? executeToolbarWidth + executeToolbarPadding + inputToolbarWidth + inputToolbarPadding : 0,
+            toolbarsHeight: this.options.renderStyle === 'compact' ? 0 : 22,
+            chatEditingStateHeight: this.chatEditingSessionWidgetContainer.offsetHeight,
             sideToolbarWidth: this.inputSideToolbarContainer ? getTotalWidth(this.inputSideToolbarContainer) + 4  : 0,
         };
     }
@@ -532,17 +823,23 @@ ChatInputPart = ChatInputPart_1 = ( (__decorate([
     ( (__param(7, IConfigurationService))),
     ( (__param(8, IKeybindingService))),
     ( (__param(9, IAccessibilityService))),
-    ( (__param(10, ILogService)))
+    ( (__param(10, ILanguageModelsService))),
+    ( (__param(11, ILogService))),
+    ( (__param(12, IHoverService))),
+    ( (__param(13, IFileService))),
+    ( (__param(14, ICommandService))),
+    ( (__param(15, IEditorService)))
 ], ChatInputPart)));
 const historyKeyFn = (entry) => JSON.stringify(entry);
 function getLastPosition(model) {
     return { lineNumber: model.getLineCount(), column: model.getLineLength(model.getLineCount()) + 1 };
 }
 let ChatSubmitDropdownActionItem = class ChatSubmitDropdownActionItem extends DropdownWithPrimaryActionViewItem {
-    constructor(action, dropdownAction, menuService, contextMenuService, chatAgentService, contextKeyService, keybindingService, notificationService, themeService, accessibilityService) {
-        super(action, dropdownAction, [], '', contextMenuService, {
+    constructor(action, dropdownAction, options, menuService, contextMenuService, chatAgentService, contextKeyService, keybindingService, notificationService, themeService, accessibilityService) {
+        super(action, dropdownAction, [], '', {
+            ...options,
             getKeyBinding: (action) => keybindingService.lookupKeybinding(action.id, contextKeyService)
-        }, keybindingService, notificationService, contextKeyService, themeService, accessibilityService);
+        }, contextMenuService, keybindingService, notificationService, contextKeyService, themeService, accessibilityService);
         const menu = menuService.createMenu(MenuId.ChatExecuteSecondary, contextKeyService);
         const setActions = () => {
             const secondary = [];
@@ -551,7 +848,7 @@ let ChatSubmitDropdownActionItem = class ChatSubmitDropdownActionItem extends Dr
             if (secondaryAgent) {
                 secondary.forEach(a => {
                     if (a.id === ChatSubmitSecondaryAgentAction.ID) {
-                        a.label = ( localize(6996, "Send to @{0}", secondaryAgent.name));
+                        a.label = ( localize(7186, "Send to @{0}", secondaryAgent.name));
                     }
                     return a;
                 });
@@ -563,15 +860,84 @@ let ChatSubmitDropdownActionItem = class ChatSubmitDropdownActionItem extends Dr
     }
 };
 ChatSubmitDropdownActionItem = ( (__decorate([
-    ( (__param(2, IMenuService))),
-    ( (__param(3, IContextMenuService))),
-    ( (__param(4, IChatAgentService))),
-    ( (__param(5, IContextKeyService))),
-    ( (__param(6, IKeybindingService))),
-    ( (__param(7, INotificationService))),
-    ( (__param(8, IThemeService))),
-    ( (__param(9, IAccessibilityService)))
+    ( (__param(3, IMenuService))),
+    ( (__param(4, IContextMenuService))),
+    ( (__param(5, IChatAgentService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, IKeybindingService))),
+    ( (__param(8, INotificationService))),
+    ( (__param(9, IThemeService))),
+    ( (__param(10, IAccessibilityService)))
 ], ChatSubmitDropdownActionItem)));
+let ModelPickerActionViewItem = class ModelPickerActionViewItem extends MenuEntryActionViewItem {
+    constructor(action, currentLanguageModel, delegate, options, keybindingService, notificationService, contextKeyService, themeService, contextMenuService, _languageModelsService, _accessibilityService) {
+        super(action, options, keybindingService, notificationService, contextKeyService, themeService, contextMenuService, _accessibilityService);
+        this.currentLanguageModel = currentLanguageModel;
+        this.delegate = delegate;
+        this._languageModelsService = _languageModelsService;
+        this._register(delegate.onDidChangeModel(modelId => {
+            this.currentLanguageModel = modelId;
+            this.updateLabel();
+        }));
+    }
+    async onClick(event) {
+        this._openContextMenu();
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add('chat-modelPicker-item');
+        this._register(addDisposableListener(container, EventType.KEY_UP, e => {
+            const event = ( (new StandardKeyboardEvent(e)));
+            if (event.equals(3 ) || event.equals(10 )) {
+                this._openContextMenu();
+            }
+        }));
+    }
+    updateLabel() {
+        if (this.label) {
+            const model = this._languageModelsService.lookupLanguageModel(this.currentLanguageModel);
+            if (model) {
+                this.label.textContent = model.name;
+                reset(this.label, ...renderLabelWithIcons(`${model.name}$(chevron-down)`));
+            }
+        }
+    }
+    _openContextMenu() {
+        const setLanguageModelAction = (id, modelMetadata) => {
+            return {
+                id,
+                label: modelMetadata.name,
+                tooltip: '',
+                class: undefined,
+                enabled: true,
+                checked: id === this.currentLanguageModel,
+                run: () => {
+                    this.currentLanguageModel = id;
+                    this.updateLabel();
+                    this.delegate.setModel(id);
+                }
+            };
+        };
+        const models = ( (this._languageModelsService.getLanguageModelIds()
+            .map(
+            modelId => ({ id: modelId, model: this._languageModelsService.lookupLanguageModel(modelId) })
+        )))
+            .filter(entry => entry.model?.isUserSelectable);
+        this._contextMenuService.showContextMenu({
+            getAnchor: () => this.element,
+            getActions: () => ( (models.map(entry => setLanguageModelAction(entry.id, entry.model)))),
+        });
+    }
+};
+ModelPickerActionViewItem = ( (__decorate([
+    ( (__param(4, IKeybindingService))),
+    ( (__param(5, INotificationService))),
+    ( (__param(6, IContextKeyService))),
+    ( (__param(7, IThemeService))),
+    ( (__param(8, IContextMenuService))),
+    ( (__param(9, ILanguageModelsService))),
+    ( (__param(10, IAccessibilityService)))
+], ModelPickerActionViewItem)));
 const chatInputEditorContainerSelector = '.interactive-input-editor';
 setupSimpleEditorSelectionStyling(chatInputEditorContainerSelector);
 export { ChatInputPart };