@codingame/monaco-vscode-api 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/chat/browser/newChatInput.js

@@ -0,0 +1,1806 @@
+
+import { registerCss } from '../../../../../../../css.js';
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as chatInput from './media/chatInput.css';
+import * as chatInputMobile from './media/chatInputMobile.css';
+import { isHTMLElement, $, append, getWindow, trackFocus, DisposableResizeObserver, addDisposableListener, EventType, clearNode, EventHelper, scheduleAtNextAnimationFrame } from '../../../../base/browser/dom.js';
+import { StandardKeyboardEvent } from '../../../../base/browser/keyboardEvent.js';
+import { Gesture, EventType as EventType$1 } from '../../../../base/browser/touch.js';
+import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Event, Emitter } from '../../../../base/common/event.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
+import { MutableDisposable, DisposableStore, Disposable, toDisposable, thenRegisterOrDispose } from '../../../../base/common/lifecycle.js';
+import { URI } from '../../../../base/common/uri.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { MenuEntryActionViewItem } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { CodeEditorWidget } from '../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import { EditorExtensionsRegistry } from '../../../../editor/browser/editorExtensions.js';
+import { IModelService } from '../../../../editor/common/services/model.service.js';
+import { ITextModelService } from '../../../../editor/common/services/resolverService.service.js';
+import { EDITOR_FONT_DEFAULTS } from '../../../../editor/common/config/fontInfo.js';
+import { EditorOptions } from '../../../../editor/common/config/editorOptions.js';
+import { SuggestController } from '../../../../editor/contrib/suggest/browser/suggestController.js';
+import { SnippetController2 } from '../../../../editor/contrib/snippet/browser/snippetController2.js';
+import { CopyPasteController } from '../../../../editor/contrib/dropOrPasteInto/browser/copyPasteController.js';
+import { PlaceholderTextContribution } from '../../../../editor/contrib/placeholderText/browser/placeholderTextContribution.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 { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { KeybindingsRegistry, KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { AccessibilityVerbositySettingId } from '../../../../workbench/contrib/accessibility/browser/accessibilityConfiguration.js';
+import { AccessibilityCommandId } from '../../../../workbench/contrib/accessibility/common/accessibilityCommands.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
+import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
+import { IHoverService } from '../../../../platform/hover/browser/hover.service.js';
+import { getDefaultHoverDelegate } from '../../../../base/browser/ui/hover/hoverDelegateFactory.js';
+import { HoverPosition } from '../../../../base/browser/ui/hover/hoverWidget.js';
+import { renderIcon } from '../../../../base/browser/ui/iconLabel/iconLabels.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+import { localize } from '../../../../nls.js';
+import { status } from '../../../../base/browser/ui/aria/aria.js';
+import { ContextMenuController } from '../../../../editor/contrib/contextmenu/browser/contextmenu.js';
+import { getSimpleEditorOptions } from '../../../../workbench/contrib/codeEditor/browser/simpleEditorOptions.js';
+import { NewChatContextAttachments } from './newChatContextAttachments.js';
+import { ChatDragAndDrop } from '../../../../workbench/contrib/chat/browser/widget/chatDragAndDrop.js';
+import { EDITOR_DRAG_AND_DROP_BACKGROUND } from '../../../../workbench/common/theme.js';
+import { inactiveSessionViewBackground, inactiveSessionViewForeground } from '../../../common/theme.js';
+import { isNewChatVoiceSessionActive, isNewChatVoiceInputModePillActive, isNewChatStandaloneDictationVisible, NewChatVoiceController, NEW_CHAT_VOICE_SENTINEL } from './newChatVoice.js';
+import { INewChatVoiceTargetService } from './newChatVoice.service.js';
+import { SessionStatus } from '../../../services/sessions/common/session.js';
+import { MobileSessionTypePicker } from './mobile/mobileSessionTypePicker.js';
+import { installMobileChipLaneScroll } from '../../../browser/parts/mobile/mobileChipLaneScroll.js';
+import { IWorkbenchLayoutService } from '../../../../workbench/services/layout/browser/layoutService.service.js';
+import { Menus } from '../../../browser/menus.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../platform/actions/browser/toolbar.js';
+import { MenuId, MenuItemAction } from '../../../../platform/actions/common/actions.js';
+import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { IThemeService } from '../../../../platform/theme/common/themeService.service.js';
+import { defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { getDictationHoverMarkdown } from '../../../../workbench/contrib/chat/browser/speechToText/micButtonHovers.js';
+import { addMicButtonContextMenuListener, getDictationContextMenuActions } from '../../../../workbench/contrib/chat/browser/speechToText/micButtonMenuActions.js';
+import { SlashCommandHandler } from './slashCommands.js';
+import { VariableCompletionHandler } from './variableCompletions.js';
+import { SessionReferenceCompletionHandler } from './sessionReferenceCompletions.js';
+import { AgentHostInputCompletionHandler } from './agentHostInputCompletions.js';
+import { isExplicitFileOrImageVariableEntry, IChatRequestVariableEntry, toFileVariableEntry, toPasteVariableEntry } from '../../../../workbench/contrib/chat/common/attachments/chatVariableEntries.js';
+import { IChatSessionsService } from '../../../../workbench/contrib/chat/common/chatSessionsService.service.js';
+import { ChatAgentLocation, ChatModeKind } from '../../../../workbench/contrib/chat/common/constants.js';
+import { ChatHistoryNavigator } from '../../../../workbench/contrib/chat/common/widget/chatWidgetHistoryService.js';
+import { registerAndCreateHistoryNavigationContext } from '../../../../platform/history/browser/contextScopedHistoryWidget.js';
+import '../../../../base/common/observableInternal/index.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { ChatInputNotificationWidget } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputNotificationWidget.js';
+import { IChatInputNotificationService } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service.js';
+import { ILanguageModelsService } from '../../../../workbench/contrib/chat/common/languageModels.service.js';
+import { ChatInputNoticeHost, ChatInputNoticeLane } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputNoticeHost.js';
+import { registerChatInputOnboardingHosts } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputOnboardingHosts.js';
+import { IChatInputNoticeHubService } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputNoticeHub.service.js';
+import { ChatInputPickerResponsiveLayout } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputPickerResponsiveLayout.js';
+import { chatInputStackClass, chatInputStackSlotClass, setChatInputStackSlot, ChatInputStackSlot, refreshChatInputStack, setChatInputStackInputFocused } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputStack.js';
+import { IChatSubmitRequestHandlerService } from '../../../../workbench/contrib/chat/browser/chatSubmitRequestHandlerService.service.js';
+import { isPhoneLayout } from '../../../browser/parts/mobile/mobileLayout.js';
+import { NewChatModelPickerService } from './newChatModelPicker.js';
+import { INewChatModelPickerService } from './newChatModelPicker.service.js';
+import { SessionModelSelection } from './sessionModelSelection.js';
+import { ISessionModelSelection } from './sessionModelSelection.service.js';
+import { hasSendableModelSelection } from './sessionModelPickerState.js';
+import { createNewSessionControlToolbar, createNewSessionConfigToolbar } from './newSessionConfigToolbars.js';
+import { SessionContext } from '../../../services/sessions/browser/sessionContext.js';
+import { ISessionContext } from '../../../services/sessions/browser/sessionContext.service.js';
+import { AGENT_SESSIONS_SCOPED_INPUT_HISTORY_SETTING } from './sessionsChatHistory.js';
+import { IChatStatusItemService } from '../../../../workbench/contrib/chat/browser/chatStatus/chatStatusItemService.service.js';
+import { handleTerminalCommandPaste, isTerminalCommandInput } from '../../../../workbench/contrib/chat/browser/chatTerminalCommandPaste.js';
+import { compactCodiconsIn } from '../../../../workbench/contrib/chat/browser/chatIcons.js';
+import { IChatPasteTargetService } from '../../../../workbench/contrib/chat/browser/chat.service.js';
+import { getGitHubIssueOrPullRequestAttachments } from '../../../../workbench/contrib/chat/browser/widget/input/editor/chatPasteProviders.js';
+import { NewChatInputPasteTarget } from './newChatInputPasteTarget.js';
+import { getChatSessionType } from '../../../../workbench/contrib/chat/common/model/chatUri.js';
+import { ChatSpeechToTextState, DictationSettingId } from '../../../../workbench/contrib/chat/browser/speechToText/chatSpeechToTextService.js';
+import { IChatSpeechToTextService } from '../../../../workbench/contrib/chat/browser/speechToText/chatSpeechToTextService.service.js';
+import { setupDictationMicGlow } from '../../../../workbench/contrib/chat/browser/speechToText/dictationMicGlow.js';
+import { IDictationOnboardingService } from '../../../../workbench/contrib/chat/browser/speechToText/dictationOnboarding.service.js';
+import { ChatVoiceInputModeAction, VoiceInputModeActionViewItem } from '../../../../workbench/contrib/chat/browser/voiceInputMode/voiceInputModeActionViewItem.js';
+import { IVoiceInputModeService } from '../../../../workbench/contrib/chat/browser/voiceInputMode/voiceInputMode.service.js';
+import { toAction } from '../../../../base/common/actions.js';
+import { runDictationShortcut } from '../../../../workbench/contrib/chat/browser/actions/chatSpeechToTextActions.js';
+import { onDidChangeDictationEditor, isDictationActiveForEditor, notifyDictationSubmitted } from '../../../../workbench/contrib/chat/browser/speechToText/dictationSession.js';
+import { combineVoiceInput } from '../../../../workbench/contrib/chat/browser/voiceClient/voiceInputUtils.js';
+import { parse, stringify } from '../../../../base/common/marshalling.js';
+import { ChatContextKeys } from '../../../../workbench/contrib/chat/common/actions/chatContextKeys.js';
+import { getDictationDownloadHoverMarkdown, DictationDownloadRing, getDictationPreparingLabel } from '../../../../workbench/contrib/chat/browser/speechToText/dictationDownloadRing.js';
+import { IVoiceSessionController } from '../../../../workbench/contrib/chat/browser/voiceClient/voiceSessionController.service.js';
+import { IChatPetWidgetService } from '../../../../workbench/contrib/chat/browser/widget/chatPetWidgetService.service.js';
+import { getChatPetPillPlatformTop, getChatPetStackPlatformTop } from '../../../../workbench/contrib/chat/browser/widget/chatPetWidget.js';
+import { IVoiceModeOnboardingService } from '../../../../workbench/contrib/agentsVoice/browser/voiceModeOnboarding.service.js';
+import { AGENTS_VOICE_ENABLED } from '../../../../workbench/contrib/agentsVoice/common/agentsVoice.js';
+import { animatePromptTyping } from './promptTypingAnimation.js';
+import { PromptTemplatePlaceholderController } from './promptTemplatePlaceholder.js';
+import { NEW_SESSION_PROMPT_TYPING_DURATION_MS } from './newSessionComposerService.js';
+import { NewSessionPromptOptionsWidget } from './newSessionPromptOptions.js';
+import { toInputGitHubContextMetadata, isInputGitHubContext } from '../common/newChatContextIds.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
+
+registerCss(chatInput, 1);
+registerCss(chatInputMobile, 1);
+const OPEN_OTEL_SETTINGS_COMMAND = "github.copilot.chat.otel.openSettings";
+const OTEL_STATUS_COMMAND = "github.copilot.chat.otel.statusActive";
+const OTEL_STATUS_ENTRY_ID = "copilot.otelStatus";
+const OTEL_DOCS_URL = "https://code.visualstudio.com/docs/agents/guides/monitoring-agents";
+const STORAGE_KEY_DRAFT_STATE = "sessions.draftState";
+const MIN_EDITOR_HEIGHT = 50;
+const MAX_EDITOR_HEIGHT = 200;
+const NEW_CHAT_INPUT_FONT_FAMILY = "system-ui, -apple-system, sans-serif";
+function getLabeledPickerResponsiveItems(container) {
+    const elements = ( new Map());
+    const actionItemLabelCounts = ( new Map());
+    const visit = (element, pickerSlot, actionItem) => {
+        const currentPickerSlot = element.classList.contains("sessions-chat-picker-slot") ? element : pickerSlot;
+        const currentActionItem = element.classList.contains("action-item") ? element : actionItem;
+        if (element.classList.contains("sessions-chat-dropdown-label")) {
+            const pickerElement = currentPickerSlot ?? currentActionItem;
+            if (pickerElement) {
+                elements.set(pickerElement, currentActionItem);
+                if (currentActionItem) {
+                    actionItemLabelCounts.set(currentActionItem, (actionItemLabelCounts.get(currentActionItem) ?? 0) + 1);
+                }
+            }
+        }
+        for (const child of element.children) {
+            if (isHTMLElement(child)) {
+                visit(child, currentPickerSlot, currentActionItem);
+            }
+        }
+    };
+    visit(container, undefined, undefined);
+    return Array.from(elements, ([element, actionItem]) => ({
+        element,
+        isCompact: () => element.classList.contains("compact-picker"),
+        setCompact: compact => {
+            element.classList.toggle("compact-picker", compact);
+            if (actionItem && actionItem !== element && actionItemLabelCounts.get(actionItem) === 1) {
+                actionItem.classList.toggle("compact-picker", compact);
+            }
+        }
+    }));
+}
+const SessionsChatInputHasDictationFocus = new RawContextKey("sessionsChatInputHasDictationFocus", false, ( localize(
+    3683,
+    "True when focus is in an Agents window chat composer that supports dictation."
+)));
+const TOGGLE_DICTATION_COMMAND_ID = "sessions.action.chat.toggleDictation";
+let activeDictationComposer;
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: TOGGLE_DICTATION_COMMAND_ID,
+    weight: KeybindingWeight.WorkbenchContrib + 1,
+    when: ( ContextKeyExpr.and(SessionsChatInputHasDictationFocus, ( ContextKeyExpr.has(ChatContextKeys.speechToTextConfigured.key)))),
+    primary: KeyMod$1.CtrlCmd | KeyCode.KeyI,
+    handler: () => activeDictationComposer?.toggleDictation()
+});
+KeybindingsRegistry.registerKeybindingRule({
+    id: "agentsVoice.startVoiceInChat",
+    weight: KeybindingWeight.WorkbenchContrib + 1,
+    when: ( ContextKeyExpr.and(SessionsChatInputHasDictationFocus, AGENTS_VOICE_ENABLED)),
+    primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Space
+});
+const INITIALIZATION_LOADING_DELAY_MS = 500;
+function hasSendableNewChatContent(query, attachments, hasAdditionalSendContent = false) {
+    return !!query.trim() || ( attachments.some(isExplicitFileOrImageVariableEntry)) || hasAdditionalSendContent;
+}
+function getInputGitHubContextAttachments(input) {
+    return getGitHubIssueOrPullRequestAttachments(input, toInputGitHubContextMetadata());
+}
+let NewChatInputStatusActionViewItem = class NewChatInputStatusActionViewItem extends MenuEntryActionViewItem {
+    constructor(
+        action,
+        options,
+        keybindingService,
+        notificationService,
+        contextKeyService,
+        themeService,
+        contextMenuService,
+        accessibilityService,
+        chatStatusItemService,
+        hoverService,
+        commandService
+    ) {
+        super(
+            action,
+            options,
+            keybindingService,
+            notificationService,
+            contextKeyService,
+            themeService,
+            contextMenuService,
+            accessibilityService
+        );
+        this.chatStatusItemService = chatStatusItemService;
+        this.hoverService = hoverService;
+        this.commandService = commandService;
+        this.hoverContentDisposables = this._register(( new MutableDisposable()));
+    }
+    render(container) {
+        this._container = container;
+        super.render(container);
+        this._updateIconPresentation();
+        if (this._commandAction.id !== OTEL_STATUS_COMMAND) {
+            return;
+        }
+        this._register(this.chatStatusItemService.onDidChange(e => {
+            if (e.entry.id === OTEL_STATUS_ENTRY_ID) {
+                this.updateTooltip();
+            }
+        }));
+    }
+    updateClass() {
+        if (this._compactCodiconClass) {
+            this.label?.classList.remove(this._compactCodiconClass);
+            this._compactCodiconClass = undefined;
+        }
+        super.updateClass();
+        this._updateIconPresentation();
+    }
+    _updateIconPresentation() {
+        const rendersIcon = !!this.label && (this.label.classList.contains("codicon") || this.label.classList.contains("icon"));
+        this._container?.classList.toggle("new-chat-status-icon-action", rendersIcon);
+        if (rendersIcon && this._container && this.label?.classList.contains("codicon")) {
+            const originalCodiconClass = this._getCodiconClass();
+            compactCodiconsIn(this._container);
+            const compactCodiconClass = this._getCodiconClass();
+            if (compactCodiconClass !== originalCodiconClass) {
+                this._compactCodiconClass = compactCodiconClass;
+            }
+        }
+    }
+    _getCodiconClass() {
+        return this.label ? [...this.label.classList].find(
+            className => className.startsWith("codicon-") && !className.startsWith("codicon-modifier-")
+        ) : undefined;
+    }
+    async onClick(event) {
+        if (this._commandAction.id === OTEL_STATUS_COMMAND && this.element) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.hoverService.showManagedHover(this.element);
+            return;
+        }
+        await super.onClick(event);
+    }
+    getHoverContents() {
+        if (this._commandAction.id === OTEL_STATUS_COMMAND) {
+            return {
+                element: () => this._renderStatusHover()
+            };
+        }
+        return super.getHoverContents();
+    }
+    getTooltip() {
+        if (this._commandAction.id === OTEL_STATUS_COMMAND) {
+            const tooltip = this._getStatusEntryTooltip();
+            if (tooltip) {
+                return tooltip;
+            }
+        }
+        return super.getTooltip();
+    }
+    _getStatusEntryTooltip() {
+        for (const entry of this.chatStatusItemService.getEntries()) {
+            if (entry.id === OTEL_STATUS_ENTRY_ID) {
+                return entry.tooltip;
+            }
+        }
+        return undefined;
+    }
+    _renderStatusHover() {
+        const store = ( new DisposableStore());
+        this.hoverContentDisposables.value = store;
+        const root = $(".new-chat-input-status-hover");
+        root.appendChild($(".new-chat-input-status-hover-title", undefined, ( localize(3684, "Monitoring with OpenTelemetry enabled"))));
+        root.appendChild($(
+            ".new-chat-input-status-hover-detail",
+            undefined,
+            this._getStatusEntryTooltip() ?? super.getTooltip()
+        ));
+        const actions = root.appendChild($(".new-chat-input-status-hover-actions"));
+        const learnMoreButton = store.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        learnMoreButton.label = ( localize(3685, "Learn More"));
+        store.add(learnMoreButton.onDidClick(() => {
+            void this.commandService.executeCommand("vscode.open", ( URI.parse(OTEL_DOCS_URL)));
+            this.hoverService.hideHover(true);
+        }));
+        const manageButton = store.add(( new Button(actions, {
+            ...defaultButtonStyles,
+            secondary: true
+        })));
+        manageButton.label = ( localize(3686, "Manage"));
+        store.add(manageButton.onDidClick(() => {
+            void this.commandService.executeCommand(OPEN_OTEL_SETTINGS_COMMAND);
+            this.hoverService.hideHover(true);
+        }));
+        return root;
+    }
+};
+NewChatInputStatusActionViewItem = ( __decorate([( __param(2, IKeybindingService)), ( __param(3, INotificationService)), ( __param(4, IContextKeyService)), ( __param(5, IThemeService)), ( __param(6, IContextMenuService)), ( __param(7, IAccessibilityService)), ( __param(8, IChatStatusItemService)), ( __param(9, IHoverService)), ( __param(10, ICommandService))], NewChatInputStatusActionViewItem));
+const RANDOM_PLACEHOLDERS = [( localize(3687, "What are you building?")), ( localize(3688, "What will you ship today?")), ( localize(3689, "Describe what you want to build")), ( localize(3690, "What's your next milestone?")), ( localize(3691, "What are you trying to achieve?")), ( localize(3692, "Pitch your idea")), ( localize(3693, "What's the goal?")), ( localize(3694, "What will you create?")), ( localize(3695, "What feature are you dreaming up?")), ( localize(3696, "Describe the outcome you want")), ( localize(3697, "What problem are you solving?")), ( localize(3698, "What's next on your roadmap?")), ( localize(3699, "What would you like to automate?")), ( localize(3700, "What will you launch?")), ( localize(3701, "Describe your mission"))];
+let lastPlaceholderIndex = -1;
+function getRandomChatInputPlaceholder() {
+    let index = Math.floor(Math.random() * RANDOM_PLACEHOLDERS.length);
+    if (index === lastPlaceholderIndex) {
+        index = (index + 1) % RANDOM_PLACEHOLDERS.length;
+    }
+    lastPlaceholderIndex = index;
+    return RANDOM_PLACEHOLDERS[index];
+}
+let NewChatInputWidget = class NewChatInputWidget extends Disposable {
+    get gettingStartedTipContainerElement() {
+        return this._gettingStartedTipContainer;
+    }
+    get hostNoticeContainerElement() {
+        return this._hostNoticeContainer;
+    }
+    get element() {
+        return this._editorContainer;
+    }
+    get inputEditor() {
+        return this._editor;
+    }
+    get selectedModelState() {
+        return this._modelSelection.state;
+    }
+    get workspacePreselectionSource() {
+        return this.options.getWorkspacePreselectionSource?.();
+    }
+    get workspaceSelection() {
+        return this.options.getWorkspaceSelection?.();
+    }
+    get onDidChangeWorkspaceSelection() {
+        return this.options.onDidChangeWorkspaceSelection ?? Event.None;
+    }
+    get hasInput() {
+        return !!this._editor?.getValue() || this._contextAttachments.attachments.length > 0;
+    }
+    get canApplyWorkspaceDefault() {
+        return !this.hasInput && (this.options.canApplyWorkspaceDefault?.() ?? false);
+    }
+    openModelPicker() {
+        this._newChatModelPickerService.openModelPicker();
+    }
+    renderSessionControls(container) {
+        if (!this._sessionControlsContainer) {
+            throw ( new Error("NewChatInputWidget must be rendered before its session controls."));
+        }
+        container.appendChild(this._sessionControlsContainer);
+    }
+    constructor(
+        options,
+        instantiationService,
+        modelService,
+        textModelService,
+        chatPasteTargetService,
+        configurationService,
+        contextKeyService,
+        logService,
+        hoverService,
+        storageService,
+        dialogService,
+        keybindingService,
+        layoutService,
+        chatSessionsService,
+        chatSpeechToTextService,
+        dictationOnboardingService,
+        chatInputNoticeHubService,
+        chatSubmitRequestHandlerService,
+        contextMenuService,
+        commandService,
+        voiceSessionController,
+        voiceInputModeService,
+        accessibilityService,
+        voiceModeOnboardingService,
+        newChatVoiceTargetService,
+        themeService,
+        chatPetWidgetService,
+        chatInputNotificationService,
+        languageModelsService
+    ) {
+        super();
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.modelService = modelService;
+        this.textModelService = textModelService;
+        this.chatPasteTargetService = chatPasteTargetService;
+        this.configurationService = configurationService;
+        this.contextKeyService = contextKeyService;
+        this.logService = logService;
+        this.hoverService = hoverService;
+        this.storageService = storageService;
+        this.dialogService = dialogService;
+        this.keybindingService = keybindingService;
+        this.layoutService = layoutService;
+        this.chatSessionsService = chatSessionsService;
+        this.chatSpeechToTextService = chatSpeechToTextService;
+        this.dictationOnboardingService = dictationOnboardingService;
+        this.chatInputNoticeHubService = chatInputNoticeHubService;
+        this.chatSubmitRequestHandlerService = chatSubmitRequestHandlerService;
+        this.contextMenuService = contextMenuService;
+        this.commandService = commandService;
+        this.voiceSessionController = voiceSessionController;
+        this.voiceInputModeService = voiceInputModeService;
+        this.accessibilityService = accessibilityService;
+        this.voiceModeOnboardingService = voiceModeOnboardingService;
+        this.newChatVoiceTargetService = newChatVoiceTargetService;
+        this.themeService = themeService;
+        this.chatPetWidgetService = chatPetWidgetService;
+        this.chatInputNotificationService = chatInputNotificationService;
+        this.languageModelsService = languageModelsService;
+        this.noticeHost = this._register(( new ChatInputNoticeHost(() => this.focus())));
+        this._onDidFocus = this._register(( new Emitter()));
+        this.onDidFocus = this._onDidFocus.event;
+        this._onDidBlur = this._register(( new Emitter()));
+        this.onDidBlur = this._onDidBlur.event;
+        this._promptTemplatePlaceholder = this._register(( new MutableDisposable()));
+        this._promptOptionsWidget = this._register(( new MutableDisposable()));
+        this._promptOptionsRefresh = this._register(( new MutableDisposable()));
+        this._promptOptionsDismissed = false;
+        this._promptOptionsSelected = false;
+        this._sending = false;
+        this._initializationLoadingDelayDisposable = this._register(( new MutableDisposable()));
+        this._loadingDelayDisposable = this._register(( new MutableDisposable()));
+        this._promptTypingAnimation = this._register(( new MutableDisposable()));
+        this._newChatModelPickerService = ( new NewChatModelPickerService());
+        this._compactModelPicker = observableValue(this, false);
+        this._draftState = {
+            inputText: "",
+            attachments: []
+        };
+        this._modelSelection = this._register(
+            this.instantiationService.createInstance(SessionModelSelection, this.options.session, {})
+        );
+        this._canSendRequest = derived(this, reader => {
+            if (this.options.canSubmitWithoutSession?.read(reader)) {
+                return true;
+            }
+            const modelSelection = this._modelSelection.state.read(reader);
+            return this.options.canSendRequest.read(reader) && hasSendableModelSelection(modelSelection);
+        });
+        this._scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection(
+            [INewChatModelPickerService, this._newChatModelPickerService],
+            [ISessionContext, ( new SessionContext(this.options.session))],
+            [ISessionModelSelection, this._modelSelection]
+        ))));
+        this._history = this._register(
+            this.instantiationService.createInstance(ChatHistoryNavigator, ChatAgentLocation.Chat)
+        );
+        if (this.options.historyKey) {
+            this._register(
+                autorun(reader => this._setHistoryKey(this.options.historyKey?.read(reader)))
+            );
+            this._register(this.configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(AGENT_SESSIONS_SCOPED_INPUT_HISTORY_SETTING)) {
+                    this._setHistoryKey(this.options.historyKey?.get());
+                }
+            }));
+        }
+        this._register(this.storageService.onWillSaveState(() => this.saveState()));
+        this._contextAttachments = this._register(this.instantiationService.createInstance(NewChatContextAttachments));
+        this.sessionTypePicker = this._register(this.instantiationService.createInstance(
+            MobileSessionTypePicker,
+            this.options.session,
+            this.options.sessionTypePickerOptions
+        ));
+        this._register(this._contextAttachments.onDidChangeContext(() => {
+            this._updateAndSaveDraftState();
+            this._updateSendButtonState();
+            this.focus();
+        }));
+        this._register(autorun(reader => {
+            this._canSendRequest.read(reader);
+            this.options.hasAdditionalSendContent?.read(reader);
+            this._updateSendButtonState();
+        }));
+    }
+    _setHistoryKey(historyKey) {
+        this._history.setHistoryKey(
+            this.configurationService.getValue(AGENT_SESSIONS_SCOPED_INPUT_HISTORY_SETTING) !== false ? historyKey : undefined
+        );
+    }
+    render(parent, root) {
+        const chatInputContainer = append(parent, $(`.new-chat-input-container.${chatInputStackClass}`));
+        const editorOverflowWidgetsDomNode = this.layoutService.getContainer(getWindow(root)).appendChild($(".sessions-chat-editor-overflow.monaco-editor"));
+        editorOverflowWidgetsDomNode.classList.add("hideSuggestTextIcons");
+        this._register(toDisposable(() => editorOverflowWidgetsDomNode.remove()));
+        this._register(
+            this.chatInputNoticeHubService.registerHost(this.noticeHost, chatInputContainer)
+        );
+        const composerFocusKey = ChatContextKeys.inChatComposer.bindTo(this._register(this.contextKeyService.createScoped(chatInputContainer)));
+        const composerFocusTracker = this._register(trackFocus(chatInputContainer));
+        this._register(composerFocusTracker.onDidFocus(() => composerFocusKey.set(true)));
+        this._register(composerFocusTracker.onDidBlur(() => composerFocusKey.set(false)));
+        const notificationContainer = append(
+            chatInputContainer,
+            $(`.chat-input-notification-container.${chatInputStackSlotClass}`)
+        );
+        const notificationWidget = this._register(this.instantiationService.createInstance(ChatInputNotificationWidget, {
+            modelTargetChatSessionType: this.sessionTypePicker.modelTargetChatSessionType,
+            sessionResource: derived(
+                this,
+                reader => this.options.session.read(reader)?.activeChat.read(reader).resource
+            ),
+            deferredNotificationsEnabled: this.options.deferredNotificationsEnabled,
+            isTransientChat: derived(
+                this,
+                reader => this.options.session.read(reader)?.isQuickChat?.read(reader) ?? false
+            ),
+            sessionStarted: derived(this, reader => {
+                const session = this.options.session.read(reader);
+                return session ? session.activeChat.read(reader).status.read(reader) !== SessionStatus.Untitled : false;
+            }),
+            modelSelection: {
+                state: this._modelSelection.state,
+                openPicker: () => this._newChatModelPickerService.openModelPicker(),
+                selectModel: modelIdentifier => this._newChatModelPickerService.switchToModel(modelIdentifier),
+                applyModelConfiguration: (modelIdentifier, values) => this.languageModelsService.setModelConfiguration(modelIdentifier, values)
+            },
+            onDidChangeVisibility: (visible, focusTarget) => this.noticeHost.setOccupied(ChatInputNoticeLane.Notification, visible, focusTarget),
+            focusInput: () => this.focus()
+        }));
+        notificationWidget.attachTo(notificationContainer);
+        const voiceOnboardingContainer = append(
+            chatInputContainer,
+            $(`.voice-mode-onboarding-container.${chatInputStackSlotClass}`)
+        );
+        const dictationOnboardingContainer = append(
+            chatInputContainer,
+            $(`.dictation-onboarding-container.${chatInputStackSlotClass}`)
+        );
+        this._register(registerChatInputOnboardingHosts(this.noticeHost, {
+            voice: voiceOnboardingContainer,
+            dictation: dictationOnboardingContainer
+        }, chatInputContainer, () => this.focus(), this.voiceModeOnboardingService, this.dictationOnboardingService));
+        this._gettingStartedTipContainer = append(
+            chatInputContainer,
+            $(`.chat-getting-started-tip-container.${chatInputStackSlotClass}`)
+        );
+        this._hostNoticeContainer = append(
+            chatInputContainer,
+            $(`.chat-input-host-notice-container.${chatInputStackSlotClass}`)
+        );
+        this._promptOptionsWidget.value = this.instantiationService.createInstance(NewSessionPromptOptionsWidget, chatInputContainer, {
+            selectOption: async (option, expectedInput, animate) => {
+                this._promptOptionsSelected = true;
+                this.focus();
+                const inserted = animate ? await this.animatePrompt(
+                    option.prompt,
+                    NEW_SESSION_PROMPT_TYPING_DURATION_MS,
+                    option.placeholder,
+                    CancellationToken.None,
+                    expectedInput
+                ) : this._replacePrompt(option.prompt, option.placeholder, expectedInput);
+                const generatedValue = option.placeholder ? option.prompt.replace(option.placeholder, "") : option.prompt;
+                if (inserted && (this._editor.getValue() === option.prompt || this._editor.getValue() === generatedValue)) {
+                    status(( localize(3702, "Inserted prompt: {0}", option.title)));
+                }
+                return inserted;
+            },
+            onDidSelectOption: option => this._promptOptionsController?.onDidSelectOption(option),
+            onDidClose: () => this._dismissPromptOptions()
+        });
+        this._promptOptionsWidget.value.setState(this._promptOptionsState);
+        const inputAreaWrapper = append(chatInputContainer, $(".new-chat-input-area-wrapper"));
+        const inputArea = append(inputAreaWrapper, $(".new-chat-input-area"));
+        const contextAttachments = this._contextAttachments;
+        const attachRow = append(inputArea, $(".sessions-chat-attach-row"));
+        const attachedContextContainer = append(attachRow, $(".sessions-chat-attached-context"));
+        this._contextAttachments.renderAttachedContext(attachedContextContainer);
+        const updateAttachmentOffset = () => {
+            if (isPhoneLayout(this.layoutService)) {
+                parent.style.removeProperty("top");
+                return;
+            }
+            parent.style.top = `${-attachRow.getBoundingClientRect().height / 2}px`;
+        };
+        this._updateAttachmentOffset = updateAttachmentOffset;
+        const attachmentResizeObserver = this._register(new DisposableResizeObserver(
+            "NewChatInputWidget.attachments",
+            updateAttachmentOffset,
+            getWindow(attachRow)
+        ));
+        this._register(attachmentResizeObserver.observe(attachRow));
+        this._register(toDisposable(() => {
+            this._updateAttachmentOffset = undefined;
+            parent.style.removeProperty("top");
+        }));
+        this._register(
+            this.instantiationService.createInstance(ChatDragAndDrop, () => undefined, {
+                get attachments() {
+                    return contextAttachments.attachments;
+                },
+                addAttachments: entries => contextAttachments.addAttachments(...entries)
+            }, {
+                listForeground: inactiveSessionViewForeground,
+                listBackground: inactiveSessionViewBackground,
+                overlayBackground: EDITOR_DRAG_AND_DROP_BACKGROUND
+            })
+        ).addOverlay(root, root);
+        this._createEditor(inputArea, editorOverflowWidgetsDomNode);
+        const inputHasContent = observableFromEvent(
+            this,
+            this._editor.onDidChangeModelContent,
+            () => this._editor.getValue().length > 0
+        );
+        this._register(this.chatPetWidgetService.register(this, {
+            parent: chatInputContainer,
+            dragBounds: inputArea,
+            movementBounds: root,
+            model: constObservable(undefined),
+            hasInput: inputHasContent,
+            inputChanged: this._editor.onDidChangeModelContent,
+            getPlatformTop: petCenterX => {
+                if (petCenterX !== undefined) {
+                    const pillTop = getChatPetPillPlatformTop(petCenterX, [
+                        ...(this.options.getChatPetPlatformElements?.() ?? []),
+                        ...this.sessionTypePicker.getChatPetPlatformElements()
+                    ].map(element => element.getBoundingClientRect()));
+                    if (pillTop !== undefined) {
+                        return pillTop;
+                    }
+                }
+                return getChatPetStackPlatformTop(chatInputContainer, inputArea);
+            },
+            onDidChangePlatform: Event.any(
+                this.options.onDidChangeChatPetPlatform ?? Event.None,
+                this.sessionTypePicker.onDidChangeChatPetPlatform
+            )
+        }, this.options.petHostPreferred, this.onDidFocus));
+        this._createInputToolbar(inputArea);
+        const newChatBottomContainer = append(parent, $(".new-chat-bottom-container"));
+        const newChatControlsContainer = append(newChatBottomContainer, $(".new-chat-controls-container"));
+        const sessionControlsContainer = this._sessionControlsContainer = append(newChatControlsContainer, $(".new-chat-session-controls"));
+        this._register(
+            createNewSessionControlToolbar(sessionControlsContainer, this._scopedInstantiationService)
+        );
+        this._register({
+            dispose: () => sessionControlsContainer.remove()
+        });
+        const repoConfigContainer = append(newChatBottomContainer, $(".new-chat-repo-config-container"));
+        if (this.options.renderRepositoryControls !== false) {
+            const session = this.options.session;
+            this._register(this._scopedInstantiationService.createInstance(
+                MenuWorkbenchToolBar,
+                repoConfigContainer,
+                Menus.NewSessionRepositoryConfig,
+                {
+                    hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                    menuOptions: {
+                        get arg() {
+                            return {
+                                session: session.get()
+                            };
+                        }
+                    }
+                }
+            ));
+        }
+        this._register(installMobileChipLaneScroll(newChatBottomContainer, this.layoutService));
+        const statusContainer = append(repoConfigContainer, $(".new-chat-status-toolbar"));
+        this._register(
+            this.instantiationService.createInstance(MenuWorkbenchToolBar, statusContainer, MenuId.ChatInputStatus, {
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                toolbarOptions: {
+                    primaryGroup: () => true
+                },
+                actionViewItemProvider: (action, options) => {
+                    if (action instanceof MenuItemAction) {
+                        return this.instantiationService.createInstance(NewChatInputStatusActionViewItem, action, options);
+                    }
+                    return undefined;
+                }
+            })
+        );
+        this._secondaryPickerResponsiveLayout = this._register(( new ChatInputPickerResponsiveLayout("NewChatInput.secondaryPicker", newChatBottomContainer, {
+            getItems: () => getLabeledPickerResponsiveItems(newChatBottomContainer)
+        })));
+        this._secondaryPickerResponsiveLayout.layout();
+        this._restoreState();
+        setChatInputStackSlot(chatInputContainer, ChatInputStackSlot.Standalone);
+        refreshChatInputStack(parent);
+        this._register(addDisposableListener(chatInputContainer, "animationend", () => {
+            this._editor?.layout();
+        }, {
+            once: true
+        }));
+    }
+    _updateInputLoadingState() {
+        const loading = this._sending;
+        if (loading) {
+            if (!this._loadingDelayDisposable.value) {
+                const timer = setTimeout(() => {
+                    this._loadingDelayDisposable.clear();
+                    if (this._sending) {
+                        this._setLoadingSpinnerVisible(true);
+                    }
+                }, 500);
+                this._loadingDelayDisposable.value = toDisposable(() => clearTimeout(timer));
+            }
+        } else {
+            this._loadingDelayDisposable.clear();
+            this._setLoadingSpinnerVisible(false);
+        }
+    }
+    _updateInitializationLoadingState(loading) {
+        if (!loading) {
+            this._initializationLoadingDelayDisposable.clear();
+            this._initializationLoadingSpinner?.classList.remove("visible");
+            return;
+        }
+        if (this._initializationLoadingSpinner?.classList.contains("visible") || this._initializationLoadingDelayDisposable.value) {
+            return;
+        }
+        const timer = setTimeout(() => {
+            this._initializationLoadingDelayDisposable.clear();
+            if (this.options.loading.get()) {
+                this._initializationLoadingSpinner?.classList.add("visible");
+            }
+        }, INITIALIZATION_LOADING_DELAY_MS);
+        this._initializationLoadingDelayDisposable.value = toDisposable(() => clearTimeout(timer));
+    }
+    _setLoadingSpinnerVisible(visible) {
+        if (visible && this._sendButton?.hasFocus()) {
+            this.focus();
+        }
+        this._loadingSpinner?.classList.toggle("visible", visible);
+        this._sendButtonContainer?.classList.toggle("loading", visible);
+    }
+    _getAriaLabel() {
+        const verbose = this.configurationService.getValue(AccessibilityVerbositySettingId.SessionsChat);
+        if (verbose) {
+            const kbLabel = this.keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
+            return kbLabel ? ( localize(
+                3703,
+                "Chat input. Press Enter to send out the request. Use {0} for Chat Accessibility Help.",
+                kbLabel
+            )) : ( localize(
+                3704,
+                "Chat input. Press Enter to send out the request. Use the Chat Accessibility Help command for more information."
+            ));
+        }
+        return localize(3705, "Chat input");
+    }
+    _getTerminalCommandPrefix() {
+        const session = this.options.session.get();
+        return session ? this.chatSessionsService.getCapabilitiesForSessionType(getChatSessionType(session.resource))?.terminalCommandPrefix : undefined;
+    }
+    _handleTerminalCommandPaste(e) {
+        handleTerminalCommandPaste(
+            e,
+            this._editor,
+            this._getTerminalCommandPrefix(),
+            this.dialogService,
+            this.storageService
+        );
+    }
+    _holdInputModelReference(uri, model) {
+        const inputModelReference = thenRegisterOrDispose(this.textModelService.createModelReference(uri), this._store);
+        void inputModelReference.catch(error => {
+            model.dispose();
+            if (!this._store.isDisposed) {
+                this.logService.error("Failed to hold the chat input model reference", error);
+            }
+        });
+    }
+    _createEditor(container, overflowWidgetsDomNode) {
+        const editorContainer = this._editorContainer = append(container, $(".sessions-chat-editor"));
+        const minHeight = this.options.minEditorHeight ?? MIN_EDITOR_HEIGHT;
+        editorContainer.style.height = `${minHeight}px`;
+        const inputScopedContextKeyService = this._register(this.contextKeyService.createScoped(container));
+        const {
+            historyNavigationBackwardsEnablement,
+            historyNavigationForwardsEnablement
+        } = this._register(
+            registerAndCreateHistoryNavigationContext(inputScopedContextKeyService, this)
+        );
+        this._historyNavigationBackwardsEnablement = historyNavigationBackwardsEnablement;
+        this._historyNavigationForwardsEnablement = historyNavigationForwardsEnablement;
+        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, inputScopedContextKeyService]))));
+        const uri = ( URI.from({
+            scheme: Schemas.sessionsChatInput,
+            path: `input-${Date.now()}`
+        }));
+        const textModel = this.modelService.createModel("", null, uri, true);
+        this._holdInputModelReference(uri, textModel);
+        const editorOptions = {
+            ...getSimpleEditorOptions(this.configurationService),
+            readOnly: false,
+            pasteAs: EditorOptions.pasteAs.defaultValue,
+            ariaLabel: this._getAriaLabel(),
+            placeholder: this.options.placeholder ?? getRandomChatInputPlaceholder(),
+            fontFamily: NEW_CHAT_INPUT_FONT_FAMILY,
+            fontSize: 13,
+            lineHeight: 20,
+            cursorWidth: 1,
+            padding: {
+                top: 8,
+                bottom: 2
+            },
+            wrappingStrategy: "advanced",
+            stickyScroll: {
+                enabled: false
+            },
+            renderWhitespace: "none",
+            scrollbar: {
+                horizontal: "hidden",
+                alwaysConsumeMouseWheel: false,
+                vertical: "auto",
+                verticalScrollbarSize: 7
+            },
+            overflowWidgetsDomNode,
+            suggest: {
+                showIcons: true,
+                showSnippets: false,
+                showWords: true,
+                showStatusBar: false,
+                insertMode: "insert",
+                fitWidthToDetails: true
+            }
+        };
+        const widgetOptions = {
+            isSimpleWidget: true,
+            contributions: EditorExtensionsRegistry.getSomeEditorContributions([
+                ContextMenuController.ID,
+                SuggestController.ID,
+                SnippetController2.ID,
+                PlaceholderTextContribution.ID,
+                CopyPasteController.ID
+            ])
+        };
+        this._editor = this._register(
+            scopedInstantiationService.createInstance(CodeEditorWidget, editorContainer, editorOptions, widgetOptions)
+        );
+        this._editor.setModel(textModel);
+        this._promptTemplatePlaceholder.value = ( new PromptTemplatePlaceholderController(this._editor, () => this._promptTypingAnimation.value?.complete()));
+        this._register(autorun(reader => {
+            this.options.session.read(reader);
+            this._updateEditorFontFamily();
+        }));
+        this._register(addDisposableListener(
+            this._editorContainer,
+            EventType.PASTE,
+            e => this._handleTerminalCommandPaste(e),
+            true
+        ));
+        SuggestController.get(this._editor)?.forceRenderingAbove();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(AccessibilityVerbositySettingId.SessionsChat)) {
+                this._editor.updateOptions({
+                    ariaLabel: this._getAriaLabel()
+                });
+            }
+        }));
+        const dictationFocusKey = SessionsChatInputHasDictationFocus.bindTo(inputScopedContextKeyService);
+        const inputHasFocusKey = ChatContextKeys.inputHasFocus.bindTo(inputScopedContextKeyService);
+        this._register(this._editor.onDidFocusEditorText(() => {
+            this._setInputEditorFocused(container, true);
+        }));
+        this._register(this._editor.onDidBlurEditorText(() => {
+            this._setInputEditorFocused(container, false);
+        }));
+        this._register(this._editor.onDidFocusEditorWidget(() => {
+            dictationFocusKey.set(true);
+            inputHasFocusKey.set(true);
+            activeDictationComposer = this;
+            this._onDidFocus.fire();
+        }));
+        this._register(this._editor.onDidBlurEditorWidget(() => {
+            dictationFocusKey.set(false);
+            inputHasFocusKey.set(false);
+            if (activeDictationComposer === this) {
+                activeDictationComposer = undefined;
+            }
+            this._onDidBlur.fire();
+        }));
+        this._register(toDisposable(() => {
+            if (activeDictationComposer === this) {
+                activeDictationComposer = undefined;
+            }
+        }));
+        this._register(this._editor.onKeyDown(e => {
+            if (e.browserEvent.defaultPrevented) {
+                return;
+            }
+            if (e.keyCode === KeyCode.Enter && !e.shiftKey && !e.ctrlKey && !e.altKey && this._promptTemplatePlaceholder.value?.replaceAtCursor()) {
+                e.preventDefault();
+                e.stopPropagation();
+                return;
+            }
+            if (e.keyCode === KeyCode.Enter && !e.shiftKey && !e.ctrlKey && !e.altKey) {
+                if (this._editor.contextKeyService.getContextKeyValue("suggestWidgetVisible")) {
+                    return;
+                }
+                e.preventDefault();
+                e.stopPropagation();
+                this._send();
+            }
+            if (this.options.supportsBackground && e.keyCode === KeyCode.Enter && !e.shiftKey && !e.ctrlKey && e.altKey) {
+                e.preventDefault();
+                e.stopPropagation();
+                this._send(true);
+            }
+            if (e.equals(KeyMod$1.CtrlCmd | KeyCode.Slash)) {
+                e.preventDefault();
+                e.stopPropagation();
+                this._showContextPicker();
+            }
+        }));
+        const updateHistoryNavigationEnablement = () => {
+            const model = this._editor.getModel();
+            const position = this._editor.getPosition();
+            if (!model || !position) {
+                return;
+            }
+            this._historyNavigationBackwardsEnablement.set(position.lineNumber === 1 && position.column === 1);
+            this._historyNavigationForwardsEnablement.set(
+                position.lineNumber === model.getLineCount() && position.column === model.getLineMaxColumn(position.lineNumber)
+            );
+        };
+        this._register(
+            this._editor.onDidChangeCursorPosition(() => updateHistoryNavigationEnablement())
+        );
+        updateHistoryNavigationEnablement();
+        let previousHeight = -1;
+        this._register(this._editor.onDidContentSizeChange(e => {
+            if (!e.contentHeightChanged) {
+                return;
+            }
+            const contentHeight = this._editor.getContentHeight();
+            const clampedHeight = Math.min(
+                MAX_EDITOR_HEIGHT,
+                Math.max(this.options.minEditorHeight ?? MIN_EDITOR_HEIGHT, contentHeight)
+            );
+            if (clampedHeight === previousHeight) {
+                return;
+            }
+            previousHeight = clampedHeight;
+            this._editorContainer.style.height = `${clampedHeight}px`;
+            this._editor.layout();
+        }));
+        this._register(
+            this._scopedInstantiationService.createInstance(SlashCommandHandler, this._editor)
+        );
+        this._register(this.instantiationService.createInstance(
+            VariableCompletionHandler,
+            this._editor,
+            this._contextAttachments,
+            () => this.options.getContextFolderUri()
+        ));
+        this._register(
+            this.instantiationService.createInstance(SessionReferenceCompletionHandler, this._editor, this._contextAttachments)
+        );
+        this._agentHostInputCompletionHandler = this._register(
+            this._scopedInstantiationService.createInstance(AgentHostInputCompletionHandler, this._editor, this._contextAttachments)
+        );
+        this._register(this.chatPasteTargetService.registerTarget(textModel.uri, ( new NewChatInputPasteTarget(
+            this._editor,
+            this._contextAttachments,
+            this._agentHostInputCompletionHandler,
+            () => this._getTerminalCommandPrefix(),
+            () => this.options.session.get()?.resource,
+            textModel.uri
+        ))));
+        this._register(this._editor.onDidChangeModelContent(() => {
+            this._syncInputGitHubContext();
+            this._updateDraftState();
+            this._updateSendButtonState();
+            this._updateEditorFontFamily();
+            this._promptOptionsWidget.value?.setInputValue(this._editor.getValue());
+        }));
+    }
+    _setInputEditorFocused(container, focused) {
+        container.classList.toggle("focused", focused);
+        setChatInputStackInputFocused(container, focused);
+    }
+    _updateEditorFontFamily() {
+        const isCommand = isTerminalCommandInput(
+            this._editor.getModel()?.getLineContent(1) || "",
+            this._getTerminalCommandPrefix()
+        );
+        this._editor.updateOptions({
+            fontFamily: isCommand ? EDITOR_FONT_DEFAULTS.fontFamily : NEW_CHAT_INPUT_FONT_FAMILY
+        });
+    }
+    _createAttachButton(container) {
+        const attachButton = append(container, $(".sessions-chat-attach-button"));
+        const attachButtonLabel = ( localize(3706, "Add Context..."));
+        attachButton.tabIndex = 0;
+        attachButton.role = "button";
+        attachButton.ariaLabel = attachButtonLabel;
+        this._register(this.hoverService.setupDelayedHover(attachButton, {
+            content: attachButtonLabel,
+            position: {
+                hoverPosition: HoverPosition.BELOW
+            },
+            appearance: {
+                showPointer: true
+            }
+        }));
+        append(attachButton, renderIcon(Codicon.addCompact));
+        this._register(addDisposableListener(attachButton, EventType.CLICK, () => {
+            this._showContextPicker();
+        }));
+    }
+    _showContextPicker() {
+        this._contextAttachments.showPicker(
+            this.options.getContextFolderUri(),
+            this.options.getContextPickerActions?.()
+        );
+    }
+    _createInputToolbar(container) {
+        const toolbar = append(container, $(".sessions-chat-toolbar"));
+        let dictationActionVisible = false;
+        let voiceInputModePillVisible = false;
+        let voiceActionCount = 0;
+        let dictationButton;
+        const isVoiceSessionActive = derived(this, reader => isNewChatVoiceSessionActive(
+            this.voiceSessionController.isConnected.read(reader),
+            this.voiceSessionController.isConnecting.read(reader),
+            this.voiceSessionController.targetSession.read(reader),
+            this.voiceSessionController.hasDraftTarget.read(reader)
+        ));
+        const voiceInputModePillActive = derived(this, reader => isNewChatVoiceInputModePillActive(
+            this.voiceInputModeService.dictationAvailable.read(reader),
+            this.voiceInputModeService.voiceAvailable.read(reader),
+            isVoiceSessionActive.read(reader) && this.voiceSessionController.isConnected.read(reader)
+        ));
+        const updateVoiceInputActionBorder = () => {
+            const showDictationAction = isNewChatStandaloneDictationVisible(dictationActionVisible, voiceInputModePillVisible);
+            dictationButton?.classList.toggle("hidden", !showDictationAction);
+            toolbar.classList.toggle(
+                "sessions-chat-voice-input-actions-multiple",
+                Number(showDictationAction) + voiceActionCount > 1
+            );
+        };
+        this._createAttachButton(toolbar);
+        const configContainer = append(toolbar, $(".sessions-chat-config-toolbar"));
+        const configToolbar = this._register(createNewSessionConfigToolbar(
+            configContainer,
+            this._scopedInstantiationService,
+            this._compactModelPicker
+        ));
+        this._initializationLoadingSpinner = append(toolbar, $(".sessions-chat-loading-spinner"));
+        const initializationLoadingIcon = append(
+            this._initializationLoadingSpinner,
+            renderIcon(ThemeIcon.modify(Codicon.loadingCompact, "spin"))
+        );
+        initializationLoadingIcon.setAttribute("aria-hidden", "true");
+        this._register(this.hoverService.setupManagedHover(
+            getDefaultHoverDelegate("mouse"),
+            this._initializationLoadingSpinner,
+            ( localize(3707, "Initializing..."))
+        ));
+        this._register(autorun(
+            reader => this._updateInitializationLoadingState(this.options.loading.read(reader))
+        ));
+        try {
+            dictationButton = this._createSpeechToTextButton(toolbar, visible => {
+                dictationActionVisible = visible;
+                updateVoiceInputActionBorder();
+            });
+            updateVoiceInputActionBorder();
+        } catch (error) {
+            this.logService.error("Failed to create new-session dictation control:", error);
+        }
+        const voiceContainer = append(toolbar, $(".sessions-chat-voice-toolbar"));
+        try {
+            this._register(this.instantiationService.createInstance(NewChatVoiceController, {
+                toolbarContainer: voiceContainer,
+                inputContainer: container,
+                composer: this,
+                voiceInputModePillActive,
+                onDidChangeActions: actionCount => {
+                    voiceActionCount = actionCount;
+                    updateVoiceInputActionBorder();
+                }
+            }));
+        } catch (error) {
+            this.logService.error("Failed to create new-session voice controls:", error);
+        }
+        try {
+            this._createVoiceInputModePill(
+                toolbar,
+                container,
+                isVoiceSessionActive,
+                voiceInputModePillActive,
+                visible => {
+                    voiceInputModePillVisible = visible;
+                    updateVoiceInputActionBorder();
+                }
+            );
+        } catch (error) {
+            this.logService.error("Failed to create new-session voice input mode pill:", error);
+        }
+        this._sendButtonContainer = this.options.renderSendButton !== false ? append(toolbar, $(".sessions-chat-send-button")) : undefined;
+        this._loadingSpinner = append(
+            this._sendButtonContainer ?? toolbar,
+            $(".sessions-chat-loading-spinner")
+        );
+        const loadingIcon = append(
+            this._loadingSpinner,
+            renderIcon(ThemeIcon.modify(Codicon.loadingCompact, "spin"))
+        );
+        loadingIcon.setAttribute("aria-hidden", "true");
+        this._register(
+            this.hoverService.setupManagedHover(getDefaultHoverDelegate("mouse"), this._loadingSpinner, ( localize(3708, "Loading...")))
+        );
+        if (this._sendButtonContainer) {
+            const sendButton = this._sendButton = this._register(( new Button(this._sendButtonContainer, {
+                secondary: true,
+                title: this.options.supportsBackground ? ( localize(3709, "Send (Alt-click to start in the background)")) : ( localize(3710, "Send")),
+                ariaLabel: ( localize(3710, "Send"))
+            })));
+            sendButton.icon = Codicon.arrowUpCompact;
+            this._register(
+                sendButton.onDidClick(e => this._send(!!this.options.supportsBackground && !!e?.altKey))
+            );
+        }
+        updateVoiceInputActionBorder();
+        this._primaryPickerResponsiveLayout = this._register(( new ChatInputPickerResponsiveLayout("NewChatInput.primaryPicker", configContainer, {
+            getItems: () => {
+                const items = [];
+                for (let index = 0; index < configToolbar.getItemsLength(); index++) {
+                    const element = configToolbar.getItemElement(index);
+                    if (!element) {
+                        continue;
+                    }
+                    const isModelPicker = element.classList.contains("model-picker-item");
+                    items.push({
+                        element,
+                        canShrink: isModelPicker,
+                        isCompact: () => element.classList.contains("compact-picker"),
+                        setCompact: compact => {
+                            element.classList.toggle("compact-picker", compact);
+                            if (isModelPicker) {
+                                this._compactModelPicker.set(compact, undefined);
+                            }
+                        }
+                    });
+                }
+                return items;
+            },
+            hasOverflow: () => configToolbar.hasOverflow(),
+            relayout: () => configToolbar.relayout()
+        })));
+        this._primaryPickerResponsiveLayout.layout();
+    }
+    _createVoiceInputModePill(
+        toolbar,
+        inputContainer,
+        isVoiceSessionActive,
+        pillActive,
+        onDidChangeVisibility
+    ) {
+        const pillContainer = append(toolbar, $(".sessions-chat-voice-input-mode"));
+        const isVoiceInputActive = derived(this, reader => isEqual(
+            this.newChatVoiceTargetService.currentVoiceInputResource.read(reader),
+            NEW_CHAT_VOICE_SENTINEL
+        ));
+        const isDictationInputActive = observableFromEvent(this, Event.any(
+            this.chatSpeechToTextService.onDidChangeState,
+            this.chatSpeechToTextService.onDidChangePreparingModel,
+            onDidChangeDictationEditor
+        ), () => isDictationActiveForEditor(this._editor));
+        const action = toAction({
+            id: ChatVoiceInputModeAction.ID,
+            label: ( localize(3711, "Voice Input Mode")),
+            run: () => {}
+        });
+        const pill = this._register(
+            this._scopedInstantiationService.createInstance(VoiceInputModeActionViewItem, action, {
+                toggleDictation: () => {
+                    void this.toggleDictation();
+                },
+                isActive: isVoiceInputActive,
+                isDictationActive: isDictationInputActive,
+                isVoiceActive: isVoiceSessionActive
+            })
+        );
+        pill.render(pillContainer);
+        this._register(autorun(reader => {
+            const active = pillActive.read(reader);
+            pillContainer.classList.toggle("hidden", !active);
+            onDidChangeVisibility(active);
+            inputContainer.classList.toggle("voice-input-mode-pill", active);
+        }));
+    }
+    _createSpeechToTextButton(container, onDidChangeVisibility) {
+        const sttService = this.chatSpeechToTextService;
+        const isDictationInputActive = observableFromEvent(this, Event.any(
+            sttService.onDidChangeState,
+            sttService.onDidChangePreparingModel,
+            onDidChangeDictationEditor
+        ), () => isDictationActiveForEditor(this._editor));
+        const button = append(container, $(".sessions-chat-stt-button"));
+        button.tabIndex = 0;
+        button.role = "button";
+        const micLabel = ( localize(3712, "Dictate (Speech to Text)"));
+        const stopLabel = ( localize(3713, "Stop Dictation"));
+        this._register(this.hoverService.setupDelayedHover(button, () => ({
+            content: isDictationInputActive.get() && sttService.isPreparingModel ? getDictationDownloadHoverMarkdown(sttService) : (isDictationInputActive.get() ? stopLabel : getDictationHoverMarkdown(micLabel, this.configurationService)),
+            position: {
+                hoverPosition: HoverPosition.BELOW
+            },
+            appearance: {
+                showPointer: true
+            }
+        })));
+        const downloadRing = this._register(( new MutableDisposable()));
+        const renderState = () => {
+            const active = isDictationActiveForEditor(this._editor);
+            const preparing = active && sttService.isPreparingModel;
+            const recording = active && sttService.state === ChatSpeechToTextState.Recording;
+            clearNode(button);
+            downloadRing.clear();
+            if (preparing) {
+                if (sttService.isDownloadingModel) {
+                    append(button, renderIcon(Codicon.micDownloadCompact));
+                    downloadRing.value = ( new DictationDownloadRing(button, sttService));
+                } else {
+                    append(button, renderIcon(ThemeIcon.modify(Codicon.loadingCompact, "spin")));
+                }
+            } else {
+                append(button, renderIcon(recording ? Codicon.micFilled : Codicon.mic));
+            }
+            button.classList.toggle("recording", recording && !preparing);
+            button.classList.toggle("preparing", preparing);
+            button.ariaLabel = preparing ? ( localize(3714, "Cancel Dictation. {0}", getDictationPreparingLabel(sttService))) : (active ? stopLabel : micLabel);
+        };
+        renderState();
+        this._register(sttService.onDidChangeState(renderState));
+        this._register(sttService.onDidChangePreparingModel(renderState));
+        this._register(sttService.onDidChangeDownloadingModel(renderState));
+        this._register(setupDictationMicGlow(
+            button,
+            sttService,
+            this.accessibilityService,
+            isDictationInputActive,
+            this.themeService
+        ));
+        const updateVisibility = () => {
+            const voiceActive = isNewChatVoiceSessionActive(
+                this.voiceSessionController.isConnected.get(),
+                this.voiceSessionController.isConnecting.get(),
+                this.voiceSessionController.targetSession.get(),
+                this.voiceSessionController.hasDraftTarget.get()
+            );
+            const buttonShown = this.configurationService.getValue(DictationSettingId.ShowButton) !== false;
+            const visible = sttService.isConfigured && !voiceActive && buttonShown;
+            onDidChangeVisibility(visible);
+        };
+        updateVisibility();
+        this._register(autorun(reader => {
+            this.voiceSessionController.isConnected.read(reader);
+            this.voiceSessionController.isConnecting.read(reader);
+            this.voiceSessionController.targetSession.read(reader);
+            this.voiceSessionController.hasDraftTarget.read(reader);
+            updateVisibility();
+        }));
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("dictation.enabled") || e.affectsConfiguration("dictation.model") || e.affectsConfiguration(DictationSettingId.ShowButton)) {
+                updateVisibility();
+            }
+        }));
+        const toggle = () => this.toggleDictation();
+        this._register(Gesture.addTarget(button));
+        [EventType.CLICK, EventType$1.Tap].forEach(eventType => {
+            this._register(addDisposableListener(button, eventType, e => {
+                EventHelper.stop(e);
+                void toggle();
+            }));
+        });
+        this._register(addDisposableListener(button, EventType.KEY_DOWN, e => {
+            const event = ( new StandardKeyboardEvent(e));
+            if (event.equals(KeyCode.Enter) || event.equals(KeyCode.Space)) {
+                EventHelper.stop(event, true);
+                void toggle();
+            }
+        }));
+        this._register(
+            addMicButtonContextMenuListener(button, () => getDictationContextMenuActions(
+                this.commandService,
+                this.configurationService,
+                this.keybindingService,
+                TOGGLE_DICTATION_COMMAND_ID
+            ), this.contextMenuService)
+        );
+        return button;
+    }
+    async toggleDictation() {
+        if (!this._editor) {
+            return;
+        }
+        await runDictationShortcut({
+            speechService: this.chatSpeechToTextService,
+            keybindingService: this.keybindingService,
+            logService: this.logService,
+            onboardingService: this.dictationOnboardingService
+        }, TOGGLE_DICTATION_COMMAND_ID, this._editor);
+    }
+    showPreviousValue() {
+        if (this._history.isAtStart()) {
+            return;
+        }
+        if (this._draftState?.inputText || this._draftState?.attachments.length) {
+            this._history.overlay(this._toHistoryEntry(this._draftState));
+        }
+        this._navigateHistory(true);
+    }
+    showNextValue() {
+        if (this._history.isAtEnd()) {
+            return;
+        }
+        if (this._draftState?.inputText || this._draftState?.attachments.length) {
+            this._history.overlay(this._toHistoryEntry(this._draftState));
+        }
+        this._navigateHistory(false);
+    }
+    _updateDraftState() {
+        this._draftState = {
+            inputText: this._editor?.getModel()?.getValue() ?? "",
+            attachments: [...this._contextAttachments.attachments]
+        };
+    }
+    _updateAndSaveDraftState() {
+        if (this._sending) {
+            return;
+        }
+        this._updateDraftState();
+        this.saveState();
+    }
+    _syncInputGitHubContext() {
+        const inputAttachments = getInputGitHubContextAttachments(this._editor?.getValue() ?? "");
+        const inputAttachmentIds = ( new Set(inputAttachments.map(attachment => attachment.id)));
+        const attachments = this._contextAttachments.attachments.filter(attachment => !isInputGitHubContext(attachment) || ( inputAttachmentIds.has(attachment.id)));
+        const attachmentIds = ( new Set(attachments.map(attachment => attachment.id)));
+        for (const attachment of inputAttachments) {
+            if (!( attachmentIds.has(attachment.id))) {
+                attachments.push(attachment);
+                attachmentIds.add(attachment.id);
+            }
+        }
+        if (attachments.length !== this._contextAttachments.attachments.length || ( attachments.some(
+            (attachment, index) => attachment !== this._contextAttachments.attachments[index]
+        ))) {
+            this._contextAttachments.setAttachments(attachments);
+        }
+    }
+    _toHistoryEntry(draft) {
+        return {
+            ...draft,
+            mode: {
+                id: ChatModeKind.Agent,
+                kind: ChatModeKind.Agent
+            },
+            selectedModel: undefined,
+            selections: [],
+            contrib: {}
+        };
+    }
+    _navigateHistory(previous) {
+        const entry = previous ? this._history.previous() : this._history.next();
+        const inputText = entry?.inputText ?? "";
+        if (entry) {
+            this._editor?.getModel()?.setValue(inputText);
+            this._contextAttachments.setAttachments(entry.attachments);
+        }
+        status(inputText);
+        if (previous) {
+            this._editor.setPosition({
+                lineNumber: 1,
+                column: 1
+            });
+        } else {
+            const model = this._editor.getModel();
+            if (model) {
+                const lastLine = model.getLineCount();
+                this._editor.setPosition({
+                    lineNumber: lastLine,
+                    column: model.getLineMaxColumn(lastLine)
+                });
+            }
+        }
+    }
+    async submit(background = false) {
+        return this._send(background);
+    }
+    async _send(background = false) {
+        const rawQuery = this._editor.getModel()?.getValue() ?? "";
+        const query = rawQuery.trim();
+        const queryOffset = rawQuery.length - rawQuery.trimStart().length;
+        const hasAdditionalSendContent = this.options.hasAdditionalSendContent?.get() ?? false;
+        if (!hasSendableNewChatContent(query, this._contextAttachments.attachments, hasAdditionalSendContent) || this._sending) {
+            return false;
+        }
+        if (!this._canSendRequest.get()) {
+            return false;
+        }
+        notifyDictationSubmitted(this._editor);
+        const session = this.options.session.get();
+        if (!hasAdditionalSendContent && session && (await this.chatSubmitRequestHandlerService.tryHandle({
+            sessionResource: session.resource,
+            providerId: session.providerId,
+            sessionId: session.sessionId,
+            input: query
+        }))) {
+            this._editor.getModel()?.setValue("");
+            return true;
+        }
+        const attachments = this._agentHostInputCompletionHandler?.getAttachmentsForSend(query, queryOffset) ?? [...this._contextAttachments.attachments];
+        const attachedContext = attachments.length > 0 ? attachments : undefined;
+        const request = query;
+        const notificationContext = this._getNotificationContext();
+        if (this._draftState) {
+            this._history.append(this._toHistoryEntry(this._draftState));
+        }
+        this._clearDraftState();
+        this._sending = true;
+        this._editor.updateOptions({
+            readOnly: true
+        });
+        this._updateSendButtonState();
+        this._updateInputLoadingState();
+        let sent = false;
+        try {
+            sent = await this.options.sendRequest({
+                query: request,
+                attachments: attachedContext,
+                background
+            });
+            if (!sent) {
+                return false;
+            }
+            this.chatInputNotificationService.handleMessageSent(notificationContext);
+            this._contextAttachments.clear();
+            this._editor.getModel()?.setValue("");
+        } catch (e) {
+            this.logService.error("Failed to send request:", e);
+            return false;
+        } finally {
+            this._sending = false;
+            this._editor.updateOptions({
+                readOnly: false
+            });
+            this._updateDraftState();
+            this._updateSendButtonState();
+            this._updateInputLoadingState();
+        }
+        return sent;
+    }
+    _getNotificationContext() {
+        const session = this.options.session.get();
+        const activeChat = session?.activeChat.get();
+        const modelSelection = this._modelSelection.state.get();
+        return {
+            sessionType: this.sessionTypePicker.modelTargetChatSessionType.get(),
+            sessionResource: activeChat?.resource,
+            deferredNotificationsEnabled: this.options.deferredNotificationsEnabled?.get() ?? true,
+            isTransientChat: session?.isQuickChat?.get() ?? false,
+            sessionStarted: activeChat ? activeChat.status.get() !== SessionStatus.Untitled : false,
+            modelState: modelSelection
+        };
+    }
+    _updateSendButtonState() {
+        if (!this._sendButton) {
+            return;
+        }
+        const hasAdditionalSendContent = this.options.hasAdditionalSendContent?.get() ?? false;
+        this._sendButton.enabled = !this._sending && hasSendableNewChatContent(
+            this._editor?.getModel()?.getValue() ?? "",
+            this._contextAttachments.attachments,
+            hasAdditionalSendContent
+        ) && this._canSendRequest.get();
+    }
+    _restoreState() {
+        const draft = this._getDraftState();
+        if (draft) {
+            this._editor?.getModel()?.setValue(draft.inputText);
+            if (draft.attachments?.length) {
+                this._contextAttachments.setAttachments(draft.attachments.map(IChatRequestVariableEntry.fromExport));
+            }
+            this._syncInputGitHubContext();
+        }
+        this._updateSendButtonState();
+    }
+    _getDraftState() {
+        const raw = this.storageService.get(STORAGE_KEY_DRAFT_STATE, StorageScope.WORKSPACE);
+        if (!raw) {
+            return undefined;
+        }
+        try {
+            return parse(raw);
+        } catch {
+            return undefined;
+        }
+    }
+    _clearDraftState() {
+        this._draftState = {
+            inputText: "",
+            attachments: []
+        };
+        this.storageService.store(
+            STORAGE_KEY_DRAFT_STATE,
+            stringify(this._draftState),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+    saveState() {
+        if (this._draftState) {
+            const state = {
+                ...this._draftState,
+                attachments: this._draftState.attachments.map(IChatRequestVariableEntry.toExport)
+            };
+            this.storageService.store(
+                STORAGE_KEY_DRAFT_STATE,
+                stringify(state),
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
+        }
+    }
+    layout(_height, _width) {
+        this._updateAttachmentOffset?.();
+        this._editor?.layout();
+        this._primaryPickerResponsiveLayout?.layout();
+        this._secondaryPickerResponsiveLayout?.layout();
+    }
+    focus() {
+        this._editor?.focus();
+    }
+    async animatePrompt(text, durationMs, placeholder, token, expectedValue = "") {
+        const editor = this._editor;
+        const model = editor?.getModel();
+        if (!editor || !model || !text || model.getValue() !== expectedValue || token.isCancellationRequested) {
+            return false;
+        }
+        this._promptTypingAnimation.clear();
+        if (expectedValue) {
+            model.setValue("");
+        }
+        this._promptTemplatePlaceholder.value?.setPlaceholder(placeholder);
+        const targetWindow = getWindow(this._editorContainer);
+        const effectiveDuration = this.accessibilityService.isMotionReduced() || this.accessibilityService.isScreenReaderOptimized() ? 0 : durationMs;
+        const animation = animatePromptTyping({
+            getValue: () => model.getValue(),
+            setValue: value => {
+                model.setValue(value);
+                const lastLine = model.getLineCount();
+                editor.setPosition({
+                    lineNumber: lastLine,
+                    column: model.getLineMaxColumn(lastLine)
+                });
+            },
+            onDidChange: listener => model.onDidChangeContent(() => listener())
+        }, text, effectiveDuration, {
+            now: () => targetWindow.performance.now(),
+            schedule: callback => scheduleAtNextAnimationFrame(targetWindow, callback)
+        });
+        this._promptTypingAnimation.value = animation;
+        const cancellationListener = token.onCancellationRequested(() => {
+            if (this._promptTypingAnimation.value === animation) {
+                this._promptTypingAnimation.clear();
+            } else {
+                animation.dispose();
+            }
+        });
+        try {
+            return (await animation.result).didWrite;
+        } finally {
+            cancellationListener.dispose();
+            if (this._promptTypingAnimation.value === animation) {
+                this._promptTypingAnimation.clear();
+            }
+        }
+    }
+    _replacePrompt(text, placeholder, expectedValue) {
+        const model = this._editor.getModel();
+        if (!model || model.getValue() !== expectedValue) {
+            return false;
+        }
+        this._promptTypingAnimation.clear();
+        this._promptTemplatePlaceholder.value?.setPlaceholder(placeholder);
+        this._editor.pushUndoStop();
+        const edited = this._editor.executeEdits("sessions.promptOption", [{
+            range: model.getFullModelRange(),
+            text
+        }]);
+        if (!edited) {
+            return false;
+        }
+        this._editor.pushUndoStop();
+        const lastLine = model.getLineCount();
+        this._editor.setPosition({
+            lineNumber: lastLine,
+            column: model.getLineMaxColumn(lastLine)
+        });
+        return true;
+    }
+    showPromptOptions(state) {
+        if (state && this._promptOptionsDismissed) {
+            return false;
+        }
+        this._promptOptionsState = state;
+        const widget = this._promptOptionsWidget.value;
+        if (!widget) {
+            return false;
+        }
+        widget.setState(state);
+        widget.setInputValue(this._editor.getValue());
+        return true;
+    }
+    setPromptOptionsController(controller) {
+        this._cancelPromptOptionsRefresh(false);
+        this._promptOptionsController = controller;
+        this._promptOptionsDismissed = false;
+        this._promptOptionsSelected = false;
+    }
+    preparePromptOptionsRefresh() {
+        if (!this._promptOptionsController || this._promptOptionsDismissed) {
+            return false;
+        }
+        this._cancelPromptOptionsRefresh();
+        this._promptOptionsSelected = false;
+        this.showPromptOptions({
+            kind: "loading"
+        });
+        return true;
+    }
+    clearPromptOptions() {
+        this._cancelPromptOptionsRefresh();
+        this.showPromptOptions(undefined);
+    }
+    _dismissPromptOptions() {
+        if (this._promptOptionsDismissed) {
+            return;
+        }
+        const controller = this._promptOptionsController;
+        this._promptOptionsDismissed = true;
+        this._cancelPromptOptionsRefresh(false);
+        this.showPromptOptions(undefined);
+        this.focus();
+        status(( localize(3715, "Prompt options closed")));
+        controller?.onDidClose();
+    }
+    _cancelPromptOptionsRefresh(clearGeneratedInput = true) {
+        const shouldClearInput = this._promptOptionsWidget.value?.shouldClearInputForRefresh() ?? false;
+        this._promptTypingAnimation.clear();
+        this._promptOptionsRefresh.value?.cancel();
+        this._promptOptionsRefresh.clear();
+        if (clearGeneratedInput && shouldClearInput) {
+            this._promptTemplatePlaceholder.value?.setPlaceholder(undefined);
+            this._editor.getModel()?.setValue("");
+        }
+    }
+    async refreshPromptOptions(token = CancellationToken.None) {
+        const controller = this._promptOptionsController;
+        if (!controller || !this.preparePromptOptionsRefresh()) {
+            return false;
+        }
+        const cts = ( new CancellationTokenSource(token));
+        this._promptOptionsRefresh.value = cts;
+        const canRerender = () => !this._promptOptionsSelected && !this._promptOptionsWidget.value?.hasFocusedOption();
+        let state;
+        try {
+            state = await controller.resolve(cts.token, progressState => {
+                if (this._promptOptionsRefresh.value !== cts || cts.token.isCancellationRequested || !canRerender()) {
+                    return false;
+                }
+                return this.showPromptOptions(progressState);
+            });
+        } catch (error) {
+            if (this._promptOptionsRefresh.value === cts) {
+                this._promptOptionsRefresh.clear();
+                if (cts.token.isCancellationRequested) {
+                    this.showPromptOptions(undefined);
+                    return false;
+                }
+            }
+            throw error;
+        }
+        if (this._promptOptionsRefresh.value !== cts) {
+            return false;
+        }
+        if (cts.token.isCancellationRequested) {
+            this._promptOptionsRefresh.clear();
+            this.showPromptOptions(undefined);
+            return false;
+        }
+        this._promptOptionsRefresh.clear();
+        if (!canRerender()) {
+            return true;
+        }
+        return this.showPromptOptions(state);
+    }
+    dispose() {
+        this._cancelPromptOptionsRefresh();
+        super.dispose();
+    }
+    get routesWhileSessionActive() {
+        return this.options.voiceRoutesWhileSessionActive === true;
+    }
+    prefillInput(text) {
+        const editor = this._editor;
+        const model = editor?.getModel();
+        if (editor && model) {
+            model.setValue(text);
+            const lastLine = model.getLineCount();
+            const maxColumn = model.getLineMaxColumn(lastLine);
+            editor.setPosition({
+                lineNumber: lastLine,
+                column: maxColumn
+            });
+            editor.focus();
+        }
+    }
+    sendQuery(text) {
+        if (this._sending) {
+            return;
+        }
+        const model = this._editor?.getModel();
+        if (model) {
+            const combined = combineVoiceInput(model.getValue(), text);
+            model.setValue(combined);
+            this._send();
+        }
+    }
+    attach(uris) {
+        this._contextAttachments.addAttachments(...uris.map(uri => toFileVariableEntry(uri)));
+    }
+    attachTextContext(name, content, icon, id = `context:${content}`) {
+        const attachment = toPasteVariableEntry(name, content, {
+            id,
+            icon
+        });
+        const index = this._contextAttachments.attachments.findIndex(entry => entry.id === id);
+        if (index < 0) {
+            this._contextAttachments.addAttachments(attachment);
+        } else {
+            const attachments = [...this._contextAttachments.attachments];
+            attachments[index] = attachment;
+            this._contextAttachments.setAttachments(attachments);
+        }
+    }
+    addAttachments(...attachments) {
+        this._contextAttachments.addAttachments(...attachments);
+    }
+    removeAttachment(id) {
+        this._contextAttachments.removeAttachment(id);
+    }
+    get onDidChangeAttachments() {
+        return this._contextAttachments.onDidChangeContext;
+    }
+    get attachments() {
+        return this._contextAttachments.attachments;
+    }
+    getVoiceModels() {
+        return this._modelSelection.state.get().models;
+    }
+    selectVoiceModel(identifier) {
+        return this._modelSelection.selectModel(identifier);
+    }
+};
+NewChatInputWidget = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IModelService)), ( __param(3, ITextModelService)), ( __param(4, IChatPasteTargetService)), ( __param(5, IConfigurationService)), ( __param(6, IContextKeyService)), ( __param(7, ILogService)), ( __param(8, IHoverService)), ( __param(9, IStorageService)), ( __param(10, IDialogService)), ( __param(11, IKeybindingService)), ( __param(12, IWorkbenchLayoutService)), ( __param(13, IChatSessionsService)), ( __param(14, IChatSpeechToTextService)), ( __param(15, IDictationOnboardingService)), ( __param(16, IChatInputNoticeHubService)), ( __param(17, IChatSubmitRequestHandlerService)), ( __param(18, IContextMenuService)), ( __param(19, ICommandService)), ( __param(20, IVoiceSessionController)), ( __param(21, IVoiceInputModeService)), ( __param(22, IAccessibilityService)), ( __param(23, IVoiceModeOnboardingService)), ( __param(24, INewChatVoiceTargetService)), ( __param(25, IThemeService)), ( __param(26, IChatPetWidgetService)), ( __param(27, IChatInputNotificationService)), ( __param(28, ILanguageModelsService))], NewChatInputWidget));
+
+export { NewChatInputWidget, hasSendableNewChatContent };