@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,2008 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ as $$1, clearNode, h, append, addStandardDisposableListener, EventType, setVisibility, isKeyboardEvent, getActiveElement, getWindow, addDisposableListener, createElement, Dimension, getTotalWidth, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { DEFAULT_FONT_FAMILY } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/fonts';
+import { hasModifierKeys } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { ActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { ButtonWithIcon, Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { createInstantHoverDelegate, getDefaultHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegateFactory';
+import { renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { RunOnceScheduler, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Lazy } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import { Disposable, MutableDisposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isMacintosh } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ScrollbarVisibility } from '@codingame/monaco-vscode-api/vscode/vs/base/common/scrollable';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { EditorExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { CodeEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { EditorOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { isLocation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { CopyPasteController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController';
+import { DropIntoEditorController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/dropOrPasteInto/browser/dropIntoEditorController';
+import { ContentHoverController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/hover/browser/contentHoverController';
+import { GlyphHoverController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/hover/browser/glyphHoverController';
+import { LinkDetector } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/links/browser/links';
+import { SuggestController } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/suggest/browser/suggestController';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAccessibilityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service';
+import { MenuWorkbenchButtonBar } from '../../../../platform/actions/browser/buttonbar.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { registerAndCreateHistoryNavigationContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/history/browser/contextScopedHistoryWidget';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { observableMemento } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/observableMemento';
+import { bindContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { ISharedWebContentExtractorService } from '@codingame/monaco-vscode-api/vscode/vs/platform/webContentExtractor/common/webContentExtractor.service';
+import { ResourceLabels } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { SIDE_GROUP, ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { AccessibilityCommandId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/common/accessibilityCommands';
+import { getSimpleEditorOptions, getSimpleCodeEditorWidgetOptions, setupSimpleEditorSelectionStyling } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/simpleEditorOptions';
+import { InlineChatConfigKeys } from '../../inlineChat/common/inlineChat.js';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { ChatRequestVariableSet, isImageVariableEntry, isNotebookOutputVariableEntry, isPromptFileVariableEntry, isPromptTextVariableEntry, isElementVariableEntry, isPasteVariableEntry, isSCMHistoryItemVariableEntry, isSCMHistoryItemChangeVariableEntry, isSCMHistoryItemChangeRangeVariableEntry, isStringVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { ChatHistoryNavigator } from '../common/chatWidgetHistoryService.js';
+import { ChatModeKind, ChatConfiguration, validateChatMode, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { 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 { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { ContinueChatInSessionAction, ChatContinueInSessionActionItem, ActionLocation } from './actions/chatContinueInAction.js';
+import { ChatSubmitAction, ChatOpenModelPickerActionId, OpenModePickerAction, ChatSessionPrimaryPickerAction } from './actions/chatExecuteActions.js';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { ImplicitContextAttachmentWidget } from './attachments/implicitContextAttachment.js';
+import { ChatAttachmentModel } from './chatAttachmentModel.js';
+import { ToolSetOrToolItemAttachmentWidget, NotebookCellOutputChatAttachmentWidget, PromptFileAttachmentWidget, PromptTextAttachmentWidget, FileAttachmentWidget, TerminalCommandAttachmentWidget, ImageAttachmentWidget, ElementChatAttachmentWidget, PasteAttachmentWidget, SCMHistoryItemAttachmentWidget, SCMHistoryItemChangeAttachmentWidget, SCMHistoryItemChangeRangeAttachmentWidget, DefaultChatAttachmentWidget } from './chatAttachmentWidgets.js';
+import { CollapsibleListPool } from './chatContentParts/chatReferencesContentPart.js';
+import { ChatTodoListWidget } from './chatContentParts/chatTodoListWidget.js';
+import { IChatContextService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextService.service';
+import { ChatDragAndDrop } from './chatDragAndDrop.js';
+import { ChatEditingShowChangesAction, ViewPreviousEditsAction, ViewAllSessionChangesAction } from './chatEditing/chatEditingActions.js';
+import { ChatFollowups } from './chatFollowups.js';
+import { ChatInputPartWidgetController } from './chatInputPartWidgets.js';
+import { ChatSelectedTools } from './chatSelectedTools.js';
+import { ChatSessionPickerActionItem } from './chatSessions/chatSessionPickerActionItem.js';
+import { ChatImplicitContext } from './contrib/chatImplicitContext.js';
+import { ChatRelatedFiles } from './contrib/chatInputRelatedFilesContrib.js';
+import { resizeImage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/imageUtils';
+import { ModelPickerActionItem } from './modelPicker/modelPickerActionItem.js';
+import { ModePickerActionItem } from './modelPicker/modePickerActionItem.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { derivedOpts, derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+
+var ChatInputPart_1;
+const $ = $$1;
+const INPUT_EDITOR_MAX_HEIGHT = 250;
+const emptyInputState = observableMemento({
+    defaultValue: undefined,
+    key: 'chat.untitledInputState',
+    toStorage: JSON.stringify,
+    fromStorage: JSON.parse,
+});
+let ChatInputPart = class ChatInputPart extends Disposable {
+    static { ChatInputPart_1 = this; }
+    static { this._counter = 0; }
+    get attachmentModel() {
+        return this._attachmentModel;
+    }
+    getAttachedContext(sessionResource) {
+        const contextArr = ( new ChatRequestVariableSet());
+        contextArr.add(...this.attachmentModel.attachments, ...this.chatContextService.getWorkspaceContextItems());
+        return contextArr;
+    }
+    getAttachedAndImplicitContext(sessionResource) {
+        const contextArr = this.getAttachedContext(sessionResource);
+        if ((this.implicitContext?.enabled && this.implicitContext?.value) || (this.implicitContext && !URI.isUri(this.implicitContext.value) && this.configurationService.getValue('chat.implicitContext.suggestedContext'))) {
+            const implicitChatVariables = this.implicitContext.toBaseEntries();
+            contextArr.add(...implicitChatVariables);
+        }
+        return contextArr;
+    }
+    get implicitContext() {
+        return this._implicitContext;
+    }
+    get relatedFiles() {
+        return this._relatedFiles;
+    }
+    get inputPartHeight() {
+        return this._inputPartHeight;
+    }
+    get followupsHeight() {
+        return this._followupsHeight;
+    }
+    get editSessionWidgetHeight() {
+        return this._editSessionWidgetHeight;
+    }
+    get todoListWidgetHeight() {
+        return this.chatInputTodoListWidgetContainer.offsetHeight;
+    }
+    get inputWidgetsHeight() {
+        return this.chatInputWidgetsContainer?.offsetHeight ?? 0;
+    }
+    get attachmentsHeight() {
+        return this.attachmentsContainer.offsetHeight + (this.attachmentsContainer.checkVisibility() ? 6 : 0);
+    }
+    get inputEditor() {
+        return this._inputEditor;
+    }
+    get currentLanguageModel() {
+        return this._currentLanguageModel?.identifier;
+    }
+    get selectedLanguageModel() {
+        return this._currentLanguageModel;
+    }
+    get currentModeKind() {
+        const mode = this._currentModeObservable.get();
+        return mode.kind === ChatModeKind.Agent && !this.agentService.hasToolsAgent ?
+            ChatModeKind.Edit :
+            mode.kind;
+    }
+    get currentModeObs() {
+        return this._currentModeObservable;
+    }
+    get currentModeInfo() {
+        const mode = this._currentModeObservable.get();
+        const modeId = mode.isBuiltin ? this.currentModeKind : 'custom';
+        const modeInstructions = mode.modeInstructions?.get();
+        return {
+            kind: this.currentModeKind,
+            isBuiltin: mode.isBuiltin,
+            modeInstructions: modeInstructions ? {
+                name: mode.name.get(),
+                content: modeInstructions.content,
+                toolReferences: this.toolService.toToolReferences(modeInstructions.toolReferences),
+                metadata: modeInstructions.metadata,
+            } : undefined,
+            modeId: modeId,
+            applyCodeBlockSuggestionId: undefined,
+        };
+    }
+    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;
+    }
+    get attemptedWorkingSetEntriesCount() {
+        return this._attemptedWorkingSetEntriesCount;
+    }
+    constructor(
+    location, options, styles, inline, modelService, instantiationService, contextKeyService, configurationService, keybindingService, accessibilityService, languageModelsService, logService, fileService, editorService, themeService, textModelResolverService, storageService, labelService, agentService, sharedWebExtracterService, experimentService, entitlementService, chatModeService, toolService, chatService, chatSessionsService, chatContextService, agentSessionsService) {
+        super();
+        this.location = location;
+        this.options = options;
+        this.inline = inline;
+        this.modelService = modelService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.accessibilityService = accessibilityService;
+        this.languageModelsService = languageModelsService;
+        this.logService = logService;
+        this.fileService = fileService;
+        this.editorService = editorService;
+        this.themeService = themeService;
+        this.textModelResolverService = textModelResolverService;
+        this.storageService = storageService;
+        this.labelService = labelService;
+        this.agentService = agentService;
+        this.sharedWebExtracterService = sharedWebExtracterService;
+        this.experimentService = experimentService;
+        this.entitlementService = entitlementService;
+        this.chatModeService = chatModeService;
+        this.toolService = toolService;
+        this.chatService = chatService;
+        this.chatSessionsService = chatSessionsService;
+        this.chatContextService = chatContextService;
+        this.agentSessionsService = agentSessionsService;
+        this._workingSetCollapsed = observableValue('chatInputPart.workingSetCollapsed', true);
+        this._chatInputTodoListWidget = this._register(( new MutableDisposable()));
+        this._chatEditingTodosDisposables = this._register(( new DisposableStore()));
+        this._onDidLoadInputState = this._register(( new Emitter()));
+        this.onDidLoadInputState = this._onDidLoadInputState.event;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( new Emitter()));
+        this.onDidBlur = this._onDidBlur.event;
+        this._onDidChangeContext = this._register(( new Emitter()));
+        this.onDidChangeContext = this._onDidChangeContext.event;
+        this._onDidAcceptFollowup = this._register(( new Emitter()));
+        this.onDidAcceptFollowup = this._onDidAcceptFollowup.event;
+        this._onDidClickOverlay = this._register(( new Emitter()));
+        this.onDidClickOverlay = this._onDidClickOverlay.event;
+        this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+        this._indexOfLastOpenedContext = -1;
+        this._onDidChangeVisibility = this._register(( new Emitter()));
+        this.inputEditorHeight = 0;
+        this.followupsDisposables = this._register(( new DisposableStore()));
+        this.overlayClickListener = this._register(( new MutableDisposable()));
+        this.attachedContextDisposables = this._register(( new MutableDisposable()));
+        this._widgetController = this._register(( new MutableDisposable()));
+        this._inputPartHeight = 0;
+        this._followupsHeight = 0;
+        this._editSessionWidgetHeight = 0;
+        this._modelSyncDisposables = this._register(( new DisposableStore()));
+        this._isSyncingToOrFromInputModel = false;
+        this.chatSessionPickerWidgets = ( new Map());
+        this._waitForPersistedLanguageModel = this._register(( new MutableDisposable()));
+        this._onDidChangeCurrentLanguageModel = this._register(( new Emitter()));
+        this._chatSessionOptionEmitters = ( new Map());
+        this._onDidChangeCurrentChatMode = this._register(( new Emitter()));
+        this.onDidChangeCurrentChatMode = this._onDidChangeCurrentChatMode.event;
+        this.inputUri = ( URI.parse(`${Schemas.vscodeChatInput}:input-${ChatInputPart_1._counter++}`));
+        this._workingSetLinesAddedSpan = ( new Lazy(() => $$1('.working-set-lines-added')));
+        this._workingSetLinesRemovedSpan = ( new Lazy(() => $$1('.working-set-lines-removed')));
+        this._chatEditsActionsDisposables = this._register(( new DisposableStore()));
+        this._chatEditsDisposables = this._register(( new DisposableStore()));
+        this._renderingChatEdits = this._register(( new MutableDisposable()));
+        this._attemptedWorkingSetEntriesCount = 0;
+        this._chatSessionIsEmpty = false;
+        this._syncTextDebounced = this._register(( new RunOnceScheduler(() => this._syncInputStateToModel(), 150)));
+        this._emptyInputState = this._register(emptyInputState(StorageScope.WORKSPACE, StorageTarget.USER, this.storageService));
+        this._contextResourceLabels = this._register(this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this._onDidChangeVisibility.event }));
+        this._currentModeObservable = observableValue('currentMode', this.options.defaultMode ?? ChatMode.Agent);
+        this._register(this.editorService.onDidActiveEditorChange(() => {
+            this._indexOfLastOpenedContext = -1;
+            this.refreshChatSessionPickers();
+        }));
+        this._register(this.chatSessionsService.onDidChangeSessionOptions(e => {
+            const sessionResource = this._widget?.viewModel?.model.sessionResource;
+            if (sessionResource && isEqual(sessionResource, e)) {
+                this.refreshChatSessionPickers();
+            }
+        }));
+        this._register(this.chatSessionsService.onDidChangeOptionGroups(chatSessionType => {
+            const sessionResource = this._widget?.viewModel?.model.sessionResource;
+            if (sessionResource) {
+                const ctx = this.chatService.getChatSessionFromInternalUri(sessionResource);
+                if (ctx?.chatSessionType === chatSessionType) {
+                    this.refreshChatSessionPickers();
+                }
+            }
+        }));
+        this._attachmentModel = this._register(this.instantiationService.createInstance(ChatAttachmentModel));
+        this._register(this._attachmentModel.onDidChange(() => this._syncInputStateToModel()));
+        this.selectedToolsModel = this._register(this.instantiationService.createInstance(ChatSelectedTools, this.currentModeObs));
+        this.dnd = this._register(this.instantiationService.createInstance(ChatDragAndDrop, () => this._widget, this._attachmentModel, styles));
+        this.inputEditorMaxHeight = this.options.renderStyle === 'compact' ? INPUT_EDITOR_MAX_HEIGHT / 3 : INPUT_EDITOR_MAX_HEIGHT;
+        this.inputEditorHasText = ChatContextKeys.inputHasText.bindTo(contextKeyService);
+        this.chatCursorAtTop = ChatContextKeys.inputCursorAtTop.bindTo(contextKeyService);
+        this.inputEditorHasFocus = ChatContextKeys.inputHasFocus.bindTo(contextKeyService);
+        this.chatModeKindKey = ChatContextKeys.chatModeKind.bindTo(contextKeyService);
+        this.withinEditSessionKey = ChatContextKeys.withinEditSessionDiff.bindTo(contextKeyService);
+        this.filePartOfEditSessionKey = ChatContextKeys.filePartOfEditSession.bindTo(contextKeyService);
+        this.chatSessionHasOptions = ChatContextKeys.chatSessionHasModels.bindTo(contextKeyService);
+        const chatToolCount = ChatContextKeys.chatToolCount.bindTo(contextKeyService);
+        this._register(autorun(reader => {
+            let count = 0;
+            const userSelectedTools = this.selectedToolsModel.userSelectedTools.read(reader);
+            for (const key in userSelectedTools) {
+                if (userSelectedTools[key] === true) {
+                    count++;
+                }
+            }
+            chatToolCount.set(count);
+        }));
+        this.history = this._register(this.instantiationService.createInstance(ChatHistoryNavigator, this.location));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            const newOptions = {};
+            if (e.affectsConfiguration(AccessibilityVerbositySettingId.Chat)) {
+                newOptions.ariaLabel = this._getAriaLabel();
+            }
+            if (e.affectsConfiguration('editor.wordSegmenterLocales')) {
+                newOptions.wordSegmenterLocales = this.configurationService.getValue('editor.wordSegmenterLocales');
+            }
+            if (e.affectsConfiguration('editor.autoClosingBrackets')) {
+                newOptions.autoClosingBrackets = this.configurationService.getValue('editor.autoClosingBrackets');
+            }
+            if (e.affectsConfiguration('editor.autoClosingQuotes')) {
+                newOptions.autoClosingQuotes = this.configurationService.getValue('editor.autoClosingQuotes');
+            }
+            if (e.affectsConfiguration('editor.autoSurround')) {
+                newOptions.autoSurround = this.configurationService.getValue('editor.autoSurround');
+            }
+            this.inputEditor.updateOptions(newOptions);
+        }));
+        this._chatEditsListPool = this._register(this.instantiationService.createInstance(CollapsibleListPool, this._onDidChangeVisibility.event, MenuId.ChatEditingWidgetModifiedFilesToolbar, { verticalScrollMode: ScrollbarVisibility.Visible }));
+        this._hasFileAttachmentContextKey = ChatContextKeys.hasFileAttachments.bindTo(contextKeyService);
+        this.initSelectedModel();
+        this._register(this.languageModelsService.onDidChangeLanguageModels((vendor) => {
+            this.storageService.store('chat.cachedLanguageModels', this.storageService.getObject('chat.cachedLanguageModels', StorageScope.APPLICATION, []).filter(m => !m.identifier.startsWith(vendor)), StorageScope.APPLICATION, StorageTarget.MACHINE);
+            const selectedModel = this._currentLanguageModel ? this.getModels().find(m => m.identifier === this._currentLanguageModel?.identifier) : undefined;
+            const selectedModelNotAvailable = this._currentLanguageModel && (!selectedModel?.metadata.isUserSelectable);
+            if (!this.currentLanguageModel || selectedModelNotAvailable) {
+                this.setCurrentLanguageModelToDefault();
+            }
+        }));
+        this._register(this.onDidChangeCurrentChatMode(() => {
+            this.accessibilityService.alert(this._currentModeObservable.get().label.get());
+            if (this._inputEditor) {
+                this._inputEditor.updateOptions({ ariaLabel: this._getAriaLabel() });
+            }
+            this.setImplicitContextEnablement();
+        }));
+        this._register(this._onDidChangeCurrentLanguageModel.event(() => {
+            if (this._currentLanguageModel?.metadata.name) {
+                this.accessibilityService.alert(this._currentLanguageModel.metadata.name);
+            }
+            this._inputEditor?.updateOptions({ ariaLabel: this._getAriaLabel() });
+        }));
+        this._register(this.chatModeService.onDidChangeChatModes(() => this.validateCurrentChatMode()));
+        this._register(autorun(r => {
+            const mode = this._currentModeObservable.read(r);
+            this.chatModeKindKey.set(mode.kind);
+            const model = mode.model?.read(r);
+            if (model) {
+                this.switchModelByQualifiedName(model);
+            }
+        }));
+        this.validateCurrentChatMode();
+    }
+    setImplicitContextEnablement() {
+        if (this.implicitContext && this.configurationService.getValue('chat.implicitContext.suggestedContext')) {
+            this.implicitContext.enabled = this._currentModeObservable.get().kind !== ChatMode.Agent.kind;
+        }
+    }
+    setIsWithinEditSession(inInsideDiff, isFilePartOfEditSession) {
+        this.withinEditSessionKey.set(inInsideDiff);
+        this.filePartOfEditSessionKey.set(isFilePartOfEditSession);
+    }
+    getSelectedModelStorageKey() {
+        return `chat.currentLanguageModel.${this.location}`;
+    }
+    getSelectedModelIsDefaultStorageKey() {
+        return `chat.currentLanguageModel.${this.location}.isDefault`;
+    }
+    initSelectedModel() {
+        const persistedSelection = this.storageService.get(this.getSelectedModelStorageKey(), StorageScope.APPLICATION);
+        const persistedAsDefault = this.storageService.getBoolean(this.getSelectedModelIsDefaultStorageKey(), StorageScope.APPLICATION, persistedSelection === 'copilot/gpt-4.1');
+        if (persistedSelection) {
+            const model = this.getModels().find(m => m.identifier === persistedSelection);
+            if (model) {
+                if (!persistedAsDefault || model.metadata.isDefault) {
+                    this.setCurrentLanguageModel(model);
+                    this.checkModelSupported();
+                }
+            }
+            else {
+                this._waitForPersistedLanguageModel.value = this.languageModelsService.onDidChangeLanguageModels(e => {
+                    const persistedModel = this.languageModelsService.lookupLanguageModel(persistedSelection);
+                    if (persistedModel) {
+                        this._waitForPersistedLanguageModel.clear();
+                        if (!persistedAsDefault || persistedModel.isDefault) {
+                            if (persistedModel.isUserSelectable) {
+                                this.setCurrentLanguageModel({ metadata: persistedModel, identifier: persistedSelection });
+                                this.checkModelSupported();
+                            }
+                        }
+                    }
+                    else {
+                        this.setCurrentLanguageModelToDefault();
+                    }
+                });
+            }
+        }
+        this._register(this._onDidChangeCurrentChatMode.event(() => {
+            this.checkModelSupported();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.Edits2Enabled)) {
+                this.checkModelSupported();
+            }
+        }));
+    }
+    setEditing(enabled) {
+        this.currentlyEditingInputKey?.set(enabled);
+    }
+    switchModel(modelMetadata) {
+        const models = this.getModels();
+        const model = models.find(m => m.metadata.vendor === modelMetadata.vendor && m.metadata.id === modelMetadata.id && m.metadata.family === modelMetadata.family);
+        if (model) {
+            this.setCurrentLanguageModel(model);
+        }
+    }
+    switchModelByQualifiedName(qualifiedModelName) {
+        const models = this.getModels();
+        const model = models.find(m => ILanguageModelChatMetadata.matchesQualifiedName(qualifiedModelName, m.metadata));
+        if (model) {
+            this.setCurrentLanguageModel(model);
+            return true;
+        }
+        return false;
+    }
+    switchToNextModel() {
+        const models = this.getModels();
+        if (models.length > 0) {
+            const currentIndex = models.findIndex(model => model.identifier === this._currentLanguageModel?.identifier);
+            const nextIndex = (currentIndex + 1) % models.length;
+            this.setCurrentLanguageModel(models[nextIndex]);
+        }
+    }
+    openModelPicker() {
+        this.modelWidget?.show();
+    }
+    openModePicker() {
+        this.modeWidget?.show();
+    }
+    openChatSessionPicker() {
+        const firstWidget = this.chatSessionPickerWidgets?.values()?.next().value;
+        firstWidget?.show();
+    }
+    createChatSessionPickerWidgets(action) {
+        this._lastSessionPickerAction = action;
+        const resolveChatSessionContext = () => {
+            const sessionResource = this._widget?.viewModel?.model.sessionResource;
+            if (!sessionResource) {
+                return undefined;
+            }
+            return this.chatService.getChatSessionFromInternalUri(sessionResource);
+        };
+        const ctx = resolveChatSessionContext();
+        const optionGroups = ctx ? this.chatSessionsService.getOptionGroupsForSessionType(ctx.chatSessionType) : undefined;
+        if (!optionGroups || optionGroups.length === 0) {
+            return [];
+        }
+        this.disposeSessionPickerWidgets();
+        const widgets = [];
+        for (const optionGroup of optionGroups) {
+            if (!ctx) {
+                continue;
+            }
+            if (!this.chatSessionsService.getSessionOption(ctx.chatSessionResource, optionGroup.id)) {
+                continue;
+            }
+            const initialItem = this.getCurrentOptionForGroup(optionGroup.id);
+            const initialState = { group: optionGroup, item: initialItem };
+            const itemDelegate = {
+                getCurrentOption: () => this.getCurrentOptionForGroup(optionGroup.id),
+                onDidChangeOption: this.getOrCreateOptionEmitter(optionGroup.id).event,
+                setOption: (option) => {
+                    const ctx = resolveChatSessionContext();
+                    if (!ctx) {
+                        return;
+                    }
+                    this.getOrCreateOptionEmitter(optionGroup.id).fire(option);
+                    this.chatSessionsService.notifySessionOptionsChange(ctx.chatSessionResource, [{ optionId: optionGroup.id, value: option }]).catch(err => this.logService.error(`Failed to notify extension of ${optionGroup.id} change:`, err));
+                },
+                getAllOptions: () => {
+                    const ctx = resolveChatSessionContext();
+                    if (!ctx) {
+                        return [];
+                    }
+                    const groups = this.chatSessionsService.getOptionGroupsForSessionType(ctx.chatSessionType);
+                    const group = groups?.find(g => g.id === optionGroup.id);
+                    return group?.items ?? [];
+                }
+            };
+            const widget = this.instantiationService.createInstance(ChatSessionPickerActionItem, action, initialState, itemDelegate);
+            this.chatSessionPickerWidgets.set(optionGroup.id, widget);
+            widgets.push(widget);
+        }
+        return widgets;
+    }
+    setInputModel(model, chatSessionIsEmpty) {
+        this._inputModel = model;
+        this._modelSyncDisposables.clear();
+        this.selectedToolsModel.resetSessionEnablementState();
+        this._chatSessionIsEmpty = chatSessionIsEmpty;
+        if (chatSessionIsEmpty) {
+            this._setEmptyModelState();
+        }
+        this._modelSyncDisposables.add(autorun(reader => {
+            let state = model.state.read(reader);
+            if (!state && this._chatSessionIsEmpty) {
+                state = this._emptyInputState.read(undefined);
+            }
+            this._syncFromModel(state);
+        }));
+    }
+    _setEmptyModelState() {
+        const storageKey = this.getDefaultModeExperimentStorageKey();
+        const hasSetDefaultMode = this.storageService.getBoolean(storageKey, StorageScope.WORKSPACE, false);
+        if (!hasSetDefaultMode) {
+            const isAnonymous = this.entitlementService.anonymous;
+            this.experimentService.getTreatment('chat.defaultMode')
+                .then((defaultModeTreatment => {
+                if (isAnonymous) {
+                    defaultModeTreatment = ChatModeKind.Agent;
+                }
+                if (typeof defaultModeTreatment === 'string') {
+                    this.storageService.store(storageKey, true, StorageScope.WORKSPACE, StorageTarget.MACHINE);
+                    const defaultMode = validateChatMode(defaultModeTreatment);
+                    if (defaultMode) {
+                        this.logService.trace(`Applying default mode from experiment: ${defaultMode}`);
+                        this.setChatMode(defaultMode, false);
+                        this.checkModelSupported();
+                    }
+                }
+            }));
+        }
+    }
+    _syncFromModel(state) {
+        if (this._isSyncingToOrFromInputModel) {
+            return;
+        }
+        try {
+            this._isSyncingToOrFromInputModel = true;
+            if (state) {
+                const currentMode = this._currentModeObservable.get();
+                if (currentMode.id !== state.mode.id) {
+                    this.setChatMode(state.mode.id, false);
+                }
+            }
+            if (state?.selectedModel) {
+                if (!this._currentLanguageModel || this._currentLanguageModel.identifier !== state.selectedModel.identifier) {
+                    this.setCurrentLanguageModel(state.selectedModel);
+                }
+            }
+            const currentAttachments = this._attachmentModel.attachments;
+            if (!state) {
+                this._attachmentModel.clear();
+            }
+            else if (!equals(currentAttachments, state.attachments)) {
+                this._attachmentModel.clearAndSetContext(...state.attachments);
+            }
+            if (this._inputEditor) {
+                this._inputEditor.setValue(state?.inputText || '');
+                if (state?.selections.length) {
+                    this._inputEditor.setSelections(state.selections);
+                }
+            }
+            if (state) {
+                this._widget?.contribs.forEach(contrib => {
+                    contrib.setInputState?.(state.contrib);
+                });
+            }
+        }
+        finally {
+            this._isSyncingToOrFromInputModel = false;
+        }
+    }
+    _syncInputStateToModel() {
+        if (this._isSyncingToOrFromInputModel) {
+            return;
+        }
+        this._isSyncingToOrFromInputModel = true;
+        const state = this.getCurrentInputState();
+        if (this._chatSessionIsEmpty) {
+            this._emptyInputState.set(state, undefined);
+        }
+        this._inputModel?.setState(state);
+        this._isSyncingToOrFromInputModel = false;
+    }
+    setCurrentLanguageModel(model) {
+        this._currentLanguageModel = model;
+        if (this.cachedDimensions) {
+            this.layout(this.cachedDimensions.height, this.cachedDimensions.width);
+        }
+        this.storageService.store(this.getSelectedModelStorageKey(), model.identifier, StorageScope.APPLICATION, StorageTarget.USER);
+        this.storageService.store(this.getSelectedModelIsDefaultStorageKey(), !!model.metadata.isDefault, StorageScope.APPLICATION, StorageTarget.USER);
+        this._onDidChangeCurrentLanguageModel.fire(model);
+        this._syncInputStateToModel();
+    }
+    checkModelSupported() {
+        if (this._currentLanguageModel && (!this.modelSupportedForDefaultAgent(this._currentLanguageModel) || !this.modelSupportedForInlineChat(this._currentLanguageModel))) {
+            this.setCurrentLanguageModelToDefault();
+        }
+    }
+    setChatMode(mode, storeSelection = true) {
+        if (!this.options.supportsChangingModes) {
+            return;
+        }
+        const mode2 = this.chatModeService.findModeById(mode) ??
+            this.chatModeService.findModeById(ChatModeKind.Agent) ??
+            ChatMode.Ask;
+        this.setChatMode2(mode2, storeSelection);
+    }
+    setChatMode2(mode, storeSelection = true) {
+        if (!this.options.supportsChangingModes) {
+            return;
+        }
+        this._currentModeObservable.set(mode, undefined);
+        this._onDidChangeCurrentChatMode.fire();
+        this._syncInputStateToModel();
+    }
+    modelSupportedForDefaultAgent(model) {
+        if (this.currentModeKind === ChatModeKind.Agent || (this.currentModeKind === ChatModeKind.Edit && this.configurationService.getValue(ChatConfiguration.Edits2Enabled))) {
+            return ILanguageModelChatMetadata.suitableForAgentMode(model.metadata);
+        }
+        return true;
+    }
+    modelSupportedForInlineChat(model) {
+        if (this.location !== ChatAgentLocation.EditorInline || !this.configurationService.getValue(InlineChatConfigKeys.EnableV2)) {
+            return true;
+        }
+        return !!model.metadata.capabilities?.toolCalling;
+    }
+    getModels() {
+        const cachedModels = this.storageService.getObject('chat.cachedLanguageModels', StorageScope.APPLICATION, []);
+        let models = ( this.languageModelsService.getLanguageModelIds()
+            .map(
+            modelId => ({ identifier: modelId, metadata: this.languageModelsService.lookupLanguageModel(modelId) })
+        ));
+        if (models.length === 0 || ( models.some(m => m.metadata.isDefault)) === false) {
+            models = cachedModels;
+        }
+        else {
+            this.storageService.store('chat.cachedLanguageModels', models, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+        models.sort((a, b) => a.metadata.name.localeCompare(b.metadata.name));
+        return models.filter(entry => entry.metadata?.isUserSelectable && this.modelSupportedForDefaultAgent(entry) && this.modelSupportedForInlineChat(entry));
+    }
+    setCurrentLanguageModelToDefault() {
+        const allModels = this.getModels();
+        const defaultModel = allModels.find(m => m.metadata.isDefault) || allModels.find(m => m.metadata.isUserSelectable);
+        if (defaultModel) {
+            this.setCurrentLanguageModel(defaultModel);
+        }
+    }
+    getCurrentInputState() {
+        const mode = this._currentModeObservable.get();
+        const state = {
+            inputText: this._inputEditor?.getValue() ?? '',
+            attachments: this._attachmentModel.attachments,
+            mode: {
+                id: mode.id,
+                kind: mode.kind
+            },
+            selectedModel: this._currentLanguageModel,
+            selections: this._inputEditor?.getSelections() || [],
+            contrib: {},
+        };
+        for (const contrib of this._widget?.contribs || Iterable.empty()) {
+            contrib.getInputState?.(state.contrib);
+        }
+        return state;
+    }
+    _getAriaLabel() {
+        const verbose = this.configurationService.getValue(AccessibilityVerbositySettingId.Chat);
+        let kbLabel;
+        if (verbose) {
+            kbLabel = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+        }
+        const mode = this._currentModeObservable.get();
+        const modelName = this._currentLanguageModel?.metadata.name;
+        const modelInfo = modelName ? ( localize(5307, ", {0}. ", modelName)) : '';
+        let modeLabel = '';
+        if (!mode.isBuiltin) {
+            const mode = this.currentModeObs.get();
+            modeLabel = ( localize(5308, "({0}), {1}", mode.label.get(), mode.description.get()));
+        }
+        else {
+            switch (this.currentModeKind) {
+                case ChatModeKind.Agent:
+                    modeLabel = ( localize(5309, "(Agent), edit files in your workspace."));
+                    break;
+                case ChatModeKind.Edit:
+                    modeLabel = ( localize(5310, "(Edit), edit files in your workspace."));
+                    break;
+                case ChatModeKind.Ask:
+                default:
+                    modeLabel = ( localize(5311, "(Ask), ask questions or type / for topics."));
+                    break;
+            }
+        }
+        if (verbose) {
+            return kbLabel
+                ? ( localize(
+                5312,
+                "Chat Input {0}{1} Press Enter to send out the request. Use {2} for Chat Accessibility Help.",
+                modeLabel,
+                modelInfo,
+                kbLabel
+            ))
+                : ( localize(
+                5313,
+                "Chat Input {0}{1} Press Enter to send out the request. Use the Chat Accessibility Help command for more information.",
+                modeLabel,
+                modelInfo
+            ));
+        }
+        else {
+            return localize(5314, "Chat Input {0}{1}.", modeLabel, modelInfo);
+        }
+    }
+    validateCurrentChatMode() {
+        const currentMode = this._currentModeObservable.get();
+        const validMode = this.chatModeService.findModeById(currentMode.id);
+        const isAgentModeEnabled = this.configurationService.getValue(ChatConfiguration.AgentEnabled);
+        if (!validMode) {
+            this.setChatMode(isAgentModeEnabled ? ChatModeKind.Agent : ChatModeKind.Ask);
+            return;
+        }
+        if (currentMode.kind === ChatModeKind.Agent && !isAgentModeEnabled) {
+            this.setChatMode(ChatModeKind.Ask);
+            return;
+        }
+    }
+    getDefaultModeExperimentStorageKey() {
+        const tag = this.options.widgetViewKindTag;
+        return `chat.${tag}.hasSetDefaultModeByExperiment`;
+    }
+    logInputHistory() {
+        const historyStr = ( this.history.values.map(entry => JSON.stringify(entry))).join('\n');
+        this.logService.info(`[${this.location}] Chat input history:`, historyStr);
+    }
+    setVisible(visible) {
+        this._onDidChangeVisibility.fire(visible);
+    }
+    get generating() {
+        return this._generating?.defer.p;
+    }
+    startGenerating() {
+        this.logService.trace('ChatWidget#startGenerating');
+        if (this._generating) {
+            this._generating.rc++;
+        }
+        else {
+            this._generating = { rc: 1, defer: ( new DeferredPromise()) };
+        }
+        return toDisposable(() => {
+            this.logService.trace('ChatWidget#doneGenerating');
+            if (this._generating && !--this._generating.rc) {
+                this._generating.defer.complete();
+                this._generating = undefined;
+            }
+        });
+    }
+    get element() {
+        return this.container;
+    }
+    async showPreviousValue() {
+        if (this.history.isAtStart()) {
+            return;
+        }
+        const state = this.getCurrentInputState();
+        if (state.inputText || state.attachments.length) {
+            this.history.overlay(state);
+        }
+        this.navigateHistory(true);
+    }
+    async showNextValue() {
+        if (this.history.isAtEnd()) {
+            return;
+        }
+        const state = this.getCurrentInputState();
+        if (state.inputText || state.attachments.length) {
+            this.history.overlay(state);
+        }
+        this.navigateHistory(false);
+    }
+    async navigateHistory(previous) {
+        const historyEntry = previous ?
+            this.history.previous() : this.history.next();
+        let historyAttachments = historyEntry?.attachments ?? [];
+        if (historyAttachments.length > 0) {
+            historyAttachments = (await Promise.all(( historyAttachments.map(async (attachment) => {
+                if (isImageVariableEntry(attachment) && attachment.references?.length && URI.isUri(attachment.references[0].reference)) {
+                    const currReference = attachment.references[0].reference;
+                    try {
+                        const imageBinary = ( currReference.toString(true)).startsWith('http') ? await this.sharedWebExtracterService.readImage(currReference, CancellationToken.None) : (await this.fileService.readFile(currReference)).value;
+                        if (!imageBinary) {
+                            return undefined;
+                        }
+                        const newAttachment = { ...attachment };
+                        newAttachment.value = (isImageVariableEntry(attachment) && attachment.isPasted) ? imageBinary.buffer : await resizeImage(imageBinary.buffer);
+                        return newAttachment;
+                    }
+                    catch (err) {
+                        this.logService.error('Failed to fetch and reference.', err);
+                        return undefined;
+                    }
+                }
+                return attachment;
+            })))).filter(attachment => attachment !== undefined);
+        }
+        this._attachmentModel.clearAndSetContext(...historyAttachments);
+        const inputText = historyEntry?.inputText ?? '';
+        const contribData = historyEntry?.contrib ?? {};
+        status(inputText);
+        this.setValue(inputText, true);
+        this._widget?.contribs.forEach(contrib => {
+            contrib.setInputState?.(contribData);
+        });
+        this._onDidLoadInputState.fire();
+        const model = this._inputEditor.getModel();
+        if (!model) {
+            return;
+        }
+        if (previous) {
+            this._inputEditor.setPosition({ lineNumber: 1, column: 1 });
+        }
+        else {
+            this._inputEditor.setPosition(getLastPosition(model));
+        }
+    }
+    setValue(value, transient) {
+        this.inputEditor.setValue(value);
+        const model = this.inputEditor.getModel();
+        if (model) {
+            this.inputEditor.setPosition(getLastPosition(model));
+        }
+    }
+    focus() {
+        this._inputEditor.focus();
+    }
+    hasFocus() {
+        return this._inputEditor.hasWidgetFocus();
+    }
+    async acceptInput(isUserQuery) {
+        if (isUserQuery) {
+            const userQuery = this.getCurrentInputState();
+            this.history.append(this._getFilteredEntry(userQuery));
+        }
+        if (this._chatSessionIsEmpty) {
+            this._chatSessionIsEmpty = false;
+            this._emptyInputState.set(undefined, undefined);
+        }
+        this.attachmentModel.clear();
+        this._onDidLoadInputState.fire();
+        if (this.accessibilityService.isScreenReaderOptimized() && isMacintosh) {
+            this._acceptInputForVoiceover();
+        }
+        else {
+            this._inputEditor.focus();
+            this._inputEditor.setValue('');
+        }
+    }
+    validateAgentMode() {
+        if (!this.agentService.hasToolsAgent && this._currentModeObservable.get().kind === ChatModeKind.Agent) {
+            this.setChatMode(ChatModeKind.Edit);
+        }
+    }
+    _getFilteredEntry(inputState) {
+        const attachmentsWithoutImageValues = ( inputState.attachments.map(attachment => {
+            if (isImageVariableEntry(attachment) && attachment.references?.length && attachment.value) {
+                const newAttachment = { ...attachment };
+                newAttachment.value = undefined;
+                return newAttachment;
+            }
+            return attachment;
+        }));
+        return { ...inputState, attachments: attachmentsWithoutImageValues };
+    }
+    _acceptInputForVoiceover() {
+        const domNode = this._inputEditor.getDomNode();
+        if (!domNode) {
+            return;
+        }
+        domNode.remove();
+        this._inputEditor.setValue('');
+        this._inputEditorElement.appendChild(domNode);
+        this._inputEditor.focus();
+    }
+    _handleAttachedContextChange() {
+        this._hasFileAttachmentContextKey.set(Boolean(this._attachmentModel.attachments.find(a => a.kind === 'file')));
+        this.renderAttachedContext();
+    }
+    getOrCreateOptionEmitter(optionGroupId) {
+        let emitter = this._chatSessionOptionEmitters.get(optionGroupId);
+        if (!emitter) {
+            emitter = this._register(( new Emitter()));
+            this._chatSessionOptionEmitters.set(optionGroupId, emitter);
+        }
+        return emitter;
+    }
+    refreshChatSessionPickers() {
+        const sessionResource = this._widget?.viewModel?.model.sessionResource;
+        const hideAll = () => {
+            this.chatSessionHasOptions.set(false);
+            this.hideAllSessionPickerWidgets();
+        };
+        if (!sessionResource) {
+            return hideAll();
+        }
+        const ctx = this.chatService.getChatSessionFromInternalUri(sessionResource);
+        if (!ctx) {
+            return hideAll();
+        }
+        const optionGroups = this.chatSessionsService.getOptionGroupsForSessionType(ctx.chatSessionType);
+        if (!optionGroups || optionGroups.length === 0) {
+            return hideAll();
+        }
+        if (!this.chatSessionsService.hasAnySessionOptions(ctx.chatSessionResource)) {
+            return hideAll();
+        }
+        this.chatSessionHasOptions.set(true);
+        const currentWidgetGroupIds = ( new Set(( this.chatSessionPickerWidgets.keys())));
+        const requiredGroupIds = ( new Set(( optionGroups.map(g => g.id))));
+        const needsRecreation = currentWidgetGroupIds.size !== requiredGroupIds.size ||
+            !Array.from(requiredGroupIds).every(id => ( currentWidgetGroupIds.has(id)));
+        if (needsRecreation && this._lastSessionPickerAction && this.chatSessionPickerContainer) {
+            const widgets = this.createChatSessionPickerWidgets(this._lastSessionPickerAction);
+            clearNode(this.chatSessionPickerContainer);
+            for (const widget of widgets) {
+                const container = $$1('.action-item.chat-sessionPicker-item');
+                widget.render(container);
+                this.chatSessionPickerContainer.appendChild(container);
+            }
+        }
+        if (this.chatSessionPickerContainer) {
+            this.chatSessionPickerContainer.style.display = '';
+        }
+        for (const [optionGroupId] of this.chatSessionPickerWidgets.entries()) {
+            const currentOption = this.chatSessionsService.getSessionOption(ctx.chatSessionResource, optionGroupId);
+            if (currentOption) {
+                const optionGroup = optionGroups.find(g => g.id === optionGroupId);
+                if (optionGroup) {
+                    const currentOptionId = typeof currentOption === 'string' ? currentOption : currentOption.id;
+                    const item = optionGroup.items.find(m => m.id === currentOptionId);
+                    if (item) {
+                        if (typeof currentOption === 'string') {
+                            this.getOrCreateOptionEmitter(optionGroupId).fire(item);
+                        }
+                        else {
+                            this.getOrCreateOptionEmitter(optionGroupId).fire(currentOption);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    hideAllSessionPickerWidgets() {
+        if (this.chatSessionPickerContainer) {
+            this.chatSessionPickerContainer.style.display = 'none';
+        }
+    }
+    disposeSessionPickerWidgets() {
+        for (const widget of ( this.chatSessionPickerWidgets.values())) {
+            widget.dispose();
+        }
+        this.chatSessionPickerWidgets.clear();
+    }
+    getCurrentOptionForGroup(optionGroupId) {
+        const sessionResource = this._widget?.viewModel?.model.sessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        const ctx = this.chatService.getChatSessionFromInternalUri(sessionResource);
+        if (!ctx) {
+            return;
+        }
+        const optionGroups = this.chatSessionsService.getOptionGroupsForSessionType(ctx.chatSessionType);
+        const optionGroup = optionGroups?.find(g => g.id === optionGroupId);
+        if (!optionGroup || optionGroup.items.length === 0) {
+            return;
+        }
+        const currentOptionValue = this.chatSessionsService.getSessionOption(ctx.chatSessionResource, optionGroupId);
+        if (!currentOptionValue) {
+            return;
+        }
+        if (typeof currentOptionValue === 'string') {
+            return optionGroup.items.find(m => m.id === currentOptionValue);
+        }
+        else {
+            return currentOptionValue;
+        }
+    }
+    tryUpdateWidgetController() {
+        const sessionResource = this._widget?.viewModel?.model.sessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        const sessionType = getChatSessionType(sessionResource);
+        const isLocalSession = sessionType === localChatSessionType;
+        if (!isLocalSession) {
+            this._widgetController.clear();
+            return;
+        }
+        if (!this._widgetController.value) {
+            this._widgetController.value = this.instantiationService.createInstance(ChatInputPartWidgetController, this.chatInputWidgetsContainer);
+            this._register(this._widgetController.value.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+        }
+    }
+    render(container, initialValue, widget) {
+        this._widget = widget;
+        this._register(widget.onDidChangeViewModel(() => {
+            this.refreshChatSessionPickers();
+            this.tryUpdateWidgetController();
+        }));
+        let elements;
+        if (this.options.renderStyle === 'compact') {
+            elements = h('.interactive-input-part', [
+                h('.interactive-input-and-edit-session', [
+                    h('.chat-input-widgets-container@chatInputWidgetsContainer'),
+                    h('.chat-todo-list-widget-container@chatInputTodoListWidgetContainer'),
+                    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-attachments-container@attachmentsContainer', [
+                        h('.chat-attachment-toolbar@attachmentToolbar'),
+                        h('.chat-attached-context@attachedContextContainer'),
+                        h('.chat-related-files@relatedFilesContainer'),
+                    ]),
+                    h('.interactive-input-followups@followupsContainer'),
+                ])
+            ]);
+        }
+        else {
+            elements = h('.interactive-input-part', [
+                h('.interactive-input-followups@followupsContainer'),
+                h('.chat-input-widgets-container@chatInputWidgetsContainer'),
+                h('.chat-todo-list-widget-container@chatInputTodoListWidgetContainer'),
+                h('.chat-editing-session@chatEditingSessionWidgetContainer'),
+                h('.interactive-input-and-side-toolbar@inputAndSideToolbar', [
+                    h('.chat-input-container@inputContainer', [
+                        h('.chat-attachments-container@attachmentsContainer', [
+                            h('.chat-attachment-toolbar@attachmentToolbar'),
+                            h('.chat-related-files@relatedFilesContainer'),
+                            h('.chat-attached-context@attachedContextContainer'),
+                        ]),
+                        h('.chat-editor-container@editorContainer'),
+                        h('.chat-input-toolbars@inputToolbars'),
+                    ]),
+                ]),
+            ]);
+        }
+        this.container = elements.root;
+        this.chatInputOverlay = $$1('.chat-input-overlay');
+        container.append(this.container);
+        this.container.append(this.chatInputOverlay);
+        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.attachmentsContainer = elements.attachmentsContainer;
+        this.attachedContextContainer = elements.attachedContextContainer;
+        this.relatedFilesContainer = elements.relatedFilesContainer;
+        const toolbarsContainer = elements.inputToolbars;
+        const attachmentToolbarContainer = elements.attachmentToolbar;
+        this.chatEditingSessionWidgetContainer = elements.chatEditingSessionWidgetContainer;
+        this.chatInputTodoListWidgetContainer = elements.chatInputTodoListWidgetContainer;
+        this.chatInputWidgetsContainer = elements.chatInputWidgetsContainer;
+        if (this.options.enableImplicitContext && !this._implicitContext) {
+            this._implicitContext = this._register(this.instantiationService.createInstance(ChatImplicitContext));
+            this.setImplicitContextEnablement();
+            this._register(this._implicitContext.onDidChangeValue(() => {
+                this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+                this._handleAttachedContextChange();
+            }));
+        }
+        else if (!this.options.enableImplicitContext && this._implicitContext) {
+            this._implicitContext?.dispose();
+            this._implicitContext = undefined;
+        }
+        this.tryUpdateWidgetController();
+        this.renderAttachedContext();
+        this._register(this._attachmentModel.onDidChange((e) => {
+            if (e.added.length > 0) {
+                this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+            }
+            this._handleAttachedContextChange();
+        }));
+        this.renderChatEditingSessionState(null);
+        if (this.options.renderWorkingSet) {
+            this._relatedFiles = this._register(( new ChatRelatedFiles()));
+            this._register(this._relatedFiles.onDidChange(() => this.renderChatRelatedFiles()));
+        }
+        this.renderChatRelatedFiles();
+        this.dnd.addOverlay(this.options.dndContainer ?? container, this.options.dndContainer ?? container);
+        const inputScopedContextKeyService = this._register(this.contextKeyService.createScoped(inputContainer));
+        ChatContextKeys.inChatInput.bindTo(inputScopedContextKeyService).set(true);
+        this.currentlyEditingInputKey = ChatContextKeys.currentlyEditingInput.bindTo(inputScopedContextKeyService);
+        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, inputScopedContextKeyService]))));
+        const { historyNavigationBackwardsEnablement, historyNavigationForwardsEnablement } = this._register(registerAndCreateHistoryNavigationContext(inputScopedContextKeyService, this));
+        this.historyNavigationBackwardsEnablement = historyNavigationBackwardsEnablement;
+        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;
+        options.fontSize = 13;
+        options.lineHeight = 20;
+        options.padding = this.options.renderStyle === 'compact' ? { top: 2, bottom: 2 } : { top: 8, bottom: 8 };
+        options.cursorWidth = 1;
+        options.wrappingStrategy = 'advanced';
+        options.bracketPairColorization = { enabled: false };
+        options.autoClosingBrackets = this.configurationService.getValue('editor.autoClosingBrackets');
+        options.autoClosingQuotes = this.configurationService.getValue('editor.autoClosingQuotes');
+        options.autoSurround = this.configurationService.getValue('editor.autoSurround');
+        options.suggest = {
+            showIcons: true,
+            showSnippets: false,
+            showWords: true,
+            showStatusBar: false,
+            insertMode: 'insert',
+        };
+        options.scrollbar = { ...(options.scrollbar ?? {}), vertical: 'hidden' };
+        options.stickyScroll = { enabled: false };
+        this._inputEditorElement = append(editorContainer, $(chatInputEditorContainerSelector));
+        const editorOptions = getSimpleCodeEditorWidgetOptions();
+        editorOptions.contributions?.push(...EditorExtensionsRegistry.getSomeEditorContributions([ContentHoverController.ID, GlyphHoverController.ID, DropIntoEditorController.ID, CopyPasteController.ID, LinkDetector.ID]));
+        this._inputEditor = this._register(scopedInstantiationService.createInstance(CodeEditorWidget, this._inputEditorElement, options, editorOptions));
+        SuggestController.get(this._inputEditor)?.forceRenderingAbove();
+        options.overflowWidgetsDomNode?.classList.add('hideSuggestTextIcons');
+        this._inputEditorElement.classList.add('hideSuggestTextIcons');
+        this._register(this._inputEditor.onKeyDown((e) => {
+            if (e.keyCode === KeyCode.Enter && !hasModifierKeys(e)) {
+                for (const keybinding of this.keybindingService.lookupKeybindings(ChatSubmitAction.ID)) {
+                    const chords = keybinding.getDispatchChords();
+                    const isPlainEnter = chords.length === 1 && chords[0] === '[Enter]';
+                    if (isPlainEnter) {
+                        e.preventDefault();
+                        break;
+                    }
+                }
+            }
+        }));
+        this._register(this._inputEditor.onDidScrollChange(e => {
+            toolbarsContainer.classList.toggle('scroll-top-decoration', e.scrollTop > 0);
+        }));
+        this._register(this._inputEditor.onDidChangeModelContent(() => {
+            const currentHeight = Math.min(this._inputEditor.getContentHeight(), this.inputEditorMaxHeight);
+            if (currentHeight !== this.inputEditorHeight) {
+                this.inputEditorHeight = currentHeight;
+                this._onDidChangeHeight.fire();
+            }
+            const model = this._inputEditor.getModel();
+            const inputHasText = !!model && model.getValue().trim().length > 0;
+            this.inputEditorHasText.set(inputHasText);
+            this._syncTextDebounced.schedule();
+        }));
+        this._register(this._inputEditor.onDidContentSizeChange(e => {
+            if (e.contentHeightChanged) {
+                this.inputEditorHeight = !this.inline ? e.contentHeight : this.inputEditorHeight;
+                this._onDidChangeHeight.fire();
+            }
+        }));
+        this._register(this._inputEditor.onDidFocusEditorText(() => {
+            this.inputEditorHasFocus.set(true);
+            this._onDidFocus.fire();
+            inputContainer.classList.toggle('focused', true);
+        }));
+        this._register(this._inputEditor.onDidBlurEditorText(() => {
+            this.inputEditorHasFocus.set(false);
+            inputContainer.classList.toggle('focused', false);
+            this._onDidBlur.fire();
+        }));
+        this._register(this._inputEditor.onDidBlurEditorWidget(() => {
+            CopyPasteController.get(this._inputEditor)?.clearWidgets();
+            DropIntoEditorController.get(this._inputEditor)?.clearWidgets();
+        }));
+        const hoverDelegate = this._register(createInstantHoverDelegate());
+        this._register(addStandardDisposableListener(toolbarsContainer, EventType.CLICK, e => this.inputEditor.focus()));
+        this._register(addStandardDisposableListener(this.attachmentsContainer, EventType.CLICK, e => this.inputEditor.focus()));
+        this.inputActionsToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, this.options.renderInputToolbarBelowInput ? this.attachmentsContainer : toolbarsContainer, MenuId.ChatInput, {
+            telemetrySource: this.options.menus.telemetrySource,
+            menuOptions: { shouldForwardArgs: true },
+            hiddenItemStrategy: HiddenItemStrategy.NoHide,
+            hoverDelegate,
+            actionViewItemProvider: (action, options) => {
+                if (action.id === ChatOpenModelPickerActionId && action instanceof MenuItemAction) {
+                    if (!this._currentLanguageModel) {
+                        this.setCurrentLanguageModelToDefault();
+                    }
+                    const itemDelegate = {
+                        getCurrentModel: () => this._currentLanguageModel,
+                        onDidChangeModel: this._onDidChangeCurrentLanguageModel.event,
+                        setModel: (model) => {
+                            this._waitForPersistedLanguageModel.clear();
+                            this.setCurrentLanguageModel(model);
+                            this.renderAttachedContext();
+                        },
+                        getModels: () => this.getModels()
+                    };
+                    return this.modelWidget = this.instantiationService.createInstance(ModelPickerActionItem, action, this._currentLanguageModel, undefined, itemDelegate);
+                }
+                else if (action.id === OpenModePickerAction.ID && action instanceof MenuItemAction) {
+                    const delegate = {
+                        currentMode: this._currentModeObservable,
+                        sessionResource: () => this._widget?.viewModel?.sessionResource,
+                    };
+                    return this.modeWidget = this.instantiationService.createInstance(ModePickerActionItem, action, delegate);
+                }
+                else if (action.id === ChatSessionPrimaryPickerAction.ID && action instanceof MenuItemAction) {
+                    const widgets = this.createChatSessionPickerWidgets(action);
+                    if (widgets.length === 0) {
+                        return undefined;
+                    }
+                    return this.instantiationService.createInstance(ChatSessionPickersContainerActionItem, action, widgets);
+                }
+                return undefined;
+            }
+        }));
+        this.inputActionsToolbar.getElement().classList.add('chat-input-toolbar');
+        this.inputActionsToolbar.context = { widget };
+        this._register(this.inputActionsToolbar.onDidChangeMenuItems(() => {
+            const toolbarElement = this.inputActionsToolbar.getElement();
+            const container = toolbarElement.querySelector('.chat-sessionPicker-container');
+            this.chatSessionPickerContainer = container;
+            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
+            },
+            hoverDelegate,
+            hiddenItemStrategy: HiddenItemStrategy.NoHide,
+            actionViewItemProvider: (action, options) => {
+                if (action.id === ContinueChatInSessionAction.ID && action instanceof MenuItemAction) {
+                    return this.instantiationService.createInstance(ChatContinueInSessionActionItem, action, ActionLocation.ChatWidget);
+                }
+                return undefined;
+            }
+        }));
+        this.executeToolbar.getElement().classList.add('chat-execute-toolbar');
+        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);
+            }
+        }));
+        if (this.options.menus.inputSideToolbar) {
+            const toolbarSide = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, inputAndSideToolbar, this.options.menus.inputSideToolbar, {
+                telemetrySource: this.options.menus.telemetrySource,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                hoverDelegate
+            }));
+            this.inputSideToolbarContainer = toolbarSide.getElement();
+            toolbarSide.getElement().classList.add('chat-side-toolbar');
+            toolbarSide.context = { widget };
+        }
+        let inputModel = this.modelService.getModel(this.inputUri);
+        if (!inputModel) {
+            inputModel = this.modelService.createModel('', null, this.inputUri, true);
+        }
+        this.textModelResolverService.createModelReference(this.inputUri).then(ref => {
+            if (this._store.isDisposed) {
+                ref.dispose();
+                return;
+            }
+            this._register(ref);
+        });
+        this.inputModel = inputModel;
+        this.inputModel.updateOptions({ bracketColorizationOptions: { enabled: false, independentColorPoolPerBracketType: false } });
+        this._inputEditor.setModel(this.inputModel);
+        if (initialValue) {
+            this.inputModel.setValue(initialValue);
+            const lineNumber = this.inputModel.getLineCount();
+            this._inputEditor.setPosition({ lineNumber, column: this.inputModel.getLineMaxColumn(lineNumber) });
+        }
+        const onDidChangeCursorPosition = () => {
+            const model = this._inputEditor.getModel();
+            if (!model) {
+                return;
+            }
+            const position = this._inputEditor.getPosition();
+            if (!position) {
+                return;
+            }
+            const atTop = position.lineNumber === 1 && position.column === 1;
+            this.chatCursorAtTop.set(atTop);
+            this.historyNavigationBackwardsEnablement.set(atTop);
+            this.historyNavigationForewardsEnablement.set(position.equals(getLastPosition(model)));
+            this._syncInputStateToModel();
+        };
+        this._register(this._inputEditor.onDidChangeCursorPosition(e => onDidChangeCursorPosition()));
+        onDidChangeCursorPosition();
+        this._register(this.themeService.onDidFileIconThemeChange(() => {
+            this.renderAttachedContext();
+        }));
+        this.addFilesToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, attachmentToolbarContainer, MenuId.ChatInputAttachmentToolbar, {
+            telemetrySource: this.options.menus.telemetrySource,
+            label: true,
+            menuOptions: { shouldForwardArgs: true, renderShortTitle: true },
+            hiddenItemStrategy: HiddenItemStrategy.NoHide,
+            hoverDelegate,
+            actionViewItemProvider: (action, options) => {
+                if (action.id === 'workbench.action.chat.attachContext') {
+                    const viewItem = this.instantiationService.createInstance(AddFilesButton, this._attachmentModel, action, options);
+                    viewItem.setShowLabel(this._attachmentModel.size === 0 && !this.hasImplicitContextBlock());
+                    this.addFilesButton = viewItem;
+                    return this.addFilesButton;
+                }
+                return undefined;
+            }
+        }));
+        this.addFilesToolbar.context = { widget, placeholder: ( localize(5315, 'Search for files and context to add to your request')) };
+        this._register(this.addFilesToolbar.onDidChangeMenuItems(() => {
+            if (this.cachedDimensions) {
+                this._onDidChangeHeight.fire();
+            }
+        }));
+    }
+    toggleChatInputOverlay(editing) {
+        this.chatInputOverlay.classList.toggle('disabled', editing);
+        if (editing) {
+            this.overlayClickListener.value = addStandardDisposableListener(this.chatInputOverlay, EventType.CLICK, e => {
+                e.preventDefault();
+                e.stopPropagation();
+                this._onDidClickOverlay.fire();
+            });
+        }
+        else {
+            this.overlayClickListener.clear();
+        }
+    }
+    renderAttachedContext() {
+        const container = this.attachedContextContainer;
+        const oldHeight = this.attachmentsContainer.offsetHeight;
+        const store = ( new DisposableStore());
+        this.attachedContextDisposables.value = store;
+        clearNode(container);
+        store.add(addStandardDisposableListener(this.attachmentsContainer, EventType.KEY_DOWN, (e) => {
+            this.handleAttachmentNavigation(e);
+        }));
+        const attachments = [...this.attachmentModel.attachments.entries()];
+        const hasAttachments = Boolean(attachments.length) || Boolean(this.implicitContext?.value);
+        setVisibility(Boolean(this.options.renderInputToolbarBelowInput || hasAttachments || (this.addFilesToolbar && !this.addFilesToolbar.isEmpty())), this.attachmentsContainer);
+        setVisibility(hasAttachments, this.attachedContextContainer);
+        if (!attachments.length) {
+            this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+            this._indexOfLastOpenedContext = -1;
+        }
+        const isSuggestedEnabled = this.configurationService.getValue('chat.implicitContext.suggestedContext');
+        if (this.implicitContext?.value && !isSuggestedEnabled) {
+            const implicitPart = store.add(this.instantiationService.createInstance(ImplicitContextAttachmentWidget, () => this._widget, this.implicitContext, this._contextResourceLabels, this.attachmentModel));
+            container.appendChild(implicitPart.domNode);
+        }
+        for (const [index, attachment] of attachments) {
+            const resource = URI.isUri(attachment.value) ? attachment.value : isLocation(attachment.value) ? attachment.value.uri : undefined;
+            const range = isLocation(attachment.value) ? attachment.value.range : undefined;
+            const shouldFocusClearButton = index === Math.min(this._indexOfLastAttachedContextDeletedWithKeyboard, this.attachmentModel.size - 1) && this._indexOfLastAttachedContextDeletedWithKeyboard > -1;
+            let attachmentWidget;
+            const options = { shouldFocusClearButton, supportsDeletion: true };
+            if (attachment.kind === 'tool' || attachment.kind === 'toolset') {
+                attachmentWidget = this.instantiationService.createInstance(ToolSetOrToolItemAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (resource && isNotebookOutputVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(NotebookCellOutputChatAttachmentWidget, resource, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isPromptFileVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(PromptFileAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isPromptTextVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(PromptTextAttachmentWidget, attachment, undefined, options, container, this._contextResourceLabels);
+            }
+            else if (resource && (attachment.kind === 'file' || attachment.kind === 'directory')) {
+                attachmentWidget = this.instantiationService.createInstance(FileAttachmentWidget, resource, range, attachment, undefined, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (attachment.kind === 'terminalCommand') {
+                attachmentWidget = this.instantiationService.createInstance(TerminalCommandAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isImageVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(ImageAttachmentWidget, resource, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isElementVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(ElementChatAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isPasteVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(PasteAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isSCMHistoryItemVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(SCMHistoryItemAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isSCMHistoryItemChangeVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(SCMHistoryItemChangeAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else if (isSCMHistoryItemChangeRangeVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(SCMHistoryItemChangeRangeAttachmentWidget, attachment, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            else {
+                attachmentWidget = this.instantiationService.createInstance(DefaultChatAttachmentWidget, resource, range, attachment, undefined, this._currentLanguageModel, options, container, this._contextResourceLabels);
+            }
+            if (shouldFocusClearButton) {
+                attachmentWidget.element.focus();
+            }
+            if (index === Math.min(this._indexOfLastOpenedContext, this.attachmentModel.size - 1)) {
+                attachmentWidget.element.focus();
+            }
+            store.add(attachmentWidget);
+            store.add(attachmentWidget.onDidDelete(e => {
+                this.handleAttachmentDeletion(e, index, attachment);
+            }));
+            store.add(attachmentWidget.onDidOpen(e => {
+                this.handleAttachmentOpen(index, attachment);
+            }));
+        }
+        const implicitValue = this.implicitContext?.value;
+        if (isSuggestedEnabled && implicitValue) {
+            const targetUri = this.implicitContext.uri;
+            const currentlyAttached = ( attachments.some(([, attachment]) => {
+                let uri;
+                if (URI.isUri(attachment.value)) {
+                    uri = attachment.value;
+                }
+                else if (isStringVariableEntry(attachment)) {
+                    uri = attachment.uri;
+                }
+                return uri && isEqual(uri, targetUri);
+            }));
+            const shouldShowImplicit = !isLocation(implicitValue) ? !currentlyAttached : implicitValue.range;
+            if (shouldShowImplicit) {
+                const implicitPart = store.add(this.instantiationService.createInstance(ImplicitContextAttachmentWidget, () => this._widget, this.implicitContext, this._contextResourceLabels, this._attachmentModel));
+                container.appendChild(implicitPart.domNode);
+            }
+        }
+        if (oldHeight !== this.attachmentsContainer.offsetHeight) {
+            this._onDidChangeHeight.fire();
+        }
+        this.addFilesButton?.setShowLabel(this._attachmentModel.size === 0 && !this.hasImplicitContextBlock());
+        this._indexOfLastOpenedContext = -1;
+    }
+    hasImplicitContextBlock() {
+        const implicit = this.implicitContext?.value;
+        if (!implicit) {
+            return false;
+        }
+        const isSuggestedEnabled = this.configurationService.getValue('chat.implicitContext.suggestedContext');
+        if (!isSuggestedEnabled) {
+            return true;
+        }
+        const isUri = URI.isUri(implicit);
+        if (isUri || isLocation(implicit)) {
+            const targetUri = isUri ? implicit : implicit.uri;
+            const attachments = [...this._attachmentModel.attachments.entries()];
+            const currentlyAttached = ( attachments.some(([, a]) => URI.isUri(a.value) && isEqual(a.value, targetUri)));
+            const shouldShowImplicit = isUri ? !currentlyAttached : implicit.range;
+            return !!shouldShowImplicit;
+        }
+        return false;
+    }
+    handleAttachmentDeletion(e, index, attachment) {
+        if (isKeyboardEvent(e)) {
+            this._indexOfLastAttachedContextDeletedWithKeyboard = index;
+        }
+        this._attachmentModel.delete(attachment.id);
+        if (this.configurationService.getValue('chat.implicitContext.enableImplicitContext')) {
+            const implicitValue = URI.isUri(this.implicitContext?.value) && URI.isUri(attachment.value) && isEqual(this.implicitContext.value, attachment.value);
+            if (this.implicitContext?.isFile && implicitValue) {
+                this.implicitContext.enabled = false;
+            }
+        }
+        if (this._attachmentModel.size === 0) {
+            this.focus();
+        }
+        this._onDidChangeContext.fire({ removed: [attachment] });
+        this.renderAttachedContext();
+    }
+    handleAttachmentOpen(index, attachment) {
+        this._indexOfLastOpenedContext = index;
+        this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+        if (this._attachmentModel.size === 0) {
+            this.focus();
+        }
+    }
+    handleAttachmentNavigation(e) {
+        if (!e.equals(KeyCode.LeftArrow) && !e.equals(KeyCode.RightArrow)) {
+            return;
+        }
+        const toolbar = this.addFilesToolbar?.getElement().querySelector('.action-label');
+        if (!toolbar) {
+            return;
+        }
+        const attachments = Array.from(this.attachedContextContainer.querySelectorAll('.chat-attached-context-attachment'));
+        if (!attachments.length) {
+            return;
+        }
+        attachments.unshift(toolbar);
+        const activeElement = getActiveElement(getWindow(this.attachmentsContainer).document);
+        const currentIndex = attachments.findIndex(attachment => attachment === activeElement);
+        let newIndex = currentIndex;
+        if (e.equals(KeyCode.LeftArrow)) {
+            newIndex = currentIndex > 0 ? currentIndex - 1 : attachments.length - 1;
+        }
+        else if (e.equals(KeyCode.RightArrow)) {
+            newIndex = currentIndex < attachments.length - 1 ? currentIndex + 1 : 0;
+        }
+        if (newIndex !== -1) {
+            const nextElement = attachments[newIndex];
+            nextElement.focus();
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    }
+    async renderChatTodoListWidget(chatSessionResource) {
+        const isTodoWidgetEnabled = this.configurationService.getValue(ChatConfiguration.TodosShowWidget) !== false;
+        if (!isTodoWidgetEnabled) {
+            return;
+        }
+        if (!this._chatInputTodoListWidget.value) {
+            const widget = this._chatEditingTodosDisposables.add(this.instantiationService.createInstance(ChatTodoListWidget));
+            this._chatInputTodoListWidget.value = widget;
+            clearNode(this.chatInputTodoListWidgetContainer);
+            append(this.chatInputTodoListWidgetContainer, widget.domNode);
+            this._chatEditingTodosDisposables.add(widget.onDidChangeHeight(() => {
+                this._onDidChangeHeight.fire();
+            }));
+        }
+        this._chatInputTodoListWidget.value.render(chatSessionResource);
+    }
+    clearTodoListWidget(sessionResource, force) {
+        this._chatInputTodoListWidget.value?.clear(sessionResource, force);
+    }
+    renderChatEditingSessionState(chatEditingSession) {
+        setVisibility(Boolean(chatEditingSession), this.chatEditingSessionWidgetContainer);
+        if (chatEditingSession) {
+            if (!isEqual(chatEditingSession.chatSessionResource, this._lastEditingSessionResource)) {
+                this._workingSetCollapsed.set(true, undefined);
+            }
+            this._lastEditingSessionResource = chatEditingSession.chatSessionResource;
+        }
+        const modifiedEntries = derivedOpts({ equalsFn: equals }, r => {
+            return chatEditingSession?.entries.read(r).filter(entry => entry.state.read(r) === ModifiedFileEntryState.Modified) || [];
+        });
+        const editSessionEntries = derived((reader) => {
+            const seenEntries = ( new ResourceSet());
+            const entries = [];
+            for (const entry of modifiedEntries.read(reader)) {
+                if (entry.state.read(reader) !== ModifiedFileEntryState.Modified) {
+                    continue;
+                }
+                if (!( seenEntries.has(entry.modifiedURI))) {
+                    seenEntries.add(entry.modifiedURI);
+                    const linesAdded = entry.linesAdded?.read(reader);
+                    const linesRemoved = entry.linesRemoved?.read(reader);
+                    entries.push({
+                        reference: entry.modifiedURI,
+                        state: ModifiedFileEntryState.Modified,
+                        kind: 'reference',
+                        options: {
+                            status: undefined,
+                            diffMeta: { added: linesAdded ?? 0, removed: linesRemoved ?? 0 }
+                        }
+                    });
+                }
+            }
+            entries.sort((a, b) => {
+                if (a.kind === 'reference' && b.kind === 'reference') {
+                    if (a.state === b.state || a.state === undefined || b.state === undefined) {
+                        return ( a.reference.toString()).localeCompare(( b.reference.toString()));
+                    }
+                    return a.state - b.state;
+                }
+                return 0;
+            });
+            return entries;
+        });
+        const sessionFileChanges = observableFromEvent(this, this.agentSessionsService.model.onDidChangeSessions, () => {
+            const sessionResource = this._widget?.viewModel?.model?.sessionResource;
+            if (!sessionResource) {
+                return Iterable.empty();
+            }
+            const model = this.agentSessionsService.getSession(sessionResource);
+            return model?.changes instanceof Array ? model.changes : Iterable.empty();
+        });
+        const sessionFiles = derived(reader => ( sessionFileChanges.read(reader).map((entry) => ({
+            reference: entry.modifiedUri,
+            state: ModifiedFileEntryState.Accepted,
+            kind: 'reference',
+            options: {
+                status: undefined,
+                diffMeta: { added: entry.insertions, removed: entry.deletions },
+                originalUri: entry.originalUri,
+            }
+        }))));
+        const shouldRender = derived(reader => editSessionEntries.read(reader).length > 0 || sessionFiles.read(reader).length > 0);
+        this._renderingChatEdits.value = autorun(reader => {
+            if (this.options.renderWorkingSet && shouldRender.read(reader)) {
+                this.renderChatEditingSessionWithEntries(reader.store, chatEditingSession, modifiedEntries, sessionFileChanges, editSessionEntries, sessionFiles);
+            }
+            else {
+                clearNode(this.chatEditingSessionWidgetContainer);
+                this._chatEditsDisposables.clear();
+                this._chatEditList = undefined;
+            }
+        });
+    }
+    renderChatEditingSessionWithEntries(store, chatEditingSession, modifiedEntries, sessionFileChanges, editSessionEntries, sessionEntries) {
+        const innerContainer = this.chatEditingSessionWidgetContainer.querySelector('.chat-editing-session-container.show-file-icons') ?? append(this.chatEditingSessionWidgetContainer, $('.chat-editing-session-container.show-file-icons'));
+        const overviewRegion = innerContainer.querySelector('.chat-editing-session-overview') ?? append(innerContainer, $('.chat-editing-session-overview'));
+        const overviewTitle = overviewRegion.querySelector('.working-set-title') ?? append(overviewRegion, $('.working-set-title'));
+        this._chatEditsActionsDisposables.clear();
+        const actionsContainer = overviewRegion.querySelector('.chat-editing-session-actions') ?? append(overviewRegion, $('.chat-editing-session-actions'));
+        const sessionResource = chatEditingSession?.chatSessionResource || this._widget?.viewModel?.model.sessionResource;
+        const scopedContextKeyService = this._chatEditsActionsDisposables.add(this.contextKeyService.createScoped(actionsContainer));
+        if (sessionResource) {
+            scopedContextKeyService.createKey(ChatContextKeys.agentSessionType.key, getChatSessionType(sessionResource));
+        }
+        this._chatEditsActionsDisposables.add(bindContextKey(ChatContextKeys.hasAgentSessionChanges, scopedContextKeyService, r => !!sessionEntries.read(r)?.length));
+        const scopedInstantiationService = this._chatEditsActionsDisposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, scopedContextKeyService]))));
+        const workingSetContainer = innerContainer.querySelector('.chat-editing-session-list') ?? append(innerContainer, $('.chat-editing-session-list'));
+        const button = this._chatEditsActionsDisposables.add(( new ButtonWithIcon(overviewTitle, {
+            supportIcons: true,
+            secondary: true,
+            ariaLabel: ( localize(5316, 'Toggle changed files.')),
+        })));
+        const topLevelStats = derived(reader => {
+            let added = 0;
+            let removed = 0;
+            const entries = modifiedEntries.read(reader);
+            for (const entry of entries) {
+                if (entry.linesAdded && entry.linesRemoved) {
+                    added += entry.linesAdded.read(reader);
+                    removed += entry.linesRemoved.read(reader);
+                }
+            }
+            let baseLabel = entries.length === 1 ? ( localize(5317, '1 file changed')) : ( localize(5318, '{0} files changed', entries.length));
+            let shouldShowEditingSession = added > 0 || removed > 0;
+            let topLevelIsSessionMenu = false;
+            if (added === 0 && removed === 0) {
+                const sessionValue = sessionFileChanges.read(reader) || [];
+                for (const entry of sessionValue) {
+                    added += entry.insertions;
+                    removed += entry.deletions;
+                }
+                shouldShowEditingSession = sessionValue.length > 0;
+                baseLabel = sessionValue.length === 1 ? ( localize(5319, '1 file ready to merge')) : ( localize(5320, '{0} files ready to merge', sessionValue.length));
+                topLevelIsSessionMenu = true;
+            }
+            button.label = baseLabel;
+            return { added, removed, shouldShowEditingSession, baseLabel, topLevelIsSessionMenu };
+        });
+        const topLevelIsSessionMenu = ( topLevelStats.map(t => t.topLevelIsSessionMenu));
+        store.add(autorun(reader => {
+            const isSessionMenu = topLevelIsSessionMenu.read(reader);
+            reader.store.add(scopedInstantiationService.createInstance(MenuWorkbenchButtonBar, actionsContainer, isSessionMenu ? MenuId.ChatEditingSessionChangesToolbar : MenuId.ChatEditingWidgetToolbar, {
+                telemetrySource: this.options.menus.telemetrySource,
+                menuOptions: {
+                    arg: sessionResource && (isSessionMenu ? sessionResource : {
+                        $mid: MarshalledId.ChatViewContext,
+                        sessionResource,
+                    }),
+                },
+                buttonConfigProvider: (action) => {
+                    if (action.id === ChatEditingShowChangesAction.ID || action.id === ViewPreviousEditsAction.Id || action.id === ViewAllSessionChangesAction.ID) {
+                        return { showIcon: true, showLabel: false, isSecondary: true };
+                    }
+                    return undefined;
+                }
+            }));
+        }));
+        store.add(autorun(reader => {
+            const { added, removed, shouldShowEditingSession, baseLabel } = topLevelStats.read(reader);
+            button.label = baseLabel;
+            this._workingSetLinesAddedSpan.value.textContent = `+${added}`;
+            this._workingSetLinesRemovedSpan.value.textContent = `-${removed}`;
+            button.element.setAttribute('aria-label', ( localize(5321, '{0}, {1} lines added, {2} lines removed', baseLabel, added, removed)));
+            setVisibility(shouldShowEditingSession, this.chatEditingSessionWidgetContainer);
+            if (!shouldShowEditingSession) {
+                this._onDidChangeHeight.fire();
+            }
+        }));
+        const countsContainer = $$1('.working-set-line-counts');
+        button.element.appendChild(countsContainer);
+        countsContainer.appendChild(this._workingSetLinesAddedSpan.value);
+        countsContainer.appendChild(this._workingSetLinesRemovedSpan.value);
+        const toggleWorkingSet = () => {
+            this._workingSetCollapsed.set(!this._workingSetCollapsed.get(), undefined);
+        };
+        this._chatEditsActionsDisposables.add(button.onDidClick(toggleWorkingSet));
+        this._chatEditsActionsDisposables.add(addDisposableListener(overviewRegion, 'click', e => {
+            if (e.defaultPrevented) {
+                return;
+            }
+            const target = e.target;
+            if (target.closest('.monaco-button')) {
+                return;
+            }
+            toggleWorkingSet();
+        }));
+        this._chatEditsActionsDisposables.add(autorun(reader => {
+            const collapsed = this._workingSetCollapsed.read(reader);
+            button.icon = collapsed ? Codicon.chevronRight : Codicon.chevronDown;
+            workingSetContainer.classList.toggle('collapsed', collapsed);
+            this._onDidChangeHeight.fire();
+        }));
+        if (!this._chatEditList) {
+            this._chatEditList = this._chatEditsListPool.get();
+            const list = this._chatEditList.object;
+            this._chatEditsDisposables.add(this._chatEditList);
+            this._chatEditsDisposables.add(list.onDidFocus(() => {
+                this._onDidFocus.fire();
+            }));
+            this._chatEditsDisposables.add(list.onDidOpen(async (e) => {
+                if (e.element?.kind === 'reference' && URI.isUri(e.element.reference)) {
+                    const modifiedFileUri = e.element.reference;
+                    const originalUri = e.element.options?.originalUri;
+                    if (originalUri) {
+                        await this.editorService.openEditor({
+                            original: { resource: originalUri },
+                            modified: { resource: modifiedFileUri },
+                            options: e.editorOptions
+                        }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+                        return;
+                    }
+                    const entry = chatEditingSession?.getEntry(modifiedFileUri);
+                    const pane = await this.editorService.openEditor({
+                        resource: modifiedFileUri,
+                        options: e.editorOptions
+                    }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+                    if (pane) {
+                        entry?.getEditorIntegration(pane).reveal(true, e.editorOptions.preserveFocus);
+                    }
+                }
+            }));
+            this._chatEditsDisposables.add(addDisposableListener(list.getHTMLElement(), 'click', e => {
+                if (!this.hasFocus()) {
+                    this._onDidFocus.fire();
+                }
+            }, true));
+            append(workingSetContainer, list.getHTMLElement());
+            append(innerContainer, workingSetContainer);
+        }
+        store.add(autorun(reader => {
+            const editEntries = editSessionEntries.read(reader);
+            const sessionFileEntries = sessionEntries.read(reader) ?? [];
+            const allEntries = [...editEntries];
+            if (sessionFileEntries.length > 0) {
+                if (editEntries.length > 0) {
+                    allEntries.push({
+                        kind: 'divider',
+                        label: ( localize(5322, 'Worktree Changes')),
+                        menuId: MenuId.ChatEditingSessionChangesToolbar,
+                        menuArg: sessionResource,
+                        scopedInstantiationService,
+                    });
+                }
+                allEntries.push(...sessionFileEntries);
+            }
+            const maxItemsShown = 6;
+            const itemsShown = Math.min(allEntries.length, maxItemsShown);
+            const height = itemsShown * 22;
+            const list = this._chatEditList.object;
+            list.layout(height);
+            list.getHTMLElement().style.height = `${height}px`;
+            list.splice(0, list.length, allEntries);
+            this._onDidChangeHeight.fire();
+        }));
+    }
+    async renderChatRelatedFiles() {
+        const anchor = this.relatedFilesContainer;
+        clearNode(anchor);
+        const shouldRender = this.configurationService.getValue('chat.renderRelatedFiles');
+        setVisibility(Boolean(this.relatedFiles?.value.length && shouldRender), anchor);
+        if (!shouldRender || !this.relatedFiles?.value.length) {
+            return;
+        }
+        const hoverDelegate = getDefaultHoverDelegate('element');
+        for (const { uri, description } of this.relatedFiles.value) {
+            const uriLabel = this._chatEditsActionsDisposables.add(( new Button(anchor, {
+                supportIcons: true,
+                secondary: true,
+                hoverDelegate
+            })));
+            uriLabel.label = this.labelService.getUriBasenameLabel(uri);
+            uriLabel.element.classList.add('monaco-icon-label');
+            uriLabel.element.title = ( localize(
+                5323,
+                "{0} - {1}",
+                this.labelService.getUriLabel(uri, { relative: true }),
+                description ?? ''
+            ));
+            this._chatEditsActionsDisposables.add(uriLabel.onDidClick(async () => {
+                group.remove();
+                await this._attachmentModel.addFile(uri);
+                this.relatedFiles?.remove(uri);
+            }));
+            const addButton = this._chatEditsActionsDisposables.add(( new Button(anchor, {
+                supportIcons: false,
+                secondary: true,
+                hoverDelegate,
+                ariaLabel: ( localize(
+                    5324,
+                    'Add suggestion {0}',
+                    this.labelService.getUriLabel(uri, { relative: true })
+                )),
+            })));
+            addButton.icon = Codicon.add;
+            addButton.setTitle(( localize(5325, 'Add suggestion')));
+            this._chatEditsActionsDisposables.add(addButton.onDidClick(async () => {
+                group.remove();
+                await this._attachmentModel.addFile(uri);
+                this.relatedFiles?.remove(uri);
+            }));
+            const sep = createElement('div');
+            sep.classList.add('separator');
+            const group = createElement('span');
+            group.classList.add('monaco-button-dropdown', 'sidebyside-button');
+            group.appendChild(addButton.element);
+            group.appendChild(sep);
+            group.appendChild(uriLabel.element);
+            append(anchor, group);
+            this._chatEditsActionsDisposables.add(toDisposable(() => {
+                group.remove();
+            }));
+        }
+        this._onDidChangeHeight.fire();
+    }
+    async renderFollowups(items, response) {
+        if (!this.options.renderFollowups) {
+            return;
+        }
+        this.followupsDisposables.clear();
+        clearNode(this.followupsContainer);
+        if (items && items.length > 0) {
+            this.followupsDisposables.add(this.instantiationService.createInstance(ChatFollowups, this.followupsContainer, items, this.location, undefined, followup => this._onDidAcceptFollowup.fire({ followup, response })));
+        }
+        this._onDidChangeHeight.fire();
+    }
+    get contentHeight() {
+        const data = this.getLayoutData();
+        return data.followupsHeight + data.inputPartEditorHeight + data.inputPartVerticalPadding + data.inputEditorBorder + data.attachmentsHeight + data.toolbarsHeight + data.chatEditingStateHeight + data.todoListWidgetContainerHeight + data.inputWidgetsContainerHeight;
+    }
+    layout(height, width) {
+        this.cachedDimensions = new Dimension(width, height);
+        return this._layout(height, width);
+    }
+    _layout(height, width, allowRecurse = true) {
+        const data = this.getLayoutData();
+        const inputEditorHeight = Math.min(data.inputPartEditorHeight, height - data.followupsHeight - data.attachmentsHeight - data.inputPartVerticalPadding - data.toolbarsHeight - data.chatEditingStateHeight - data.todoListWidgetContainerHeight - data.inputWidgetsContainerHeight);
+        const followupsWidth = width - data.inputPartHorizontalPadding;
+        this.followupsContainer.style.width = `${followupsWidth}px`;
+        this._inputPartHeight = data.inputPartVerticalPadding + data.followupsHeight + inputEditorHeight + data.inputEditorBorder + data.attachmentsHeight + data.toolbarsHeight + data.chatEditingStateHeight + data.todoListWidgetContainerHeight + data.inputWidgetsContainerHeight;
+        this._followupsHeight = data.followupsHeight;
+        this._editSessionWidgetHeight = data.chatEditingStateHeight;
+        const initialEditorScrollWidth = this._inputEditor.getScrollWidth();
+        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);
+            this.previousInputEditorDimension = newDimension;
+        }
+        if (allowRecurse && initialEditorScrollWidth < 10) {
+            return this._layout(height, width, false);
+        }
+    }
+    getLayoutData() {
+        const executeToolbarWidth = this.cachedExecuteToolbarWidth = this.executeToolbar.getItemsWidth();
+        const inputToolbarWidth = this.cachedInputToolbarWidth = this.inputActionsToolbar.getItemsWidth();
+        const inputSideToolbarWidth = this.inputSideToolbarContainer ? getTotalWidth(this.inputSideToolbarContainer) : 0;
+        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' ? 16 : 32,
+            inputPartVerticalPadding: this.options.renderStyle === 'compact' ? 12 : ((16  + 6  + (2 * 4)) ),
+            attachmentsHeight: this.attachmentsHeight,
+            editorBorder: 2,
+            inputPartHorizontalPaddingInside: 12,
+            toolbarsWidth: this.options.renderStyle === 'compact' ? executeToolbarWidth + executeToolbarPadding + (this.options.renderInputToolbarBelowInput ? 0 : inputToolbarWidth + inputToolbarPadding) : 0,
+            toolbarsHeight: this.options.renderStyle === 'compact' ? 0 : 22,
+            chatEditingStateHeight: this.chatEditingSessionWidgetContainer.offsetHeight,
+            sideToolbarWidth: inputSideToolbarWidth > 0 ? inputSideToolbarWidth + 4  : 0,
+            todoListWidgetContainerHeight: this.chatInputTodoListWidgetContainer.offsetHeight,
+            inputWidgetsContainerHeight: this.inputWidgetsHeight,
+        };
+    }
+};
+ChatInputPart = ChatInputPart_1 = ( __decorate([
+    ( __param(4, IModelService)),
+    ( __param(5, IInstantiationService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IKeybindingService)),
+    ( __param(9, IAccessibilityService)),
+    ( __param(10, ILanguageModelsService)),
+    ( __param(11, ILogService)),
+    ( __param(12, IFileService)),
+    ( __param(13, IEditorService)),
+    ( __param(14, IThemeService)),
+    ( __param(15, ITextModelService)),
+    ( __param(16, IStorageService)),
+    ( __param(17, ILabelService)),
+    ( __param(18, IChatAgentService)),
+    ( __param(19, ISharedWebContentExtractorService)),
+    ( __param(20, IWorkbenchAssignmentService)),
+    ( __param(21, IChatEntitlementService)),
+    ( __param(22, IChatModeService)),
+    ( __param(23, ILanguageModelToolsService)),
+    ( __param(24, IChatService)),
+    ( __param(25, IChatSessionsService)),
+    ( __param(26, IChatContextService)),
+    ( __param(27, IAgentSessionsService))
+], ChatInputPart));
+function getLastPosition(model) {
+    return { lineNumber: model.getLineCount(), column: model.getLineLength(model.getLineCount()) + 1 };
+}
+const chatInputEditorContainerSelector = '.interactive-input-editor';
+setupSimpleEditorSelectionStyling(chatInputEditorContainerSelector);
+class ChatSessionPickersContainerActionItem extends ActionViewItem {
+    constructor(action, widgets, options) {
+        super(null, action, options ?? {});
+        this.widgets = widgets;
+    }
+    render(container) {
+        container.classList.add('chat-sessionPicker-container');
+        for (const widget of this.widgets) {
+            const itemContainer = $$1('.action-item.chat-sessionPicker-item');
+            widget.render(itemContainer);
+            container.appendChild(itemContainer);
+        }
+    }
+    dispose() {
+        for (const widget of this.widgets) {
+            widget.dispose();
+        }
+        super.dispose();
+    }
+}
+class AddFilesButton extends ActionViewItem {
+    constructor(context, action, options) {
+        super(context, action, {
+            ...options,
+            icon: false,
+            label: true,
+            keybindingNotRenderedWithLabel: true,
+        });
+    }
+    setShowLabel(show) {
+        this.showLabel = show;
+        this.updateLabel();
+    }
+    render(container) {
+        container.classList.add('chat-attachment-button');
+        super.render(container);
+        this.updateLabel();
+    }
+    updateLabel() {
+        if (!this.label) {
+            return;
+        }
+        assertType(this.label);
+        this.label.classList.toggle('has-label', this.showLabel);
+        const message = this.showLabel ? `$(attach) ${this.action.label}` : `$(attach)`;
+        reset(this.label, ...renderLabelWithIcons(message));
+    }
+}
+
+export { ChatInputPart };