@codingame/monaco-vscode-api 37.6.1 → 38.0.1

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

@@ -2,40 +2,53 @@
 import { registerCss } from '../../../../../../../css.js';
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import * as chatWidget from './media/chatWidget.css';
-import { append, $, addDisposableListener, EventType, getWindow, clearNode } from '../../../../base/browser/dom.js';
+import { append, $, addDisposableListener, EventType, getWindow, isHTMLElement, getActiveElement, EventHelper, clearNode } from '../../../../base/browser/dom.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
 import { StandardMouseEvent } from '../../../../base/browser/mouseEvent.js';
-import { Action } from '../../../../base/common/actions.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { Action, toAction } from '../../../../base/common/actions.js';
+import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { toErrorMessage } from '../../../../base/common/errorMessage.js';
 import { isCancellationError, onUnexpectedError } from '../../../../base/common/errors.js';
 import { Event } from '../../../../base/common/event.js';
 import { Disposable, MutableDisposable, DisposableMap, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
 import '../../../../base/common/observableInternal/index.js';
 import { isWeb } from '../../../../base/common/platform.js';
-import { basename } from '../../../../base/common/resources.js';
+import { isEqual, basename } from '../../../../base/common/resources.js';
 import { URI } from '../../../../base/common/uri.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { IMenuService } from '../../../../platform/actions/common/actions.service.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { IContextMenuService } from '../../../../platform/contextview/browser/contextView.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.service.js';
+import { defaultButtonStyles } from '../../../../platform/theme/browser/defaultStyles.js';
 import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.service.js';
 import { IDefaultAccountService } from '../../../../platform/defaultAccount/common/defaultAccount.service.js';
+import { SessionConfigKey } from '../../../../platform/agentHost/common/sessionConfigKeys.js';
+import { deriveGitHubEndpoints } from '../../../../platform/github/common/githubEndpoints.js';
+import { isSuccess, asJson } from '../../../../platform/request/common/request.js';
+import { IRequestService } from '../../../../platform/request/common/request.service.js';
 import { localize } from '../../../../nls.js';
+import { WorkspaceNotTrustedError } from '../../../services/sessions/common/sessionsManagement.js';
 import { ISessionsManagementService } from '../../../services/sessions/common/sessionsManagement.service.js';
 import { SESSION_WORKSPACE_GROUP_GITHUB, GITHUB_REMOTE_FILE_SCHEME } from '../../../services/sessions/common/session.js';
 import { ISessionsService } from '../../../services/sessions/browser/sessionsService.service.js';
 import { ISessionsProvidersService } from '../../../services/sessions/browser/sessionsProvidersService.service.js';
 import { shouldShowGitHubWorkspaceGroupSignIn, isAllowSignedOutWhenUsableEnabled } from '../../../browser/sessionsAuthGate.js';
-import { AGENTIC_SIGN_IN_COMMAND_ID } from '../../../common/sessionCommands.js';
-import { isAgentHostProvider } from '../../../common/agentHostSessionsProvider.js';
+import { AGENTIC_SIGN_IN_COMMAND_ID, FOCUS_NEW_SESSION_HARNESS_PICKER_COMMAND_ID, FOCUS_NEW_SESSION_WORKSPACE_PICKER_COMMAND_ID } from '../../../common/sessionCommands.js';
+import { isAgentHostProvider, LOCAL_AGENT_HOST_PROVIDER_ID } from '../../../common/agentHostSessionsProvider.js';
+import { NewSessionCreationProviderIdContext, IsPhoneLayoutContext } from '../../../common/contextkeys.js';
 import { IAquariumService } from '../../aquarium/browser/aquariumOverlay.service.js';
 import { WorkspacePicker } from './sessionWorkspacePicker.js';
 import { WebWorkspacePicker } from './webWorkspacePicker.js';
-import { NewChatInputWidget } from './newChatInput.js';
+import { NewChatInputWidget, NEW_SESSION_PROMPT_PLACEHOLDER, getLabeledPickerResponsiveItems } from './newChatInput.js';
+import { ChatInputPickerResponsiveLayout } from '../../../../workbench/contrib/chat/browser/widget/input/chatInputPickerResponsiveLayout.js';
 import { NoAgentHostEmptyState } from './noAgentHostEmptyState.js';
 import { IAgentHostFilterService } from '../../../services/agentHostFilter/common/agentHostFilter.service.js';
 import { WorkspaceSelectionOrigin } from '../../../common/workspaceSelection.js';
-import { SessionWorkspacePickerVisibleContext } from '../../../common/contextkeys.js';
+import { noSessionPickerVisibility } from '../../../services/sessions/common/sessionPickerVisibility.js';
 import { AGENT_FEEDBACK_NEW_SESSION_RESOURCE } from '../../agentFeedback/browser/agentFeedbackService.js';
 import { IAgentFeedbackService } from '../../agentFeedback/browser/agentFeedbackService.service.js';
 import { buildNewSessionPrompt } from '../../agentFeedback/browser/agentFeedbackAttachmentEntry.js';
@@ -48,15 +61,32 @@ import { IChatTipService } from '../../../../workbench/contrib/chat/browser/chat
 import { ChatContextKeys } from '../../../../workbench/contrib/chat/common/actions/chatContextKeys.js';
 import { ChatModeKind } from '../../../../workbench/contrib/chat/common/constants.js';
 import { IOpenerService } from '../../../../platform/opener/common/opener.service.js';
-import { StorageScope } from '../../../../platform/storage/common/storage.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { IStorageService } from '../../../../platform/storage/common/storage.service.js';
-import { TOTAL_SESSIONS_KEY } from '../../sessions/browser/sessionsLifecycleTracker.js';
+import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.service.js';
+import { logSettingExperimentTrigger } from '../../../../platform/telemetry/common/experimentTrigger.js';
+import { AgentsWindowUsage } from '../../../../workbench/contrib/chat/common/agentsWindowUsage.js';
 import { NewSessionWorkspacePreselectionSource } from './newSessionComposerService.js';
 import { INewSessionComposerService } from './newSessionComposerService.service.js';
 import { Menus } from '../../../browser/menus.js';
 import { getAdditionalFolderContextId, getAdditionalRepositoryContextId } from '../common/newChatContextIds.js';
-import { UNIFIED_WORKSPACE_PICKER_SETTING } from '../common/constants.js';
+import { UNIFIED_WORKSPACE_PICKER_SETTING, EXPERIMENTAL_NEW_SESSION_COMPOSER_LAYOUT_SETTING, NEW_SESSION_WELCOME_PHRASES_SETTING, AGENTS_PICKER_IN_ATTACH_CONTEXT_MENU_SETTING, COLLAPSED_SESSION_OPTIONS_SHOW_ICONS_SETTING, NEW_SESSION_WELCOME_NAME_SETTING, NEW_SESSION_WELCOME_MESSAGES_SETTING, NEW_SESSION_COMPOSER_OPTIONS_EXPANDED_SETTING, COMPARE_AGENTS_OPEN_IN_GRID_SETTING } from '../common/constants.js';
+import { getNewSessionWelcomePhrases } from '../common/welcomePhrases.js';
 import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { COMPARE_AGENTS_ENABLED_SETTING, getSessionComparisonWorkspaceError } from '../../../services/sessions/common/sessionComparison.js';
+import { ISessionComparisonService } from '../../../services/sessions/common/sessionComparison.service.js';
+import { OPEN_SESSION_COMPARISON_COMMAND_ID } from '../../sessionComparison/common/sessionComparison.js';
+import { SessionComparisonModelSelection } from './sessionComparisonModelSelection.js';
+import { isAutoModel, isHydraFusionModel } from '../../../../workbench/contrib/chat/browser/widget/input/modelPicker/modelPickerPresentation.js';
+import { reviveChatDraft } from '../../../../workbench/contrib/chat/common/attachments/chatDraft.js';
+import { NewChatMigrationNotice } from './newChatMigrationNotice.js';
+import { FOCUS_NEW_SESSION_HARNESS_PICKER_WHEN, FOCUS_NEW_SESSION_WORKSPACE_PICKER_WHEN } from './newChatPickerKeybinding.js';
+import { IAuthenticationService } from '../../../../workbench/services/authentication/common/authentication.service.js';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '../../../../platform/actions/browser/toolbar.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.service.js';
+import { AccessibilityVerbositySettingId } from '../../../../workbench/contrib/accessibility/browser/accessibilityConfiguration.js';
+import { ISessionsRecentWorkspacesService } from '../../../services/sessions/browser/sessionsRecentWorkspacesService.service.js';
+import { disposableObservableValue, observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 import { derivedObservableWithCache } from '../../../../base/common/observableInternal/utils/utils.js';
 import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
 import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
@@ -64,20 +94,59 @@ import { observableSignalFromEvent } from '../../../../base/common/observableInt
 import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
 import { AgentFeedbackState } from '../../agentFeedback/browser/agentFeedbackModel.js';
 import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
+import { waitForState } from '../../../../base/common/observableInternal/utils/utilsCancellation.js';
 
+var NewChatWidget_1;
 registerCss(chatWidget, 1);
 const MIN_SESSIONS_FOR_FIRST_RUN_NOTICES = 2;
-let NewChatWidget = class NewChatWidget extends Disposable {
+const SESSION_OPTIONS_EXPANDED_STORAGE_KEY = "agentSessions.newSession.sessionOptionsExpanded2";
+let sessionOptionsIdPool = 0;
+let nextNewSessionWelcomePhraseIndex = 0;
+const githubProfileNames = ( new Map());
+function getComparisonSelectedWorkspaceFolder(selectedWorkspace, selectedFolderUri) {
+    if (!selectedFolderUri) {
+        return selectedWorkspace?.folders[0];
+    }
+    return selectedWorkspace?.folders.find(folder => isEqual(folder.root, selectedFolderUri));
+}
+function getComparisonSessionFolder(session, selectedFolderUri) {
+    if (!selectedFolderUri) {
+        return session?.workspace.get()?.folders[0];
+    }
+    return session?.workspace.get()?.folders.find(folder => isEqual(folder.root, selectedFolderUri));
+}
+function getComparisonHasGitRemote(session, selectedWorkspace, selectedFolderUri) {
+    const selectedWorkspaceHasGitRemote = getComparisonSelectedWorkspaceFolder(selectedWorkspace, selectedFolderUri)?.gitRepository?.hasGitRemote;
+    if (selectedWorkspaceHasGitRemote !== undefined) {
+        return selectedWorkspaceHasGitRemote;
+    }
+    return getComparisonSessionFolder(session, selectedFolderUri)?.gitRepository?.hasGitRemote;
+}
+function isExperimentalSessionComposerLayoutEnabled(configurationService) {
+    return configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING) && configurationService.getValue(EXPERIMENTAL_NEW_SESSION_COMPOSER_LAYOUT_SETTING);
+}
+function areNewSessionWelcomePhrasesEnabled(configurationService) {
+    return configurationService.getValue(NEW_SESSION_WELCOME_PHRASES_SETTING);
+}
+let NewChatWidget = NewChatWidget_1 = class NewChatWidget extends Disposable {
+    static _takeNextWelcomePhraseIndex() {
+        const index = nextNewSessionWelcomePhraseIndex;
+        nextNewSessionWelcomePhraseIndex = index + 1 < Number.MAX_SAFE_INTEGER ? index + 1 : 0;
+        return index;
+    }
     constructor(
         options,
         instantiationService,
         contextKeyService,
+        menuService,
         contextMenuService,
         configurationService,
+        accessibilityService,
         logService,
         sessionsManagementService,
         sessionsService,
         sessionsProvidersService,
+        recentWorkspacesService,
         aquariumService,
         agentHostFilterService,
         uriIdentityService,
@@ -86,9 +155,14 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         chatTipService,
         openerService,
         defaultAccountService,
+        authenticationService,
+        requestService,
         storageService,
         newSessionComposerService,
-        commandService
+        commandService,
+        sessionComparisonService,
+        notificationService,
+        telemetryService
     ) {
         super();
         this.options = options;
@@ -96,10 +170,12 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         this.contextKeyService = contextKeyService;
         this.contextMenuService = contextMenuService;
         this.configurationService = configurationService;
+        this.accessibilityService = accessibilityService;
         this.logService = logService;
         this.sessionsManagementService = sessionsManagementService;
         this.sessionsService = sessionsService;
         this.sessionsProvidersService = sessionsProvidersService;
+        this.recentWorkspacesService = recentWorkspacesService;
         this.aquariumService = aquariumService;
         this.agentHostFilterService = agentHostFilterService;
         this.uriIdentityService = uriIdentityService;
@@ -108,18 +184,32 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         this.chatTipService = chatTipService;
         this.openerService = openerService;
         this.defaultAccountService = defaultAccountService;
+        this.authenticationService = authenticationService;
+        this.requestService = requestService;
         this.storageService = storageService;
         this.newSessionComposerService = newSessionComposerService;
         this.commandService = commandService;
+        this.sessionComparisonService = sessionComparisonService;
+        this.notificationService = notificationService;
+        this.telemetryService = telemetryService;
         this._chatTipPresenter = this._register(( new MutableDisposable()));
         this._isChatTipSessionInitialized = false;
         this._pendingPreferredUpgrade = ( new MutableDisposable());
         this._newSessionCreation = ( new MutableDisposable());
+        this._noWorkspaceRestore = this._register(( new MutableDisposable()));
+        this._activeEmptyState = this._register(disposableObservableValue(this, undefined));
+        this._sessionOptionsExpanded = observableValue(this, true);
         this._pendingBackgroundSends = this._register(( new DisposableMap()));
-        this._workspacePickerVisibleKey = SessionWorkspacePickerVisibleContext.bindTo(contextKeyService);
-        this._register(toDisposable(() => this._workspacePickerVisibleKey.reset()));
+        this._welcomePhraseIndex = NewChatWidget_1._takeNextWelcomePhraseIndex();
+        this._githubProfileName = observableValue(this, undefined);
+        this._welcomePhraseAnnounced = false;
+        this._newSessionAttachContextMenu = this._register(
+            menuService.createMenu(Menus.NewSessionAttachContext, this.contextKeyService)
+        );
+        this._usage = ( new AgentsWindowUsage(storageService));
         this._register(this._pendingPreferredUpgrade);
         this._register(this._newSessionCreation);
+        this._restoreSessionOptionsExpanded();
         this._session = derivedObservableWithCache(this, (reader, prev) => {
             const activeSession = this.sessionsService.activeSession.read(reader);
             if (activeSession && activeSession.isCreated.read(reader)) {
@@ -135,21 +225,50 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             this.configurationService.onDidChangeConfiguration,
             event => event.affectsConfiguration(UNIFIED_WORKSPACE_PICKER_SETTING)
         ), () => this.configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING));
+        this._compareAgentsEnabled = observableFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(COMPARE_AGENTS_ENABLED_SETTING)
+        ), () => this.configurationService.getValue(COMPARE_AGENTS_ENABLED_SETTING));
+        this._useExperimentalComposerLayout = observableFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(UNIFIED_WORKSPACE_PICKER_SETTING) || event.affectsConfiguration(EXPERIMENTAL_NEW_SESSION_COMPOSER_LAYOUT_SETTING)
+        ), () => isExperimentalSessionComposerLayoutEnabled(this.configurationService));
+        this._agentsPickerInAttachContextMenu = observableFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(AGENTS_PICKER_IN_ATTACH_CONTEXT_MENU_SETTING)
+        ), () => this.configurationService.getValue(AGENTS_PICKER_IN_ATTACH_CONTEXT_MENU_SETTING));
+        this._screenReaderOptimized = observableFromEvent(
+            this,
+            this.accessibilityService.onDidChangeScreenReaderOptimized,
+            () => this.accessibilityService.isScreenReaderOptimized()
+        );
+        this._collapsedSessionOptionsShowIcons = observableFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(COLLAPSED_SESSION_OPTIONS_SHOW_ICONS_SETTING)
+        ), () => this.configurationService.getValue(COLLAPSED_SESSION_OPTIONS_SHOW_ICONS_SETTING));
+        this._showWelcomePhrases = observableFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(NEW_SESSION_WELCOME_PHRASES_SETTING)
+        ), () => areNewSessionWelcomePhrasesEnabled(this.configurationService));
         this._isWorkspacePickerQuickChat = derived(this, reader => {
             const session = this._session.read(reader);
             return this._useConsolidatedRemoteWorkspaces.read(reader) && !!session?.isQuickChat?.read(reader);
         });
         const PickerCtor = isWeb ? WebWorkspacePicker : WorkspacePicker;
         this._workspacePicker = this._register(this.instantiationService.createInstance(PickerCtor, {
-            canRestoreWorkspace: () => !this._isQuickChatComposer.get(),
+            canRestoreWorkspace: () => !this._isQuickChatComposer.get() || this._newChatInput?.canApplyWorkspaceDefault === true,
             onUserSelection: () => newSessionComposerService.notifyUserWorkspaceSelection(),
+            whenSelectionAccepted: async () => {
+                const session = this._pendingWorkspaceCreation ? (await this._pendingWorkspaceCreation).session : this._session.get();
+                return !!session && this._session.get()?.sessionId === session.sessionId;
+            },
             getWorkspaceGroupAction: group => {
                 if (group === SESSION_WORKSPACE_GROUP_GITHUB && shouldShowGitHubWorkspaceGroupSignIn(
                     this.defaultAccountService.currentDefaultAccount !== null,
                     isAllowSignedOutWhenUsableEnabled(this.configurationService)
                 )) {
                     return {
-                        label: ( localize(3746, "Sign in to GitHub")),
+                        label: ( localize(4212, "Sign in to GitHub")),
                         icon: Codicon.signIn,
                         commandId: AGENTIC_SIGN_IN_COMMAND_ID,
                         hideWorkspaceItems: true
@@ -163,6 +282,8 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         this._register(autorun(reader => {
             providersChanged.read(reader);
             const activeSession = this._session.read(reader);
+            activeSession?.isQuickChat?.read(reader);
+            this._workspacePicker.refreshTriggerLabel();
             if (!activeSession) {
                 return;
             }
@@ -182,6 +303,21 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             feedbackChanged.read(reader);
             return this.agentFeedbackService.getFeedback(AGENT_FEEDBACK_NEW_SESSION_RESOURCE).filter(item => item.state === AgentFeedbackState.Accepted);
         });
+        const comparisonWorkspaceChanged = observableSignalFromEvent(this, this._workspacePicker.onDidChangeSelection);
+        const comparisonConfigResolving = derived(this, reader => {
+            const session = this._session.read(reader);
+            const provider = session ? this.sessionsProvidersService.getProvider(session.providerId) : undefined;
+            return !!session && !!provider && isAgentHostProvider(provider) && provider.isSessionConfigResolving(session.sessionId).read(reader);
+        });
+        this._comparisonSelection = this._register(( new SessionComparisonModelSelection(derived(this, reader => {
+            comparisonWorkspaceChanged.read(reader);
+            comparisonConfigResolving.read(reader);
+            this._compareAgentsEnabled.read(reader);
+            const session = this._session.read(reader);
+            session?.workspace.read(reader);
+            session?.loading.read(reader);
+            return !this._isQuickChatComposer.read(reader) && this._shouldShowComparisonAction();
+        }), comparisonConfigResolving)));
         const canSendRequest = derived(reader => {
             const session = this._session.read(reader);
             if (!session) {
@@ -190,7 +326,7 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             if (session.loading.read(reader)) {
                 return false;
             }
-            return true;
+            return !this._comparisonSelection.enabled.read(reader) || this._comparisonSelection.available.read(reader) && this._comparisonSelection.configured.read(reader);
         });
         const loading = derived(reader => {
             const session = this._session.read(reader);
@@ -200,13 +336,23 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         const canSubmitWithoutSession = derived(this, reader => !this._session.read(reader));
         const deferredNotificationsEnabled = observableFromEvent(
             this,
-            this.storageService.onDidChangeValue(StorageScope.APPLICATION, TOTAL_SESSIONS_KEY, this._store),
+            this._usage.onDidChangeCreatedSessionCount(this._store),
             () => this._hasEnoughSessionsForFirstRunNotices()
         );
+        const creationProviderId = observableFromEvent(
+            this,
+            this.agentHostFilterService.onDidChange,
+            () => isWeb ? this.agentHostFilterService.selectedHost?.sessionCreationProviderId : undefined
+        );
+        const creationProviderKey = NewSessionCreationProviderIdContext.bindTo(contextKeyService);
+        this._register(
+            autorun(reader => creationProviderKey.set(creationProviderId.read(reader) ?? ""))
+        );
+        this._register(toDisposable(() => creationProviderKey.reset()));
         const newChatInput = this.instantiationService.createInstance(NewChatInputWidget, {
             session: this._session,
             getContextFolderUri: () => this._getContextFolderUri(),
-            getContextPickerActions: () => this._workspacePicker.getContextPickerActions(),
+            getContextPickerActions: () => this._getContextPickerActions(),
             getWorkspacePreselectionSource: () => this._isQuickChatComposer.get() ? NewSessionWorkspacePreselectionSource.None : this._workspacePicker.preselectionSource,
             getWorkspaceSelection: () => this._isQuickChatComposer.get() ? {
                 ...this._workspacePicker.selectionSnapshot,
@@ -223,26 +369,66 @@ let NewChatWidget = class NewChatWidget extends Disposable {
                 {
                     query,
                     attachments,
-                    background
+                    background,
+                    userInteraction
                 }
-            ) => this._send(query, attachments, background),
+            ) => this._send(query, attachments, background, userInteraction),
+            clearInputOnSendStart: () => this._comparisonSelection.enabled.get(),
+            modelPickerWorkflow: this._comparisonSelection,
+            sendButtonLabel: derived(
+                this,
+                reader => this._comparisonSelection.enabled.read(reader) ? ( localize(
+                    4213,
+                    "Run {0} Attempts",
+                    this._comparisonSelection.attemptModelIds.read(reader).length
+                )) : undefined
+            ),
+            inputVisible: this.options.inputVisible,
+            hostVisible: this.options.hostVisible,
             canSendRequest,
             canSubmitWithoutSession,
             hasAdditionalSendContent: hasFeedback,
             loading,
+            useExperimentalLayout: this._useExperimentalComposerLayout,
             historyKey: constObservable(undefined),
-            placeholder: ( localize(3747, "Pitch your idea")),
+            placeholder: NEW_SESSION_PROMPT_PLACEHOLDER,
             supportsBackground: true,
             deferredNotificationsEnabled,
             petHostPreferred: this.options.petHostPreferred,
             getChatPetPlatformElements: () => this._workspacePicker.getChatPetPlatformElements(),
             onDidChangeChatPetPlatform: this._workspacePicker.onDidChangeChatPetPlatform,
             sessionTypePickerOptions: {
-                prepareSessionTypeSelection: pick => this._prepareSessionTypeSelection(pick)
+                providerId: creationProviderId,
+                prepareSessionTypeSelection: pick => this._prepareSessionTypeSelection(pick),
+                focusCommand: {
+                    id: FOCUS_NEW_SESSION_HARNESS_PICKER_COMMAND_ID,
+                    label: ( localize(4214, "Choose the harness for the new session")),
+                    when: FOCUS_NEW_SESSION_HARNESS_PICKER_WHEN,
+                    enabled: this._useConsolidatedRemoteWorkspaces
+                }
             }
         });
         this._register(toDisposable(() => newChatInput.saveState()));
         this._newChatInput = this._register(newChatInput);
+        let comparisonHarness;
+        this._register(autorun(reader => {
+            const session = this._session.read(reader);
+            const harness = session ? JSON.stringify([session.providerId, session.sessionType]) : undefined;
+            if (harness !== comparisonHarness) {
+                this._comparisonSelection.reset();
+                comparisonHarness = harness;
+            }
+            const state = newChatInput.selectedModelState.read(reader);
+            if (!session?.loading.read(reader) && !comparisonConfigResolving.read(reader)) {
+                this._comparisonSelection.retainModels(( new Set(
+                    state.models.filter(model => !isAutoModel(model) && !isHydraFusionModel(model)).map(model => model.identifier)
+                )));
+            }
+        }));
+        this.pickerVisibility = derived(
+            this,
+            reader => this._activeEmptyState.read(reader) ? noSessionPickerVisibility : newChatInput.pickerVisibility.visibility.read(reader)
+        );
         const workspacePickerSelectionChanged = observableSignalFromEvent(this, this._workspacePicker.onDidChangeSelection);
         this._newChatInput.sessionTypePicker.setSessionWorkspaceFolderSource(derived(this, reader => {
             workspacePickerSelectionChanged.read(reader);
@@ -272,7 +458,9 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             }
         }));
         this._register(this._workspacePicker.onDidSelectWorkspace(async folderUri => {
-            await this._onWorkspaceSelected(folderUri);
+            if (!this._isCurrentWorkspaceSelection(folderUri)) {
+                await this._onWorkspaceSelected(folderUri);
+            }
             this._newChatInput.focus();
         }));
         this._register(this._workspacePicker.onDidSelectWorkspaceMode((
@@ -354,7 +542,7 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             }
         }));
         this._register(
-            this.storageService.onDidChangeValue(StorageScope.APPLICATION, TOTAL_SESSIONS_KEY, this._store)(() => this._renderChatTip())
+            this._usage.onDidChangeCreatedSessionCount(this._store)(() => this._renderChatTip())
         );
         const foregroundSessionCountContextKeys = ( new Set([ChatContextKeys.foregroundSessionCount.key]));
         this._register(this.contextKeyService.onDidChangeContext(e => {
@@ -380,6 +568,30 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             this._syncWorkspacePickerFromSessionWorkspace(workspace);
         }));
     }
+    _getContextPickerActions() {
+        const actions = this._workspacePicker.getContextPickerActions();
+        const session = this._session.get();
+        const provider = session ? this.sessionsProvidersService.getProvider(session.providerId) : undefined;
+        if (!session || !provider || !isAgentHostProvider(provider) || this.contextKeyService.getContextKeyValue(IsPhoneLayoutContext.key)) {
+            return actions;
+        }
+        logSettingExperimentTrigger(this.telemetryService, AGENTS_PICKER_IN_ATTACH_CONTEXT_MENU_SETTING);
+        if (!this._agentsPickerInAttachContextMenu.get()) {
+            return actions;
+        }
+        const agentAction = this._newSessionAttachContextMenu.getActions({
+            shouldForwardArgs: true
+        }).flatMap(([, menuActions]) => menuActions).find(action => action.id === "sessions.agentHost.agentPicker");
+        if (!agentAction) {
+            return actions;
+        }
+        return [{
+            label: ( localize(4215, "Agent...")),
+            icon: Codicon.agent,
+            placement: "top",
+            run: async () => this._newChatInput.runAttachContextAction(agentAction)
+        }, ...actions];
+    }
     _syncWorkspacePickerFromSessionWorkspace(workspace) {
         const folderUri = workspace?.folders[0]?.root;
         if (folderUri && !this._workspacePicker.matchesSelectedWorkspace(workspace)) {
@@ -407,9 +619,72 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             chatWidgetContainer,
             $(`.new-chat-widget-content.${chatInputStackClass}`)
         );
+        const welcomeMessage = append(chatWidgetContent, $(".new-session-welcome-message"));
+        const welcomeMessageTitle = append(welcomeMessage, $("h2.new-session-welcome-message-title"));
+        const welcomeMessageActions = append(welcomeMessage, $(".new-session-welcome-message-actions"));
+        this._register(
+            this.instantiationService.createInstance(MenuWorkbenchToolBar, welcomeMessageActions, Menus.NewSessionWelcome, {
+                ariaLabel: ( localize(4216, "Welcome message actions")),
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                toolbarOptions: {
+                    primaryGroup: () => true
+                },
+                telemetrySource: "newSessionWelcome",
+                menuOptions: {
+                    arg: welcomeMessageActions
+                }
+            })
+        );
+        this._register(
+            addDisposableListener(welcomeMessage, EventType.CONTEXT_MENU, event => {
+                event.preventDefault();
+                event.stopPropagation();
+                const mouseEvent = ( new StandardMouseEvent(getWindow(welcomeMessage), event));
+                this.contextMenuService.showContextMenu({
+                    getAnchor: () => mouseEvent,
+                    menuId: Menus.NewSessionWelcomeContext,
+                    contextKeyService: this.contextKeyService
+                });
+            })
+        );
+        const configuredWelcomeNameChanged = observableSignalFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(NEW_SESSION_WELCOME_NAME_SETTING)
+        ));
+        const configuredWelcomeMessagesChanged = observableSignalFromEvent(this, Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(NEW_SESSION_WELCOME_MESSAGES_SETTING)
+        ));
+        this._register(autorun(reader => {
+            configuredWelcomeNameChanged.read(reader);
+            this._showWelcomePhrases.read(reader);
+            void this._refreshGitHubProfileName();
+        }));
+        this._register(autorun(reader => {
+            configuredWelcomeNameChanged.read(reader);
+            configuredWelcomeMessagesChanged.read(reader);
+            const profileName = this._githubProfileName.read(reader);
+            const inputVisible = this.options.inputVisible?.read(reader) ?? true;
+            const phrases = getNewSessionWelcomePhrases(
+                this.configurationService.getValue(NEW_SESSION_WELCOME_MESSAGES_SETTING),
+                this._getWelcomeName(profileName)
+            );
+            const phrase = this._updateWelcomeMessage(
+                welcomeMessage,
+                welcomeMessageTitle,
+                this._showWelcomePhrases.read(reader),
+                phrases,
+                this._welcomePhraseIndex
+            );
+            chatWidgetContent.classList.toggle("welcome-phrases-visible", !!phrase);
+            this._announceWelcomeMessage(phrase, inputVisible);
+        }));
+        this._register(
+            this.defaultAccountService.onDidChangeDefaultAccount(() => void this._refreshGitHubProfileName())
+        );
         this._aquariumToggle = this._register(this.aquariumService.mountToggle(element));
-        const aquariumAction = this._register(( new Action("sessions.aquarium.showAction", ( localize(3748, "Aquarium")), undefined, true, () => this.aquariumService.toggleActionVisibility())));
-        const petAction = this._register(( new Action("sessions.chatPet.toggle", ( localize(3749, "Pet (/vscode-pet)")), undefined, true, () => this.chatPetService.toggle())));
+        const aquariumAction = this._register(( new Action("sessions.aquarium.showAction", ( localize(4217, "Aquarium")), undefined, true, () => this.aquariumService.toggleActionVisibility())));
+        const petAction = this._register(( new Action("sessions.chatPet.toggle", ( localize(4218, "Pet (/vscode-pet)")), undefined, true, () => this.chatPetService.toggle())));
         this._register(addDisposableListener(element, EventType.CONTEXT_MENU, e => {
             const target = e.target;
             if (target && chatWidgetContent.contains(target)) {
@@ -440,8 +715,30 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         }
         this._renderFeedbackBanner(chatWidgetContent);
         this._newChatInput.render(chatWidgetContent, parent);
-        const chatTipContainer = this._newChatInput.gettingStartedTipContainerElement;
-        this._chatTipPresenter.value = chatTipContainer && this.instantiationService.createInstance(ChatInputTipPresenter, {
+        this._register(autorun(reader => {
+            const useExperimentalLayout = this._useExperimentalComposerLayout.read(reader);
+            const isQuickChat = this._isQuickChatComposer.read(reader);
+            const isWorkspacePickerQuickChat = this._isWorkspacePickerQuickChat.read(reader);
+            chatWidgetContent.classList.toggle("experimental-new-session-composer", useExperimentalLayout);
+            this._newChatInput.placeRepositoryControls(
+                useExperimentalLayout && (!isQuickChat || isWorkspacePickerQuickChat) ? this._workspaceRepositoryControlsHost : undefined
+            );
+        }));
+        this._register(this.instantiationService.createInstance(
+            NewChatMigrationNotice,
+            chatWidgetContent,
+            this._session,
+            () => this.focusInput()
+        ));
+        const inputTipSlot = this._newChatInput.gettingStartedTipContainerElement;
+        const tipBelowHost = append(chatWidgetContent, $(
+            ".new-session-getting-started-tip-below.chat-getting-started-tip-container"
+        ));
+        const chatTipContainer = $(".new-session-getting-started-tip");
+        this._register(autorun(reader => {
+            (this._useExperimentalComposerLayout.read(reader) ? tipBelowHost : inputTipSlot)?.appendChild(chatTipContainer);
+        }));
+        this._chatTipPresenter.value = this.instantiationService.createInstance(ChatInputTipPresenter, {
             container: chatTipContainer,
             onBeforeUpdate: () => {
                 if (this.contextKeyService.getContextKeyValue(ChatContextKeys.foregroundSessionCount.key) !== 0) {
@@ -460,15 +757,22 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             chatWidgetContent.classList.toggle("quick-chat", isQuickChat && !isWorkspacePickerQuickChat);
             this._workspacePicker.refreshPresentation();
             if (!isWeb) {
-                this._workspacePickerVisibleKey.set(!isQuickChat || isWorkspacePickerQuickChat);
+                this._newChatInput.pickerVisibility.setVisible("workspace", !isQuickChat || isWorkspacePickerQuickChat);
             }
         }));
         if (!isWeb) {
             this._register(autorun(reader => {
                 const isQuickChat = this._isQuickChatComposer.read(reader);
                 const isWorkspacePickerQuickChat = this._isWorkspacePickerQuickChat.read(reader);
+                this._compareAgentsEnabled.read(reader);
+                const session = this._session.read(reader);
+                session?.loading.read(reader);
+                const provider = session ? this.sessionsProvidersService.getProvider(session.providerId) : undefined;
+                if (session && provider && isAgentHostProvider(provider)) {
+                    provider.isSessionConfigResolving(session.sessionId).read(reader);
+                }
                 const useHeaderHost = isQuickChat && !isWorkspacePickerQuickChat;
-                const target = useHeaderHost ? this._quickChatHeaderPickerHost : this._workspacePickerRow;
+                const target = useHeaderHost ? this._quickChatHeaderPickerHost : this._workspaceSessionOptionsHost;
                 if (!target) {
                     return;
                 }
@@ -530,6 +834,114 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             return false;
         }
     }
+    _getWelcomeName(
+        gitHubName,
+        configuredName = this.configurationService.getValue(NEW_SESSION_WELCOME_NAME_SETTING).trim()
+    ) {
+        return configuredName.trim() || this._getFirstName(gitHubName);
+    }
+    _getFirstName(name) {
+        return name?.trim().split(/\s+/u)[0] || undefined;
+    }
+    async _refreshGitHubProfileName() {
+        if (!areNewSessionWelcomePhrasesEnabled(this.configurationService) || this.configurationService.getValue(NEW_SESSION_WELCOME_NAME_SETTING).trim()) {
+            this._githubProfileAccountKey = undefined;
+            this._githubProfileName.set(undefined, undefined);
+            return;
+        }
+        const account = this.defaultAccountService.currentDefaultAccount ?? (await this.defaultAccountService.getDefaultAccount());
+        if (!areNewSessionWelcomePhrasesEnabled(this.configurationService) || this.configurationService.getValue(NEW_SESSION_WELCOME_NAME_SETTING).trim()) {
+            this._githubProfileAccountKey = undefined;
+            this._githubProfileName.set(undefined, undefined);
+            return;
+        }
+        if (account?.authenticationProvider.id !== "github" && account?.authenticationProvider.id !== "github-enterprise") {
+            this._githubProfileAccountKey = undefined;
+            this._githubProfileName.set(undefined, undefined);
+            return;
+        }
+        const accountKey = `${account.authenticationProvider.id}:${account.sessionId}`;
+        if (this._githubProfileAccountKey !== accountKey) {
+            this._githubProfileAccountKey = accountKey;
+            this._githubProfileName.set(undefined, undefined);
+        }
+        let profileName = githubProfileNames.get(accountKey);
+        if (!profileName) {
+            profileName = this._fetchGitHubProfileName(
+                account.authenticationProvider.id,
+                account.authenticationProvider.enterprise,
+                account.sessionId
+            );
+            githubProfileNames.set(accountKey, profileName);
+        }
+        const resolvedProfileName = await profileName;
+        const currentAccount = this.defaultAccountService.currentDefaultAccount;
+        if (this._githubProfileAccountKey === accountKey && currentAccount?.authenticationProvider.id === account.authenticationProvider.id && currentAccount.sessionId === account.sessionId && areNewSessionWelcomePhrasesEnabled(this.configurationService) && !this.configurationService.getValue(NEW_SESSION_WELCOME_NAME_SETTING).trim()) {
+            this._githubProfileName.set(resolvedProfileName, undefined);
+        }
+    }
+    async _fetchGitHubProfileName(providerId, enterprise, sessionId) {
+        try {
+            const enterpriseUri = enterprise ? this.defaultAccountService.resolveGitHubUrl("") : undefined;
+            if (enterprise && !enterpriseUri) {
+                this.logService.warn(
+                    "Failed to fetch GitHub profile name because the enterprise URL is unavailable."
+                );
+                return undefined;
+            }
+            const sessions = await this.authenticationService.getSessions(providerId, [], {
+                silent: true
+            });
+            const session = sessions.find(candidate => candidate.id === sessionId);
+            if (!session) {
+                return undefined;
+            }
+            const response = await this.requestService.request({
+                type: "GET",
+                url: `${deriveGitHubEndpoints(enterpriseUri).apiBaseUri}/user`,
+                disableCache: true,
+                callSite: "newChatWidget.fetchGitHubProfileName",
+                headers: {
+                    "Authorization": `token ${session.accessToken}`,
+                    "Accept": "application/vnd.github.v3+json",
+                    "User-Agent": "VSCode-Sessions"
+                }
+            }, CancellationToken.None);
+            if (!isSuccess(response)) {
+                this.logService.warn(
+                    `Failed to fetch GitHub profile name: ${response.res.statusCode ?? "unknown status"}`
+                );
+                return undefined;
+            }
+            const profile = await asJson(response);
+            return profile?.name?.trim() || undefined;
+        } catch (error) {
+            this.logService.warn("Failed to fetch GitHub profile name:", error);
+            return undefined;
+        }
+    }
+    _updateWelcomeMessage(container, title, visible, phrases, phraseIndex) {
+        container.hidden = !visible;
+        if (!visible || phrases.length === 0) {
+            title.textContent = "";
+            return undefined;
+        }
+        const phrase = phrases[phraseIndex % phrases.length];
+        title.textContent = phrase;
+        return phrase;
+    }
+    _announceWelcomeMessage(phrase, inputVisible) {
+        if (!phrase || !inputVisible || this._welcomePhraseAnnounced || !this.accessibilityService.isScreenReaderOptimized() || !this.configurationService.getValue(AccessibilityVerbositySettingId.NewSessionWelcome)) {
+            return;
+        }
+        this._welcomePhraseAnnounced = true;
+        this.accessibilityService.status(( localize(
+            4219,
+            "{0}\nTo disable this announcement, set {1} to false.",
+            phrase,
+            AccessibilityVerbositySettingId.NewSessionWelcome
+        )));
+    }
     _renderChatTip() {
         this._chatTipPresenter.value?.update();
     }
@@ -537,25 +949,52 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         this._chatTipPresenter.value?.clear();
     }
     _hasEnoughSessionsForFirstRunNotices() {
-        return this.storageService.getNumber(TOTAL_SESSIONS_KEY, StorageScope.APPLICATION, 0) >= MIN_SESSIONS_FOR_FIRST_RUN_NOTICES;
+        return this._usage.createdSessionCount >= MIN_SESSIONS_FOR_FIRST_RUN_NOTICES;
     }
     _seedWorkspaceDraft() {
         const restoredFolderUri = this._workspacePicker.selectedFolderUri;
         if (this._syncWorkspacePickerFromActiveSession()) {
             return;
         }
-        if (!this._restoreNoWorkspaceDraft() && restoredFolderUri) {
+        if (restoredFolderUri) {
             void this._createNewSession(restoredFolderUri);
+        } else {
+            void this._restoreNoWorkspaceDraft();
         }
     }
-    _restoreNoWorkspaceDraft() {
-        if (this._session.get() || !this._workspacePicker.isNoWorkspaceSelected()) {
-            return false;
-        }
-        if (this.sessionsManagementService.isQuickChatTargetAvailable()) {
-            this.selectNoWorkspace();
+    async _restoreNoWorkspaceDraft() {
+        const cancellation = ( new CancellationTokenSource());
+        const lifetime = toDisposable(() => cancellation.dispose(true));
+        this._noWorkspaceRestore.value = lifetime;
+        try {
+            await waitForState(
+                this.sessionsService.initialRestoreComplete,
+                complete => complete,
+                undefined,
+                cancellation.token
+            );
+            if (!this._workspacePicker.isNoWorkspaceSelected() && !(await this._workspacePicker.whenWorkspaceRestored(cancellation.token))) {
+                return;
+            }
+            if (cancellation.token.isCancellationRequested || this.sessionsService.activeSession.get() || this._newSessionCreation.value || this._workspacePicker.selectedFolderUri) {
+                return;
+            }
+            if (this.sessionsManagementService.isQuickChatTargetAvailable()) {
+                if (this._workspacePicker.isNoWorkspaceSelected()) {
+                    this.selectNoWorkspace();
+                } else {
+                    this._createdSessionId = this.sessionsService.openQuickChat(undefined, true)?.sessionId;
+                }
+            }
+        } catch (error) {
+            if (!isCancellationError(error)) {
+                onUnexpectedError(error);
+            }
+        } finally {
+            if (this._noWorkspaceRestore.value === lifetime) {
+                this._noWorkspaceRestore.clear();
+            }
         }
-        return true;
     }
     _syncWorkspacePickerFromActiveSession() {
         const activeSession = this._session.get();
@@ -598,16 +1037,18 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         void this._createNewSession(folderUri);
     }
     _isPreferredServable(folderUri, pick) {
+        const creationProviderId = isWeb ? this.agentHostFilterService.selectedHost?.sessionCreationProviderId : undefined;
         return ( this.sessionsManagementService.getSessionTypesForFolder(folderUri).some(
-            t => (pick.providerId === undefined || t.providerId === pick.providerId) && t.sessionType.id === pick.sessionTypeId
+            t => (!creationProviderId || t.providerId === creationProviderId) && (pick.providerId === undefined || t.providerId === pick.providerId) && t.sessionType.id === pick.sessionTypeId
         ));
     }
     async _createNewSession(
         folderUri,
-        userPick = this._newChatInput.sessionTypePicker.getUserPickedSessionType()
+        userPick = this._newChatInput.sessionTypePicker.getUserPickedSessionType(),
+        handoff
     ) {
         this._pendingPreferredUpgrade.clear();
-        const creationCts = ( new CancellationTokenSource());
+        const creationCts = ( new CancellationTokenSource(handoff?.token));
         const creationLifecycle = toDisposable(() => creationCts.dispose(true));
         this._newSessionCreation.value = creationLifecycle;
         const pendingChange = ( new DisposableStore());
@@ -616,12 +1057,18 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             this.sessionsManagementService.onDidChangeSessionTypes(() => changedWhilePending = true)
         );
         let result;
+        const creation = this._createSessionNow(folderUri, userPick, creationCts.token, handoff?.providerId);
+        this._pendingWorkspaceCreation = creation;
         try {
-            result = await this._createSessionNow(folderUri, userPick, creationCts.token);
+            result = await creation;
         } finally {
             pendingChange.dispose();
+            if (this._pendingWorkspaceCreation === creation) {
+                this._pendingWorkspaceCreation = undefined;
+            }
         }
         const isCurrentCreation = this._newSessionCreation.value === creationLifecycle;
+        const cancelled = creationCts.token.isCancellationRequested;
         if (isCurrentCreation) {
             if (result.session) {
                 this._createdSessionId = result.session.sessionId;
@@ -630,6 +1077,12 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         } else {
             return result;
         }
+        if (cancelled) {
+            return result;
+        }
+        if (handoff) {
+            this._preferredDevContainerFolderUri = handoff.preferDevContainer ? folderUri : undefined;
+        }
         this._applyPreferredDevContainer(result.session, folderUri);
         if (result.trustDeclined) {
             this._preferredDevContainerFolderUri = undefined;
@@ -652,9 +1105,9 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         provider.preferDevContainer(session.sessionId);
         this._preferredDevContainerFolderUri = undefined;
     }
-    async _createSessionNow(folderUri, userPick, token) {
+    async _createSessionNow(folderUri, userPick, token, providerId) {
         const preferredPick = userPick && this._isPreferredServable(folderUri, userPick) ? userPick : this._newChatInput.sessionTypePicker.getPreferredSessionType(folderUri);
-        const fallbackProviderId = this._workspacePicker.selectedResolved?.providerId;
+        const fallbackProviderId = providerId ?? this._workspacePicker.selectedResolved?.providerId;
         try {
             return await this.sessionsService.openNewSession({
                 folderUri,
@@ -710,44 +1163,211 @@ let NewChatWidget = class NewChatWidget extends Disposable {
     _getContextFolderUri() {
         return this._isQuickChatComposer.get() ? undefined : this._workspacePicker.selectedFolderUri;
     }
-    selectNoWorkspace() {
+    selectNoWorkspace(options, selectionOptions) {
         this._pendingPreferredUpgrade.clear();
         this._newSessionCreation.clear();
-        this._workspacePicker.selectNoWorkspace();
-        this._openQuickChat();
+        this._workspacePicker.selectNoWorkspace(selectionOptions?.userSelection !== false);
+        this._openQuickChat(options, selectionOptions?.preserveNavigation);
     }
-    _openQuickChat(options) {
-        return this.sessionsService.openQuickChat(options);
+    _openQuickChat(options, preserveNavigation) {
+        return this.sessionsService.openQuickChat(options, preserveNavigation);
     }
     _getNoWorkspaceOption() {
         const isWorkspacePickerQuickChat = this._isWorkspacePickerQuickChat.get();
-        if (isWeb || !this._useConsolidatedRemoteWorkspaces.get() || (!isWorkspacePickerQuickChat && !this.sessionsManagementService.isQuickChatTargetAvailable())) {
+        if (isWeb || !this._useConsolidatedRemoteWorkspaces.get()) {
             return undefined;
         }
+        const providers = this.sessionsProvidersService.getProviders().filter(
+            provider => isAgentHostProvider(provider) && !provider.hostGroup && provider.supportsQuickChats
+        );
+        if (!isWorkspacePickerQuickChat && !this.sessionsManagementService.isQuickChatTargetAvailable() && providers.length === 0) {
+            return undefined;
+        }
+        const activeProviderId = isWorkspacePickerQuickChat ? this._session.get()?.providerId : undefined;
+        const activeProvider = activeProviderId ? providers.find(provider => provider.id === activeProviderId) : undefined;
+        const submenuActions = providers.length > 1 ? providers.map(provider => {
+            const label = provider.id === LOCAL_AGENT_HOST_PROVIDER_ID ? ( localize(4220, "Local")) : provider.label;
+            const action = toAction({
+                id: `newSessionWorkspacePicker.quickChat.${provider.id}`,
+                label,
+                checked: provider.id === activeProviderId,
+                run: () => {
+                    if (provider.id !== activeProviderId) {
+                        this.selectNoWorkspace({
+                            providerId: provider.id
+                        });
+                    }
+                }
+            });
+            return Object.assign(action, {
+                icon: provider.icon
+            });
+        }) : undefined;
         return {
-            description: ( localize(3750, "Start without a backing workspace")),
+            description: ( localize(4221, "Start without a backing workspace")),
             isSelected: isWorkspacePickerQuickChat,
-            select: () => this.selectNoWorkspace()
+            selectedLabel: activeProvider && activeProvider.id !== LOCAL_AGENT_HOST_PROVIDER_ID ? ( localize(4222, "Chat [{0}]", activeProvider.label)) : undefined,
+            select: () => {
+                if (!isWorkspacePickerQuickChat) {
+                    this.selectNoWorkspace(providers.length === 1 ? {
+                        providerId: providers[0].id
+                    } : undefined);
+                }
+            },
+            submenuActions
         };
     }
     _renderWorkspacePicker(container) {
-        this._workspacePickerVisibleKey.set(true);
+        const store = ( new DisposableStore());
+        const selectsRepository = isWeb && !!this.agentHostFilterService.selectedHost?.sessionCreationProviderId;
         const workspaceTrigger = {
-            label: ( localize(3751, "Workspace")),
-            ariaLabel: ( localize(3752, "Choose a workspace for the new session")),
-            tooltip: ( localize(3753, "Choose where the new session runs")),
-            icon: Codicon.project,
+            label: selectsRepository ? ( localize(4223, "Select Repository")) : ( localize(4224, "Workspace")),
+            ariaLabel: selectsRepository ? ( localize(4225, "Choose a repository for the new session")) : ( localize(4226, "Choose a workspace for the new session")),
+            tooltip: ( localize(4227, "Choose where the new session runs")),
+            focusCommand: {
+                id: FOCUS_NEW_SESSION_WORKSPACE_PICKER_COMMAND_ID,
+                when: FOCUS_NEW_SESSION_WORKSPACE_PICKER_WHEN,
+                enabled: this._useConsolidatedRemoteWorkspaces
+            },
+            icon: selectsRepository ? Codicon.repo : Codicon.project,
             reflectsWorkspace: true,
             attachesContext: false
         };
         const row = this._workspacePicker.renderCategoryTriggers(container, [workspaceTrigger]);
-        this._renderSessionTypePicker(row, false);
+        const sessionOptions = append(row, $(".new-chat-session-options-details"));
+        sessionOptions.id = `new-chat-session-options-${++sessionOptionsIdPool}`;
+        const repositoryControlsHost = append(sessionOptions, $(".new-chat-repository-controls-host"));
         this._workspacePickerRow = row;
-        return toDisposable(() => {
+        this._workspaceRepositoryControlsHost = repositoryControlsHost;
+        this._workspaceSessionOptionsHost = sessionOptions;
+        this._renderSessionTypePicker(sessionOptions, false);
+        this._newChatInput.placeRepositoryControls(repositoryControlsHost);
+        const toggle = store.add(( new Button(row, {
+            ...defaultButtonStyles,
+            buttonBackground: undefined,
+            buttonHoverBackground: undefined,
+            buttonForeground: undefined,
+            buttonBorder: undefined
+        })));
+        toggle.element.classList.add("new-chat-session-options-toggle");
+        toggle.element.setAttribute("aria-controls", sessionOptions.id);
+        store.add(toggle.onDidClick(
+            () => this._setSessionOptionsExpandedFromUser(!this._sessionOptionsExpanded.get())
+        ));
+        store.add(addDisposableListener(row, EventType.KEY_DOWN, event => {
+            if (!this._useExperimentalComposerLayout.get() || event.altKey || event.ctrlKey || event.metaKey || !["Tab", "ArrowLeft", "ArrowRight"].includes(event.key)) {
+                return;
+            }
+            const controls = [];
+            const walker = row.ownerDocument.createTreeWalker(row, NodeFilter.SHOW_ELEMENT);
+            for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+                if (isHTMLElement(node) && node.role === "button" && node.getAttribute("aria-disabled") !== "true" && !node.closest("[hidden], [inert], .disabled, .loading, .resolving") && node.checkVisibility()) {
+                    controls.push(node);
+                }
+            }
+            const activeElement = getActiveElement();
+            const index = controls.findIndex(control => control === activeElement);
+            if (index < 0) {
+                return;
+            }
+            const previous = event.key === "ArrowLeft" || (event.key === "Tab" && event.shiftKey);
+            const nextIndex = index + (previous ? -1 : 1);
+            if (event.key === "Tab" && (nextIndex < 0 || nextIndex >= controls.length)) {
+                return;
+            }
+            EventHelper.stop(event, true);
+            controls[(nextIndex + controls.length) % controls.length].focus();
+        }, true));
+        const responsiveLayout = store.add(( new ChatInputPickerResponsiveLayout("NewChatWidget.sessionOptions", container, {
+            usePreferredWidth: true,
+            getItems: () => getLabeledPickerResponsiveItems(row).map(item => item.element && sessionOptions.contains(item.element) ? item : {
+                ...item,
+                setCompact: () => {}
+            })
+        })));
+        store.add(autorun(reader => {
+            const useExperimentalLayout = this._useExperimentalComposerLayout.read(reader);
+            const screenReaderOptimized = this._screenReaderOptimized.read(reader);
+            const disclosureAvailable = useExperimentalLayout && !screenReaderOptimized;
+            const expanded = this._sessionOptionsExpanded.read(reader);
+            const collapsed = disclosureAvailable && !expanded;
+            if (collapsed) {
+                logSettingExperimentTrigger(this.telemetryService, COLLAPSED_SESSION_OPTIONS_SHOW_ICONS_SETTING);
+            }
+            const iconRail = collapsed && this._collapsedSessionOptionsShowIcons.read(reader);
+            const showDetails = !disclosureAvailable || expanded || iconRail;
+            row.classList.toggle("new-chat-session-options", useExperimentalLayout);
+            sessionOptions.classList.toggle("legacy-session-options-details", !useExperimentalLayout);
+            sessionOptions.classList.toggle("collapsed-icon-rail", iconRail);
+            toggle.element.hidden = !disclosureAvailable;
+            if (!showDetails && sessionOptions.contains(getActiveElement())) {
+                toggle.focus();
+            }
+            sessionOptions.inert = !showDetails;
+            sessionOptions.hidden = !showDetails;
+            toggle.icon = expanded ? Codicon.chevronLeftCompact : Codicon.chevronRightCompact;
+            toggle.element.setAttribute("aria-expanded", String(expanded));
+            const label = expanded ? ( localize(4228, "Hide Session Options")) : ( localize(4229, "Show Session Options"));
+            toggle.setAriaLabel(label);
+            toggle.setTitle(label);
+            responsiveLayout.layout();
+        }));
+        responsiveLayout.layout();
+        this._newChatInput.pickerVisibility.setVisible("workspace", true);
+        store.add(toDisposable(() => {
             if (this._workspacePickerRow === row) {
                 this._workspacePickerRow = undefined;
+                this._workspaceRepositoryControlsHost = undefined;
+                this._workspaceSessionOptionsHost = undefined;
+                this._newChatInput.placeRepositoryControls();
+                this._newChatInput.pickerVisibility.setVisible("workspace", false);
             }
-        });
+        }));
+        return store;
+    }
+    _getComparisonBranch(session = this._session.get()) {
+        const selectedFolderUri = this._workspacePicker.selectedFolderUri;
+        const provider = session ? this.sessionsProvidersService.getProvider(session.providerId) : undefined;
+        const matchesSelectedFolder = !selectedFolderUri || !!session?.workspace.get()?.folders.some(folder => isEqual(folder.root, selectedFolderUri));
+        if (session && provider && isAgentHostProvider(provider) && matchesSelectedFolder) {
+            const branch = provider.getCreateSessionConfig(session.sessionId)?.[SessionConfigKey.Branch];
+            if (typeof branch === "string" && branch.trim()) {
+                return branch;
+            }
+        }
+        const selectedWorkspaceRepository = getComparisonSelectedWorkspaceFolder(this._workspacePicker.selectedResolved?.workspace, selectedFolderUri)?.gitRepository;
+        const selectedWorkspaceBranch = selectedWorkspaceRepository?.branchName?.trim() || selectedWorkspaceRepository?.baseBranchName?.trim();
+        if (selectedWorkspaceBranch) {
+            return selectedWorkspaceBranch;
+        }
+        const sessionRepository = getComparisonSessionFolder(session, selectedFolderUri)?.gitRepository;
+        const workspaceBranch = sessionRepository?.branchName?.trim() || sessionRepository?.baseBranchName?.trim();
+        if (workspaceBranch) {
+            return workspaceBranch;
+        }
+        return undefined;
+    }
+    _shouldShowComparisonAction() {
+        const session = this._session.get();
+        const provider = session ? this.sessionsProvidersService.getProvider(session.providerId) : undefined;
+        const selectedFolderUri = this._workspacePicker.selectedFolderUri;
+        const providerIsAgentHost = !!provider && isAgentHostProvider(provider);
+        const resolvingConfig = session && providerIsAgentHost ? provider.isSessionConfigResolving(session.sessionId).get() : false;
+        const sessionMatchesSelectedFolder = !!selectedFolderUri && !!session?.workspace.get()?.folders.some(folder => isEqual(folder.root, selectedFolderUri));
+        if (!sessionMatchesSelectedFolder) {
+            return false;
+        }
+        const hasGitRemote = getComparisonHasGitRemote(
+            session,
+            this._workspacePicker.selectedResolved?.workspace,
+            selectedFolderUri
+        );
+        if (hasGitRemote !== true) {
+            return false;
+        }
+        return this._compareAgentsEnabled.get() && selectedFolderUri !== undefined && !!session && hasGitRemote && providerIsAgentHost && ( this.sessionsManagementService.getSessionTypesForFolder(selectedFolderUri).some(
+            type => type.providerId === session.providerId && type.sessionType.id === session.sessionType && type.sessionType.supportsWorktreeConfiguration
+        )) && !resolvingConfig && this._getComparisonBranch(session) !== undefined;
     }
     _renderSessionTypePicker(container, prependBeforeSiblings) {
         this._newChatInput.sessionTypePicker.render(container, {
@@ -758,22 +1378,46 @@ let NewChatWidget = class NewChatWidget extends Disposable {
             container.prepend(sessionTypePicker);
         } else if (sessionTypePicker) {
             const workspaceTrigger = container.firstElementChild;
-            workspaceTrigger?.after(sessionTypePicker);
+            const insertionAnchor = container === this._workspaceSessionOptionsHost ? this._workspaceRepositoryControlsHost ?? workspaceTrigger : workspaceTrigger;
+            insertionAnchor?.after(sessionTypePicker);
         }
     }
+    focusWorkspacePicker() {
+        this._workspacePicker.showPicker();
+    }
+    focusHarnessPicker() {
+        this._sessionOptionsExpanded.set(true, undefined);
+        this._newChatInput.sessionTypePicker.showPicker();
+    }
+    _restoreSessionOptionsExpanded() {
+        const storedExpanded = this.storageService.getBoolean(SESSION_OPTIONS_EXPANDED_STORAGE_KEY, StorageScope.PROFILE);
+        let initialExpanded = storedExpanded ?? true;
+        const hasCreatedSession = this._usage.createdSessionCount > 0;
+        if (storedExpanded === undefined && !hasCreatedSession && isExperimentalSessionComposerLayoutEnabled(this.configurationService)) {
+            logSettingExperimentTrigger(this.telemetryService, NEW_SESSION_COMPOSER_OPTIONS_EXPANDED_SETTING);
+            initialExpanded = this.configurationService.getValue(NEW_SESSION_COMPOSER_OPTIONS_EXPANDED_SETTING) ?? true;
+        }
+        this._sessionOptionsExpanded.set(initialExpanded, undefined);
+    }
+    _setSessionOptionsExpandedFromUser(expanded) {
+        this._sessionOptionsExpanded.set(expanded, undefined);
+        this.storageService.store(
+            SESSION_OPTIONS_EXPANDED_STORAGE_KEY,
+            expanded,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
     _renderEmptyState(container) {
-        this._workspacePickerVisibleKey.set(false);
+        this._newChatInput.pickerVisibility.setVisible("workspace", false);
         const emptyState = this.instantiationService.createInstance(NoAgentHostEmptyState);
+        this._activeEmptyState.set(emptyState, undefined);
         emptyState.render(container);
-        this._activeEmptyState = emptyState;
-        return {
-            dispose: () => {
-                if (this._activeEmptyState === emptyState) {
-                    this._activeEmptyState = undefined;
-                }
-                emptyState.dispose();
+        return toDisposable(() => {
+            if (this._activeEmptyState.get() === emptyState) {
+                this._activeEmptyState.set(undefined, undefined);
             }
-        };
+        });
     }
     _renderEmptyStateGate(container, chatWidgetContent) {
         const store = ( new DisposableStore());
@@ -818,7 +1462,103 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         }));
         return store;
     }
-    async _send(query, attachedContext, background) {
+    async _sendComparison(session, request, requestContext) {
+        try {
+            if (!this._comparisonSelection.available.get()) {
+                throw ( new Error(( localize(
+                    4230,
+                    "Comparison is no longer available for this draft. Check its workspace and agent configuration."
+                ))));
+            }
+            if (!this._comparisonSelection.configured.get()) {
+                throw ( new Error(( localize(4231, "Finish configuring the comparison in the model picker."))));
+            }
+            const workspace = this._workspacePicker.selectedFolderUri;
+            if (!workspace) {
+                throw ( new Error(( localize(4232, "Select a workspace for the comparison."))));
+            }
+            const branch = this._getComparisonBranch(session);
+            const workspaceError = getSessionComparisonWorkspaceError(
+                branch,
+                getComparisonHasGitRemote(session, this._workspacePicker.selectedResolved?.workspace, workspace)
+            );
+            if (workspaceError) {
+                throw ( new Error(workspaceError));
+            }
+            const provider = this.sessionsProvidersService.getProvider(session.providerId);
+            const type = this.sessionsManagementService.getSessionTypesForFolder(workspace).find(
+                type => type.providerId === session.providerId && type.sessionType.id === session.sessionType && type.sessionType.supportsWorktreeConfiguration
+            );
+            if (!provider || !type) {
+                throw ( new Error(( localize(4233, "The selected agent no longer supports worktree comparisons."))));
+            }
+            const permission = provider.getPermissionOptionForSession?.(session.sessionId);
+            if (!permission || permission.locked) {
+                throw ( new Error(( localize(
+                    4234,
+                    "The current permissions are unavailable for comparison. Update the draft permissions and try again."
+                ))));
+            }
+            const resolveHarness = modelId => {
+                const resolution = provider.getModelsSnapshotForCreation?.(workspace, session.sessionType, modelId).desiredModelResolution;
+                if (resolution?.kind !== "available") {
+                    throw ( new Error(( localize(
+                        4235,
+                        "A selected comparison model is no longer available. Update the model picker selection."
+                    ))));
+                }
+                const modelConfiguration = {};
+                for (const [key, value] of Object.entries(
+                    provider.getAutomationModelConfiguration?.(session.sessionId)?.getModelConfiguration(resolution.model.identifier) ?? {}
+                )) {
+                    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+                        modelConfiguration[key] = value;
+                    }
+                }
+                return {
+                    providerId: session.providerId,
+                    sessionTypeId: session.sessionType,
+                    label: type.sessionType.label,
+                    modelId: resolution.model.identifier,
+                    modelLabel: resolution.model.metadata.name,
+                    modelConfiguration: ( Object.keys(modelConfiguration)).length ? modelConfiguration : undefined,
+                    permissionId: permission?.id,
+                    permissionLabel: permission?.label,
+                    modeId: permission.comparisonModeId
+                };
+            };
+            const judgeModelId = this._comparisonSelection.judgeModelId.get();
+            const synthesisModelId = this._comparisonSelection.synthesizerModelId.get();
+            const comparison = await this.sessionComparisonService.startComparison({
+                workspace,
+                prompt: request,
+                attachedContext: requestContext.size ? [...( requestContext.values())] : undefined,
+                attempts: this._comparisonSelection.attemptModelIds.get().map(modelId => ({
+                    id: generateUuid(),
+                    harness: resolveHarness(modelId)
+                })),
+                judgeHarness: judgeModelId ? resolveHarness(judgeModelId) : undefined,
+                synthesisHarness: synthesisModelId ? resolveHarness(synthesisModelId) : undefined,
+                branch
+            });
+            this._comparisonSelection.reset();
+            try {
+                if (this.configurationService.getValue(COMPARE_AGENTS_OPEN_IN_GRID_SETTING)) {
+                    await this.commandService.executeCommand(OPEN_SESSION_COMPARISON_COMMAND_ID, comparison.id);
+                }
+                this.sessionsManagementService.discardNewSession(session);
+            } catch (error) {
+                this.logService.error("Failed to open session comparison:", error);
+                this.notificationService.error(error);
+            }
+            return true;
+        } catch (error) {
+            this.logService.error("Failed to start session comparison:", error);
+            this.notificationService.error(error);
+            return false;
+        }
+    }
+    async _send(query, attachedContext, background, userInteraction) {
         const session = this._session.get();
         if (!session) {
             this._workspacePicker.showPicker();
@@ -833,40 +1573,61 @@ let NewChatWidget = class NewChatWidget extends Disposable {
                 requestContext.set(context.id, context);
             }
         }
+        if (this._comparisonSelection.enabled.get()) {
+            return this._sendComparison(session, request, requestContext);
+        }
         const wasQuickChat = this._isQuickChatComposer.get();
-        const reseedFolderUri = background && !wasQuickChat ? this._workspacePicker.selectedFolderUri : undefined;
+        const folderUri = wasQuickChat ? undefined : this._workspacePicker.selectedFolderUri;
+        const reseedFolderUri = background ? folderUri : undefined;
         const sendOptions = {
             query: request,
             attachedContext: requestContext.size > 0 ? [...( requestContext.values())] : undefined,
-            background
+            background,
+            ...(userInteraction ? {
+                onDidCreateResponse: userInteraction.onDidCreateResponse
+            } : {})
         };
         const clearFeedback = () => {
             for (const item of feedbackItems) {
                 this.agentFeedbackService.removeFeedback(AGENT_FEEDBACK_NEW_SESSION_RESOURCE, item.id);
             }
         };
+        const restoreWorkspace = () => {
+            if (folderUri) {
+                this.recentWorkspacesService.restoreDismissedWorkspace(folderUri);
+            }
+        };
         if (background) {
             this._pendingBackgroundSends.set(sendOptions, Event.once(Event.filter(
                 this.sessionsManagementService.onDidSendRequest,
                 event => event.options === sendOptions
             ))(() => {
                 clearFeedback();
+                restoreWorkspace();
                 this._pendingBackgroundSends.deleteAndDispose(sendOptions);
             }));
         }
         try {
+            userInteraction?.handoff(session, session.activeChat.get());
             this.newSessionComposerService.notifyWillSendRequest(
                 sendOptions,
                 wasQuickChat ? undefined : this._workspacePicker.selectionSnapshot
             );
             await this.sessionsManagementService.sendNewChatRequest(session, sendOptions);
         } catch (e) {
+            userInteraction?.cancel(
+                isCancellationError(e) || e instanceof WorkspaceNotTrustedError ? "cancelled" : "error"
+            );
             this._pendingBackgroundSends.deleteAndDispose(sendOptions);
-            this.logService.error("Failed to send request:", e);
+            if (!isCancellationError(e) && !(e instanceof WorkspaceNotTrustedError)) {
+                this.logService.error("Failed to send request:", e);
+                this.notificationService.error(( localize(4236, "Failed to start session: {0}", toErrorMessage(e))));
+            }
             return false;
         }
         if (!background) {
             clearFeedback();
+            restoreWorkspace();
         }
         this._workspacePicker.clearAttachedContext();
         if (background) {
@@ -898,7 +1659,7 @@ let NewChatWidget = class NewChatWidget extends Disposable {
                 return;
             }
             const count = feedbackItems.length;
-            const text = count === 1 ? ( localize(3754, "1 comment")) : ( localize(3755, "{0} comments", count));
+            const text = count === 1 ? ( localize(4237, "1 comment")) : ( localize(4238, "{0} comments", count));
             const store = ( new DisposableStore());
             content.value = store;
             const banner = store.add(this.instantiationService.createInstance(SessionInputBannerWidget, {
@@ -907,7 +1668,7 @@ let NewChatWidget = class NewChatWidget extends Disposable {
                 text,
                 ariaLabel: text,
                 actions: [{
-                    label: ( localize(3756, "Reveal")),
+                    label: ( localize(4239, "Reveal")),
                     run: () => this.agentFeedbackService.revealFeedback(AGENT_FEEDBACK_NEW_SESSION_RESOURCE, feedbackItems[0].id)
                 }]
             }));
@@ -922,21 +1683,36 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         this._newChatInput.layout(_height, _width);
     }
     focusInput() {
-        if (this._activeEmptyState) {
-            this._activeEmptyState.focus();
+        const emptyState = this._activeEmptyState.get();
+        if (emptyState) {
+            emptyState.focus();
             return;
         }
         this._newChatInput.focus();
     }
+    _isCurrentWorkspaceSelection(folderUri) {
+        const session = this._session.get();
+        if (!folderUri || !session || session.isCreated.get() || this._pendingWorkspaceCreation || !this.uriIdentityService.extUri.isEqual(session.workspace.get()?.folders[0]?.root, folderUri) || this._workspacePicker.selectedResolved?.providerId !== session.providerId) {
+            return false;
+        }
+        const provider = this.sessionsProvidersService.getProvider(session.providerId);
+        const devContainerEnabled = !!provider && isAgentHostProvider(provider) && provider.isDevContainerEnabled?.(session.sessionId) === true;
+        return devContainerEnabled === this.uriIdentityService.extUri.isEqual(this._preferredDevContainerFolderUri, folderUri);
+    }
     async _onWorkspaceSelected(folderUri, userPick) {
         this._pendingPreferredUpgrade.clear();
         if (!folderUri || !this._preferredDevContainerFolderUri || !this.uriIdentityService.extUri.isEqual(this._preferredDevContainerFolderUri, folderUri)) {
             this._preferredDevContainerFolderUri = undefined;
         }
         const currentFolderUri = this._session.get()?.workspace.get()?.folders[0]?.root;
+        if (!folderUri || !currentFolderUri || !this.uriIdentityService.extUri.isEqual(currentFolderUri, folderUri)) {
+            this._comparisonSelection.reset();
+        }
         const refreshingPromptOptions = !!currentFolderUri && (!folderUri || !this.uriIdentityService.extUri.isEqual(currentFolderUri, folderUri)) && this._newChatInput.preparePromptOptionsRefresh();
         if (!folderUri) {
+            this._newSessionCreation.clear();
             this.sessionsService.unsetNewSession();
+            void this._restoreNoWorkspaceDraft();
             return;
         }
         if (this._store.isDisposed) {
@@ -981,13 +1757,61 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         const session = this._session.get();
         return !session || session.sessionId === this._createdSessionId;
     }
+    async applyDraft(draft, folderUri, options, token) {
+        if (!this._newChatInput.isInputReady) {
+            return "notReady";
+        }
+        if (token.isCancellationRequested || this._newChatInput.hasInput || this._feedbackItems.get().length > 0) {
+            return "preserved";
+        }
+        const input = reviveChatDraft(draft);
+        const store = ( new DisposableStore());
+        const cancellation = ( new CancellationTokenSource(token));
+        store.add(toDisposable(() => cancellation.dispose(true)));
+        store.add(this._newChatInput.onDidChangeInput(() => {
+            if (this._newChatInput.hasInput) {
+                cancellation.cancel();
+            }
+        }));
+        try {
+            if (folderUri) {
+                const result = await this._createNewSession(
+                    folderUri,
+                    this._newChatInput.sessionTypePicker.getUserPickedSessionType(),
+                    {
+                        token: cancellation.token,
+                        providerId: options.providerId,
+                        preferDevContainer: options.preferDevContainer
+                    }
+                );
+                if (cancellation.token.isCancellationRequested || this._store.isDisposed || this._newChatInput.hasInput || result.trustDeclined) {
+                    return "preserved";
+                }
+                if (!result.session) {
+                    return "notReady";
+                }
+                this._workspacePicker.setSelectedWorkspace(folderUri, {
+                    fireEvent: false,
+                    providerId: result.session.providerId,
+                    preferDevContainer: options.preferDevContainer,
+                    origin: options.selectionOrigin
+                });
+            }
+            if (cancellation.token.isCancellationRequested || this._store.isDisposed) {
+                return "preserved";
+            }
+            return this._newChatInput.applyDraft(input) ? "applied" : "preserved";
+        } finally {
+            store.dispose();
+        }
+    }
     selectWorkspace(folderUri, options) {
         if (options?.isDefault) {
             if (this._newSessionCreation.value) {
                 return "notReady";
             }
             const selection = this._workspacePicker.selectionSnapshot;
-            if (!this._newChatInput.canApplyWorkspaceDefault || this._isQuickChatComposer.get() || selection.state === "noWorkspace" || selection.origin === WorkspaceSelectionOrigin.User || selection.origin === WorkspaceSelectionOrigin.WindowOpen || selection.origin === WorkspaceSelectionOrigin.RestoredDraft || selection.origin === WorkspaceSelectionOrigin.SessionSync || selection.origin === WorkspaceSelectionOrigin.Programmatic) {
+            if (!this._newChatInput.canApplyWorkspaceDefault || selection.state === "noWorkspace" || selection.origin === WorkspaceSelectionOrigin.User || selection.origin === WorkspaceSelectionOrigin.WindowOpen || selection.origin === WorkspaceSelectionOrigin.RestoredDraft || selection.origin === WorkspaceSelectionOrigin.SessionSync || selection.origin === WorkspaceSelectionOrigin.Programmatic) {
                 return "preserved";
             }
         }
@@ -1001,6 +1825,6 @@ let NewChatWidget = class NewChatWidget extends Disposable {
         return selection.state === "selected" && this.uriIdentityService.extUri.isEqual(selection.folderUri, folderUri) ? "applied" : "notReady";
     }
 };
-NewChatWidget = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IContextKeyService)), ( __param(3, IContextMenuService)), ( __param(4, IConfigurationService)), ( __param(5, ILogService)), ( __param(6, ISessionsManagementService)), ( __param(7, ISessionsService)), ( __param(8, ISessionsProvidersService)), ( __param(9, IAquariumService)), ( __param(10, IAgentHostFilterService)), ( __param(11, IUriIdentityService)), ( __param(12, IAgentFeedbackService)), ( __param(13, IChatPetService)), ( __param(14, IChatTipService)), ( __param(15, IOpenerService)), ( __param(16, IDefaultAccountService)), ( __param(17, IStorageService)), ( __param(18, INewSessionComposerService)), ( __param(19, ICommandService))], NewChatWidget));
+NewChatWidget = NewChatWidget_1 = ( __decorate([( __param(1, IInstantiationService)), ( __param(2, IContextKeyService)), ( __param(3, IMenuService)), ( __param(4, IContextMenuService)), ( __param(5, IConfigurationService)), ( __param(6, IAccessibilityService)), ( __param(7, ILogService)), ( __param(8, ISessionsManagementService)), ( __param(9, ISessionsService)), ( __param(10, ISessionsProvidersService)), ( __param(11, ISessionsRecentWorkspacesService)), ( __param(12, IAquariumService)), ( __param(13, IAgentHostFilterService)), ( __param(14, IUriIdentityService)), ( __param(15, IAgentFeedbackService)), ( __param(16, IChatPetService)), ( __param(17, IChatTipService)), ( __param(18, IOpenerService)), ( __param(19, IDefaultAccountService)), ( __param(20, IAuthenticationService)), ( __param(21, IRequestService)), ( __param(22, IStorageService)), ( __param(23, INewSessionComposerService)), ( __param(24, ICommandService)), ( __param(25, ISessionComparisonService)), ( __param(26, INotificationService)), ( __param(27, ITelemetryService))], NewChatWidget));
 
-export { NewChatWidget };
+export { NewChatWidget, areNewSessionWelcomePhrasesEnabled, isExperimentalSessionComposerLayoutEnabled };