@codingame/monaco-vscode-api 37.2.0 → 37.3.1

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

@@ -0,0 +1,4571 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { $ as $$1, isAncestorOfActiveElement, clearNode, h, hide, append, addDisposableListener, EventType, getWindow, addStandardDisposableListener, isHTMLElement, AnimationFrameScheduler, DisposableResizeObserver, setVisibility, isKeyboardEvent, getActiveElement, show, scheduleAtNextAnimationFrame, getTotalWidth } from '../../../../../../base/browser/dom.js';
+import { DEFAULT_FONT_FAMILY } from '../../../../../../base/browser/fonts.js';
+import { hasModifierKeys } from '../../../../../../base/browser/keyboardEvent.js';
+import { ActionViewItem, BaseActionViewItem } from '../../../../../../base/browser/ui/actionbar/actionViewItems.js';
+import { status } from '../../../../../../base/browser/ui/aria/aria.js';
+import { ButtonWithIcon } from '../../../../../../base/browser/ui/button/button.js';
+import { createInstantHoverDelegate } from '../../../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { equals } from '../../../../../../base/common/arrays.js';
+import { RunOnceScheduler, DeferredPromise } from '../../../../../../base/common/async.js';
+import { isDefined } from '../../../../../../base/common/types.js';
+import { CancellationToken } from '../../../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { Emitter, Event } from '../../../../../../base/common/event.js';
+import { onUnexpectedError } from '../../../../../../base/common/errors.js';
+import { Iterable } from '../../../../../../base/common/iterator.js';
+import { KeyCode } from '../../../../../../base/common/keyCodes.js';
+import { Lazy } from '../../../../../../base/common/lazy.js';
+import { Disposable, DisposableStore, toDisposable, MutableDisposable, DisposableMap } from '../../../../../../base/common/lifecycle.js';
+import { ResourceSet } from '../../../../../../base/common/map.js';
+import { MarshalledId } from '../../../../../../base/common/marshallingIds.js';
+import { Schemas } from '../../../../../../base/common/network.js';
+import { mixin } from '../../../../../../base/common/objects.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { isMacintosh } from '../../../../../../base/common/platform.js';
+import { isEqual } from '../../../../../../base/common/resources.js';
+import { ScrollbarVisibility } from '../../../../../../base/common/scrollable.js';
+import { ThemeIcon } from '../../../../../../base/common/themables.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { EditorExtensionsRegistry } from '../../../../../../editor/browser/editorExtensions.js';
+import { CodeEditorWidget } from '../../../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { EditorOptions } from '../../../../../../editor/common/config/editorOptions.js';
+import { EDITOR_FONT_DEFAULTS } from '../../../../../../editor/common/config/fontInfo.js';
+import { Range } from '../../../../../../editor/common/core/range.js';
+import { isLocation } from '../../../../../../editor/common/languages.js';
+import { IModelService } from '../../../../../../editor/common/services/model.service.js';
+import { ITextModelService } from '../../../../../../editor/common/services/resolverService.service.js';
+import { CopyPasteController } from '../../../../../../editor/contrib/dropOrPasteInto/browser/copyPasteController.js';
+import { DropIntoEditorController } from '../../../../../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorController.js';
+import { ContentHoverController } from '../../../../../../editor/contrib/hover/browser/contentHoverController.js';
+import { GlyphHoverController } from '../../../../../../editor/contrib/hover/browser/glyphHoverController.js';
+import { LinkDetector } from '../../../../../../editor/contrib/links/browser/links.js';
+import { SuggestController } from '../../../../../../editor/contrib/suggest/browser/suggestController.js';
+import { localize } from '../../../../../../nls.js';
+import { IAccessibilityService } from '../../../../../../platform/accessibility/common/accessibility.service.js';
+import { MenuWorkbenchButtonBar } from '../../../../../../platform/actions/browser/buttonbar.js';
+import { IActionViewItemService } from '../../../../../../platform/actions/browser/actionViewItemService.service.js';
+import { MenuEntryActionViewItem } from '../../../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../../../platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction } from '../../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
+import { RawContextKey, ContextKeyExpr } from '../../../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../../../platform/contextkey/common/contextkey.service.js';
+import { IDialogService } from '../../../../../../platform/dialogs/common/dialogs.service.js';
+import { IFileService } from '../../../../../../platform/files/common/files.service.js';
+import { registerAndCreateHistoryNavigationContext } from '../../../../../../platform/history/browser/contextScopedHistoryWidget.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../../../platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from '../../../../../../platform/keybinding/common/keybinding.service.js';
+import { canLog, LogLevel } from '../../../../../../platform/log/common/log.js';
+import { ILogService } from '../../../../../../platform/log/common/log.service.js';
+import { observableMemento } from '../../../../../../platform/observable/common/observableMemento.js';
+import { bindContextKey } from '../../../../../../platform/observable/common/platformObservableUtils.js';
+import { IVoiceModeOnboardingService } from '../../../../agentsVoice/browser/voiceModeOnboarding.service.js';
+import { StorageScope, StorageTarget } from '../../../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../../../platform/storage/common/storage.service.js';
+import { IThemeService } from '../../../../../../platform/theme/common/themeService.service.js';
+import { ISharedWebContentExtractorService } from '../../../../../../platform/webContentExtractor/common/webContentExtractor.service.js';
+import { WorkbenchState } from '../../../../../../platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from '../../../../../../platform/workspace/common/workspace.service.js';
+import { ISCMService } from '../../../../scm/common/scm.service.js';
+import { Position } from '../../../../../services/layout/browser/layoutService.js';
+import { IWorkbenchLayoutService } from '../../../../../services/layout/browser/layoutService.service.js';
+import { ViewContainerLocation } from '../../../../../common/views.js';
+import { IViewDescriptorService } from '../../../../../common/views.service.js';
+import { ResourceLabels } from '../../../../../browser/labels.js';
+import { IChatEntitlementService } from '../../../../../services/chat/common/chatEntitlementService.service.js';
+import { SIDE_GROUP, ACTIVE_GROUP } from '../../../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.service.js';
+import { IWorkbenchEnvironmentService } from '../../../../../services/environment/common/environmentService.service.js';
+import { AccessibilityVerbositySettingId } from '../../../../accessibility/browser/accessibilityConfiguration.js';
+import { AccessibilityCommandId } from '../../../../accessibility/common/accessibilityCommands.js';
+import { getSimpleEditorOptions, getSimpleCodeEditorWidgetOptions, setupSimpleEditorSelectionStyling } from '../../../../codeEditor/browser/simpleEditorOptions.js';
+import { ChatContextKeys } from '../../../common/actions/chatContextKeys.js';
+import { ChatRequestVariableSet, isImageVariableEntry, isExplicitFileOrImageVariableEntry, getImageAttachmentLimit, OmittedState, isNotebookOutputVariableEntry, isPromptFileVariableEntry, isPromptTextVariableEntry, isElementVariableEntry, isPasteVariableEntry, isSCMHistoryItemVariableEntry, isSCMHistoryItemChangeVariableEntry, isSCMHistoryItemChangeRangeVariableEntry, isBrowserViewVariableEntry, isPastedTextArtifact, isAgentHostCompletionVariableEntry } from '../../../common/attachments/chatVariableEntries.js';
+import { getModeNameForTelemetry, ChatMode } from '../../../common/chatModes.js';
+import { IChatModeService } from '../../../common/chatModes.service.js';
+import { IChatService } from '../../../common/chatService/chatService.service.js';
+import { SessionType, localChatSessionType, isAgentHostTarget, isIChatSessionFileChange2 } from '../../../common/chatSessionsService.js';
+import { IChatSessionsService } from '../../../common/chatSessionsService.service.js';
+import { getStoredSelectedModel, storeSelectedModel } from '../../../common/chatSelectedModel.js';
+import { ChatAgentLocation, ChatModeKind, ChatConfiguration, ChatPermissionLevel, isChatPermissionLevel } from '../../../common/constants.js';
+import { isAutoApproveValuePolicyRestricted, isAutoApprovePolicyRestricted } from '../../../common/agentHostConfigPolicy.js';
+import { ModifiedFileEntryState } from '../../../common/editing/chatEditingService.js';
+import { ILanguageModelChatMetadata } from '../../../common/languageModels.js';
+import { ILanguageModelsService } from '../../../common/languageModels.service.js';
+import { ChatInputModelSelectionController } from './chatInputModelSelectionController.js';
+import { ChatModelConfigurationStore } from './chatModelConfigurationStore.js';
+import { ChatModelSelectionDiagnostics } from './chatModelSelectionDiagnostics.js';
+import { deserializeUntitledInputState, serializeUntitledInputState, deserializeUntitledInputAttachments, serializeUntitledInputAttachments } from './chatInputStatePersistence.js';
+import { IntendedModelSlot, logChangesToStateModel, ChatInputStateOrigin } from '../../../common/model/chatModel.js';
+import { ModelSelectionReason, isInConversationModelChoice, resolveConfiguredModel } from '../../../common/modelSelection.js';
+import { isSessionStarted, isModelSupportedForMode, isModelSupportedForInlineChat, hasModelsTargetingSession, filterModelsForSession, shouldResetOnModelListChange, isNewConversation, shouldRestorePerTypeModelOnSessionSwitch, mergeModelsWithCache, isModelHiddenInPicker, shouldDropAgnosticDraftModel } from './chatInputModelUtils.js';
+import { LocalChatSessionUri, getChatSessionType, isUntitledChatSession } from '../../../common/model/chatUri.js';
+import { isResponseVM } from '../../../common/model/chatViewModel.js';
+import { IChatAgentService } from '../../../common/participants/chatAgents.service.js';
+import { ILanguageModelToolsService } from '../../../common/tools/languageModelToolsService.service.js';
+import { ChatHistoryNavigator } from '../../../common/widget/chatWidgetHistoryService.js';
+import { OpenModelPickerAction, ChatSubmitAction, OpenModePickerAction, OpenSessionTargetPickerAction, OpenDelegationPickerAction, ChatSessionPrimaryPickerAction, ChatEditingSessionSubmitAction, OpenWorkspacePickerAction, OpenPermissionPickerAction } from '../../actions/chatExecuteActions.js';
+import { ChatVoiceInputModeAction, VoiceInputModeActionViewItem } from '../../voiceInputMode/voiceInputModeActionViewItem.js';
+import { ChatSpeechToTextPreparingAction, ChatSpeechToTextConnectingAction, ToggleChatSpeechToTextAction } from '../../actions/chatSpeechToTextActions.js';
+import { DictationActionViewItem } from '../../speechToText/dictationActionViewItem.js';
+import { DictationDownloadActionViewItem } from '../../speechToText/dictationDownloadActionViewItem.js';
+import { ChatSpeechToTextState } from '../../speechToText/chatSpeechToTextService.js';
+import { IChatSpeechToTextService } from '../../speechToText/chatSpeechToTextService.service.js';
+import { IDictationOnboardingService } from '../../speechToText/dictationOnboarding.service.js';
+import { notifyDictationSubmitted, onDidChangeDictationEditor, isDictationActiveForEditor } from '../../speechToText/dictationSession.js';
+import { VoiceModeActionViewItem } from '../../voiceClient/voiceModeActionViewItem.js';
+import { isVoiceSessionActiveForInput } from '../../voiceClient/voiceSessionController.js';
+import { IVoiceSessionController } from '../../voiceClient/voiceSessionController.service.js';
+import { getAgentSessionProvider, AgentSessionProviders } from '../../agentSessions/agentSessions.js';
+import { getAgentSessionPullRequestContextValue } from '../../agentSessions/agentSessionsModel.js';
+import { IAgentSessionsService } from '../../agentSessions/agentSessionsService.service.js';
+import { ChatAttachmentModel } from '../../attachments/chatAttachmentModel.js';
+import { IChatAttachmentWidgetRegistry } from '../../attachments/chatAttachmentWidgetRegistry.service.js';
+import { ToolSetOrToolItemAttachmentWidget, NotebookCellOutputChatAttachmentWidget, PromptFileAttachmentWidget, PromptTextAttachmentWidget, FileAttachmentWidget, TerminalCommandAttachmentWidget, ImageAttachmentWidget, ElementChatAttachmentWidget, PasteAttachmentWidget, SCMHistoryItemAttachmentWidget, SCMHistoryItemChangeAttachmentWidget, SCMHistoryItemChangeRangeAttachmentWidget, BrowserViewAttachmentWidget, DefaultChatAttachmentWidget } from '../../attachments/chatAttachmentWidgets.js';
+import { ChatImplicitContexts } from '../../attachments/chatImplicitContext.js';
+import { isImplicitContextAlreadyAttached, ImplicitContextAttachmentWidget } from '../../attachments/implicitContextAttachment.js';
+import { isIChatResourceViewContext, isIChatViewViewContext } from '../../chat.js';
+import { IChatWidgetService } from '../../chat.service.js';
+import { ChatEditingShowChangesAction, ViewPreviousEditsAction } from '../../chatEditing/chatEditingActions.js';
+import { resizeImage } from '../../chatImageUtils.js';
+import { ChatSessionPickerActionItem } from '../../chatSessions/chatSessionPickerActionItem.js';
+import { AgentHostChatInputPicker, AgentHostChatInputPickerActionViewItem } from '../../agentSessions/agentHost/agentHostChatInputPicker.js';
+import { OpenAgentHostModePickerAction, OpenAgentHostAutoApprovePickerAction, OpenAgentHostPermissionModePickerAction, OpenAgentHostCodexApprovalsPickerAction, OpenAgentHostFolderPickerAction, getAgentHostPickerProperty } from '../../agentSessions/agentHost/agentHostChatInputPicker.contribution.js';
+import { AgentHostGenericConfigChips } from '../../agentSessions/agentHost/agentHostGenericConfigChips.js';
+import { AgentHostFolderPickerActionItem } from '../../agentSessions/agentHost/agentHostFolderPickerActionItem.js';
+import { MobileChatInputCombinedPickerActionItem } from './chatPhoneInputPresenter.js';
+import { IChatPhoneInputPresenter } from './chatPhoneInputPresenter.service.js';
+import { IChatContextService } from '../../contextContrib/chatContextService.service.js';
+import { ChatPlanReviewPart } from '../chatContentParts/chatPlanReviewPart.js';
+import { ChatQuestionCarouselPart } from '../chatContentParts/chatQuestionCarouselPart.js';
+import { ChatToolConfirmationCarouselPart } from '../chatContentParts/toolInvocationParts/chatToolConfirmationCarouselPart.js';
+import { CollapsibleListPool } from '../chatContentParts/chatReferencesContentPart.js';
+import { ChatTodoListWidget } from '../chatContentParts/chatTodoListWidget.js';
+import { ChatArtifactsWidget } from '../chatArtifactsWidget.js';
+import { isTerminalCommandPaste, isTerminalCommandInput, handleTerminalCommandPaste } from '../../chatTerminalCommandPaste.js';
+import { ChatDynamicVariableModel } from '../../attachments/chatDynamicVariables.js';
+import { ChatDragAndDrop } from '../chatDragAndDrop.js';
+import { getChatPetPillPlatformTop, getChatPetStackPlatformTop } from '../chatPetWidget.js';
+import { ChatFollowups } from './chatFollowups.js';
+import { IChatInputNotificationService } from './chatInputNotificationService.service.js';
+import { ChatGoalBannerWidget } from './chatGoalBannerWidget.js';
+import { ChatInputNotificationWidget } from './chatInputNotificationWidget.js';
+import { ChatInputNoticeHost, ChatInputNoticeLane } from './chatInputNoticeHost.js';
+import { registerChatInputOnboardingHosts } from './chatInputOnboardingHosts.js';
+import { IChatInputNoticeHubService } from './chatInputNoticeHub.service.js';
+import { isChatInputPickerResponsiveState, ChatInputPickerResponsiveLayout } from './chatInputPickerResponsiveLayout.js';
+import { chatInputSurfaceStackClass, chatInputSurfaceStackSlotClass, chatInputStackClass, chatInputStackSlotClass, setChatInputStackInputFocused, setChatInputStackSlot, ChatInputStackSlot } from './chatInputStack.js';
+import { ChatSessionArchiveNudge } from './chatSessionArchiveNudge.js';
+import { ChatSelectedTools } from './chatSelectedTools.js';
+import { didExplicitlySwitchChatPetModel, ChatPetAchievementIds } from '../../chatPetAchievements.js';
+import { IChatPetService } from '../../chatPetService.service.js';
+import { DelegationSessionPickerActionItem } from './delegationSessionPickerActionItem.js';
+import { ModelPickerActionItem } from './modelPicker/modelPickerActionItem.js';
+import { ModePickerActionItem } from './modePickerActionItem.js';
+import { PermissionPickerActionItem } from './permissionPickerActionItem.js';
+import { SessionTypePickerActionItem } from './sessionTargetPickerActionItem.js';
+import { WorkspacePickerActionItem } from './workspacePickerActionItem.js';
+import { ChatContextUsageWidget } from '../../widgetHosts/viewPane/chatContextUsageWidget.js';
+import { Target } from '../../../common/promptSyntax/promptTypes.js';
+import { ConfigureToolsAction } from '../../actions/chatToolActions.js';
+import { InlineCompletionsController } from '../../../../../../editor/contrib/inlineCompletions/browser/controller/inlineCompletionsController.js';
+import { PlaceholderTextContribution } from '../../../../../../editor/contrib/placeholderText/browser/placeholderTextContribution.js';
+import { observableValue } from '../../../../../../base/common/observableInternal/observables/observableValue.js';
+import { derived, derivedOpts } from '../../../../../../base/common/observableInternal/observables/derived.js';
+import { observableSignalFromEvent } from '../../../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
+import { autorun } from '../../../../../../base/common/observableInternal/reactions/autorun.js';
+import { constObservable } from '../../../../../../base/common/observableInternal/observables/constObservable.js';
+import { transaction } from '../../../../../../base/common/observableInternal/transaction.js';
+import { observableFromEvent } from '../../../../../../base/common/observableInternal/observables/observableFromEvent.js';
+
+var ChatInputPart_1;
+const $ = $$1;
+const INPUT_EDITOR_MAX_HEIGHT = 250;
+const INPUT_EDITOR_LINE_HEIGHT = 20;
+const INPUT_EDITOR_PADDING = {
+    compact: {
+        top: 2,
+        bottom: 2
+    },
+    default: {
+        top: 12,
+        bottom: 12
+    }
+};
+const CachedLanguageModelsKey = "chat.cachedLanguageModels.v2";
+const PERMISSION_LEVEL_OPTION_ID = "permissionLevel";
+const CHAT_INPUT_COMPACT_PICKER_WIDTH = 22;
+function getToolbarPickerResponsiveItems(toolbar, compactStates, minimalStates) {
+    const items = [];
+    const visibleActionIds = ( new Set());
+    for (let index = 0; index < toolbar.getItemsLength(); index++) {
+        const action = toolbar.getItemAction(index);
+        const state = action && compactStates.get(action.id);
+        const minimalState = action && minimalStates?.get(action.id);
+        const viewItem = toolbar.getItemViewItem(index);
+        const viewItemState = isChatInputPickerResponsiveState(viewItem) ? viewItem : undefined;
+        if (!action || (!state && !viewItemState)) {
+            continue;
+        }
+        visibleActionIds.add(action.id);
+        const element = toolbar.getItemElement(index);
+        items.push({
+            element,
+            canShrink: action.id === OpenModelPickerAction.ID,
+            isCompact: () => viewItemState?.isCompact() ?? state.get(),
+            isMinimal: minimalState ? () => minimalState.get() : undefined,
+            setCompact: compact => {
+                state?.set(compact, undefined);
+                viewItemState?.setCompact(compact);
+                element?.classList.toggle("compact-picker", compact);
+            },
+            setMinimal: minimalState ? minimal => minimalState.set(minimal, undefined) : undefined
+        });
+    }
+    for (const [actionId, state] of compactStates) {
+        if (!( visibleActionIds.has(actionId))) {
+            const minimalState = minimalStates?.get(actionId);
+            items.push({
+                element: undefined,
+                isCompact: () => state.get(),
+                isMinimal: minimalState ? () => minimalState.get() : undefined,
+                setCompact: compact => state.set(compact, undefined),
+                setMinimal: minimalState ? minimal => minimalState.set(minimal, undefined) : undefined
+            });
+        }
+    }
+    return items;
+}
+function isShowableActionViewItem(item) {
+    return !!item && "show" in item && typeof item.show === "function";
+}
+function createOverflowAction(action, run) {
+    return {
+        id: action.id,
+        label: action.label,
+        tooltip: action.tooltip,
+        class: action.class,
+        enabled: action.enabled,
+        checked: action.checked,
+        run
+    };
+}
+var ChatWidgetLocation;
+(function(ChatWidgetLocation) {
+    ChatWidgetLocation["SidebarLeft"] = "sidebarLeft";
+    ChatWidgetLocation["SidebarRight"] = "sidebarRight";
+    ChatWidgetLocation["Panel"] = "panel";
+    ChatWidgetLocation["Editor"] = "editor";
+})(ChatWidgetLocation || (ChatWidgetLocation = {}));
+const LEGACY_SHARED_INPUT_STATE_TAGS = ( new Set(["view", "editor", "quick"]));
+function getInputStateStorageKey(widgetViewKindTag) {
+    if (( LEGACY_SHARED_INPUT_STATE_TAGS.has(widgetViewKindTag))) {
+        return "chat.untitledInputState";
+    }
+    return `chat.untitledInputState.${widgetViewKindTag}`;
+}
+function createEmptyInputStateMemento(widgetViewKindTag) {
+    return observableMemento({
+        defaultValue: undefined,
+        key: getInputStateStorageKey(widgetViewKindTag),
+        toStorage: serializeUntitledInputState,
+        fromStorage(value) {
+            const obj = deserializeUntitledInputState(value);
+            if (obj.selectedModel && !obj.selectedModel.metadata.isDefaultForLocation) {
+                const oldIsDefault = obj.selectedModel.metadata.isDefault;
+                const isDefaultForLocation = {
+                    [ChatAgentLocation.Chat]: Boolean(oldIsDefault)
+                };
+                mixin(obj.selectedModel.metadata, {
+                    isDefaultForLocation: isDefaultForLocation
+                });
+                delete obj.selectedModel.metadata.isDefault;
+            }
+            return obj;
+        }
+    });
+}
+const emptyInputAttachments = observableMemento({
+    defaultValue: [],
+    key: "chat.untitledInputAttachments",
+    toStorage: serializeUntitledInputAttachments,
+    fromStorage: deserializeUntitledInputAttachments
+});
+let ChatInputPart = class ChatInputPart extends Disposable {
+    static {
+        ChatInputPart_1 = this;
+    }
+    static {
+        this._counter = 0;
+    }
+    get attachmentModel() {
+        return this._attachmentModel;
+    }
+    getAttachedContext() {
+        const contextArr = ( new ChatRequestVariableSet());
+        contextArr.add(
+            ...this.attachmentModel.attachments,
+            ...this.chatContextService.getWorkspaceContextItems()
+        );
+        return contextArr;
+    }
+    getAttachedAndImplicitContext() {
+        const contextArr = this.getAttachedContext();
+        if (this.implicitContext) {
+            const implicitChatVariables = this.implicitContext.enabledBaseEntries(
+                this.configurationService.getValue("chat.implicitContext.suggestedContext")
+            );
+            contextArr.add(...implicitChatVariables);
+        }
+        return contextArr;
+    }
+    get implicitContext() {
+        return this._implicitContext;
+    }
+    get inputContainerElement() {
+        return this.inputContainer;
+    }
+    get inputRowHeight() {
+        return this.inputAndSideToolbar.offsetHeight;
+    }
+    get persistentContentContainerElement() {
+        return this.persistentContentContainer;
+    }
+    get hasSessionArchiveNudge() {
+        return !!this.sessionArchiveNudgeWidget.value;
+    }
+    setSessionArchiveNudge(options) {
+        this.sessionArchiveNudgeOptions = options;
+        if (!this.sessionArchiveNudgeContainer) {
+            return;
+        }
+        if (!options) {
+            const restoreFocus = this.sessionArchiveNudgeWidget.value && isAncestorOfActiveElement(this.sessionArchiveNudgeWidget.value.domNode);
+            this.sessionArchiveNudgeWidget.clear();
+            if (restoreFocus) {
+                this.focus();
+            }
+            return;
+        }
+        const widgetOptions = {
+            ...options,
+            onDismiss: () => {
+                this.focus();
+                this.setSessionArchiveNudge(undefined);
+                options.onDismiss();
+            }
+        };
+        if (this.sessionArchiveNudgeWidget.value) {
+            this.sessionArchiveNudgeWidget.value.setOptions(widgetOptions);
+        } else {
+            const widget = this.sessionArchiveNudgeWidget.value = this.instantiationService.createInstance(ChatSessionArchiveNudge, widgetOptions);
+            this.sessionArchiveNudgeContainer.appendChild(widget.domNode);
+        }
+    }
+    get gettingStartedTipContainerElement() {
+        return this.chatGettingStartedTipContainer;
+    }
+    registerChatPetHorizontalPlatformProvider(provider) {
+        this._chatPetHorizontalPlatformProviders.add(provider);
+        const store = ( new DisposableStore());
+        store.add(
+            provider.onDidChange(() => this._onDidChangeChatPetHorizontalPlatforms.fire())
+        );
+        store.add(toDisposable(() => {
+            this._chatPetHorizontalPlatformProviders.delete(provider);
+            this._onDidChangeChatPetHorizontalPlatforms.fire();
+        }));
+        this._onDidChangeChatPetHorizontalPlatforms.fire();
+        return store;
+    }
+    getChatPetPlatformTop(petCenterX) {
+        if (petCenterX !== undefined) {
+            const pillBounds = [];
+            for (const provider of this._chatPetHorizontalPlatformProviders) {
+                for (const element of provider.getElements()) {
+                    pillBounds.push(element.getBoundingClientRect());
+                }
+            }
+            const pillTop = getChatPetPillPlatformTop(petCenterX, pillBounds);
+            if (pillTop !== undefined) {
+                return pillTop;
+            }
+        }
+        return getChatPetStackPlatformTop(this.container, this.inputContainer, this.persistentContentContainer);
+    }
+    get _intentHolder() {
+        return this._inputModel ?? this._unboundIntent;
+    }
+    _restoreReasonFor(model) {
+        const intended = this._intentHolder.intendedModel;
+        return intended?.modelId === model.identifier && isInConversationModelChoice(intended.reason) ? ModelSelectionReason.RestoredChoice : ModelSelectionReason.SessionRestore;
+    }
+    get inputEditor() {
+        return this._inputEditor;
+    }
+    setHistoryKey(historyKey) {
+        this.history.setHistoryKey(historyKey);
+    }
+    get currentLanguageModel() {
+        return this._currentLanguageModel.get()?.identifier;
+    }
+    get selectedLanguageModel() {
+        return this._currentLanguageModel;
+    }
+    get availableLanguageModels() {
+        return this.getModels();
+    }
+    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 currentChatModesObs() {
+        return this._currentChatModesObservable;
+    }
+    get currentPermissionLevelObs() {
+        return this._currentPermissionLevel;
+    }
+    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 ? {
+                uri: mode.uri?.get(),
+                name: mode.name.get(),
+                content: modeInstructions.content,
+                toolReferences: this.toolService.toToolReferences(modeInstructions.toolReferences),
+                allowedSubagents: mode.agents?.get(),
+                metadata: modeInstructions.metadata,
+                isBuiltin: mode.isBuiltin
+            } : undefined,
+            telemetryModeId: modeId,
+            telemetryModeName: getModeNameForTelemetry(mode),
+            applyCodeBlockSuggestionId: undefined,
+            permissionLevel: this._currentPermissionLevel.get()
+        };
+    }
+    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;
+    }
+    get pendingDelegationTarget() {
+        return this._pendingDelegationTarget;
+    }
+    get _pendingDelegationTarget() {
+        return this._pendingDelegationTargetObservable.get();
+    }
+    set _pendingDelegationTarget(value) {
+        this._pendingDelegationTargetObservable.set(value, undefined);
+    }
+    get _currentSessionType() {
+        return this._currentSessionTypeObservable.get();
+    }
+    set _currentSessionType(value) {
+        this._currentSessionTypeObservable.set(value, undefined);
+    }
+    constructor(
+        location,
+        options,
+        styles,
+        inline,
+        modelService,
+        instantiationService,
+        contextKeyService,
+        configurationService,
+        keybindingService,
+        accessibilityService,
+        languageModelsService,
+        logService,
+        fileService,
+        editorService,
+        themeService,
+        textModelResolverService,
+        storageService,
+        dialogService,
+        agentService,
+        sharedWebExtracterService,
+        entitlementService,
+        chatModeService,
+        toolService,
+        chatSessionsService,
+        chatContextService,
+        agentSessionsService,
+        speechToTextService,
+        dictationOnboardingService,
+        chatInputNoticeHubService,
+        workspaceContextService,
+        scmService,
+        layoutService,
+        viewDescriptorService,
+        _chatAttachmentWidgetRegistry,
+        chatInputNotificationService,
+        chatPhoneInputPresenter,
+        voiceModeOnboardingService,
+        chatWidgetService,
+        voiceSessionController,
+        chatService,
+        environmentService,
+        chatPetService,
+        actionViewItemService
+    ) {
+        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.dialogService = dialogService;
+        this.agentService = agentService;
+        this.sharedWebExtracterService = sharedWebExtracterService;
+        this.entitlementService = entitlementService;
+        this.chatModeService = chatModeService;
+        this.toolService = toolService;
+        this.chatSessionsService = chatSessionsService;
+        this.chatContextService = chatContextService;
+        this.agentSessionsService = agentSessionsService;
+        this.speechToTextService = speechToTextService;
+        this.dictationOnboardingService = dictationOnboardingService;
+        this.chatInputNoticeHubService = chatInputNoticeHubService;
+        this.workspaceContextService = workspaceContextService;
+        this.scmService = scmService;
+        this.layoutService = layoutService;
+        this.viewDescriptorService = viewDescriptorService;
+        this._chatAttachmentWidgetRegistry = _chatAttachmentWidgetRegistry;
+        this.chatInputNotificationService = chatInputNotificationService;
+        this.chatPhoneInputPresenter = chatPhoneInputPresenter;
+        this.voiceModeOnboardingService = voiceModeOnboardingService;
+        this.chatWidgetService = chatWidgetService;
+        this.voiceSessionController = voiceSessionController;
+        this.chatService = chatService;
+        this.environmentService = environmentService;
+        this.chatPetService = chatPetService;
+        this.actionViewItemService = actionViewItemService;
+        this._workingSetCollapsed = observableValue("chatInputPart.workingSetCollapsed", true);
+        this._chatInputTodoListWidget = this._register(( new MutableDisposable()));
+        this._chatArtifactsWidget = this._register(( new MutableDisposable()));
+        this._chatQuestionCarouselWidgets = this._register(( new DisposableMap()));
+        this._questionCarouselResponseIds = ( new Map());
+        this._questionCarouselSessionResources = ( new Map());
+        this._chatPlanReviewWidgets = this._register(( new DisposableMap()));
+        this._planReviewResponseIds = ( new Map());
+        this._planReviewSessionResources = ( new Map());
+        this._chatToolConfirmationCarousels = this._register(( new DisposableMap()));
+        this._onDidChangeActiveConfirmationSubagent = this._register(( new Emitter()));
+        this.onDidChangeActiveConfirmationSubagent = this._onDidChangeActiveConfirmationSubagent.event;
+        this._chatEditingTodosDisposables = this._register(( new DisposableStore()));
+        this._onDidLoadInputState = this._register(( new Emitter()));
+        this.onDidLoadInputState = this._onDidLoadInputState.event;
+        this._toolbarRelayoutScheduler = this._register(( new RunOnceScheduler(() => {
+            this.layoutForToolbarChange();
+        }, 0)));
+        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.ignoreInputEditorContentSizeChanges = false;
+        this.followupsDisposables = this._register(( new DisposableStore()));
+        this.overlayClickListener = this._register(( new MutableDisposable()));
+        this.attachedContextDisposables = this._register(( new MutableDisposable()));
+        this.sessionArchiveNudgeWidget = this._register(( new MutableDisposable()));
+        this._chatPetHorizontalPlatformProviders = ( new Set());
+        this._onDidChangeChatPetHorizontalPlatforms = this._register(( new Emitter()));
+        this.onDidChangeChatPetHorizontalPlatforms = this._onDidChangeChatPetHorizontalPlatforms.event;
+        this._notificationWidget = this._register(( new MutableDisposable()));
+        this._goalBannerWidget = this._register(( new MutableDisposable()));
+        this._onDidDismissGoalBanner = this._register(( new Emitter()));
+        this.onDidDismissGoalBanner = this._onDidDismissGoalBanner.event;
+        this._contextUsageDisposables = this._register(( new MutableDisposable()));
+        this.noticeHost = this._register(( new ChatInputNoticeHost(() => this.focus())));
+        this.height = observableValue(this, 0);
+        this._forceVisibleScrollbarUntilAccept = false;
+        this._unboundIntent = ( new IntendedModelSlot());
+        this._restorePerTypeModel = false;
+        this._modelSyncDisposables = this._register(( new DisposableStore()));
+        this._currentChatModes = this._register(( new MutableDisposable()));
+        this._isSyncingToOrFromInputModel = false;
+        this.permissionWidgetDisposeListener = this._register(( new MutableDisposable()));
+        this.overflowPickerWidget = this._register(( new MutableDisposable()));
+        this.chatSessionPickerWidgets = this._register(( new DisposableMap()));
+        this._chatSessionOptionEmitters = this._register(( new DisposableMap()));
+        this._optionContextKeys = ( 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._pendingDelegationTargetObservable = observableValue(this, undefined);
+        this._currentSessionTypeObservable = observableValue(this, undefined);
+        this._currentSessionResourceObservable = observableValue(this, undefined);
+        this._currentSessionModelObservable = observableValue(this, undefined);
+        this._deferredNotificationsEnabled = observableValue(this, true);
+        this._notificationAvailableLanguageModels = observableValue(this, []);
+        this._notificationModelState = derived(this, reader => {
+            const models = this._notificationAvailableLanguageModels.read(reader);
+            const currentModel = this.selectedLanguageModel.read(reader);
+            return {
+                currentModel: models.find(model => model.identifier === currentModel?.identifier),
+                models
+            };
+        });
+        this._sessionStarted = derived(this, reader => {
+            const model = this._currentSessionModelObservable.read(reader);
+            return isSessionStarted(!!model, !!model?.lastRequestObs.read(reader));
+        });
+        this._notificationModelTargetChatSessionType = derived(
+            this,
+            reader => this._pendingDelegationTargetObservable.read(reader) ?? this._currentSessionTypeObservable.read(reader) ?? this.getCurrentSessionType()
+        );
+        this._modelSelectionDiagnostics = ( new ChatModelSelectionDiagnostics(this.logService, this.storageService, () => ({
+            surface: "workbench",
+            location: this.location,
+            modelTarget: this.getSelectedModelTarget(),
+            sessionKey: this.getCurrentSessionType(),
+            conversationKey: this._inputModelSessionResource?.toString(),
+            metadata: {
+                widgetViewKind: this.options.widgetViewKindTag
+            }
+        })));
+        this._modelSelectionRuntime = {
+            getCurrentSessionType: () => this._currentSessionType ?? this.getCurrentSessionType(),
+            isEmpty: () => !this._inputModel || this._chatSessionIsEmpty,
+            getModels: sessionType => this.getModelsForSessionType(sessionType),
+            getAllModels: () => this.getAllMergedModels(),
+            isAwaitingSessionModels: sessionType => this.chatSessionsService.requiresCustomModelsForSessionType(sessionType) && !hasModelsTargetingSession(this.getAllMergedModels(), sessionType),
+            getConfiguredModelValue: () => this.getConfiguredModelValue(),
+            isModelSupportedHere: model => isModelSupportedForMode(model, this.currentModeKind) && isModelSupportedForInlineChat(model, this.location),
+            getDeclaredDefaultModel: models => models.find(model => model.metadata.isDefaultForLocation[this.location]),
+            subscribeToModelChanges: listener => this.languageModelsService.onDidChangeLanguageModels(listener),
+            getBoundConversationKey: () => this._inputModelSessionResource?.toString(),
+            getIntentHolder: () => this._intentHolder,
+            restoreModelConfiguration: (modelId, configuration) => this.restoreModelConfiguration(modelId, configuration),
+            applyModel: () => {
+                if (this.cachedWidth) {
+                    this.layout(this.cachedWidth);
+                }
+                this._syncInputStateToModel();
+            }
+        };
+        this._modelSelectionController = this._register(( new ChatInputModelSelectionController(this._modelSelectionRuntime, this._modelSelectionDiagnostics)));
+        this._currentLanguageModel = this._modelSelectionController.currentModel;
+        this._register(
+            this.storageService.onDidChangeValue(StorageScope.PROFILE, undefined, this._store)(event => {
+                this._modelSelectionDiagnostics.logStorageChange(event, this._currentLanguageModel.get()?.identifier);
+            })
+        );
+        this._modelConfigStore = this._register(( new ChatModelConfigurationStore(
+            () => this.getModelConfigurationStorageKey(),
+            this.languageModelsService,
+            this.storageService
+        )));
+        this._syncTextDebounced = this._register(( new RunOnceScheduler(() => {
+            logChangesToStateModel(
+                this._inputModel,
+                `[DEBOUNCE] _syncTextDebounced fired -> _syncInputStateToModel in ${this._currentSessionKey}`,
+                undefined,
+                this._inputModel?.state.get(),
+                this.logService
+            );
+            this._syncInputStateToModel();
+        }, 150)));
+        this._emptyInputState = this._register(
+            createEmptyInputStateMemento(this.options.widgetViewKindTag)(StorageScope.WORKSPACE, StorageTarget.USER, this.storageService)
+        );
+        this._emptyInputAttachments = this._register(
+            emptyInputAttachments(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);
+        const localModes = this.chatModeService.createModes(LocalChatSessionUri.getNewSessionUri());
+        this._currentChatModes.value = localModes;
+        this._currentChatModesObservable = observableValue("currentChatModes", localModes);
+        this._currentPermissionLevel = observableValue("permissionLevel", this.getDefaultPermissionLevel());
+        const languageModelListChanged = observableSignalFromEvent(this, Event.any(
+            this.languageModelsService.onDidChangeLanguageModels,
+            this.languageModelsService.onDidChangeModelVisibility
+        ));
+        this._register(autorun(reader => {
+            languageModelListChanged.read(reader);
+            const sessionType = this._notificationModelTargetChatSessionType.read(reader);
+            this._currentModeObservable.read(reader);
+            this._notificationAvailableLanguageModels.set(this.getModelsForSessionType(sessionType), undefined);
+        }));
+        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.sessionResource)) {
+                this.refreshChatSessionPickers();
+            }
+        }));
+        this._register(this.chatSessionsService.onDidChangeOptionGroups(chatSessionType => {
+            const sessionResource = this._widget?.viewModel?.model.sessionResource;
+            if (sessionResource) {
+                const delegateSessionType = this.options.sessionTypePickerDelegate?.getActiveSessionProvider?.();
+                if (getChatSessionType(sessionResource) === chatSessionType || delegateSessionType === chatSessionType) {
+                    this.refreshChatSessionPickers();
+                }
+            }
+        }));
+        if (this.options.sessionTypePickerDelegate?.onDidChangeActiveSessionProvider) {
+            this._register(
+                this.options.sessionTypePickerDelegate.onDidChangeActiveSessionProvider(async newSessionType => {
+                    this._currentSessionType = newSessionType;
+                    this.getVisibleOptionGroupsModeAndUpdateContextKeys(this.getCurrentSessionResource());
+                    this.agentSessionTypeKey.set(newSessionType);
+                    this.chatSessionSupportsDelegationKey.set(this.chatSessionsService.supportsDelegationForSessionType(newSessionType));
+                    this.updateWidgetLockStateFromSessionType(newSessionType);
+                    this.checkModeInSessionPool(newSessionType);
+                    this._modelSelectionController.revalidateForSessionType(() => this.initSelectedModel());
+                    this.refreshChatSessionPickers();
+                })
+            );
+        }
+        this._attachmentModel = this._register(this.instantiationService.createInstance(ChatAttachmentModel));
+        const attachmentModel = this._attachmentModel;
+        this._register(this._attachmentModel.onDidChange(() => {
+            if (this._chatSessionIsEmpty) {
+                this._emptyInputAttachments.set(this._attachmentModel.attachments, undefined);
+            }
+            this._syncInputStateToModel();
+        }));
+        this._register(this._modelConfigStore.onDidChange(() => this._syncInputStateToModel()));
+        this.selectedToolsModel = this._register(
+            this.instantiationService.createInstance(ChatSelectedTools, this.currentModeObs, this._currentLanguageModel)
+        );
+        this.dnd = this._register(
+            this.instantiationService.createInstance(ChatDragAndDrop, () => this._widget, {
+                get attachments() {
+                    return attachmentModel.attachments;
+                },
+                addAttachments: entries => attachmentModel.addContext(...entries)
+            }, styles)
+        );
+        this.inputEditorMaxHeight = this.options.renderStyle === "compact" ? INPUT_EDITOR_MAX_HEIGHT / 3 : INPUT_EDITOR_MAX_HEIGHT;
+        const padding = this.options.renderStyle === "compact" ? INPUT_EDITOR_PADDING.compact : INPUT_EDITOR_PADDING.default;
+        this.singleLineInputEditorHeight = INPUT_EDITOR_LINE_HEIGHT + padding.top + padding.bottom;
+        this.inputEditorMinHeight = this.options.inputEditorMinLines ? this.options.inputEditorMinLines * INPUT_EDITOR_LINE_HEIGHT + padding.top + padding.bottom : undefined;
+        this.inputEditorHasText = ChatContextKeys.inputHasText.bindTo(contextKeyService);
+        this.inputEditorHasSendableContent = ChatContextKeys.inputHasSendableContent.bindTo(contextKeyService);
+        this.chatCursorAtTop = ChatContextKeys.inputCursorAtTop.bindTo(contextKeyService);
+        this.inputEditorHasFocus = ChatContextKeys.inputHasFocus.bindTo(contextKeyService);
+        this._hasQuestionCarouselContextKey = ChatContextKeys.Editing.hasQuestionCarousel.bindTo(contextKeyService);
+        this.chatModeKindKey = ChatContextKeys.chatModeKind.bindTo(contextKeyService);
+        this.chatModeNameKey = ChatContextKeys.chatModeName.bindTo(contextKeyService);
+        this.chatModelIdKey = ChatContextKeys.chatModelId.bindTo(contextKeyService);
+        this.permissionLevelKey = ChatContextKeys.chatPermissionLevel.bindTo(contextKeyService);
+        this.permissionLevelKey.set(this._currentPermissionLevel.get());
+        this.withinEditSessionKey = ChatContextKeys.withinEditSessionDiff.bindTo(contextKeyService);
+        this.filePartOfEditSessionKey = ChatContextKeys.filePartOfEditSession.bindTo(contextKeyService);
+        this.chatSessionHasOptions = ChatContextKeys.chatSessionHasModels.bindTo(contextKeyService);
+        this.chatSessionOptionsValid = ChatContextKeys.chatSessionOptionsValid.bindTo(contextKeyService);
+        this.agentSessionTypeKey = ChatContextKeys.agentSessionType.bindTo(contextKeyService);
+        this.chatSessionSupportsDelegationKey = ChatContextKeys.chatSessionSupportsDelegation.bindTo(contextKeyService);
+        this.chatHasPendingDelegationTargetKey = ChatContextKeys.hasPendingDelegationTarget.bindTo(contextKeyService);
+        if (this.options.sessionTypePickerDelegate?.getActiveSessionProvider) {
+            const initialSessionType = this.options.sessionTypePickerDelegate.getActiveSessionProvider();
+            if (initialSessionType) {
+                this.agentSessionTypeKey.set(initialSessionType);
+                this.chatSessionSupportsDelegationKey.set(
+                    this.chatSessionsService.supportsDelegationForSessionType(initialSessionType)
+                );
+            }
+        }
+        this.chatSessionHasCustomAgentTarget = ChatContextKeys.chatSessionHasCustomAgentTarget.bindTo(contextKeyService);
+        this.chatSessionHasTargetedModels = ChatContextKeys.chatSessionHasTargetedModels.bindTo(contextKeyService);
+        this.history = this._register(
+            this.instantiationService.createInstance(ChatHistoryNavigator, this.location)
+        );
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            const newOptions = {};
+            if (e.affectsConfiguration(ChatConfiguration.GlobalAutoApprove)) {
+                this.setPermissionLevel(this._currentPermissionLevel.get());
+            }
+            if (e.affectsConfiguration(ChatConfiguration.DefaultPermissionLevel)) {
+                if (this._chatSessionIsEmpty) {
+                    this.setPermissionLevel(this.getDefaultPermissionLevel());
+                }
+            }
+            if (e.affectsConfiguration(ChatConfiguration.DefaultModel)) {
+                this._modelSelectionController.applyConfiguredDefault();
+            }
+            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._onDidChangeCurrentChatMode.event(() => {
+            this._modelSelectionController.ensureCurrentModelSupported();
+        }));
+        const updateAfterModelListChange = reconcileSelection => {
+            const modelIdentifier = this._currentLanguageModel.get()?.identifier;
+            const models = this.getModels();
+            if (canLog(this.logService.getLevel(), LogLevel.Debug)) {
+                const mergedModels = this.getAllMergedModels();
+                const filteredModels = filterModelsForSession(models, this.getCurrentSessionType(), this.currentModeKind, this.location);
+                const messageparts = [
+                    `resetting current language model due to model list change from ${modelIdentifier}`,
+                    `this._widget?.viewModel?.model.sessionResource = ${this._widget?.viewModel?.model.sessionResource?.toString()}`,
+                    `this.currentModeKind = ${this.currentModeKind}`,
+                    `this.getCurrentSessionType = ${this.getCurrentSessionType()}`,
+                    `this._currentSessionType = ${this._currentSessionType}`,
+                    `shouldResetOnModelListChange(modelIdentifier, models) = ${shouldResetOnModelListChange(modelIdentifier, models)}`,
+                    `vendors: ${this.languageModelsService.getVendors().map(v => v.vendor).join(", ")}`,
+                    `hiddenModelIds: ${this.languageModelsService.getHiddenModelIds().join(", ")}`,
+                    `model identifiers: ${models.map(m => m.identifier).join(", ")}`,
+                    `model target Session Types: ${models.map(m => m.metadata.targetChatSessionType || "").join(", ")}`,
+                    `model metadataid: ${models.map(m => m.metadata.id).join(", ")}`,
+                    `merged.model identifiers: ${mergedModels.map(m => m.identifier).join(", ")}`,
+                    `merged.model target Session Types: ${mergedModels.map(m => m.metadata.targetChatSessionType || "").join(", ")}`,
+                    `merged.model metadataid: ${mergedModels.map(m => m.metadata.id).join(", ")}`,
+                    `filtered.model identifiers: ${filteredModels.map(m => m.identifier).join(", ")}`,
+                    `filtered.model target Session Types: ${filteredModels.map(m => m.metadata.targetChatSessionType || "").join(", ")}`,
+                    `filtered.model metadataid: ${filteredModels.map(m => m.metadata.id).join(", ")}`
+                ];
+                if (this.getCurrentSessionType() !== SessionType.CopilotCLI) {
+                    const delegateSessionType = this.options.sessionTypePickerDelegate?.getActiveSessionProvider?.();
+                    if (delegateSessionType) {
+                        messageparts.push(`delegateSessionType = ${delegateSessionType}`);
+                    }
+                    const sessionResource = this._widget?.viewModel?.model.sessionResource;
+                    messageparts.push(`current session resource = ${sessionResource}`);
+                }
+                logChangesToStateModel(
+                    this._inputModel,
+                    messageparts.join(", "),
+                    undefined,
+                    undefined,
+                    this.logService
+                );
+            }
+            if (reconcileSelection) {
+                this._modelSelectionController.reconcileModelListChange(models);
+            }
+            this._updateInputContentContextKeys();
+        };
+        this._register(
+            this.languageModelsService.onDidChangeLanguageModels(() => updateAfterModelListChange(false))
+        );
+        this._register(
+            this.languageModelsService.onDidChangeModelVisibility(() => updateAfterModelListChange(true))
+        );
+        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(autorun(reader => {
+            const lm = this._currentLanguageModel.read(reader);
+            this.chatModelIdKey.set(lm?.metadata.id.toLowerCase() ?? "");
+            this.contextUsageWidget?.setSelectedModel(lm?.identifier);
+            if (lm?.metadata.name) {
+                this.accessibilityService.alert(lm.metadata.name);
+            }
+            this._inputEditor?.updateOptions({
+                ariaLabel: this._getAriaLabel()
+            });
+        }));
+        this._register(autorun(reader => {
+            const modes = this._currentChatModesObservable.read(reader);
+            reader.store.add(modes.onDidChange(() => {
+                this.validateCurrentChatMode();
+                this._restorePersistedCustomModeIfAvailable();
+            }));
+        }));
+        this._register(autorun(r => {
+            const mode = this._currentModeObservable.read(r);
+            this.chatModeKindKey.set(mode.kind);
+            this.chatModeNameKey.set(mode.name.read(r));
+            if (this.options.suppressModePreferredModel) {
+                return;
+            }
+            const models = mode.model?.read(r);
+            if (models) {
+                this.switchModelByQualifiedName(models);
+            }
+        }));
+        this.validateCurrentChatMode();
+    }
+    setImplicitContextEnablement() {
+        if (this.implicitContext && this.configurationService.getValue("chat.implicitContext.suggestedContext")) {
+            this.implicitContext.setEnabled(this._currentModeObservable.get().name.get().toLowerCase() === "ask");
+        }
+    }
+    setIsWithinEditSession(inInsideDiff, isFilePartOfEditSession) {
+        this.withinEditSessionKey.set(inInsideDiff);
+        this.filePartOfEditSessionKey.set(isFilePartOfEditSession);
+    }
+    getSelectedModelTarget() {
+        const sessionType = this._currentSessionType;
+        return sessionType && this.sessionTypeHasOwnModelPool(sessionType) ? sessionType : undefined;
+    }
+    sessionTypeHasOwnModelPool(sessionType) {
+        return this.chatSessionsService.requiresCustomModelsForSessionType(sessionType) || hasModelsTargetingSession(this.getAllMergedModels(), sessionType);
+    }
+    initSelectedModel() {
+        this._modelConfigStore.clear();
+        const storedSelection = getStoredSelectedModel(this.storageService, this.location, this.getSelectedModelTarget());
+        this._modelSelectionController.initialize(storedSelection);
+    }
+    setEditing(enabled, editingSentRequest) {
+        this.currentlyEditingInputKey?.set(enabled);
+        this.editingSentRequestKey?.set(editingSentRequest);
+    }
+    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, true);
+        }
+    }
+    switchModelByIdentifier(identifier, storeSelection = false, isUserAction = false) {
+        const models = this.getModels();
+        const model = models.find(m => m.identifier === identifier);
+        if (model) {
+            if (isUserAction) {
+                this.setCurrentLanguageModel(model, true, storeSelection);
+            } else {
+                this._applyProgrammaticLanguageModel(model);
+            }
+            return true;
+        }
+        return false;
+    }
+    switchModelByQualifiedName(qualifiedModelNames) {
+        const models = this.getModels();
+        for (const qualifiedModelName of qualifiedModelNames) {
+            const model = models.find(
+                m => ILanguageModelChatMetadata.matchesQualifiedName(qualifiedModelName, m.metadata)
+            );
+            if (model) {
+                this._applyProgrammaticLanguageModel(model);
+                return true;
+            }
+        }
+        this.logService.warn(
+            `[chat] Node of the models "${qualifiedModelNames.join(", ")}" not found. Use format "<name> (<vendor>)", e.g. "GPT-4o (copilot)".`
+        );
+        return false;
+    }
+    requestModelByIdentifier(identifier) {
+        return this._requestProgrammaticLanguageModel(() => this.getModels().find(model => model.identifier === identifier));
+    }
+    requestModelByQualifiedName(qualifiedModelNames) {
+        return this._requestProgrammaticLanguageModel(() => {
+            const models = this.getModels();
+            return qualifiedModelNames.map(name => models.find(
+                model => ILanguageModelChatMetadata.matchesQualifiedName(name, model.metadata)
+            )).find(isDefined);
+        });
+    }
+    get hasPendingProgrammaticModelSelection() {
+        return this._modelSelectionController.hasPendingProgrammaticSelection();
+    }
+    switchToNextModel() {
+        const models = this.getModels();
+        if (models.length > 0) {
+            const currentIndex = models.findIndex(model => model.identifier === this._currentLanguageModel.get()?.identifier);
+            const nextIndex = (currentIndex + 1) % models.length;
+            this.setCurrentLanguageModel(models[nextIndex], true);
+        }
+    }
+    switchToNextPinnedModel() {
+        const models = this.getModels();
+        if (models.length === 0) {
+            return;
+        }
+        const modelMap = ( new Map(models.map(model => [model.identifier, model])));
+        const pinnedModels = this.languageModelsService.getPinnedModelIds().map(modelId => modelMap.get(modelId)).filter(isDefined);
+        if (pinnedModels.length === 0) {
+            return;
+        }
+        const currentIndex = pinnedModels.findIndex(model => model.identifier === this._currentLanguageModel.get()?.identifier);
+        const nextIndex = (currentIndex + 1) % pinnedModels.length;
+        this.setCurrentLanguageModel(pinnedModels[nextIndex], true);
+    }
+    openModelPicker() {
+        if (this.chatPhoneInputPresenter.enabled.get()) {
+            this._showCombinedPhonePickerSheet();
+            return;
+        }
+        this.modelWidget?.show();
+    }
+    openModePicker() {
+        if (this.chatPhoneInputPresenter.enabled.get()) {
+            this._showCombinedPhonePickerSheet();
+            return;
+        }
+        this.modeWidget?.show();
+    }
+    _showCombinedPhonePickerSheet() {
+        const target = this.inputActionsToolbar.getElement();
+        this.chatPhoneInputPresenter.showCombinedModeAndModelSheet(target, {
+            kind: "delegates",
+            modeDelegate: this._createModePickerDelegate(),
+            modelDelegate: this._createModelPickerDelegate()
+        }).catch(
+            err => this.logService.error("[ChatInputPart] phone picker sheet failed", err)
+        );
+    }
+    _createModelPickerDelegate() {
+        return {
+            currentModel: this._currentLanguageModel,
+            setModel: model => {
+                const previousModelIdentifier = this._currentLanguageModel.get()?.identifier;
+                this.setCurrentLanguageModel(model, true, !this.options.suppressModelPersistence);
+                if (didExplicitlySwitchChatPetModel(previousModelIdentifier, model.identifier)) {
+                    this.chatPetService.unlockAchievement(ChatPetAchievementIds.ModelSwitch);
+                }
+                this.renderAttachedContext();
+            },
+            getModels: () => this.getModels(),
+            isCacheWarm: () => (this._widget?.viewModel?.model.getRequests().length ?? 0) > 0,
+            getPresentationOptions: () => this._getModelPickerPresentationOptions(),
+            modelConfiguration: this._modelConfigStore
+        };
+    }
+    _getModelPickerPresentationOptions() {
+        const sessionType = this.getCurrentSessionType();
+        const useRichPicker = !sessionType || sessionType === localChatSessionType || isAgentHostTarget(sessionType);
+        return {
+            useGroupedModelPicker: useRichPicker,
+            showManageModelsAction: useRichPicker,
+            showUnavailableFeatured: useRichPicker,
+            showFeatured: useRichPicker,
+            showAutoModel: this._showAutoModel(),
+            showModelIcon: this.options.isSessionsWindow || !this._usesHarnessProviderIcon()
+        };
+    }
+    _usesHarnessProviderIcon() {
+        const sessionType = this.getCurrentSessionType();
+        return sessionType === SessionType.Codex || sessionType === SessionType.AgentHostClaude || sessionType === SessionType.AgentHostCodex;
+    }
+    getModelConfiguration(modelId) {
+        return this._modelConfigStore.getModelConfiguration(modelId);
+    }
+    restoreModelConfiguration(modelId, modelConfiguration) {
+        if (modelConfiguration) {
+            this._modelConfigStore.restoreModelConfiguration(modelId, modelConfiguration);
+        }
+    }
+    getModelConfigurationStorageKey() {
+        const sessionType = this._currentSessionType;
+        if (sessionType && this.sessionTypeHasOwnModelPool(sessionType)) {
+            return `chat.modelConfiguration.${this.location}.${sessionType}`;
+        }
+        return `chat.modelConfiguration.${this.location}`;
+    }
+    _createModePickerDelegate() {
+        return {
+            currentMode: this._currentModeObservable,
+            currentChatModes: this._currentChatModesObservable,
+            sessionResource: () => this._widget?.viewModel?.sessionResource,
+            setMode: mode => this.setChatMode2(mode, true),
+            customAgentTarget: () => {
+                const sessionResource = this._widget?.viewModel?.model.sessionResource;
+                return (sessionResource && this.chatSessionsService.getCustomAgentTargetForSessionType(getChatSessionType(sessionResource))) ?? Target.Undefined;
+            }
+        };
+    }
+    openPermissionPicker() {
+        this.permissionWidget?.show();
+    }
+    setPermissionLevel(level) {
+        level = this.getPermittedPermissionLevel(level);
+        this._currentPermissionLevel.set(level, undefined);
+        this.permissionLevelKey.set(level);
+        this.permissionWidget?.refresh();
+        const sessionResource = this.getCurrentSessionResource();
+        if (sessionResource) {
+            this.chatSessionsService.setSessionOption(sessionResource, PERMISSION_LEVEL_OPTION_ID, level);
+        }
+        logChangesToStateModel(
+            this._inputModel,
+            `setPermissionLevel -> _syncInputStateToModel (level=${level}, currentLanguageModel=${this._currentLanguageModel.get()?.identifier}) in ${this._currentSessionKey}`,
+            undefined,
+            undefined,
+            this.logService
+        );
+        this._syncInputStateToModel();
+    }
+    getDefaultPermissionLevel() {
+        const level = this.configurationService.getValue(ChatConfiguration.DefaultPermissionLevel);
+        return isChatPermissionLevel(level) ? level : ChatPermissionLevel.Default;
+    }
+    getPermittedPermissionLevel(level) {
+        if (isAutoApproveValuePolicyRestricted(level, isAutoApprovePolicyRestricted(this.configurationService))) {
+            return ChatPermissionLevel.Default;
+        }
+        return level;
+    }
+    openSessionTargetPicker() {
+        this.sessionTargetWidget?.show();
+    }
+    openDelegationPicker() {
+        this.delegationWidget?.show();
+    }
+    openChatSessionPicker() {
+        const firstWidget = this.chatSessionPickerWidgets?.values()?.next().value;
+        firstWidget?.show();
+    }
+    createChatSessionPickerWidgets(action, pickerOptions) {
+        this._lastSessionPickerAction = action;
+        this._lastSessionPickerOptions = pickerOptions;
+        const sessionResource = this.getCurrentSessionResource();
+        const visibleOptionGroups = this.getVisibleOptionGroupsModeAndUpdateContextKeys(sessionResource);
+        if (!visibleOptionGroups.length) {
+            return [];
+        }
+        const effectiveSessionType = this.getEffectiveSessionType(sessionResource);
+        if (!effectiveSessionType) {
+            return [];
+        }
+        this.chatSessionPickerWidgets.clearAndDisposeAll();
+        const widgets = [];
+        for (const optionGroup of visibleOptionGroups) {
+            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 => {
+                    this.updateOptionContextKey(optionGroup.id, option.id);
+                    this.getOrCreateOptionEmitter(optionGroup.id).fire(option);
+                    const sessionResource = this._widget?.viewModel?.model.sessionResource;
+                    if (sessionResource) {
+                        this.chatSessionsService.setSessionOption(sessionResource, optionGroup.id, option);
+                    }
+                    this.refreshChatSessionPickers();
+                },
+                getOptionGroup: () => {
+                    const groups = this.chatSessionsService.getOptionGroupsForSessionType(effectiveSessionType);
+                    return groups?.find(g => g.id === optionGroup.id);
+                },
+                getSessionResource: () => {
+                    return this._widget?.viewModel?.model.sessionResource;
+                }
+            };
+            const widget = this.instantiationService.createInstance(
+                ChatSessionPickerActionItem,
+                action,
+                initialState,
+                itemDelegate,
+                pickerOptions
+            );
+            this.chatSessionPickerWidgets.set(optionGroup.id, widget);
+            widgets.push(widget);
+        }
+        return widgets;
+    }
+    setInputModel(model, chatSessionIsEmpty, forSessionResource) {
+        logChangesToStateModel(this._inputModel, `setInputModel for ${( forSessionResource.toString())} (chatSessionIsEmpty=${chatSessionIsEmpty}, outgoing._inputModel=${this._inputModel ? "present" : "undefined"})`, model.state.get(), this._inputModel?.state.get(), this.logService);
+        if (this._inputModel) {
+            logChangesToStateModel(
+                this._inputModel,
+                `[FLUSH-PRE] setInputModel pre-flush boundInputModelSession=${this._inputModelSessionResource?.toString()} widgetSession=${this._currentSessionKey} incoming=${( forSessionResource.toString())}`,
+                undefined,
+                this._inputModel.state.get(),
+                this.logService
+            );
+            this._syncInputStateToModel();
+        }
+        this._currentSessionType = getChatSessionType(forSessionResource);
+        this._currentSessionModelObservable.set(undefined, undefined);
+        this._inputModel = model;
+        this._inputModelSessionResource = forSessionResource;
+        this._modelSyncDisposables.clear();
+        const chatModes = this.chatModeService.createModes(forSessionResource);
+        this._currentChatModes.value = chatModes;
+        this._currentChatModesObservable.set(chatModes, undefined);
+        this.selectedToolsModel.resetSessionEnablementState();
+        this._chatSessionIsEmpty = isNewConversation(forSessionResource, chatSessionIsEmpty);
+        const ownsPool = !!this._currentSessionType && this.sessionTypeHasOwnModelPool(this._currentSessionType);
+        const hadIncomingModel = !!model.state.get()?.selectedModel;
+        this._modelSelectionController.beginConversationSwitch();
+        this._restorePerTypeModel = shouldRestorePerTypeModelOnSessionSwitch(this._chatSessionIsEmpty, ownsPool, hadIncomingModel);
+        if (this._chatSessionIsEmpty) {
+            const persistedState = model.state.get() ? undefined : this._getPersistedEmptyInputState();
+            if (persistedState) {
+                model.setState(persistedState);
+                this._syncFromModel(persistedState, forSessionResource);
+            }
+            this._setEmptyModelState();
+            this._modelSyncDisposables.add(this.configurationService.onDidChangeConfiguration(e => {
+                if (this._chatSessionIsEmpty && e.affectsConfiguration(ChatConfiguration.DefaultNewSessionMode)) {
+                    this._setEmptyModelState();
+                }
+            }));
+            this._modelSyncDisposables.add(this._currentChatModesObservable.get().onDidChange(() => {
+                if (this._chatSessionIsEmpty) {
+                    this._setEmptyModelState();
+                }
+            }));
+        }
+        const widgetViewModelSession = this._widget?.viewModel?.model.sessionResource;
+        const isStaleAtRegistration = !!widgetViewModelSession && !isEqual(widgetViewModelSession, forSessionResource);
+        logChangesToStateModel(
+            this._inputModel,
+            `[AUTORUN-REG] registering model->view autorun for ${( forSessionResource.toString())}, widgetSession=${this._currentSessionKey}, widgetViewModelSession=${widgetViewModelSession?.toString()}, isStaleAtRegistration=${isStaleAtRegistration}, model.state.selectedModel=${model.state.get()?.selectedModel?.identifier}, _currentLanguageModel=${this._currentLanguageModel.get()?.identifier}`,
+            undefined,
+            undefined,
+            this.logService
+        );
+        this._modelSyncDisposables.add(autorun(reader => {
+            let state = model.state.read(reader);
+            let message = `syncing from model for ${( forSessionResource.toString())} in ${this._currentSessionKey}`;
+            if (!state && this._chatSessionIsEmpty) {
+                state = this._getPersistedEmptyInputState();
+                message = `syncing from empty input state for ${( forSessionResource.toString())}`;
+                if (state) {
+                    const resolved = this.resolveDraftModel(state.selectedModel, this._currentSessionType, false);
+                    if (resolved.changed) {
+                        state = {
+                            ...state,
+                            selectedModel: resolved.model,
+                            modelConfiguration: undefined
+                        };
+                    }
+                }
+            }
+            const widgetSessionResource = this._widget?.viewModel?.model.sessionResource;
+            const isStaleSession = !!this._inputModelSessionResource && !isEqual(this._inputModelSessionResource, forSessionResource);
+            if (isStaleSession) {
+                message = `[STALE-SESSION-AUTORUN] ${message} (widget now on ${widgetSessionResource?.toString()}, ${this._inputModelSessionResource?.toString()}, ${( forSessionResource.toString())} is old)`;
+            }
+            const prevState = this._inputModel?.state.read(undefined);
+            logChangesToStateModel(this._inputModel, message, state, prevState, this.logService);
+            if (isStaleSession) {
+                return;
+            }
+            this._syncFromModel(state, forSessionResource);
+        }));
+    }
+    _getPersistedEmptyInputState() {
+        let state = this._emptyInputState.read(undefined);
+        if (!state) {
+            return undefined;
+        }
+        const persistedAttachments = this._emptyInputAttachments.read(undefined);
+        state = {
+            ...state,
+            attachments: persistedAttachments.length > 0 ? persistedAttachments : state.attachments
+        };
+        const resolved = this.resolveDraftModel(state.selectedModel, this._currentSessionType, true);
+        if (resolved.changed) {
+            state = {
+                ...state,
+                selectedModel: resolved.model,
+                modelConfiguration: undefined
+            };
+        }
+        return state;
+    }
+    _setEmptyModelState() {
+        logChangesToStateModel(
+            this._inputModel,
+            `setting empty model state for ${this._widget?.viewModel?.sessionResource.toString()} in ${this._currentSessionKey}`,
+            undefined,
+            undefined,
+            this.logService
+        );
+        const currentLevel = this._inputModel?.state?.get()?.permissionLevel;
+        if (currentLevel === undefined || !isChatPermissionLevel(currentLevel)) {
+            this.setPermissionLevel(this.getDefaultPermissionLevel());
+        }
+        if (this.entitlementService.anonymous) {
+            this.setChatMode(ChatModeKind.Agent, false);
+            this._modelSelectionController.ensureCurrentModelSupported();
+            return;
+        }
+        const rawDefaultMode = this.configurationService.getValue(ChatConfiguration.DefaultNewSessionMode);
+        if (typeof rawDefaultMode === "string") {
+            const defaultMode = rawDefaultMode.trim();
+            if (defaultMode) {
+                const defaultModeLower = defaultMode.toLowerCase();
+                const modes = this._currentChatModesObservable.get();
+                const resolved = modes.findModeById(defaultMode) ?? modes.findModeByName(defaultMode) ?? modes.custom.find(m => m.name.get().toLowerCase() === defaultModeLower);
+                if (resolved) {
+                    this.logService.trace(
+                        `[ChatInputPart] Applying default mode from setting: ${defaultMode} -> ${resolved.id}`
+                    );
+                    this.setChatMode(resolved.id, false);
+                    this._modelSelectionController.ensureCurrentModelSupported();
+                }
+            }
+        }
+    }
+    _syncFromModel(state, forSessionResource) {
+        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) {
+                const sessionType = getChatSessionType(forSessionResource);
+                this._modelSelectionController.syncFromConversationState(state.selectedModel, state.modelConfiguration, sessionType, ( forSessionResource.toString()), state.origin === ChatInputStateOrigin.Remote, this._restoreReasonFor(state.selectedModel));
+            } else if (state) {
+                this._modelSelectionDiagnostics.report("conversation-state-without-model", {
+                    conversation: ( forSessionResource.toString()),
+                    currentModel: this._currentLanguageModel.get()?.identifier
+                });
+            }
+            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 (!this.configurationService.getValue(ChatConfiguration.GlobalAutoApprove)) {
+                const targetLevel = this.getPermittedPermissionLevel(state?.permissionLevel ?? ChatPermissionLevel.Default);
+                if (this._currentPermissionLevel.get() !== targetLevel) {
+                    this._currentPermissionLevel.set(targetLevel, undefined);
+                    this.permissionLevelKey.set(targetLevel);
+                    this.permissionWidget?.refresh();
+                }
+            }
+            if (state) {
+                this._widget?.contribs.forEach(contrib => {
+                    contrib.setInputState?.(state.contrib);
+                });
+            }
+        } finally {
+            this._isSyncingToOrFromInputModel = false;
+            this._syncTextDebounced.cancel();
+        }
+    }
+    _syncInputStateToModel() {
+        if (this._isSyncingToOrFromInputModel) {
+            return;
+        }
+        this._isSyncingToOrFromInputModel = true;
+        const state = this.getCurrentInputState();
+        if (this._chatSessionIsEmpty) {
+            this._emptyInputState.set(state, undefined);
+        }
+        const prevState = this._inputModel?.state.get();
+        logChangesToStateModel(
+            this._inputModel,
+            `_syncInputStateToModel boundInputModelSession=${this._inputModelSessionResource?.toString()} widgetSession=${this._currentSessionKey} mismatch=${this._inputModelSessionResource?.toString() !== this._currentSessionKey}`,
+            state,
+            prevState,
+            this.logService
+        );
+        this._inputModel?.setState(state);
+        this._isSyncingToOrFromInputModel = false;
+        queueMicrotask(() => this.inputActionsToolbar?.relayout());
+    }
+    flushInputStateToModel() {
+        if (this._inputModel) {
+            this._syncInputStateToModel();
+        }
+    }
+    setCurrentLanguageModel(model, isUserAction = false, storeSelection = isUserAction) {
+        const persistSelection = isUserAction && storeSelection;
+        this._modelSelectionDiagnostics.report("set-model", {
+            model: model.identifier,
+            isUserAction,
+            persistSelection,
+            available: this.getModels().length
+        }, "info");
+        const apply = () => {
+            if (this.cachedWidth) {
+                this.layout(this.cachedWidth);
+            }
+            if (persistSelection) {
+                storeSelectedModel(
+                    this.storageService,
+                    this.location,
+                    this.getSelectedModelTarget(),
+                    model.identifier
+                );
+            }
+            this._syncInputStateToModel();
+        };
+        this._modelSelectionController.applySelection(model, apply, isUserAction);
+    }
+    _applyProgrammaticLanguageModel(model) {
+        this._modelSelectionController.applyProgrammaticSelection(model);
+    }
+    _requestProgrammaticLanguageModel(resolveModel) {
+        const result = this._modelSelectionController.requestProgrammaticSelection(resolveModel, this._inputModelSessionResource?.toString());
+        this._updateInputContentContextKeys();
+        void result.finally(() => this._updateInputContentContextKeys());
+        return result;
+    }
+    setChatMode(mode, storeSelection = true, isUserInitiated = false) {
+        if (!this.options.supportsChangingModes) {
+            return;
+        }
+        const modes = this._currentChatModesObservable.get();
+        const mode2 = modes.findModeById(mode) ?? modes.findModeByName(mode) ?? modes.findModeById(ChatModeKind.Agent) ?? ChatMode.Ask;
+        this.setChatMode2(mode2, storeSelection, isUserInitiated);
+    }
+    setChatMode2(mode, storeSelection = true, isUserInitiated = false) {
+        if (!this.options.supportsChangingModes) {
+            return;
+        }
+        this._currentModeObservable.set(mode, undefined);
+        this._onDidChangeCurrentChatMode.fire({
+            isUserInitiated
+        });
+        if (storeSelection) {
+            logChangesToStateModel(
+                this._inputModel,
+                `setChatMode2 -> _syncInputStateToModel (mode=${mode.id}, storeSelection=${storeSelection}, isUserInitiated=${isUserInitiated}, currentLanguageModel=${this._currentLanguageModel.get()?.identifier}) in ${this._currentSessionKey}`,
+                undefined,
+                undefined,
+                this.logService
+            );
+            this._syncInputStateToModel();
+        }
+    }
+    getAllMergedModels() {
+        const cachedModels = this.storageService.getObject(CachedLanguageModelsKey, StorageScope.APPLICATION, []);
+        const liveModels = this.languageModelsService.getLanguageModelIds().map(modelId => ({
+            identifier: modelId,
+            metadata: this.languageModelsService.lookupLanguageModel(modelId)
+        }));
+        const contributedVendors = ( new Set(this.languageModelsService.getVendors().map(v => v.vendor)));
+        const resolvedVendors = ( new Set());
+        for (const v of contributedVendors) {
+            if (this.languageModelsService.hasResolvedVendor(v)) {
+                resolvedVendors.add(v);
+            }
+        }
+        const models = mergeModelsWithCache(liveModels, cachedModels, contributedVendors, resolvedVendors);
+        if (liveModels.length > 0 || resolvedVendors.size > 0) {
+            this.storageService.store(
+                CachedLanguageModelsKey,
+                models,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        return models;
+    }
+    getModels() {
+        return this.getModelsForSessionType(this.getCurrentSessionType());
+    }
+    _showAutoModel() {
+        const sessionType = this.getCurrentSessionType();
+        return !sessionType || this.chatSessionsService.supportsAutoModelForSessionType(sessionType);
+    }
+    hasNoAvailableModel() {
+        return !this._showAutoModel() && this.getModels().length === 0;
+    }
+    getModelsForSessionType(sessionType) {
+        const allModels = this.getAllMergedModels();
+        if (sessionType && this.chatSessionsService.requiresCustomModelsForSessionType(sessionType) && !hasModelsTargetingSession(allModels, sessionType)) {
+            return [];
+        }
+        allModels.sort((a, b) => a.metadata.name.localeCompare(b.metadata.name));
+        const sessionFiltered = filterModelsForSession(allModels, sessionType, this.currentModeKind, this.location);
+        return sessionFiltered.filter(
+            m => !isModelHiddenInPicker(m, id => this.languageModelsService.isModelHidden(id))
+        );
+    }
+    getCurrentSessionType() {
+        const sessionResource = this._widget?.viewModel?.model.sessionResource;
+        if (sessionResource) {
+            return getChatSessionType(sessionResource);
+        }
+        return this.options.sessionTypePickerDelegate?.getActiveSessionProvider?.();
+    }
+    checkModeInSessionPool(sessionType) {
+        if (!sessionType) {
+            const sessionResource = this._widget?.viewModel?.model.sessionResource;
+            if (!sessionResource) {
+                return;
+            }
+            sessionType = getChatSessionType(sessionResource);
+        }
+        const customAgentTarget = this.chatSessionsService.getCustomAgentTargetForSessionType(sessionType);
+        if (!customAgentTarget || customAgentTarget === Target.Undefined) {
+            return;
+        }
+        const currentMode = this._currentModeObservable.get();
+        if (currentMode.id === ChatMode.Agent.id) {
+            return;
+        }
+        if (currentMode.isBuiltin) {
+            this.setChatMode(ChatModeKind.Agent, false);
+            return;
+        }
+        const modeTarget = currentMode.target.get();
+        if (modeTarget !== customAgentTarget && modeTarget !== Target.Undefined) {
+            this.setChatMode(ChatModeKind.Agent, false);
+        }
+    }
+    setCurrentLanguageModelToDefault(forSessionType) {
+        this._modelSelectionController.selectDefault(forSessionType ?? this.getCurrentSessionType());
+    }
+    getConfiguredModelValue() {
+        const model = this.configurationService.getValue(ChatConfiguration.DefaultModel)?.trim();
+        return model ? model : undefined;
+    }
+    resolveDraftModel(draftModel, sessionTypeForValidation, validatePool) {
+        let model = draftModel;
+        if (validatePool && shouldDropAgnosticDraftModel(model, this.getAllMergedModels(), sessionTypeForValidation)) {
+            model = undefined;
+        }
+        const configuredValue = this.getConfiguredModelValue();
+        if (configuredValue) {
+            model = resolveConfiguredModel(
+                configuredValue,
+                this.getModelsForSessionType(this._currentSessionType ?? this.getCurrentSessionType())
+            );
+        }
+        return {
+            model,
+            changed: model?.identifier !== draftModel?.identifier
+        };
+    }
+    reinitializeIfOutsidePool(initialize) {
+        const currentModel = this._modelSelectionController.currentModel.get();
+        const pool = this.getModelsForSessionType(this._currentSessionType ?? this.getCurrentSessionType());
+        if (!currentModel || ( pool.some(model => model.identifier === currentModel.identifier))) {
+            return;
+        }
+        initialize();
+        this._modelSelectionController.ensureCurrentModelSupported();
+    }
+    resetLanguageModelToDefault() {
+        this._modelSelectionController.resetToDefault(this.getCurrentSessionType());
+    }
+    getCurrentInputState() {
+        const mode = this._currentModeObservable.get();
+        const selectedModel = this._currentLanguageModel.get();
+        const state = {
+            inputText: this._inputEditor?.getValue() ?? "",
+            attachments: this._attachmentModel.attachments,
+            mode: {
+                id: mode.id,
+                kind: mode.kind
+            },
+            selectedModel,
+            modelConfiguration: selectedModel ? this._modelConfigStore.getModelConfiguration(selectedModel.identifier) : undefined,
+            selectedModelReason: selectedModel ? this._modelSelectionController.selectionReason : undefined,
+            selections: this._inputEditor?.getSelections() || [],
+            permissionLevel: this._currentPermissionLevel.get(),
+            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.get()?.metadata.name;
+        const modelInfo = modelName ? ( localize(11958, ", {0}. ", modelName)) : "";
+        let modeLabel = "";
+        if (!mode.isBuiltin) {
+            const mode = this.currentModeObs.get();
+            modeLabel = ( localize(11959, "({0}), {1}", mode.label.get(), mode.description.get()));
+        } else {
+            switch (this.currentModeKind) {
+            case ChatModeKind.Agent:
+                modeLabel = ( localize(11960, "(Agent), edit files in your workspace."));
+                break;
+            case ChatModeKind.Edit:
+                modeLabel = ( localize(11961, "(Edit), edit files in your workspace."));
+                break;
+            case ChatModeKind.Ask:
+            default:
+                modeLabel = ( localize(11962, "(Ask), ask questions or type / for topics."));
+                break;
+            }
+        }
+        if (verbose) {
+            return kbLabel ? ( localize(
+                11963,
+                "Chat Input {0}{1} Press Enter to send out the request. Use {2} for Chat Accessibility Help.",
+                modeLabel,
+                modelInfo,
+                kbLabel
+            )) : ( localize(
+                11964,
+                "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(11965, "Chat Input {0}{1}.", modeLabel, modelInfo);
+        }
+    }
+    validateCurrentChatMode() {
+        const currentMode = this._currentModeObservable.get();
+        const validMode = this._currentChatModesObservable.get().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;
+        }
+    }
+    _restorePersistedCustomModeIfAvailable() {
+        const persistedMode = this._inputModel?.state.get()?.mode;
+        if (!persistedMode) {
+            return;
+        }
+        const modes = this._currentChatModesObservable.get();
+        const found = modes.findModeById(persistedMode.id) ?? modes.findModeByName(persistedMode.id);
+        if (found && !found.isBuiltin && this._currentModeObservable.get().id !== found.id) {
+            this.setChatMode(found.id, false);
+        }
+    }
+    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 restoreAttachments(attachments) {
+        let restored = [...attachments];
+        if (restored.length > 0) {
+            restored = (await Promise.all(restored.map(async attachment => {
+                if (isImageVariableEntry(attachment) && !attachment.value && 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(isDefined);
+        }
+        this._attachmentModel.clearAndSetContext(...restored);
+    }
+    async navigateHistory(previous) {
+        const historyEntry = previous ? this.history.previous() : this.history.next();
+        await this.restoreAttachments(historyEntry?.attachments ?? []);
+        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();
+    }
+    focusTodoList() {
+        return this._chatInputTodoListWidget.value?.focus() ?? false;
+    }
+    isTodoListFocused() {
+        return this._chatInputTodoListWidget.value?.hasFocus() ?? false;
+    }
+    hasVisibleTodos() {
+        return this._chatInputTodoListWidget.value?.hasTodos() ?? false;
+    }
+    async acceptInput(isUserQuery, preserveFocus, preserveInput) {
+        if (isUserQuery) {
+            const userQuery = this.getCurrentInputState();
+            this.history.append(this._getFilteredEntry(userQuery));
+        }
+        this.resetScrollbarVisibilityAfterAccept();
+        this.chatInputNotificationService.handleMessageSent(this.getNotificationContext());
+        if (this._chatSessionIsEmpty) {
+            this._chatSessionIsEmpty = false;
+            this._emptyInputState.set(undefined, undefined);
+            this._emptyInputAttachments.set([], undefined);
+        }
+        if (preserveInput) {
+            if (!preserveFocus) {
+                this._inputEditor.focus();
+            }
+            return;
+        }
+        notifyDictationSubmitted(this._inputEditor);
+        logChangesToStateModel(
+            this._inputModel,
+            `[ACCEPT] acceptInput -> attachmentModel.clear() in ${this._currentSessionKey}`,
+            undefined,
+            this._inputModel?.state.get(),
+            this.logService
+        );
+        this.attachmentModel.clear();
+        this._onDidLoadInputState.fire();
+        if (this.accessibilityService.isScreenReaderOptimized() && isMacintosh) {
+            this._acceptInputForVoiceover();
+        } else if (preserveFocus) {
+            this._inputEditor.setValue("");
+        } 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._updateInputContentContextKeys();
+        this.renderAttachedContext();
+    }
+    _updateInputContentContextKeys() {
+        const inputHasText = !!this._inputEditor?.getModel()?.getValue().trim();
+        this.inputEditorHasText.set(inputHasText);
+        const hasSendableContent = inputHasText || ( this._attachmentModel.attachments.some(isExplicitFileOrImageVariableEntry));
+        this.inputEditorHasSendableContent.set(
+            hasSendableContent && !this.hasNoAvailableModel() && !this.hasPendingProgrammaticModelSelection
+        );
+    }
+    getOrCreateOptionEmitter(optionGroupId) {
+        let emitter = this._chatSessionOptionEmitters.get(optionGroupId);
+        if (!emitter) {
+            emitter = ( new Emitter());
+            this._chatSessionOptionEmitters.set(optionGroupId, emitter);
+        }
+        return emitter;
+    }
+    getOrCreateOptionContextKey(optionGroupId) {
+        if (!this._scopedContextKeyService) {
+            return undefined;
+        }
+        let contextKey = this._optionContextKeys.get(optionGroupId);
+        if (!contextKey) {
+            const rawKey = new RawContextKey(`chatSessionOption.${optionGroupId}`, "");
+            contextKey = rawKey.bindTo(this._scopedContextKeyService);
+            this._optionContextKeys.set(optionGroupId, contextKey);
+        }
+        return contextKey;
+    }
+    updateOptionContextKey(optionGroupId, optionItemId) {
+        const normalizedOptionId = optionItemId.trim();
+        const contextKey = this.getOrCreateOptionContextKey(optionGroupId);
+        if (contextKey) {
+            contextKey.set(normalizedOptionId);
+        }
+    }
+    evaluateOptionGroupVisibility(optionGroup) {
+        if (!optionGroup.when) {
+            return true;
+        }
+        if (!this._scopedContextKeyService) {
+            return true;
+        }
+        const expr = ContextKeyExpr.deserialize(optionGroup.when);
+        if (!expr) {
+            return true;
+        }
+        return this._scopedContextKeyService.contextMatchesRules(expr);
+    }
+    getVisibleOptionGroupsModeAndUpdateContextKeys(sessionResource) {
+        const sessionType = this.getEffectiveSessionType(sessionResource);
+        const customAgentTarget = sessionType ? this.chatSessionsService.getCustomAgentTargetForSessionType(sessionType) : Target.Undefined;
+        this.chatSessionHasCustomAgentTarget.set(customAgentTarget !== Target.Undefined);
+        const requiresCustomModels = sessionType && this.chatSessionsService.requiresCustomModelsForSessionType(sessionType);
+        this.chatSessionHasTargetedModels.set(!!requiresCustomModels);
+        const visibleOptionGroups = this.getVisibleOptionGroups(sessionResource);
+        this.permissionWidget?.refresh();
+        if (!visibleOptionGroups.length) {
+            this.chatSessionHasOptions.set(false);
+            this.chatSessionOptionsValid.set(true);
+            this._updateInputContentContextKeys();
+            return [];
+        }
+        const allOptionsValid = sessionResource ? this.areAllOptionsValid(sessionResource, visibleOptionGroups) : true;
+        this.chatSessionHasOptions.set(true);
+        this.chatSessionOptionsValid.set(allOptionsValid);
+        this._updateInputContentContextKeys();
+        return visibleOptionGroups;
+    }
+    getCurrentSessionResource() {
+        return this._widget?.viewModel?.model.sessionResource;
+    }
+    getTerminalCommandPrefix() {
+        const sessionResource = this.getCurrentSessionResource();
+        return sessionResource ? this.chatSessionsService.getCapabilitiesForSessionType(getChatSessionType(sessionResource))?.terminalCommandPrefix : undefined;
+    }
+    isTerminalCommandPaste(pastedText, range) {
+        const model = this._inputEditor.getModel();
+        const prefix = this.getTerminalCommandPrefix();
+        if (!model || !prefix) {
+            return false;
+        }
+        return isTerminalCommandPaste({
+            prefix,
+            pastedText,
+            currentValue: model.getValue(),
+            selectionStartOffset: model.getOffsetAt(Range.getStartPosition(range)),
+            selectionEndOffset: model.getOffsetAt(Range.getEndPosition(range))
+        });
+    }
+    updateInputEditorFontFamily() {
+        if (!this._inputEditor) {
+            return;
+        }
+        const isCommand = isTerminalCommandInput(
+            this._inputEditor.getModel()?.getLineContent(1) || "",
+            this.getTerminalCommandPrefix()
+        );
+        this._inputEditor.updateOptions({
+            fontFamily: isCommand ? EDITOR_FONT_DEFAULTS.fontFamily : DEFAULT_FONT_FAMILY
+        });
+    }
+    handleTerminalCommandPaste(e) {
+        handleTerminalCommandPaste(
+            e,
+            this._inputEditor,
+            this.getTerminalCommandPrefix(),
+            this.dialogService,
+            this.storageService
+        );
+    }
+    areAllOptionsValid(sessionResource, visibleOptionGroups) {
+        for (const optionGroup of visibleOptionGroups) {
+            const currentOption = this.chatSessionsService.getSessionOption(sessionResource, optionGroup.id);
+            if (currentOption) {
+                const currentOptionId = typeof currentOption === "string" ? currentOption : currentOption.id;
+                if (!( optionGroup.items.some(item => item.id === currentOptionId)) && typeof currentOption === "string") {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    getAllOptionsGroups(sessionResource) {
+        const delegateSessionType = this.options.sessionTypePickerDelegate?.getActiveSessionProvider?.();
+        const effectiveSessionType = delegateSessionType ?? (sessionResource ? getChatSessionType(sessionResource) : undefined);
+        if (!effectiveSessionType) {
+            return [];
+        }
+        const allOptionGroups = this.chatSessionsService.getOptionGroupsForSessionType(effectiveSessionType);
+        return allOptionGroups ?? [];
+    }
+    getVisibleOptionGroups(sessionResource) {
+        const allOptionGroups = this.getAllOptionsGroups(sessionResource);
+        if (!allOptionGroups.length) {
+            return [];
+        }
+        if (sessionResource) {
+            for (const optionGroup of allOptionGroups) {
+                const currentOption = this.chatSessionsService.getSessionOption(sessionResource, optionGroup.id);
+                if (currentOption) {
+                    const optionId = typeof currentOption === "string" ? currentOption : currentOption.id;
+                    this.updateOptionContextKey(optionGroup.id, optionId);
+                }
+            }
+        }
+        const visibleGroups = ( new Map());
+        for (const optionGroup of allOptionGroups) {
+            if (optionGroup.kind === "permissions") {
+                continue;
+            }
+            const hasItems = optionGroup.items.length > 0 || (optionGroup.commands || []).length > 0;
+            const passesWhenClause = this.evaluateOptionGroupVisibility(optionGroup);
+            const sessionHasOption = !sessionResource || this.chatSessionsService.getSessionOption(sessionResource, optionGroup.id) !== undefined;
+            if (hasItems && passesWhenClause && sessionHasOption) {
+                visibleGroups.set(optionGroup.id, optionGroup);
+            }
+        }
+        return Array.from(( visibleGroups.values()));
+    }
+    getActiveExtensionPermissionGroup(sessionResource) {
+        const allOptionGroups = this.getAllOptionsGroups(sessionResource);
+        return allOptionGroups.find(
+            g => g.kind === "permissions" && g.items.length > 0 && this.evaluateOptionGroupVisibility(g)
+        );
+    }
+    refreshChatSessionPickers() {
+        const sessionResource = this.getCurrentSessionResource();
+        const allOptionsGroups = this.getAllOptionsGroups(sessionResource);
+        const visibleOptionGroups = this.getVisibleOptionGroupsModeAndUpdateContextKeys(sessionResource);
+        if (!allOptionsGroups.length || !visibleOptionGroups.length) {
+            this.hideAllSessionPickerWidgets();
+            return;
+        }
+        const currentWidgetGroupIds = ( new Set(( this.chatSessionPickerWidgets.keys())));
+        const needsRecreation = currentWidgetGroupIds.size !== visibleOptionGroups.length || !visibleOptionGroups.every(group => ( currentWidgetGroupIds.has(group.id)));
+        if (needsRecreation && this._lastSessionPickerAction && this.chatSessionPickerContainer) {
+            const widgets = this.createChatSessionPickerWidgets(this._lastSessionPickerAction, this._lastSessionPickerOptions);
+            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 = "";
+        }
+        if (sessionResource) {
+            for (const [optionGroupId] of this.chatSessionPickerWidgets) {
+                const currentOption = this.chatSessionsService.getSessionOption(sessionResource, optionGroupId);
+                if (currentOption) {
+                    const optionGroup = allOptionsGroups.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 && typeof currentOption === "string") {
+                            this.getOrCreateOptionEmitter(optionGroupId).fire(item);
+                        } else if (typeof currentOption !== "string") {
+                            this.getOrCreateOptionEmitter(optionGroupId).fire(currentOption);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    hideAllSessionPickerWidgets() {
+        if (this.chatSessionPickerContainer) {
+            this.chatSessionPickerContainer.style.display = "none";
+        }
+    }
+    getCurrentOptionForGroup(optionGroupId) {
+        const sessionResource = this._widget?.viewModel?.model.sessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        if (this.chatSessionsService.getSessionOption(sessionResource, optionGroupId) === undefined) {
+            return;
+        }
+        const effectiveSessionType = this.getEffectiveSessionType(sessionResource);
+        const optionGroups = effectiveSessionType ? this.chatSessionsService.getOptionGroupsForSessionType(effectiveSessionType) : undefined;
+        const optionGroup = optionGroups?.find(g => g.id === optionGroupId);
+        if (!optionGroup || optionGroup.items.length === 0) {
+            return;
+        }
+        const currentOptionValue = this.chatSessionsService.getSessionOption(sessionResource, optionGroupId);
+        if (!currentOptionValue) {
+            const defaultItem = optionGroup.items.find(item => item.default);
+            return defaultItem;
+        }
+        if (typeof currentOptionValue === "string") {
+            const normalizedOptionId = currentOptionValue.trim();
+            return optionGroup.items.find(m => m.id === normalizedOptionId);
+        } else {
+            return currentOptionValue;
+        }
+    }
+    hasWorkspaceScmRepository() {
+        const folders = this.workspaceContextService.getWorkspace().folders;
+        if (folders.length === 0) {
+            return false;
+        }
+        for (const repo of this.scmService.repositories) {
+            if (repo.provider.rootUri && this.workspaceContextService.getWorkspaceFolder(repo.provider.rootUri)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getEffectiveSessionType(sessionResource) {
+        return this.options.sessionTypePickerDelegate?.getActiveSessionProvider?.() ?? (sessionResource ? getChatSessionType(sessionResource) : undefined);
+    }
+    updateAgentSessionTypeContextKey() {
+        const sessionResource = this._widget?.viewModel?.model.sessionResource;
+        const delegate = this.options.sessionTypePickerDelegate;
+        const delegateSessionType = delegate?.setActiveSessionProvider && delegate?.getActiveSessionProvider?.();
+        const sessionType = delegateSessionType || (sessionResource ? getChatSessionType(sessionResource) : "");
+        this.agentSessionTypeKey.set(sessionType);
+        this.chatSessionSupportsDelegationKey.set(this.chatSessionsService.supportsDelegationForSessionType(sessionType));
+    }
+    updateWidgetLockStateFromSessionType(sessionType) {
+        if (sessionType === localChatSessionType) {
+            this._widget?.unlockFromCodingAgent();
+            return;
+        }
+        const contribution = this.chatSessionsService.getChatSessionContribution(sessionType);
+        if (contribution) {
+            this._widget?.lockToCodingAgent(
+                contribution.name,
+                contribution.displayName,
+                contribution.type,
+                contribution.agentHostProviderId
+            );
+        } else {
+            this._widget?.unlockFromCodingAgent();
+        }
+    }
+    getActiveSessionTypeForDelegation() {
+        const sessionResource = this._widget?.viewModel?.sessionResource;
+        return sessionResource ? (getAgentSessionProvider(sessionResource) ?? getChatSessionType(sessionResource)) : undefined;
+    }
+    continueInSession(provider) {
+        this.setPendingDelegationTarget(provider);
+        this.focus();
+    }
+    setPendingDelegationTarget(provider) {
+        const isActive = this.getActiveSessionTypeForDelegation() === provider;
+        this._pendingDelegationTarget = isActive ? undefined : provider;
+        this.chatHasPendingDelegationTargetKey.set(!!this._pendingDelegationTarget);
+        this.updateWidgetLockStateFromSessionType(provider);
+        this.updateAgentSessionTypeContextKey();
+        this.refreshChatSessionPickers();
+    }
+    ensureNotificationWidget() {
+        if (!this._notificationWidget.value) {
+            this._notificationWidget.value = this.instantiationService.createInstance(ChatInputNotificationWidget, {
+                modelTargetChatSessionType: this._notificationModelTargetChatSessionType,
+                sessionResource: this._currentSessionResourceObservable,
+                deferredNotificationsEnabled: this._deferredNotificationsEnabled,
+                isTransientChat: constObservable(this.options.isTransientChat ?? false),
+                sessionStarted: this._sessionStarted,
+                modelSelection: {
+                    state: this._notificationModelState,
+                    openPicker: () => this.openModelPicker(),
+                    selectModel: modelIdentifier => this.selectNotificationModel(modelIdentifier),
+                    applyModelConfiguration: (modelIdentifier, values) => this.applyNotificationModelConfiguration(modelIdentifier, values)
+                },
+                onDidChangeVisibility: (visible, focusTarget) => this.noticeHost.setOccupied(ChatInputNoticeLane.Notification, visible, focusTarget),
+                focusInput: () => this.focus()
+            });
+            this._notificationWidget.value.attachTo(this.chatInputNotificationContainer);
+        }
+    }
+    getNotificationContext() {
+        return {
+            sessionType: this._notificationModelTargetChatSessionType.get(),
+            sessionResource: this._currentSessionResourceObservable.get(),
+            deferredNotificationsEnabled: this._deferredNotificationsEnabled.get(),
+            isTransientChat: this.options.isTransientChat ?? false,
+            sessionStarted: this._sessionStarted.get(),
+            modelState: this._notificationModelState.get()
+        };
+    }
+    selectNotificationModel(identifier) {
+        const model = this._notificationModelState.get().models.find(model => model.identifier === identifier);
+        if (!model) {
+            return false;
+        }
+        this.setCurrentLanguageModel(model, true, !this._pendingDelegationTarget);
+        return true;
+    }
+    async applyNotificationModelConfiguration(modelIdentifier, values) {
+        if (this._pendingDelegationTarget) {
+            return;
+        }
+        await this._modelConfigStore.setModelConfiguration(modelIdentifier, values);
+    }
+    ensureGoalBannerWidget() {
+        if (!this._goalBannerWidget.value) {
+            const widget = ( new ChatGoalBannerWidget());
+            this._register(widget.onDismiss(() => this._onDidDismissGoalBanner.fire()));
+            this._goalBannerWidget.value = widget;
+            widget.attachTo(this.chatGoalBannerContainer);
+        }
+        return this._goalBannerWidget.value;
+    }
+    showGoalBannerLoading() {
+        this.ensureGoalBannerWidget().setLoading();
+    }
+    setGoalBanner(summary) {
+        this.ensureGoalBannerWidget().setGoal(summary);
+    }
+    clearGoalBanner() {
+        this._goalBannerWidget.value?.clear();
+    }
+    showContextUsageDetails() {
+        return this.contextUsageWidget?.showDetails() ?? false;
+    }
+    updateContextUsageWidget() {
+        this._contextUsageDisposables.clear();
+        const model = this._widget?.viewModel?.model;
+        if (!model || !this.contextUsageWidget) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        this._contextUsageDisposables.value = store;
+        let lastRequest = model.lastRequest;
+        const observePreviousResponse = request => {
+            if (request?.response) {
+                store.add(
+                    request.response.onDidChange(() => this.contextUsageWidget?.updateSessionCost(model.sessionCost))
+                );
+            }
+        };
+        for (const request of model.getRequests().slice(0, -1)) {
+            observePreviousResponse(request);
+        }
+        store.add(model.onDidChange(e => {
+            if (e.kind === "addRequest") {
+                observePreviousResponse(lastRequest);
+                lastRequest = e.request;
+                this.contextUsageWidget?.update(model.lastRequest);
+            } else if (e.kind === "completedRequest") {
+                this.contextUsageWidget?.update(model.lastRequest);
+            }
+        }));
+        store.add(this.languageModelsService.onDidChangeLanguageModels(() => {
+            const lastRequest = model.lastRequest;
+            if (lastRequest?.modelId) {
+                this.contextUsageWidget?.update(lastRequest);
+            }
+        }));
+        this.contextUsageWidget.update(model.lastRequest);
+    }
+    handleViewModelChange(e) {
+        this.updateDeferredNotificationsEligibility(e);
+        transaction(observableTransaction => {
+            try {
+                this.updateInputEditorFontFamily();
+                this.resetPendingDelegationForViewModelChange(observableTransaction);
+                this.refreshViewModelScopedState();
+                this.clearQuestionCarouselIfSessionChanged(e);
+                this.clearPlanReviewIfSessionChanged(e);
+                this._syncToolConfirmationCarouselForSession();
+                this.reconcileSessionTypeForViewModelChange(e, observableTransaction);
+            } finally {
+                this._restorePerTypeModel = false;
+            }
+        });
+        this._modelSelectionController.applyConfiguredDefault();
+    }
+    updateDeferredNotificationsEligibility(e) {
+        if (this.environmentService.isSessionsWindow) {
+            this._deferredNotificationsEnabled.set(true, undefined);
+            return;
+        }
+        this._isFirstWorkbenchSession ??= !this.chatService.hasSessions();
+        if (this._isFirstWorkbenchSession && e?.previousSessionResource && e.currentSessionResource && !isEqual(e.previousSessionResource, e.currentSessionResource) && !isUntitledChatSession(e.previousSessionResource)) {
+            this._isFirstWorkbenchSession = false;
+        }
+        this._deferredNotificationsEnabled.set(!this._isFirstWorkbenchSession, undefined);
+    }
+    resetPendingDelegationForViewModelChange(transaction) {
+        this._pendingDelegationTargetObservable.set(undefined, transaction);
+        this.chatHasPendingDelegationTargetKey.set(false);
+    }
+    refreshViewModelScopedState() {
+        this.updateAgentSessionTypeContextKey();
+        this.refreshChatSessionPickers();
+        this.ensureNotificationWidget();
+        this.updateContextUsageWidget();
+    }
+    clearQuestionCarouselIfSessionChanged(e) {
+        let hasMatchingResource = false;
+        if (e.currentSessionResource) {
+            for (const r of ( this._questionCarouselSessionResources.values())) {
+                if (isEqual(r, e.currentSessionResource)) {
+                    hasMatchingResource = true;
+                    break;
+                }
+            }
+        }
+        if (this._questionCarouselSessionResources.size > 0 && (!e.currentSessionResource || !hasMatchingResource)) {
+            this.clearQuestionCarousel();
+        }
+    }
+    clearPlanReviewIfSessionChanged(e) {
+        let hasMatchingPlanReviewResource = false;
+        if (e.currentSessionResource) {
+            for (const r of ( this._planReviewSessionResources.values())) {
+                if (isEqual(r, e.currentSessionResource)) {
+                    hasMatchingPlanReviewResource = true;
+                    break;
+                }
+            }
+        }
+        if (this._planReviewSessionResources.size > 0 && (!e.currentSessionResource || !hasMatchingPlanReviewResource)) {
+            this.clearPlanReview();
+        }
+    }
+    reconcileSessionTypeForViewModelChange(e, transaction) {
+        this._currentSessionResourceObservable.set(e.currentSessionResource, transaction);
+        this._currentSessionModelObservable.set(this._widget?.viewModel?.model, transaction);
+        const newSessionType = this.getCurrentSessionType();
+        if (e.currentSessionResource && this._currentSessionType && newSessionType !== this._currentSessionType) {
+            logChangesToStateModel(
+                this._inputModel,
+                `[CVVM].1 onDidChangeViewModel -> session change: ${this._currentSessionType} -> ${newSessionType} in ${this._currentSessionKey}, ${( e.currentSessionResource.toString())}`,
+                undefined,
+                this._inputModel?.state.get(),
+                this.logService
+            );
+            this._currentSessionTypeObservable.set(newSessionType, transaction);
+            this.initSelectedModel();
+            this.checkModeInSessionPool();
+            this._modelSelectionController.ensureCurrentModelSupported();
+        } else if (e.currentSessionResource) {
+            logChangesToStateModel(
+                this._inputModel,
+                `[CVVM].2 onDidChangeViewModel -> session change: ${this._currentSessionType} -> ${newSessionType} in ${this._currentSessionKey}, ${( e.currentSessionResource.toString())}`,
+                undefined,
+                this._inputModel?.state.get(),
+                this.logService
+            );
+            this._currentSessionTypeObservable.set(newSessionType, transaction);
+            this.restorePerTypeModelAfterViewModelAssignment();
+            this.reinitializeIfOutsidePool(() => this.initSelectedModel());
+        }
+    }
+    restorePerTypeModelAfterViewModelAssignment() {
+        if (this._restorePerTypeModel) {
+            this.initSelectedModel();
+            if (!this._modelSelectionController.hasPendingProgrammaticSelection() && !this._modelSelectionController.isAwaitingRememberedModel()) {
+                this._modelSelectionController.ensureCurrentModelSupported();
+            }
+        }
+    }
+    render(container, initialValue, widget) {
+        this._widget = widget;
+        this.updateDeferredNotificationsEligibility();
+        this._currentSessionResourceObservable.set(widget.viewModel?.sessionResource, undefined);
+        this._currentSessionModelObservable.set(widget.viewModel?.model, undefined);
+        this.getVisibleOptionGroupsModeAndUpdateContextKeys(this.getCurrentSessionResource());
+        const delegate = this.options.sessionTypePickerDelegate;
+        if (delegate?.setActiveSessionProvider && delegate?.getActiveSessionProvider) {
+            const initialSessionType = delegate.getActiveSessionProvider();
+            if (initialSessionType) {
+                this.updateWidgetLockStateFromSessionType(initialSessionType);
+            }
+        }
+        this._register(widget.onDidChangeViewModel(e => this.handleViewModelChange(e)));
+        let elements;
+        if (this.options.renderStyle === "compact") {
+            elements = h(
+                `.interactive-input-part.${chatInputSurfaceStackClass}`,
+                [h(".chat-input-persistent-content@persistentContentContainer"), h(
+                    `.chat-session-archive-nudge-container.${chatInputSurfaceStackSlotClass}@sessionArchiveNudgeContainer`
+                ), h(
+                    `.interactive-input-and-edit-session.${chatInputSurfaceStackClass}`,
+                    [h(
+                        `.chat-plan-review-widget-container.${chatInputSurfaceStackSlotClass}@chatPlanReviewContainer`
+                    ), h(
+                        `.chat-question-carousel-widget-container.${chatInputSurfaceStackSlotClass}@chatQuestionCarouselContainer`
+                    ), h(
+                        `.chat-tool-confirmation-carousel-container.${chatInputSurfaceStackSlotClass}@chatToolConfirmationCarouselContainer`
+                    ), h(`.${chatInputStackClass}`, [h(
+                        `.chat-input-notification-container.${chatInputStackSlotClass}@chatInputNotificationContainer`
+                    ), h(
+                        `.voice-mode-onboarding-container.${chatInputStackSlotClass}@voiceModeOnboardingContainer`
+                    ), h(
+                        `.dictation-onboarding-container.${chatInputStackSlotClass}@dictationOnboardingContainer`
+                    ), h(
+                        `.chat-goal-banner-container.${chatInputStackSlotClass}@chatGoalBannerContainer`
+                    ), h(".chat-todo-list-widget-container@chatInputTodoListWidgetContainer"), h(".chat-artifacts-widget-container@chatArtifactsWidgetContainer"), h(".chat-editing-session@chatEditingSessionWidgetContainer"), h(
+                        `.chat-getting-started-tip-container.${chatInputStackSlotClass}@chatGettingStartedTipContainer`
+                    ), h(
+                        ".interactive-input-and-side-toolbar@inputAndSideToolbar",
+                        [h(".chat-input-container@inputContainer", [
+                            h(".chat-editor-container@editorContainer"),
+                            h(".chat-input-toolbars@inputToolbars")
+                        ])]
+                    )]), h(".chat-secondary-toolbar@secondaryToolbar", [
+                        h(".chat-responsive-picker-container@responsivePickerContainer"),
+                        h(".chat-context-usage-container@contextUsageWidgetContainer"),
+                        h(".chat-input-status-container@statusToolbarContainer")
+                    ]), h(
+                        `.chat-attachments-container.${chatInputSurfaceStackSlotClass}@attachmentsContainer`,
+                        [h(".chat-attached-context@attachedContextContainer")]
+                    ), h(
+                        `.interactive-input-followups.${chatInputSurfaceStackSlotClass}@followupsContainer`
+                    )]
+                )]
+            );
+        } else {
+            elements = h(
+                `.interactive-input-part.${chatInputSurfaceStackClass}`,
+                [h(".chat-input-persistent-content@persistentContentContainer"), h(
+                    `.chat-session-archive-nudge-container.${chatInputSurfaceStackSlotClass}@sessionArchiveNudgeContainer`
+                ), h(
+                    `.chat-plan-review-widget-container.${chatInputSurfaceStackSlotClass}@chatPlanReviewContainer`
+                ), h(
+                    `.chat-question-carousel-widget-container.${chatInputSurfaceStackSlotClass}@chatQuestionCarouselContainer`
+                ), h(
+                    `.chat-tool-confirmation-carousel-container.${chatInputSurfaceStackSlotClass}@chatToolConfirmationCarouselContainer`
+                ), h(
+                    `.interactive-input-followups.${chatInputSurfaceStackSlotClass}@followupsContainer`
+                ), h(`.${chatInputStackClass}`, [h(
+                    `.chat-input-notification-container.${chatInputStackSlotClass}@chatInputNotificationContainer`
+                ), h(
+                    `.voice-mode-onboarding-container.${chatInputStackSlotClass}@voiceModeOnboardingContainer`
+                ), h(
+                    `.dictation-onboarding-container.${chatInputStackSlotClass}@dictationOnboardingContainer`
+                ), h(
+                    `.chat-goal-banner-container.${chatInputStackSlotClass}@chatGoalBannerContainer`
+                ), h(".chat-todo-list-widget-container@chatInputTodoListWidgetContainer"), h(".chat-artifacts-widget-container@chatArtifactsWidgetContainer"), h(".chat-editing-session@chatEditingSessionWidgetContainer"), h(
+                    `.chat-getting-started-tip-container.${chatInputStackSlotClass}@chatGettingStartedTipContainer`
+                ), h(
+                    ".interactive-input-and-side-toolbar@inputAndSideToolbar",
+                    [h(".chat-input-container@inputContainer", [h(
+                        ".chat-attachments-container@attachmentsContainer",
+                        [h(".chat-attached-context@attachedContextContainer")]
+                    ), h(".chat-editor-container@editorContainer"), h(".chat-input-toolbars@inputToolbars")])]
+                )]), h(".chat-secondary-toolbar@secondaryToolbar", [
+                    h(".chat-responsive-picker-container@responsivePickerContainer"),
+                    h(".chat-context-usage-container@contextUsageWidgetContainer"),
+                    h(".chat-input-status-container@statusToolbarContainer")
+                ])]
+            );
+        }
+        this.container = elements.root;
+        this.persistentContentContainer = elements.persistentContentContainer;
+        this.sessionArchiveNudgeContainer = elements.sessionArchiveNudgeContainer;
+        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._scopedContextKeyService = this._register(this.contextKeyService.createScoped(this.container));
+        const archiveNudgeContextKeyService = this._register(this.contextKeyService.createScoped(this.sessionArchiveNudgeContainer));
+        ChatContextKeys.inChatInput.bindTo(archiveNudgeContextKeyService).set(true);
+        this.followupsContainer = elements.followupsContainer;
+        const inputAndSideToolbar = elements.inputAndSideToolbar;
+        this.inputAndSideToolbar = inputAndSideToolbar;
+        const inputContainer = elements.inputContainer;
+        this.inputContainer = inputContainer;
+        const editorContainer = elements.editorContainer;
+        this.attachmentsContainer = elements.attachmentsContainer;
+        this.attachedContextContainer = elements.attachedContextContainer;
+        const toolbarsContainer = elements.inputToolbars;
+        this.secondaryToolbarContainer = elements.secondaryToolbar;
+        const responsivePickerContainer = elements.responsivePickerContainer;
+        if (this.options.renderStyle === "compact") {
+            this.secondaryToolbarContainer.style.display = "none";
+        }
+        this.chatEditingSessionWidgetContainer = elements.chatEditingSessionWidgetContainer;
+        this.chatInputTodoListWidgetContainer = elements.chatInputTodoListWidgetContainer;
+        this.chatArtifactsWidgetContainer = elements.chatArtifactsWidgetContainer;
+        this.chatGettingStartedTipContainer = elements.chatGettingStartedTipContainer;
+        this.chatQuestionCarouselContainer = elements.chatQuestionCarouselContainer;
+        this.chatPlanReviewContainer = elements.chatPlanReviewContainer;
+        this.chatToolConfirmationCarouselContainer = elements.chatToolConfirmationCarouselContainer;
+        hide(this.chatToolConfirmationCarouselContainer);
+        this._register(
+            this.chatInputNoticeHubService.registerHost(this.noticeHost, this.container)
+        );
+        this.chatInputNotificationContainer = elements.chatInputNotificationContainer;
+        this._register(registerChatInputOnboardingHosts(this.noticeHost, {
+            voice: elements.voiceModeOnboardingContainer,
+            dictation: elements.dictationOnboardingContainer
+        }, this.container, () => this.focus(), this.voiceModeOnboardingService, this.dictationOnboardingService));
+        this.chatGoalBannerContainer = elements.chatGoalBannerContainer;
+        this.contextUsageWidgetContainer = elements.contextUsageWidgetContainer;
+        this.statusToolbarContainer = elements.statusToolbarContainer;
+        if (this.options.renderStyle === "compact") {
+            toolbarsContainer.prepend(this.contextUsageWidgetContainer);
+        }
+        this.contextUsageWidget = this._register(this.instantiationService.createInstance(ChatContextUsageWidget));
+        this.contextUsageWidget.setChatWidget(widget);
+        this.contextUsageWidget.setSelectedModel(this._currentLanguageModel.get()?.identifier);
+        this.contextUsageWidget.setModelConfigurationResolver(
+            modelId => this.getModelConfiguration(modelId),
+            this._modelConfigStore.onDidChange
+        );
+        this.contextUsageWidgetContainer.appendChild(this.contextUsageWidget.domNode);
+        if (this.options.enableImplicitContext && !this._implicitContext) {
+            this._implicitContext = this._register(this.instantiationService.createInstance(ChatImplicitContexts));
+            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.ensureNotificationWidget();
+        this._register(this._attachmentModel.onDidChange(e => {
+            if (e.added.length > 0) {
+                this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+            }
+            this._handleAttachedContextChange();
+        }));
+        this.renderChatEditingSessionState(null);
+        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);
+        this.editingSentRequestKey = ChatContextKeys.editingRequestType.bindTo(this.contextKeyService);
+        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 = INPUT_EDITOR_LINE_HEIGHT;
+        options.padding = this.options.renderStyle === "compact" ? INPUT_EDITOR_PADDING.compact : INPUT_EDITOR_PADDING.default;
+        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.quickSuggestions = this.options.inputEditorQuickSuggestions ?? false;
+        options.suggest = {
+            showIcons: true,
+            showSnippets: false,
+            showWords: true,
+            showStatusBar: false,
+            insertMode: "insert",
+            fitWidthToDetails: true
+        };
+        options.scrollbar = this.options.renderStyle === "compact" ? {
+            ...(options.scrollbar ?? {}),
+            vertical: "hidden"
+        } : {
+            ...(options.scrollbar ?? {}),
+            vertical: "auto",
+            verticalScrollbarSize: 7
+        };
+        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,
+            InlineCompletionsController.ID,
+            PlaceholderTextContribution.ID
+        ]));
+        this._inputEditor = this._register(
+            scopedInstantiationService.createInstance(CodeEditorWidget, this._inputEditorElement, options, editorOptions)
+        );
+        this.updateInputEditorFontFamily();
+        this._register(addDisposableListener(
+            this._inputEditorElement,
+            EventType.PASTE,
+            e => this.handleTerminalCommandPaste(e),
+            true
+        ));
+        const dictationRecording = ChatContextKeys.speechToTextRecording.bindTo(this.contextKeyService);
+        const dictationPreparing = ChatContextKeys.speechToTextPreparing.bindTo(this.contextKeyService);
+        const isDictationInputActive = observableFromEvent(this, Event.any(
+            this.speechToTextService.onDidChangeState,
+            this.speechToTextService.onDidChangePreparingModel,
+            onDidChangeDictationEditor
+        ), () => isDictationActiveForEditor(this._inputEditor));
+        const updateDictationContextKeys = () => {
+            const active = isDictationActiveForEditor(this._inputEditor);
+            dictationRecording.set(
+                active && this.speechToTextService.state === ChatSpeechToTextState.Recording
+            );
+            dictationPreparing.set(active && this.speechToTextService.isPreparingModel);
+        };
+        this._register(Event.any(
+            this.speechToTextService.onDidChangeState,
+            this.speechToTextService.onDidChangePreparingModel,
+            onDidChangeDictationEditor
+        )(updateDictationContextKeys));
+        updateDictationContextKeys();
+        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.onDidChangeModelContent(() => {
+            const currentHeight = Math.min(this._inputEditor.getContentHeight(), this._effectiveInputEditorMaxHeight);
+            if (currentHeight !== this.inputEditorHeight) {
+                this.inputEditorHeight = currentHeight;
+                if (this.cachedWidth) {
+                    this._layout(this.cachedWidth);
+                }
+            }
+            this._updateInputContentContextKeys();
+            this.updateInputEditorFontFamily();
+            this._syncTextDebounced.schedule();
+        }));
+        this._register(this._inputEditor.onDidContentSizeChange(e => {
+            if (e.contentHeightChanged && !this.ignoreInputEditorContentSizeChanges) {
+                this.inputEditorHeight = !this.inline ? e.contentHeight : this.inputEditorHeight;
+                if (this.cachedWidth) {
+                    this._layout(this.cachedWidth);
+                }
+            }
+        }));
+        this._register(this._inputEditor.onDidFocusEditorText(() => {
+            this.inputEditorHasFocus.set(true);
+            this._onDidFocus.fire();
+            inputContainer.classList.toggle("focused", true);
+            setChatInputStackInputFocused(inputContainer, true);
+        }));
+        this._register(this._inputEditor.onDidBlurEditorText(() => {
+            this.inputEditorHasFocus.set(false);
+            inputContainer.classList.toggle("focused", false);
+            setChatInputStackInputFocused(inputContainer, false);
+            this._onDidBlur.fire();
+        }));
+        this._register(this._inputEditor.onDidBlurEditorWidget(() => {
+            CopyPasteController.get(this._inputEditor)?.clearWidgets();
+            DropIntoEditorController.get(this._inputEditor)?.clearWidgets();
+        }));
+        const hoverDelegate = this._register(createInstantHoverDelegate());
+        const {
+            location
+        } = this.getWidgetLocationInfo(widget);
+        const focusedWidget = observableFromEvent(
+            this,
+            this.chatWidgetService.onDidChangeFocusedSession,
+            () => this.chatWidgetService.lastFocusedWidget
+        );
+        const voiceSessionResource = observableFromEvent(this, widget.onDidChangeViewModel, () => widget.viewModel?.sessionResource);
+        const isVoiceInputActive = derived(this, reader => focusedWidget.read(reader) === widget);
+        const isVoiceSessionActive = derived(this, reader => {
+            const target = this.voiceSessionController.targetSession.read(reader);
+            const hasDraftTarget = this.voiceSessionController.hasDraftTarget.read(reader);
+            const resource = voiceSessionResource.read(reader);
+            return isVoiceSessionActiveForInput(isVoiceInputActive.read(reader), target, hasDraftTarget, resource);
+        });
+        const inputPickerCompactStates = ( new Map());
+        const inputPickerMinimalStates = ( new Map());
+        const secondaryPickerCompactStates = ( new Map());
+        const inputOverflowPickerHandlers = ( new Map());
+        const secondaryOverflowPickerHandlers = ( new Map());
+        const getCompactState = (states, actionId) => {
+            let state = states.get(actionId);
+            if (!state) {
+                state = observableValue(this, false);
+                states.set(actionId, state);
+            }
+            return state;
+        };
+        const getInputPickerOptions = actionId => ({
+            getOverflowAnchor: () => this.inputActionsToolbar.getElement(),
+            actionContext: {
+                widget
+            },
+            compact: getCompactState(inputPickerCompactStates, actionId),
+            minimal: actionId === OpenModelPickerAction.ID ? getCompactState(inputPickerMinimalStates, actionId) : undefined
+        });
+        const getSecondaryPickerOptions = actionId => ({
+            getOverflowAnchor: () => this.secondaryToolbar.getElement(),
+            actionContext: {
+                widget
+            },
+            compact: getCompactState(secondaryPickerCompactStates, actionId)
+        });
+        const showOverflowPicker = (factory, anchor) => {
+            const item = factory();
+            if (!item) {
+                return;
+            }
+            this.overflowPickerWidget.value = item;
+            item.render($$1(".chat-overflow-picker-item"));
+            item.show(anchor);
+        };
+        const showRegisteredOverflowPicker = (factory, action, anchor) => {
+            const item = factory(action, {
+                hoverDelegate
+            }, this.instantiationService, getWindow(anchor).vscodeWindowId);
+            if (!isShowableActionViewItem(item)) {
+                item?.dispose();
+                return false;
+            }
+            this.overflowPickerWidget.value = item;
+            item.render($$1(".chat-overflow-picker-item"));
+            item.show(anchor);
+            return true;
+        };
+        const getOverflowAction = (action, menuId, handlers, getAnchor, fallbackAnchor, hostHandler) => {
+            const handler = handlers.get(action.id);
+            const registeredFactory = this.actionViewItemService.lookUp(menuId, action.id);
+            if (!handler && !hostHandler && !registeredFactory) {
+                return action;
+            }
+            return createOverflowAction(action, () => {
+                const overflowAnchor = getAnchor();
+                const anchor = overflowAnchor ?? fallbackAnchor;
+                getWindow(anchor).setTimeout(() => {
+                    overflowAnchor?.focus();
+                    if (handler) {
+                        handler(anchor);
+                    } else if (hostHandler?.(action.id, anchor)) {
+                        return;
+                    } else if (registeredFactory && showRegisteredOverflowPicker(registeredFactory, action, anchor)) {
+                        return;
+                    } else {
+                        void action.run({
+                            widget
+                        });
+                    }
+                }, 0);
+            });
+        };
+        const shorterChatInputActionIds = ( new Set([OpenModePickerAction.ID, ConfigureToolsAction.ID]));
+        const getInputActionMinWidth = action => {
+            if (action.id === OpenModelPickerAction.ID) {
+                return this.modelWidget?.minimumWidth ?? 60;
+            }
+            if (( shorterChatInputActionIds.has(action.id))) {
+                return CHAT_INPUT_COMPACT_PICKER_WIDTH;
+            }
+            return inputPickerCompactStates.get(action.id)?.get() ? CHAT_INPUT_COMPACT_PICKER_WIDTH : undefined;
+        };
+        this._register(
+            addStandardDisposableListener(toolbarsContainer, EventType.CLICK, e => this.inputEditor.focus())
+        );
+        this._register(addStandardDisposableListener(
+            this.attachmentsContainer,
+            EventType.CLICK,
+            e => this.inputEditor.focus()
+        ));
+        const inputToolbarMenu = this.options.menus.inputToolbar ?? MenuId.ChatInput;
+        this.inputActionsToolbar = this._register(this.instantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            this.options.renderInputToolbarBelowInput ? this.attachmentsContainer : toolbarsContainer,
+            inputToolbarMenu,
+            {
+                telemetrySource: this.options.menus.telemetrySource,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                hoverDelegate,
+                responsiveBehavior: {
+                    enabled: true,
+                    kind: "last",
+                    minItems: 2,
+                    actionMinWidth: 48,
+                    getActionMinWidth: getInputActionMinWidth,
+                    allowOverflow: () => this._inputPickerResponsiveLayout?.areAllItemsCompact() === true,
+                    getOverflowAction: (action, getAnchor) => getOverflowAction(
+                        action,
+                        inputToolbarMenu,
+                        inputOverflowPickerHandlers,
+                        getAnchor,
+                        toolbarsContainer
+                    )
+                },
+                actionViewItemProvider: (action, options) => {
+                    if (this.chatPhoneInputPresenter.enabled.get()) {
+                        if (action.id === OpenModelPickerAction.ID && action instanceof MenuItemAction) {
+                            if (!this._currentLanguageModel.get()) {
+                                this.setCurrentLanguageModelToDefault();
+                            }
+                            const modelDelegate = this._createModelPickerDelegate();
+                            const modeDelegate = this._createModePickerDelegate();
+                            return this.instantiationService.createInstance(
+                                MobileChatInputCombinedPickerActionItem,
+                                action,
+                                modeDelegate,
+                                modelDelegate
+                            );
+                        } else if (action.id === OpenModePickerAction.ID && action instanceof MenuItemAction) {
+                            return ( new HiddenActionViewItem(action));
+                        }
+                    }
+                    if (action.id === OpenModelPickerAction.ID && action instanceof MenuItemAction) {
+                        if (!this._currentLanguageModel.get()) {
+                            this._modelSelectionDiagnostics.report("no-model-at-toolbar-build", {}, "info");
+                            this.setCurrentLanguageModelToDefault();
+                        }
+                        const itemDelegate = this._createModelPickerDelegate();
+                        const createPicker = () => this.instantiationService.createInstance(
+                            ModelPickerActionItem,
+                            action,
+                            itemDelegate,
+                            getInputPickerOptions(action.id)
+                        );
+                        inputOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        return this.modelWidget = createPicker();
+                    } else if (action.id === OpenModePickerAction.ID && action instanceof MenuItemAction) {
+                        const delegate = this._createModePickerDelegate();
+                        const createPicker = () => this.instantiationService.createInstance(ModePickerActionItem, action, delegate, getInputPickerOptions(action.id));
+                        inputOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        return this.modeWidget = createPicker();
+                    } else if ((action.id === OpenSessionTargetPickerAction.ID || action.id === OpenDelegationPickerAction.ID) && action instanceof MenuItemAction) {
+                        const delegate = this.options.sessionTypePickerDelegate ?? {
+                            getActiveSessionProvider: () => {
+                                return this.getActiveSessionTypeForDelegation();
+                            },
+                            getPendingDelegationTarget: () => {
+                                return this._pendingDelegationTarget;
+                            },
+                            setPendingDelegationTarget: provider => {
+                                this.setPendingDelegationTarget(provider);
+                            },
+                            hasGitRepository: () => this.hasWorkspaceScmRepository()
+                        };
+                        const isWelcomeViewMode = !!this.options.sessionTypePickerDelegate?.setActiveSessionProvider;
+                        const Picker = (action.id === OpenSessionTargetPickerAction.ID || isWelcomeViewMode) ? SessionTypePickerActionItem : DelegationSessionPickerActionItem;
+                        const createPicker = () => this.instantiationService.createInstance(
+                            Picker,
+                            action,
+                            location === ChatWidgetLocation.Editor ? "editor" : "sidebar",
+                            delegate,
+                            getInputPickerOptions(action.id)
+                        );
+                        inputOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        const picker = createPicker();
+                        if (picker instanceof DelegationSessionPickerActionItem) {
+                            this.delegationWidget = picker;
+                        } else {
+                            this.sessionTargetWidget = picker;
+                        }
+                        return picker;
+                    } else if (action.id === ChatSessionPrimaryPickerAction.ID && action instanceof MenuItemAction) {
+                        const createPicker = () => {
+                            const widgets = this.createChatSessionPickerWidgets(action, getInputPickerOptions(action.id));
+                            return widgets.length === 0 ? undefined : this.instantiationService.createInstance(ChatSessionPickersContainerActionItem, action, widgets);
+                        };
+                        inputOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        return createPicker() ?? ( new HiddenActionViewItem(action));
+                    }
+                    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 primaryPickerContainer = toolbarElement.querySelector(".chat-sessionPicker-container");
+            if (primaryPickerContainer) {
+                this.chatSessionPickerContainer = primaryPickerContainer;
+            }
+            if (this.cachedWidth && typeof this.cachedInputToolbarWidth === "number" && this.cachedInputToolbarWidth !== this.inputActionsToolbar.getItemsWidth()) {
+                this._toolbarRelayoutScheduler.schedule();
+            }
+        }));
+        let lastPhoneEnabled = this.chatPhoneInputPresenter.enabled.get();
+        this._register(autorun(reader => {
+            const enabled = this.chatPhoneInputPresenter.enabled.read(reader);
+            if (enabled !== lastPhoneEnabled) {
+                lastPhoneEnabled = enabled;
+                this.inputActionsToolbar.refresh();
+            }
+        }));
+        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 === ChatVoiceInputModeAction.ID) {
+                        return this.instantiationService.createInstance(VoiceInputModeActionViewItem, action, {
+                            isActive: isVoiceInputActive,
+                            isDictationActive: isDictationInputActive,
+                            isVoiceActive: isVoiceSessionActive
+                        });
+                    }
+                    if ((action.id === ChatSubmitAction.ID || action.id === ChatEditingSessionSubmitAction.ID) && action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(class extends MenuEntryActionViewItem {
+                            render(container) {
+                                super.render(container);
+                                container.classList.add("chat-submit-button");
+                            }
+                        }, action, options);
+                    }
+                    if ((action.id === ChatSpeechToTextPreparingAction.ID || action.id === ChatSpeechToTextConnectingAction.ID) && action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(DictationDownloadActionViewItem, action, options);
+                    }
+                    if (action.id === ToggleChatSpeechToTextAction.ID && action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(DictationActionViewItem, action, options, isDictationInputActive);
+                    }
+                    if ((action.id === "agentsVoice.startVoiceInChat" || action.id === "agentsVoice.pttStopInChat") && action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(VoiceModeActionViewItem, action, options);
+                    }
+                    return undefined;
+                }
+            }
+        ));
+        this.executeToolbar.getElement().classList.add("chat-execute-toolbar");
+        this.executeToolbar.context = {
+            widget
+        };
+        const voiceInputActionIconClasses = ( new Set([
+            Codicon.micCompact,
+            Codicon.micFilled,
+            Codicon.micDownloadCompact,
+            Codicon.voiceModeCompact,
+            Codicon.loadingCompact,
+            Codicon.debugDisconnectCompact
+        ].map(icon => ThemeIcon.asClassName(icon))));
+        const updateVoiceInputActionBorder = () => {
+            let voiceInputActionCount = 0;
+            for (let i = 0; ; i++) {
+                const action = this.executeToolbar.getItemAction(i);
+                if (!action) {
+                    break;
+                }
+                if (action.class && ( voiceInputActionIconClasses.has(action.class))) {
+                    voiceInputActionCount++;
+                }
+            }
+            this.executeToolbar.getElement().classList.toggle("chat-voice-input-actions-multiple", voiceInputActionCount > 1);
+        };
+        updateVoiceInputActionBorder();
+        this._register(this.executeToolbar.onDidChangeMenuItems(() => {
+            updateVoiceInputActionBorder();
+            if (this.cachedWidth && typeof this.cachedExecuteToolbarWidth === "number" && this.cachedExecuteToolbarWidth !== this.executeToolbar.getItemsWidth()) {
+                this._toolbarRelayoutScheduler.schedule();
+            }
+        }));
+        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
+            };
+        }
+        const secondaryPickerMinWidths = ( new Map([
+            [OpenSessionTargetPickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [OpenDelegationPickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [OpenWorkspacePickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [OpenPermissionPickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [ChatSessionPrimaryPickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [OpenAgentHostModePickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [
+                "sessions.agentHost.runningSessionModePicker",
+                CHAT_INPUT_COMPACT_PICKER_WIDTH
+            ],
+            [
+                "sessions.agentHost.runningSessionConfigPicker",
+                CHAT_INPUT_COMPACT_PICKER_WIDTH
+            ],
+            [
+                "sessions.agentHost.runningSessionPermissionModePicker",
+                CHAT_INPUT_COMPACT_PICKER_WIDTH
+            ],
+            [
+                "sessions.agentHost.runningSessionCodexApprovalsPicker",
+                CHAT_INPUT_COMPACT_PICKER_WIDTH
+            ],
+            [OpenAgentHostAutoApprovePickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            [
+                OpenAgentHostPermissionModePickerAction.ID,
+                CHAT_INPUT_COMPACT_PICKER_WIDTH
+            ],
+            [
+                OpenAgentHostCodexApprovalsPickerAction.ID,
+                CHAT_INPUT_COMPACT_PICKER_WIDTH
+            ],
+            [OpenAgentHostFolderPickerAction.ID, CHAT_INPUT_COMPACT_PICKER_WIDTH],
+            ["sessions.tunnelHost.toggleSharing", 16]
+        ]));
+        const genericChipsContainer = $$1(".chat-secondary-generic-chips");
+        const genericChipsLane = this._register(
+            this.instantiationService.createInstance(AgentHostGenericConfigChips, widget)
+        );
+        genericChipsLane.render(genericChipsContainer);
+        const getSecondaryToolbarAvailableWidth = () => {
+            const laneWidth = responsivePickerContainer.getBoundingClientRect().width;
+            if (genericChipsContainer.parentElement !== responsivePickerContainer || genericChipsContainer.getClientRects().length === 0) {
+                return laneWidth;
+            }
+            const gap = Number.parseFloat(
+                getWindow(responsivePickerContainer).getComputedStyle(responsivePickerContainer).columnGap
+            ) || 0;
+            return Math.max(0, laneWidth - genericChipsContainer.getBoundingClientRect().width - gap);
+        };
+        this.secondaryToolbar = this._register(this.instantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            responsivePickerContainer,
+            MenuId.ChatInputSecondary,
+            {
+                telemetrySource: this.options.menus.telemetrySource,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                hoverDelegate,
+                responsiveBehavior: {
+                    enabled: true,
+                    kind: "all",
+                    minItems: 1,
+                    actionMinWidth: 48,
+                    getActionMinWidth: action => secondaryPickerMinWidths.get(action.id) ?? (secondaryPickerCompactStates.get(action.id)?.get() ? 22 : undefined),
+                    observedElement: responsivePickerContainer,
+                    getAvailableWidth: getSecondaryToolbarAvailableWidth,
+                    allowOverflow: () => this._secondaryPickerResponsiveLayout?.areAllItemsCompact() === true,
+                    getOverflowAction: (action, getAnchor) => getOverflowAction(
+                        action,
+                        MenuId.ChatInputSecondary,
+                        secondaryOverflowPickerHandlers,
+                        getAnchor,
+                        responsivePickerContainer,
+                        this.options.secondaryToolbarOverflowActionHandler
+                    )
+                },
+                actionViewItemProvider: (action, options) => {
+                    const agentHostPickerProperty = getAgentHostPickerProperty(action.id);
+                    const customSecondaryItem = this.options.secondaryToolbarActionViewItemProvider?.(action, options);
+                    if (customSecondaryItem) {
+                        getCompactState(secondaryPickerCompactStates, action.id);
+                        return customSecondaryItem;
+                    }
+                    if ((action.id === OpenSessionTargetPickerAction.ID || action.id === OpenDelegationPickerAction.ID) && action instanceof MenuItemAction) {
+                        const delegate = this.options.sessionTypePickerDelegate ?? {
+                            getActiveSessionProvider: () => {
+                                return this.getActiveSessionTypeForDelegation();
+                            },
+                            getPendingDelegationTarget: () => {
+                                return this._pendingDelegationTarget;
+                            },
+                            setPendingDelegationTarget: provider => {
+                                this.setPendingDelegationTarget(provider);
+                            },
+                            hasGitRepository: () => this.hasWorkspaceScmRepository()
+                        };
+                        const isWelcomeViewMode = !!this.options.sessionTypePickerDelegate?.setActiveSessionProvider;
+                        const Picker = (action.id === OpenSessionTargetPickerAction.ID || isWelcomeViewMode) ? SessionTypePickerActionItem : DelegationSessionPickerActionItem;
+                        const createPicker = () => this.instantiationService.createInstance(
+                            Picker,
+                            action,
+                            location === ChatWidgetLocation.Editor ? "editor" : "sidebar",
+                            delegate,
+                            getSecondaryPickerOptions(action.id)
+                        );
+                        secondaryOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        const picker = createPicker();
+                        if (picker instanceof DelegationSessionPickerActionItem) {
+                            this.delegationWidget = picker;
+                        } else {
+                            this.sessionTargetWidget = picker;
+                        }
+                        return picker;
+                    } else if (action.id === OpenWorkspacePickerAction.ID && action instanceof MenuItemAction) {
+                        const workspacePickerDelegate = this.options.workspacePickerDelegate;
+                        if (this.workspaceContextService.getWorkbenchState() === WorkbenchState.EMPTY && workspacePickerDelegate) {
+                            const createPicker = () => this.instantiationService.createInstance(
+                                WorkspacePickerActionItem,
+                                action,
+                                workspacePickerDelegate,
+                                getSecondaryPickerOptions(action.id)
+                            );
+                            secondaryOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                            return createPicker();
+                        } else {
+                            return ( new HiddenActionViewItem(action));
+                        }
+                    } else if (action.id === OpenPermissionPickerAction.ID && action instanceof MenuItemAction) {
+                        const delegate = {
+                            currentPermissionLevel: this._currentPermissionLevel,
+                            setPermissionLevel: level => {
+                                this.setPermissionLevel(level);
+                            },
+                            getExtensionPermissions: () => {
+                                const sessionResource = this.getCurrentSessionResource();
+                                const group = this.getActiveExtensionPermissionGroup(sessionResource);
+                                if (!group) {
+                                    return undefined;
+                                }
+                                const current = sessionResource ? this.chatSessionsService.getSessionOption(sessionResource, group.id) : undefined;
+                                const defaultId = group.selected?.id ?? group.items.find(i => i.default)?.id;
+                                const rawSelectedId = current === undefined ? defaultId : typeof current === "string" ? current : current.id;
+                                const selectedId = rawSelectedId !== undefined && ( group.items.some(i => i.id === rawSelectedId)) ? rawSelectedId : defaultId;
+                                const sessionType = sessionResource ? getChatSessionType(sessionResource) : (this.options.sessionTypePickerDelegate?.getActiveSessionProvider?.() ?? "");
+                                return {
+                                    sessionType,
+                                    groupId: group.id,
+                                    items: group.items,
+                                    selectedId
+                                };
+                            },
+                            setExtensionPermission: (groupId, item) => {
+                                this.updateOptionContextKey(groupId, item.id);
+                                this.getOrCreateOptionEmitter(groupId).fire(item);
+                                const sessionResource = this.getCurrentSessionResource();
+                                if (sessionResource) {
+                                    this.chatSessionsService.setSessionOption(sessionResource, groupId, item);
+                                }
+                                this.permissionWidget?.refresh();
+                            },
+                            isSandboxToggleApplicable: () => this.getEffectiveSessionType(this.getCurrentSessionResource()) === SessionType.Local
+                        };
+                        const createPicker = () => this.instantiationService.createInstance(
+                            PermissionPickerActionItem,
+                            action,
+                            delegate,
+                            getSecondaryPickerOptions(action.id)
+                        );
+                        secondaryOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        const widget = createPicker();
+                        this.permissionWidget = widget;
+                        this.permissionWidgetDisposeListener.value = widget.onDidDispose(() => {
+                            if (this.permissionWidget === widget) {
+                                this.permissionWidget = undefined;
+                            }
+                            this.permissionWidgetDisposeListener.clear();
+                        });
+                        return widget;
+                    } else if (agentHostPickerProperty && action instanceof MenuItemAction) {
+                        if (this.options.isSessionsWindow) {
+                            return ( new HiddenActionViewItem(action));
+                        }
+                        getCompactState(secondaryPickerCompactStates, action.id);
+                        const createPicker = () => this.instantiationService.createInstance(AgentHostChatInputPicker, widget, agentHostPickerProperty);
+                        secondaryOverflowPickerHandlers.set(action.id, anchor => {
+                            const picker = createPicker();
+                            this.overflowPickerWidget.value = picker;
+                            picker.show(anchor);
+                        });
+                        return ( new AgentHostChatInputPickerActionViewItem(action, createPicker()));
+                    } else if (action.id === OpenAgentHostFolderPickerAction.ID && action instanceof MenuItemAction) {
+                        if (this.options.isSessionsWindow) {
+                            return ( new HiddenActionViewItem(action));
+                        }
+                        const createPicker = () => this.instantiationService.createInstance(
+                            AgentHostFolderPickerActionItem,
+                            action,
+                            widget,
+                            getSecondaryPickerOptions(action.id)
+                        );
+                        secondaryOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        return createPicker();
+                    } else if (action.id === ChatSessionPrimaryPickerAction.ID && action instanceof MenuItemAction) {
+                        const createPicker = () => {
+                            const widgets = this.createChatSessionPickerWidgets(action, getSecondaryPickerOptions(action.id));
+                            return widgets.length === 0 ? undefined : this.instantiationService.createInstance(ChatSessionPickersContainerActionItem, action, widgets);
+                        };
+                        secondaryOverflowPickerHandlers.set(action.id, anchor => showOverflowPicker(createPicker, anchor));
+                        return createPicker() ?? ( new HiddenActionViewItem(action));
+                    }
+                    return undefined;
+                }
+            }
+        ));
+        this.secondaryToolbar.getElement().classList.add("chat-secondary-input-toolbar");
+        this.secondaryToolbar.context = {
+            widget
+        };
+        append(responsivePickerContainer, genericChipsContainer);
+        this._register(this.secondaryToolbar.onDidChangeMenuItems(() => {
+            const toolbarElement = this.secondaryToolbar.getElement();
+            const container = toolbarElement.querySelector(".chat-sessionPicker-container");
+            if (isHTMLElement(container)) {
+                this.chatSessionPickerContainer = container;
+            }
+        }));
+        this.statusToolbar = this._register(this.instantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            this.statusToolbarContainer,
+            MenuId.ChatInputStatus,
+            {
+                telemetrySource: this.options.menus.telemetrySource,
+                menuOptions: {
+                    shouldForwardArgs: true
+                },
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                hoverDelegate
+            }
+        ));
+        this.statusToolbar.getElement().classList.add("chat-input-status-toolbar");
+        this.statusToolbar.context = {
+            widget
+        };
+        const inputToolbarElement = this.inputActionsToolbar.getElement();
+        this._inputPickerResponsiveLayout = this._register(( new ChatInputPickerResponsiveLayout("ChatInputPart.primaryPicker", inputToolbarElement, {
+            getItems: () => getToolbarPickerResponsiveItems(
+                this.inputActionsToolbar,
+                inputPickerCompactStates,
+                inputPickerMinimalStates
+            ),
+            hasOverflow: () => this.inputActionsToolbar.hasOverflow(),
+            relayout: () => this.inputActionsToolbar.relayout()
+        })));
+        this._secondaryPickerResponsiveLayout = this._register(( new ChatInputPickerResponsiveLayout("ChatInputPart.secondaryPicker", responsivePickerContainer, {
+            getItems: () => [
+                ...getToolbarPickerResponsiveItems(this.secondaryToolbar, secondaryPickerCompactStates),
+                ...genericChipsLane.getCompactableElements().map(element => ({
+                    element,
+                    isCompact: () => element.classList.contains("compact-picker"),
+                    setCompact: compact => element.classList.toggle("compact-picker", compact)
+                }))
+            ],
+            hasOverflow: () => this.secondaryToolbar.hasOverflow(),
+            relayout: () => this.secondaryToolbar.relayout()
+        })));
+        this._inputPickerResponsiveLayout.layout();
+        this._secondaryPickerResponsiveLayout.layout();
+        let inputModel = this.modelService.getModel(this.inputUri);
+        let createdInputModel;
+        if (!inputModel) {
+            inputModel = createdInputModel = this.modelService.createModel("", null, this.inputUri, false);
+        }
+        const inputModelReference = this.textModelResolverService.createModelReference(this.inputUri);
+        if (createdInputModel) {
+            const model = createdInputModel;
+            this._register(toDisposable(() => {
+                void inputModelReference.then(() => model.dispose(), () => model.dispose());
+            }));
+        }
+        inputModelReference.then(ref => {
+            if (this._store.isDisposed) {
+                ref.dispose();
+                return;
+            }
+            this._register(ref);
+        }, error => {
+            if (!this._store.isDisposed) {
+                onUnexpectedError(error);
+            }
+        });
+        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.renderAttachedContext();
+        this.setSessionArchiveNudge(this.sessionArchiveNudgeOptions);
+        const updateCarouselMaxHeightScheduler = this._register(
+            new AnimationFrameScheduler(this.container, () => this.updateToolConfirmationCarouselMaxHeight())
+        );
+        const inputResizeObserver = this._register(new DisposableResizeObserver("ChatInputPart.containerHeight", () => {
+            updateCarouselMaxHeightScheduler.schedule();
+            const newHeight = this.container.offsetHeight;
+            this.height.set(newHeight, undefined);
+        }));
+        this._register(inputResizeObserver.observe(this.container));
+        if (this.options.renderStyle === "compact") {
+            const toolbarsResizeObserver = this._register(new DisposableResizeObserver("ChatInputPart.compactToolbars", () => {
+                this.layoutForToolbarChange();
+            }));
+            this._register(toolbarsResizeObserver.observe(toolbarsContainer));
+        }
+    }
+    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 store = ( new DisposableStore());
+        this.attachedContextDisposables.value = store;
+        clearNode(container);
+        store.add(
+            addStandardDisposableListener(this.attachmentsContainer, EventType.KEY_DOWN, e => {
+                this.handleAttachmentNavigation(e);
+            })
+        );
+        const attachments = this.getRenderableAttachments().map((attachment, index) => [index, attachment]);
+        const hasAttachments = Boolean(attachments.length);
+        let hasImplicitContext = false;
+        const isSuggestedEnabled = this.configurationService.getValue("chat.implicitContext.suggestedContext");
+        const hasVisibleImplicitContext = isSuggestedEnabled ? this._implicitContext?.hasValue ?? false : this._implicitContext?.values.some(v => v.enabled || v.isSelection) ?? false;
+        if (this._implicitContext && hasVisibleImplicitContext) {
+            const isAttachmentAlreadyAttached = (targetUri, targetRange, targetHandle) => {
+                return isImplicitContextAlreadyAttached(this._attachmentModel.attachments, targetUri, targetRange, targetHandle);
+            };
+            const implicitContextWidget = this.instantiationService.createInstance(
+                ImplicitContextAttachmentWidget,
+                () => this._widget,
+                isAttachmentAlreadyAttached,
+                this._implicitContext,
+                this._contextResourceLabels,
+                this._attachmentModel,
+                container
+            );
+            store.add(implicitContextWidget);
+            hasImplicitContext = implicitContextWidget.hasRenderedContexts;
+        }
+        setVisibility(Boolean(
+            this.options.renderInputToolbarBelowInput || hasAttachments || hasImplicitContext
+        ), this.attachmentsContainer);
+        setVisibility(hasAttachments || hasImplicitContext, this.attachedContextContainer);
+        if (!attachments.length) {
+            this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+            this._indexOfLastOpenedContext = -1;
+        }
+        const maxImagesPerRequest = getImageAttachmentLimit(this._currentLanguageModel.get()?.metadata);
+        const imageAttachments = attachments.filter(([, a]) => isImageVariableEntry(a));
+        if (maxImagesPerRequest !== undefined && imageAttachments.length > maxImagesPerRequest) {
+            const excessCount = imageAttachments.length - maxImagesPerRequest;
+            for (let i = 0; i < excessCount; i++) {
+                const attachment = imageAttachments[i][1];
+                if (attachment.omittedState === OmittedState.NotOmitted || attachment.omittedState === OmittedState.ImageLimitExceeded) {
+                    attachment.omittedState = OmittedState.ImageLimitExceeded;
+                }
+            }
+            for (let i = excessCount; i < imageAttachments.length; i++) {
+                if (imageAttachments[i][1].omittedState === OmittedState.ImageLimitExceeded) {
+                    imageAttachments[i][1].omittedState = OmittedState.NotOmitted;
+                }
+            }
+        } else {
+            for (const [, a] of imageAttachments) {
+                if (a.omittedState === OmittedState.ImageLimitExceeded) {
+                    a.omittedState = OmittedState.NotOmitted;
+                }
+            }
+        }
+        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,
+                attachments.length - 1
+            ) && this._indexOfLastAttachedContextDeletedWithKeyboard > -1;
+            let attachmentWidget;
+            const options = {
+                shouldFocusClearButton,
+                supportsDeletion: true,
+                isCurrentInput: true
+            };
+            const lm = this._currentLanguageModel.get();
+            if (attachment.kind === "tool" || attachment.kind === "toolset") {
+                attachmentWidget = this.instantiationService.createInstance(
+                    ToolSetOrToolItemAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (resource && isNotebookOutputVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    NotebookCellOutputChatAttachmentWidget,
+                    resource,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isPromptFileVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    PromptFileAttachmentWidget,
+                    attachment,
+                    lm,
+                    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,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (attachment.kind === "terminalCommand") {
+                attachmentWidget = this.instantiationService.createInstance(
+                    TerminalCommandAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isImageVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    ImageAttachmentWidget,
+                    resource,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isElementVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    ElementChatAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isPasteVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    PasteAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isSCMHistoryItemVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    SCMHistoryItemAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isSCMHistoryItemChangeVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    SCMHistoryItemChangeAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isSCMHistoryItemChangeRangeVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    SCMHistoryItemChangeRangeAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else if (isBrowserViewVariableEntry(attachment)) {
+                attachmentWidget = this.instantiationService.createInstance(
+                    BrowserViewAttachmentWidget,
+                    attachment,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            } else {
+                attachmentWidget = this._chatAttachmentWidgetRegistry.createWidget(attachment, options, container) ?? this.instantiationService.createInstance(
+                    DefaultChatAttachmentWidget,
+                    resource,
+                    range,
+                    attachment,
+                    undefined,
+                    lm,
+                    options,
+                    container,
+                    this._contextResourceLabels
+                );
+            }
+            if (shouldFocusClearButton) {
+                attachmentWidget.element.focus();
+            }
+            if (index === Math.min(this._indexOfLastOpenedContext, attachments.length - 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);
+            }));
+        }
+        this._indexOfLastOpenedContext = -1;
+    }
+    removeInlineReferenceText(attachment) {
+        if (!attachment.range || !isPastedTextArtifact(attachment)) {
+            return;
+        }
+        const model = this._inputEditor.getModel();
+        const reference = this._widget?.getContrib(ChatDynamicVariableModel.ID)?.variables.find(variable => variable.id === attachment.id);
+        if (!model || !reference) {
+            return;
+        }
+        const range = Range.lift(reference.range);
+        const endColumn = model.getValueInRange(( new Range(
+            range.endLineNumber,
+            range.endColumn,
+            range.endLineNumber,
+            range.endColumn + 1
+        ))) === " " ? range.endColumn + 1 : range.endColumn;
+        this._inputEditor.executeEdits("chatRemoveAttachmentReference", [{
+            range: ( new Range(range.startLineNumber, range.startColumn, range.endLineNumber, endColumn)),
+            text: ""
+        }]);
+    }
+    handleAttachmentDeletion(e, index, attachment) {
+        if (isKeyboardEvent(e)) {
+            this._indexOfLastAttachedContextDeletedWithKeyboard = index;
+        }
+        this._attachmentModel.delete(attachment.id);
+        this.removeInlineReferenceText(attachment);
+        if (this.configurationService.getValue("chat.implicitContext.enableImplicitContext")) {
+            for (const implicitContext of (this._implicitContext?.values || [])) {
+                const implicitValue = URI.isUri(implicitContext?.value) && URI.isUri(attachment.value) && isEqual(implicitContext.value, attachment.value);
+                if (implicitContext?.isFile && implicitValue) {
+                    implicitContext.enabled = false;
+                }
+            }
+        }
+        if (this.getRenderableAttachments().length === 0) {
+            this.focus();
+        }
+        this._onDidChangeContext.fire({
+            removed: [attachment]
+        });
+        this.renderAttachedContext();
+    }
+    getRenderableAttachments() {
+        return this.attachmentModel.attachments.filter(attachment => !isAgentHostCompletionVariableEntry(attachment));
+    }
+    handleAttachmentOpen(index, attachment) {
+        this._indexOfLastOpenedContext = index;
+        this._indexOfLastAttachedContextDeletedWithKeyboard = -1;
+        if (this.getRenderableAttachments().length === 0) {
+            this.focus();
+        }
+    }
+    handleAttachmentNavigation(e) {
+        if (!e.equals(KeyCode.LeftArrow) && !e.equals(KeyCode.RightArrow)) {
+            return;
+        }
+        const attachments = Array.from(
+            this.attachedContextContainer.querySelectorAll(".chat-attached-context-attachment")
+        );
+        if (!attachments.length) {
+            return;
+        }
+        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);
+            widget.attachTo(this.chatInputTodoListWidgetContainer);
+        }
+        this._chatInputTodoListWidget.value.render(chatSessionResource);
+    }
+    clearTodoListWidget(sessionResource, force) {
+        this._chatInputTodoListWidget.value?.clear(sessionResource, force);
+    }
+    renderArtifactsWidget(chatSessionResource) {
+        if (!this.configurationService.getValue(ChatConfiguration.ArtifactsEnabled)) {
+            return;
+        }
+        if (!this._chatArtifactsWidget.value) {
+            const widget = this._register(this.instantiationService.createInstance(ChatArtifactsWidget));
+            this._chatArtifactsWidget.value = widget;
+            clearNode(this.chatArtifactsWidgetContainer);
+            widget.attachTo(this.chatArtifactsWidgetContainer);
+        }
+        this._chatArtifactsWidget.value.setSessionResource(chatSessionResource);
+    }
+    clearArtifactsWidget() {
+        this._chatArtifactsWidget.value?.setSessionResource(undefined);
+    }
+    renderQuestionCarousel(carousel, context, options) {
+        const carouselKey = carousel.resolveId ?? `${isResponseVM(context.element) ? context.element.requestId : ""}_${context.contentIndex}`;
+        const existing = this._chatQuestionCarouselWidgets.get(carouselKey);
+        if (existing) {
+            return existing;
+        }
+        if (isResponseVM(context.element)) {
+            this._questionCarouselResponseIds.set(carouselKey, context.element.requestId);
+            this._questionCarouselSessionResources.set(carouselKey, context.element.sessionResource);
+        }
+        const part = this.instantiationService.createInstance(ChatQuestionCarouselPart, carousel, context, options);
+        this._chatQuestionCarouselWidgets.set(carouselKey, part);
+        this._hasQuestionCarouselContextKey?.set(true);
+        append(this.chatQuestionCarouselContainer, part.domNode);
+        return part;
+    }
+    clearQuestionCarousel(responseId, resolveId) {
+        if (resolveId !== undefined) {
+            const part = this._chatQuestionCarouselWidgets.get(resolveId);
+            if (part) {
+                part.domNode.remove();
+                this._chatQuestionCarouselWidgets.deleteAndDispose(resolveId);
+            }
+            this._questionCarouselResponseIds.delete(resolveId);
+            this._questionCarouselSessionResources.delete(resolveId);
+        } else if (responseId !== undefined) {
+            for (const [key, rid] of this._questionCarouselResponseIds) {
+                if (rid === responseId) {
+                    const part = this._chatQuestionCarouselWidgets.get(key);
+                    if (part) {
+                        part.domNode.remove();
+                        this._chatQuestionCarouselWidgets.deleteAndDispose(key);
+                    }
+                    this._questionCarouselResponseIds.delete(key);
+                    this._questionCarouselSessionResources.delete(key);
+                }
+            }
+        } else {
+            this._chatQuestionCarouselWidgets.clearAndDisposeAll();
+            this._questionCarouselResponseIds.clear();
+            this._questionCarouselSessionResources.clear();
+            clearNode(this.chatQuestionCarouselContainer);
+        }
+        this._hasQuestionCarouselContextKey?.set(this._chatQuestionCarouselWidgets.size > 0);
+    }
+    get questionCarousel() {
+        for (const part of ( this._chatQuestionCarouselWidgets.values())) {
+            if (part.hasFocus()) {
+                return part;
+            }
+        }
+        return this._chatQuestionCarouselWidgets.size > 0 ? ( this._chatQuestionCarouselWidgets.values()).next().value : undefined;
+    }
+    focusQuestionCarousel() {
+        const carousel = this.questionCarousel;
+        if (carousel) {
+            carousel.focus();
+            return true;
+        }
+        return false;
+    }
+    isQuestionCarouselFocused() {
+        for (const part of ( this._chatQuestionCarouselWidgets.values())) {
+            if (part.hasFocus()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    navigateToPreviousQuestion() {
+        const carousel = this.questionCarousel;
+        return carousel?.navigateToPreviousQuestion() ?? false;
+    }
+    navigateToNextQuestion() {
+        const carousel = this.questionCarousel;
+        return carousel?.navigateToNextQuestion() ?? false;
+    }
+    focusQuestionCarouselTerminal() {
+        const carousel = this.questionCarousel;
+        return carousel?.focusTerminal() ?? false;
+    }
+    renderPlanReview(review, context, options) {
+        const key = review.resolveId ?? `${isResponseVM(context.element) ? context.element.requestId : ""}_${context.contentIndex}`;
+        const existing = this._chatPlanReviewWidgets.get(key);
+        if (existing) {
+            return existing;
+        }
+        if (isResponseVM(context.element)) {
+            this._planReviewResponseIds.set(key, context.element.requestId);
+            this._planReviewSessionResources.set(key, context.element.sessionResource);
+        }
+        const part = this.instantiationService.createInstance(ChatPlanReviewPart, review, context, options);
+        this._chatPlanReviewWidgets.set(key, part);
+        append(this.chatPlanReviewContainer, part.domNode);
+        return part;
+    }
+    clearPlanReview(responseId, resolveId) {
+        if (resolveId !== undefined) {
+            const part = this._chatPlanReviewWidgets.get(resolveId);
+            if (part) {
+                part.domNode.remove();
+                this._chatPlanReviewWidgets.deleteAndDispose(resolveId);
+            }
+            this._planReviewResponseIds.delete(resolveId);
+            this._planReviewSessionResources.delete(resolveId);
+        } else if (responseId !== undefined) {
+            for (const [key, rid] of this._planReviewResponseIds) {
+                if (rid === responseId) {
+                    const part = this._chatPlanReviewWidgets.get(key);
+                    if (part) {
+                        part.domNode.remove();
+                        this._chatPlanReviewWidgets.deleteAndDispose(key);
+                    }
+                    this._planReviewResponseIds.delete(key);
+                    this._planReviewSessionResources.delete(key);
+                }
+            }
+        } else {
+            this._chatPlanReviewWidgets.clearAndDisposeAll();
+            this._planReviewResponseIds.clear();
+            this._planReviewSessionResources.clear();
+            clearNode(this.chatPlanReviewContainer);
+        }
+    }
+    get planReview() {
+        return this._chatPlanReviewWidgets.size > 0 ? ( this._chatPlanReviewWidgets.values()).next().value : undefined;
+    }
+    get _currentSessionKey() {
+        return this._widget?.viewModel?.model.sessionResource.toString();
+    }
+    get _currentToolConfirmationCarousel() {
+        const key = this._currentSessionKey;
+        return key ? this._chatToolConfirmationCarousels.get(key) : undefined;
+    }
+    renderToolConfirmationCarousel(
+        tool,
+        factory,
+        subAgentInvocationId,
+        subagentTitle,
+        revealSubagent,
+        revealSubagentLabel,
+        toolPart
+    ) {
+        const existing = this._currentToolConfirmationCarousel;
+        if (existing) {
+            existing.addToolInvocation(
+                tool,
+                subAgentInvocationId,
+                subagentTitle,
+                revealSubagent,
+                revealSubagentLabel,
+                toolPart
+            );
+            this.updateToolConfirmationCarouselMaxHeight();
+            return existing;
+        }
+        const key = this._currentSessionKey;
+        if (!key) {
+            throw ( new Error("Cannot render tool confirmation carousel without an active session"));
+        }
+        const part = ( new ChatToolConfirmationCarouselPart(
+            factory,
+            [],
+            revealSubagent,
+            revealSubagentLabel,
+            subAgentInvocationId,
+            subagentTitle
+        ));
+        part.addToolInvocation(
+            tool,
+            subAgentInvocationId,
+            subagentTitle,
+            revealSubagent,
+            revealSubagentLabel,
+            toolPart
+        );
+        this._chatToolConfirmationCarousels.set(key, part);
+        const capturedKey = key;
+        this._register(part.onDidChangeActiveSubagent(id => {
+            if (this._currentSessionKey === capturedKey) {
+                this._onDidChangeActiveConfirmationSubagent.fire(id);
+            }
+        }));
+        if (this._currentSessionKey === capturedKey) {
+            this._onDidChangeActiveConfirmationSubagent.fire(part.activeSubAgentInvocationId);
+        }
+        append(this.chatToolConfirmationCarouselContainer, part.domNode);
+        show(this.chatToolConfirmationCarouselContainer);
+        this.updateToolConfirmationCarouselMaxHeight();
+        this._register(Event.once(part.onDidEmpty)(() => {
+            this._chatToolConfirmationCarousels.deleteAndDispose(capturedKey);
+            if (this._currentSessionKey === capturedKey) {
+                this._onDidChangeActiveConfirmationSubagent.fire(undefined);
+                clearNode(this.chatToolConfirmationCarouselContainer);
+                hide(this.chatToolConfirmationCarouselContainer);
+            }
+        }));
+        return part;
+    }
+    addToolToConfirmationCarousel(
+        tool,
+        factory,
+        subAgentInvocationId,
+        subagentTitle,
+        revealSubagent,
+        revealSubagentLabel,
+        toolPart
+    ) {
+        const existing = this._currentToolConfirmationCarousel;
+        if (existing) {
+            existing.addToolInvocation(
+                tool,
+                subAgentInvocationId,
+                subagentTitle,
+                revealSubagent,
+                revealSubagentLabel,
+                toolPart
+            );
+            this.updateToolConfirmationCarouselMaxHeight();
+        } else {
+            this.renderToolConfirmationCarousel(
+                tool,
+                factory,
+                subAgentInvocationId,
+                subagentTitle,
+                revealSubagent,
+                revealSubagentLabel,
+                toolPart
+            );
+        }
+    }
+    get activeConfirmationSubagentId() {
+        return this._currentToolConfirmationCarousel?.activeSubAgentInvocationId;
+    }
+    activateCarouselForSubagent(subAgentInvocationId) {
+        this._currentToolConfirmationCarousel?.activateFirstToolForSubagent(subAgentInvocationId);
+    }
+    hasToolInConfirmationCarousel(toolCallId) {
+        return this._currentToolConfirmationCarousel?.hasToolInvocation(toolCallId) ?? false;
+    }
+    get hasActiveToolConfirmationCarousel() {
+        const carousel = this._currentToolConfirmationCarousel;
+        return !!carousel && carousel.pendingCount > 0;
+    }
+    clearToolConfirmationCarousel() {
+        const key = this._currentSessionKey;
+        if (key) {
+            this._chatToolConfirmationCarousels.deleteAndDispose(key);
+        }
+        this._onDidChangeActiveConfirmationSubagent.fire(undefined);
+        clearNode(this.chatToolConfirmationCarouselContainer);
+        hide(this.chatToolConfirmationCarouselContainer);
+    }
+    _syncToolConfirmationCarouselForSession() {
+        clearNode(this.chatToolConfirmationCarouselContainer);
+        const carousel = this._currentToolConfirmationCarousel;
+        if (carousel && carousel.pendingCount > 0) {
+            append(this.chatToolConfirmationCarouselContainer, carousel.domNode);
+            show(this.chatToolConfirmationCarouselContainer);
+            this.updateToolConfirmationCarouselMaxHeight();
+        } else {
+            hide(this.chatToolConfirmationCarouselContainer);
+        }
+        this._onDidChangeActiveConfirmationSubagent.fire(carousel?.activeSubAgentInvocationId);
+    }
+    setWorkingSetCollapsed(collapsed) {
+        this._workingSetCollapsed.set(collapsed, undefined);
+    }
+    renderChatEditingSessionState(chatEditingSession) {
+        this.setChatEditingSessionVisible(Boolean(chatEditingSession));
+        if (chatEditingSession) {
+            if (!isEqual(chatEditingSession.chatSessionResource, this._lastEditingSessionResource)) {
+                this._workingSetCollapsed.set(true, undefined);
+            }
+            this._lastEditingSessionResource = chatEditingSession.chatSessionResource;
+        }
+        const modifiedEntries = derivedOpts({
+            equalsFn: equals
+        }, r => {
+            const sessionResource = chatEditingSession?.chatSessionResource ?? this._widget?.viewModel?.model.sessionResource;
+            if (sessionResource && getChatSessionType(sessionResource) === AgentSessionProviders.Background) {
+                return [];
+            }
+            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
+                            },
+                            isDeletion: !!entry.isDeletion,
+                            originalUri: entry.isDeletion ? entry.originalURI : undefined
+                        }
+                    });
+                }
+            }
+            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: isIChatSessionFileChange2(entry) ? entry.modifiedUri ?? entry.uri : entry.modifiedUri,
+            state: ModifiedFileEntryState.Accepted,
+            kind: "reference",
+            options: {
+                diffMeta: {
+                    added: entry.insertions,
+                    removed: entry.deletions
+                },
+                isDeletion: entry.modifiedUri === undefined,
+                originalUri: entry.originalUri,
+                status: undefined
+            }
+        })));
+        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, editSessionEntries, sessionFiles);
+            } else {
+                clearNode(this.chatEditingSessionWidgetContainer);
+                this._chatEditsDisposables.clear();
+                this._chatEditList = undefined;
+                this.setChatEditingSessionVisible(false);
+            }
+        });
+    }
+    setChatEditingSessionVisible(visible) {
+        setVisibility(visible, this.chatEditingSessionWidgetContainer);
+        setChatInputStackSlot(
+            this.chatEditingSessionWidgetContainer,
+            visible ? ChatInputStackSlot.Docked : ChatInputStackSlot.Empty
+        );
+    }
+    renderChatEditingSessionWithEntries(store, chatEditingSession, editSessionEntriesObs, sessionEntriesObs) {
+        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));
+            const sessionPullRequest = observableFromEvent(this, this.agentSessionsService.model.onDidChangeSessions, () => {
+                const session = this.agentSessionsService.getSession(sessionResource);
+                return session ? getAgentSessionPullRequestContextValue(session) : "";
+            });
+            this._chatEditsActionsDisposables.add(bindContextKey(
+                ChatContextKeys.agentSessionPullRequest,
+                scopedContextKeyService,
+                r => sessionPullRequest.read(r)
+            ));
+        }
+        this._chatEditsActionsDisposables.add(bindContextKey(
+            ChatContextKeys.hasAgentSessionChanges,
+            scopedContextKeyService,
+            r => !!sessionEntriesObs.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(11966, "Toggle changed files."))
+        })));
+        const topLevelStats = derived(reader => {
+            const entries = editSessionEntriesObs.read(reader);
+            const sessionEntries = sessionEntriesObs.read(reader);
+            let added = 0, removed = 0;
+            if (entries.length > 0) {
+                for (const entry of entries) {
+                    if (entry.kind === "reference" && entry.options?.diffMeta) {
+                        added += entry.options.diffMeta.added;
+                        removed += entry.options.diffMeta.removed;
+                    }
+                }
+            } else {
+                for (const entry of sessionEntries) {
+                    if (entry.kind === "reference" && entry.options?.diffMeta) {
+                        added += entry.options.diffMeta.added;
+                        removed += entry.options.diffMeta.removed;
+                    }
+                }
+            }
+            const files = entries.length > 0 ? entries.length : sessionEntries.length;
+            const topLevelIsSessionMenu = entries.length === 0 && sessionEntries.length > 0;
+            const shouldShowEditingSession = entries.length > 0 || sessionEntries.length > 0;
+            return {
+                files,
+                added,
+                removed,
+                shouldShowEditingSession,
+                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,
+                    small: true,
+                    menuOptions: sessionResource ? (isSessionMenu ? {
+                        args: [
+                            sessionResource,
+                            this.agentSessionsService.getSession(sessionResource)?.metadata
+                        ]
+                    } : {
+                        arg: {
+                            $mid: MarshalledId.ChatViewContext,
+                            sessionResource
+                        }
+                    }) : undefined,
+                    disableWhileRunning: isSessionMenu,
+                    buttonConfigProvider: action => {
+                        if (action.id === ChatEditingShowChangesAction.ID || action.id === ViewPreviousEditsAction.Id) {
+                            return {
+                                showIcon: true,
+                                showLabel: false,
+                                isSecondary: true
+                            };
+                        }
+                        if (action.id === "github.copilot.chat.cloudSessions.openPullRequestForTask") {
+                            return {
+                                showIcon: true,
+                                showLabel: false
+                            };
+                        }
+                        return undefined;
+                    }
+                }
+            ));
+        }));
+        store.add(autorun(reader => {
+            const {
+                files,
+                added,
+                removed,
+                shouldShowEditingSession
+            } = topLevelStats.read(reader);
+            const buttonLabel = files === 1 ? ( localize(11967, "1 file changed")) : ( localize(11968, "{0} files changed", files));
+            button.label = buttonLabel;
+            button.element.setAttribute("aria-label", ( localize(
+                11969,
+                "{0}, {1} lines added, {2} lines removed",
+                buttonLabel,
+                added,
+                removed
+            )));
+            this._workingSetLinesAddedSpan.value.textContent = `+${added}`;
+            this._workingSetLinesRemovedSpan.value.textContent = `-${removed}`;
+            this.setChatEditingSessionVisible(shouldShowEditingSession);
+        }));
+        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);
+        }));
+        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 (e.element.options?.isDeletion && originalUri) {
+                        await this.editorService.openEditor({
+                            resource: originalUri,
+                            options: e.editorOptions
+                        }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+                        return;
+                    }
+                    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 = editSessionEntriesObs.read(reader);
+            const sessionFileEntries = sessionEntriesObs.read(reader);
+            const allEntries = editEntries.concat(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);
+            workingSetContainer.classList.toggle("overflowing", allEntries.length > maxItemsShown);
+        }));
+    }
+    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
+                })
+            ));
+        }
+    }
+    setMaxHeight(maxHeight) {
+        this._maxHeight = maxHeight;
+        this.updateToolConfirmationCarouselMaxHeight();
+    }
+    updateToolConfirmationCarouselMaxHeight() {
+        const carousel = this._currentToolConfirmationCarousel;
+        if (!carousel) {
+            return;
+        }
+        if (this._maxHeight === undefined) {
+            carousel.setMaxHeight(undefined);
+            return;
+        }
+        const carouselHeight = this.chatToolConfirmationCarouselContainer.offsetHeight;
+        const otherInputHeight = Math.max(0, this.container.offsetHeight - carouselHeight);
+        carousel.setMaxHeight(this._maxHeight - otherInputHeight);
+    }
+    layout(width) {
+        this.cachedWidth = width;
+        this._updateWorkingProgressAnimationDuration(width);
+        const result = this._layout(width);
+        this._inputPickerResponsiveLayout?.layout();
+        this._secondaryPickerResponsiveLayout?.layout();
+        return result;
+    }
+    layoutForToolbarChange() {
+        if (typeof this.cachedWidth === "number") {
+            this._layout(this.cachedWidth, true, true);
+        }
+    }
+    _updateWorkingProgressAnimationDuration(width) {
+        if (!this.inputContainer) {
+            return;
+        }
+        const MIN_DURATION_S = 1.4;
+        const MAX_DURATION_S = 2.5;
+        const safeWidth = Math.max(50, width);
+        const raw = 0.55 + 0.075 * Math.sqrt(safeWidth);
+        const duration = Math.min(MAX_DURATION_S, Math.max(MIN_DURATION_S, raw));
+        if (this._lastAnimDurationS !== undefined && Math.abs(this._lastAnimDurationS - duration) < 0.05) {
+            return;
+        }
+        this._lastAnimDurationS = duration;
+        this.inputContainer.style.setProperty("--chat-input-anim-duration", `${duration.toFixed(2)}s`);
+        if (this.inputContainer.classList.contains("working")) {
+            const inputContainer = this.inputContainer;
+            inputContainer.classList.add("chat-input-anim-restart");
+            scheduleAtNextAnimationFrame(getWindow(inputContainer), () => {
+                inputContainer.classList.remove("chat-input-anim-restart");
+            });
+        }
+    }
+    get _effectiveInputEditorMaxHeight() {
+        if (this._maxHeight === undefined) {
+            return this.inputEditorMaxHeight;
+        }
+        const currentEditorHeight = this.previousInputEditorDimension?.height ?? 0;
+        const nonEditorHeight = Math.max(0, this.height.get() - currentEditorHeight);
+        const budgetForEditor = this._maxHeight - nonEditorHeight;
+        const minEditorHeight = this.inputEditorMinHeight ?? this.singleLineInputEditorHeight;
+        return Math.max(
+            minEditorHeight,
+            Math.min(this.inputEditorMaxHeight, Math.max(0, budgetForEditor))
+        );
+    }
+    _layout(width, allowRecurse = true, preserveInputEditorHeight = false) {
+        const data = this.getLayoutData();
+        const followupsWidth = width - data.inputPartHorizontalPadding;
+        this.followupsContainer.style.width = `${followupsWidth}px`;
+        const initialEditorScrollWidth = this._inputEditor.getScrollWidth();
+        const newEditorWidth = width - data.inputPartHorizontalPadding - data.editorBorder - data.inputPartHorizontalPaddingInside - data.toolbarsWidth - data.sideToolbarWidth;
+        const effectiveMaxHeight = this._effectiveInputEditorMaxHeight;
+        const contentHeight = preserveInputEditorHeight && this.previousInputEditorDimension ? this.previousInputEditorDimension.height : this._inputEditor.getContentHeight();
+        const clampedContentHeight = Math.min(contentHeight, effectiveMaxHeight);
+        const inputEditorHeight = this.inputEditorMinHeight ? Math.min(
+            Math.max(this.inputEditorMinHeight, clampedContentHeight),
+            effectiveMaxHeight
+        ) : clampedContentHeight;
+        const newDimension = {
+            width: newEditorWidth,
+            height: inputEditorHeight
+        };
+        if (!this.previousInputEditorDimension || (this.previousInputEditorDimension.width !== newDimension.width || this.previousInputEditorDimension.height !== newDimension.height)) {
+            this.ignoreInputEditorContentSizeChanges = preserveInputEditorHeight;
+            try {
+                this._inputEditor.layout(newDimension);
+            } finally {
+                this.ignoreInputEditorContentSizeChanges = false;
+            }
+            this.previousInputEditorDimension = newDimension;
+        }
+        if (allowRecurse && initialEditorScrollWidth < 10) {
+            return this._layout(width, false, preserveInputEditorHeight);
+        }
+    }
+    getLayoutData() {
+        const inputSideToolbarWidth = this.inputSideToolbarContainer ? getTotalWidth(this.inputSideToolbarContainer) : 0;
+        const getToolbarsWidthCompact = () => {
+            const toolbarItemGap = 4;
+            const executeToolbarWidth = this.cachedExecuteToolbarWidth = this.executeToolbar.getItemsWidth();
+            const inputToolbarWidth = this.cachedInputToolbarWidth = this.inputActionsToolbar.getItemsWidth();
+            const executeToolbarPadding = (this.executeToolbar.getItemsLength() - 1) * toolbarItemGap;
+            const inputToolbarPadding = this.inputActionsToolbar.getItemsLength() ? (this.inputActionsToolbar.getItemsLength() - 1) * toolbarItemGap : 0;
+            const contextUsageWidth = getTotalWidth(this.contextUsageWidgetContainer);
+            const inputToolbarsPadding = 12;
+            return executeToolbarWidth + executeToolbarPadding + contextUsageWidth + (this.options.renderInputToolbarBelowInput ? 0 : inputToolbarWidth + inputToolbarPadding + inputToolbarsPadding);
+        };
+        return {
+            editorBorder: 2,
+            inputPartHorizontalPadding: this.options.inputPartHorizontalPadding ?? (this.options.renderStyle === "compact" ? 16 : (this.options.isSessionsWindow ? 64 : 24)),
+            inputPartHorizontalPaddingInside: this.options.renderStyle === "compact" ? 12 : 10,
+            toolbarsWidth: this.options.renderStyle === "compact" ? getToolbarsWidthCompact() : 0,
+            sideToolbarWidth: inputSideToolbarWidth > 0 ? inputSideToolbarWidth + 4  : 0
+        };
+    }
+    getWidgetLocationInfo(widget) {
+        if (isIChatResourceViewContext(widget.viewContext)) {
+            return {
+                location: ChatWidgetLocation.Editor,
+                isMaximized: false
+            };
+        }
+        if (isIChatViewViewContext(widget.viewContext)) {
+            const viewLocation = this.viewDescriptorService.getViewLocationById(widget.viewContext.viewId);
+            const sideBarPosition = this.layoutService.getSideBarPosition();
+            switch (viewLocation) {
+            case ViewContainerLocation.Panel:
+                return {
+                    location: ChatWidgetLocation.Panel,
+                    isMaximized: this.layoutService.isPanelMaximized()
+                };
+            case ViewContainerLocation.AuxiliaryBar:
+                return {
+                    location: sideBarPosition === Position.LEFT ? ChatWidgetLocation.SidebarRight : ChatWidgetLocation.SidebarLeft,
+                    isMaximized: this.layoutService.isAuxiliaryBarMaximized()
+                };
+            case ViewContainerLocation.Sidebar:
+            default:
+                return {
+                    location: sideBarPosition === Position.LEFT ? ChatWidgetLocation.SidebarLeft : ChatWidgetLocation.SidebarRight,
+                    isMaximized: false
+                };
+            }
+        }
+        return {
+            location: ChatWidgetLocation.Editor,
+            isMaximized: false
+        };
+    }
+    getDefaultScrollbarOptions() {
+        const scrollbar = this._inputEditor.getRawOptions().scrollbar ?? {};
+        return this.options.renderStyle === "compact" ? {
+            ...scrollbar,
+            vertical: "hidden"
+        } : {
+            ...scrollbar,
+            vertical: "auto",
+            verticalScrollbarSize: 7
+        };
+    }
+    getVisibleScrollbarOptions() {
+        const scrollbar = this._inputEditor.getRawOptions().scrollbar ?? {};
+        return this.options.renderStyle === "compact" ? {
+            ...scrollbar,
+            vertical: "hidden"
+        } : {
+            ...scrollbar,
+            vertical: "visible",
+            verticalScrollbarSize: 7
+        };
+    }
+    updateInputEditorScrollbarOptions() {
+        this._inputEditor.updateOptions({
+            scrollbar: this._forceVisibleScrollbarUntilAccept ? this.getVisibleScrollbarOptions() : this.getDefaultScrollbarOptions()
+        });
+    }
+    showScrollbarUntilAccept() {
+        this._forceVisibleScrollbarUntilAccept = true;
+        this.updateInputEditorScrollbarOptions();
+    }
+    resetScrollbarVisibilityAfterAccept() {
+        if (!this._forceVisibleScrollbarUntilAccept) {
+            return;
+        }
+        this._forceVisibleScrollbarUntilAccept = false;
+        this.updateInputEditorScrollbarOptions();
+    }
+};
+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, IDialogService)), ( __param(18, IChatAgentService)), ( __param(19, ISharedWebContentExtractorService)), ( __param(20, IChatEntitlementService)), ( __param(21, IChatModeService)), ( __param(22, ILanguageModelToolsService)), ( __param(23, IChatSessionsService)), ( __param(24, IChatContextService)), ( __param(25, IAgentSessionsService)), ( __param(26, IChatSpeechToTextService)), ( __param(27, IDictationOnboardingService)), ( __param(28, IChatInputNoticeHubService)), ( __param(29, IWorkspaceContextService)), ( __param(30, ISCMService)), ( __param(31, IWorkbenchLayoutService)), ( __param(32, IViewDescriptorService)), ( __param(33, IChatAttachmentWidgetRegistry)), ( __param(34, IChatInputNotificationService)), ( __param(35, IChatPhoneInputPresenter)), ( __param(36, IVoiceModeOnboardingService)), ( __param(37, IChatWidgetService)), ( __param(38, IVoiceSessionController)), ( __param(39, IChatService)), ( __param(40, IWorkbenchEnvironmentService)), ( __param(41, IChatPetService)), ( __param(42, IActionViewItemService))], 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);
+        }
+    }
+    show() {
+        this.widgets[0]?.show();
+    }
+    dispose() {
+        for (const widget of this.widgets) {
+            widget.dispose();
+        }
+        super.dispose();
+    }
+}
+class HiddenActionViewItem extends BaseActionViewItem {
+    constructor(action) {
+        super(undefined, action);
+    }
+    render(container) {
+        super.render(container);
+        container.style.display = "none";
+    }
+}
+
+export { ChatInputPart, ChatWidgetLocation };