@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/sessions/browser/sessionsActions.js

@@ -0,0 +1,1550 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { fromNow } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { KeyMod, KeyCode, KeyChord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { DisposableStore, toDisposable, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuId, MenuItemAction, MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { isConfigured } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { InputFocusedContext } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkeys';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { KeybindingWeight, KeybindingsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { WorkbenchListFocusContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IsSessionsWindowContext, IsAuxiliaryWindowContext, EditorAreaFocusContext, FocusedViewContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { getQuickNavigateHandler, inQuickPickContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/quickaccess';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SessionsCategories } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/categories';
+import { SessionsPickerVisibleContext, SessionsWelcomeVisibleContext, CanGoBackContext, CanGoForwardContext, SessionsFocusContext, SessionFocusedChatIsRenameTargetContext, SessionIsCreatedContext, SessionSupportsMultipleChatsContext, IsQuickChatSessionContext, SessionIsArchivedContext, SessionHasMultipleOpenChatsContext, SessionActiveChatIsClosableContext, SessionActiveChatIsDeletableContext, SessionsHasClosedItemContext, SessionsEditorScopeContext, SessionChatsPickerVisibleContext, SessionHasMultipleCommittedChatsContext, SessionsTitleBarNewSessionEnabledContext, SessionIdContext, SessionHasSideChatsContext, SessionIsStickyContext, SessionProviderIdContext, SessionSupportsRenameContext, MultipleSessionsVisibleContext, SessionIsMaximizedContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { ANY_AGENT_HOST_PROVIDER_RE } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { FOCUS_ACTIVE_SESSION_COMMAND_ID, FOCUS_PREVIOUS_CHAT_GROUP_COMMAND_ID, FOCUS_NEXT_CHAT_GROUP_COMMAND_ID, SPLIT_CHAT_GROUP_RIGHT_COMMAND_ID, SPLIT_CHAT_GROUP_DOWN_COMMAND_ID, MOVE_CHAT_TO_PREVIOUS_GROUP_COMMAND_ID, MOVE_CHAT_TO_NEXT_GROUP_COMMAND_ID, RENAME_CHAT_COMMAND_ID, CLOSE_CHAT_COMMAND_ID, RENAME_SESSION_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionCommands';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { getUntitledSessionTitle, getGitHubPullRequestRefs, SessionStatus, getChatCapabilities, ChatOriginKind } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { ISessionsListModelService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsListModelService.service';
+import { EventHelper, isMouseEvent, $, reset, append, ModifierKeyEmitter } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { HoverPosition } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget';
+import { KeybindingLabel } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/keybindingLabel/keybindingLabel';
+import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { asCssVariable } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { markOnboardingTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/onboarding/browser/spotlight/onboardingTarget';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { agentsNewSessionButtonBorder, agentsNewSessionButtonHoverBackground, agentsNewSessionButtonForeground, agentsNewSessionButtonBackground } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/theme';
+import { logSessionsInteraction } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { NEW_SESSION_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/common/constants';
+import { groupSessionsForPicker } from './sessionsPicker.js';
+import { SESSION_CONVERSATION_SIDE_CHATS_GROUP, getSessionConversationActionId, isSessionConversationSideChat } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/sessionConversationGroups';
+import { SessionsListFocusedChatItemContext, SessionChatItemCanRenameContext, SessionChatItemIsUntitledContext, SessionChatItemCanDeleteContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+import { SessionsViewId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsView';
+import * as newSessionActionViewItem from './media/newSessionActionViewItem.css';
+import { INewSessionComposerService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/browser/newSessionComposerService.service';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { getHighestPriorityPullRequestIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/chatPullRequest';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+var NewSessionActionViewItemContribution_1;
+registerCss(newSessionActionViewItem, 1);
+const NEW_SESSION_BUTTON_STYLE_SETTING = "sessions.newSessionButton.style";
+const NEW_SESSION_BUTTON_STYLE_TREATMENT = "agentSessionsNewSessionButtonStyle";
+const SHOW_SESSIONS_PICKER_COMMAND_ID = "sessions.showSessionsPicker";
+registerAction2(class ShowSessionsPickerAction extends Action2 {
+    constructor() {
+        super({
+            id: SHOW_SESSIONS_PICKER_COMMAND_ID,
+            title: ( localize2(4534, "Show Sessions Picker")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                primary: KeyMod.CtrlCmd | KeyCode.KeyR,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyMod.Alt | KeyCode.KeyR
+                },
+                weight: KeybindingWeight.SessionsContrib,
+                when: IsSessionsWindowContext
+            }
+        });
+    }
+    async run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const sessionsListModelService = accessor.get(ISessionsListModelService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        const composerService = accessor.get(INewSessionComposerService);
+        const activeSessionId = sessionsService.activeSession.get()?.sessionId;
+        const toPickItem = (session, reader) => {
+            const title = session.title.read(reader) || getUntitledSessionTitle(session.isQuickChat?.read(reader) ?? false);
+            const status = session.status.read(reader);
+            const isRead = session.isRead.read(reader);
+            const isArchived = session.isArchived.read(reader);
+            const workspace = session.workspace.read(reader);
+            const gitHubInfo = workspace?.folders[0]?.gitRepository?.gitHubInfo.read(reader);
+            const pullRequestIcon = getHighestPriorityPullRequestIcon(getGitHubPullRequestRefs(gitHubInfo).map(pullRequest => pullRequest.icon));
+            const completedStateIcon = session.completedStateIcon?.read(reader) ?? pullRequestIcon;
+            const icon = sessionsListModelService.getStatusIcon(status, isRead, isArchived, completedStateIcon);
+            const detailParts = [];
+            if (workspace?.label) {
+                const isWorkspaceFolder = workspace.folders.length > 0 && workspace.folders[0]?.gitRepository?.workTreeUri === undefined;
+                const workspaceIcon = workspace.typeIcon ?? (workspace.isVirtualWorkspace ? Codicon.cloud : isWorkspaceFolder ? Codicon.folder : Codicon.worktree);
+                detailParts.push(`$(${Codicon.blank.id}) $(${workspaceIcon.id}) ${workspace.label}`);
+            } else {
+                detailParts.push(`$(${Codicon.blank.id})`);
+            }
+            detailParts.push(fromNow(session.updatedAt.read(reader), true, true));
+            return {
+                id: session.sessionId,
+                label: title,
+                detail: detailParts.join(" · "),
+                iconClass: ThemeIcon.asClassName(icon),
+                iconColor: icon.color,
+                session
+            };
+        };
+        const picker = quickInputService.createQuickPick({
+            useSeparators: true
+        });
+        picker.placeholder = ( localize(4535, "Search sessions by name or folder"));
+        picker.canAcceptInBackground = true;
+        picker.matchOnDetail = true;
+        const disposables = ( new DisposableStore());
+        disposables.add(picker);
+        const sessionsChanged = observableSignalFromEvent(
+            "sessionsPickerSessionsChanged",
+            sessionsManagementService.onDidChangeSessions
+        );
+        disposables.add(autorun(reader => {
+            sessionsChanged.read(reader);
+            const {
+                recent,
+                other
+            } = sessionsService.getRecentlyOpenedSessions();
+            const sessionGroups = groupSessionsForPicker(recent, other, reader);
+            const items = [{
+                id: "newSession",
+                label: `$(add) ${( localize(4536, "New Session"))}`,
+                session: undefined
+            }];
+            let firstSessionItem;
+            const appendSessions = (label, sessions) => {
+                if (sessions.length === 0) {
+                    return;
+                }
+                items.push({
+                    type: "separator",
+                    label
+                });
+                for (const session of sessions) {
+                    const item = toPickItem(session, reader);
+                    firstSessionItem ??= item;
+                    items.push(item);
+                }
+            };
+            appendSessions(( localize(4537, "needs input")), sessionGroups.needsInput);
+            appendSessions(( localize(4538, "unread")), sessionGroups.unread);
+            appendSessions(( localize(4539, "recently opened")), sessionGroups.recent);
+            appendSessions(( localize(4540, "other sessions")), sessionGroups.other);
+            const activeItemId = picker.activeItems[0]?.id;
+            picker.items = items;
+            const activeItem = activeItemId ? items.find(item => item.type !== "separator" && item.id === activeItemId) : firstSessionItem;
+            if (activeItem) {
+                picker.activeItems = [activeItem];
+            }
+        }));
+        const pickerVisibleContext = SessionsPickerVisibleContext.bindTo(contextKeyService);
+        pickerVisibleContext.set(true);
+        disposables.add(toDisposable(() => pickerVisibleContext.reset()));
+        const openSelected = (selected, inBackground, toSide) => {
+            composerService.notifyUserNavigation();
+            if (!selected.session) {
+                sessionsService.openNewSession();
+                sessionsPartService.focusSession(sessionsService.activeSession.get());
+                return;
+            }
+            if (toSide && activeSessionId !== undefined && selected.session.sessionId !== activeSessionId) {
+                sessionsService.insertAt(selected.session, activeSessionId, "right", !inBackground);
+            } else {
+                sessionsService.openSession(selected.session.resource, {
+                    preserveFocus: inBackground,
+                    source: "sessionsList"
+                });
+            }
+        };
+        disposables.add(picker.onDidAccept(e => {
+            const [selected] = picker.selectedItems;
+            if (selected) {
+                const toSide = picker.keyMods.ctrlCmd || picker.keyMods.alt;
+                openSelected(selected, e.inBackground, toSide);
+            }
+            if (!e.inBackground) {
+                picker.hide();
+            }
+        }));
+        disposables.add(picker.onDidHide(() => disposables.dispose()));
+        picker.show();
+    }
+});
+const SESSIONS_PICKER_NAVIGATE_NEXT_ID = "sessions.showSessionsPicker.navigateNext";
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: SESSIONS_PICKER_NAVIGATE_NEXT_ID,
+    weight: KeybindingWeight.SessionsContrib + 50,
+    handler: getQuickNavigateHandler(SESSIONS_PICKER_NAVIGATE_NEXT_ID, true),
+    when: SessionsPickerVisibleContext,
+    primary: KeyMod.CtrlCmd | KeyCode.KeyR,
+    mac: {
+        primary: KeyMod.WinCtrl | KeyMod.Alt | KeyCode.KeyR
+    }
+});
+const SESSIONS_PICKER_NAVIGATE_PREVIOUS_ID = "sessions.showSessionsPicker.navigatePrevious";
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: SESSIONS_PICKER_NAVIGATE_PREVIOUS_ID,
+    weight: KeybindingWeight.SessionsContrib + 50,
+    handler: getQuickNavigateHandler(SESSIONS_PICKER_NAVIGATE_PREVIOUS_ID, false),
+    when: SessionsPickerVisibleContext,
+    primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyR,
+    mac: {
+        primary: KeyMod.WinCtrl | KeyMod.Alt | KeyMod.Shift | KeyCode.KeyR
+    }
+});
+registerAction2(class GoBackAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.goBack",
+            title: {
+                ...( localize2(4541, "Go Back")),
+                mnemonicTitle: ( localize(4542, "&&Back"))
+            },
+            f1: true,
+            icon: Codicon.arrowLeft,
+            tooltip: ( localize(4543, "Go Back One Session")),
+            category: SessionsCategories.Sessions,
+            precondition: CanGoBackContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                win: {
+                    primary: KeyMod.Alt | KeyCode.LeftArrow,
+                    secondary: [KeyCode.BrowserBack, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Tab]
+                },
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyCode.Minus,
+                    secondary: [KeyCode.BrowserBack, KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Tab]
+                },
+                linux: {
+                    primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.Minus,
+                    secondary: [KeyCode.BrowserBack, KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Tab]
+                },
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated())))
+            },
+            menu: [{
+                id: Menus.TitleBarCenterLeft,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(( IsAuxiliaryWindowContext.toNegated()), ( SessionsWelcomeVisibleContext.toNegated())))
+            }, {
+                id: Menus.GoMenu,
+                group: "1_history_nav",
+                order: 1
+            }]
+        });
+    }
+    async run(accessor) {
+        await accessor.get(ISessionsService).openPreviousSession();
+    }
+});
+registerAction2(class GoForwardAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.goForward",
+            title: {
+                ...( localize2(4544, "Go Forward")),
+                mnemonicTitle: ( localize(4545, "&&Forward"))
+            },
+            f1: true,
+            icon: Codicon.arrowRight,
+            tooltip: ( localize(4546, "Go Forward One Session")),
+            category: SessionsCategories.Sessions,
+            precondition: CanGoForwardContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                win: {
+                    primary: KeyMod.Alt | KeyCode.RightArrow,
+                    secondary: [KeyCode.BrowserForward, KeyMod.CtrlCmd | KeyCode.Tab]
+                },
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Minus,
+                    secondary: [KeyCode.BrowserForward, KeyMod.WinCtrl | KeyCode.Tab]
+                },
+                linux: {
+                    primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Minus,
+                    secondary: [KeyCode.BrowserForward, KeyMod.CtrlCmd | KeyCode.Tab]
+                },
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated())))
+            },
+            menu: [{
+                id: Menus.TitleBarCenterLeft,
+                group: "navigation",
+                order: 2,
+                when: ( ContextKeyExpr.and(( IsAuxiliaryWindowContext.toNegated()), ( SessionsWelcomeVisibleContext.toNegated())))
+            }, {
+                id: Menus.GoMenu,
+                group: "1_history_nav",
+                order: 2
+            }]
+        });
+    }
+    async run(accessor) {
+        await accessor.get(ISessionsService).openNextSession();
+    }
+});
+registerAction2(class FocusActiveSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: FOCUS_ACTIVE_SESSION_COMMAND_ID,
+            title: ( localize2(4547, "Focus Active Session")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyI,
+                secondary: [KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyI],
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyMod.WinCtrl | KeyCode.KeyI,
+                    secondary: [KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyI]
+                },
+                linux: {
+                    primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyI,
+                    secondary: [KeyMod.CtrlCmd | KeyMod.Alt | KeyMod.Shift | KeyCode.KeyI]
+                }
+            }
+        });
+    }
+    async run(accessor) {
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const sessionsService = accessor.get(ISessionsService);
+        sessionsPartService.focusSession(sessionsService.activeSession.get());
+    }
+});
+function withActiveSessionView(accessor, action) {
+    const sessionsService = accessor.get(ISessionsService);
+    const view = accessor.get(ISessionsPartService).getSessionView(sessionsService.activeSession.get()?.sessionId);
+    if (view) {
+        action(view);
+    }
+}
+registerAction2(class FocusPreviousChatGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: FOCUS_PREVIOUS_CHAT_GROUP_COMMAND_ID,
+            title: ( localize2(4548, "Focus Previous Chat Group")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.LeftArrow),
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated())))
+            }
+        });
+    }
+    run(accessor) {
+        withActiveSessionView(accessor, view => view.focusAdjacentChatGroup("previous"));
+    }
+});
+registerAction2(class FocusNextChatGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: FOCUS_NEXT_CHAT_GROUP_COMMAND_ID,
+            title: ( localize2(4549, "Focus Next Chat Group")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.RightArrow),
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated())))
+            }
+        });
+    }
+    run(accessor) {
+        withActiveSessionView(accessor, view => view.focusAdjacentChatGroup("next"));
+    }
+});
+registerAction2(class SplitChatGroupRightAction extends Action2 {
+    constructor() {
+        super({
+            id: SPLIT_CHAT_GROUP_RIGHT_COMMAND_ID,
+            title: ( localize2(4550, "Split Chat Group Right")),
+            f1: true,
+            category: SessionsCategories.Sessions
+        });
+    }
+    run(accessor) {
+        withActiveSessionView(accessor, view => view.splitActiveChat("right"));
+    }
+});
+registerAction2(class SplitChatGroupDownAction extends Action2 {
+    constructor() {
+        super({
+            id: SPLIT_CHAT_GROUP_DOWN_COMMAND_ID,
+            title: ( localize2(4551, "Split Chat Group Down")),
+            f1: true,
+            category: SessionsCategories.Sessions
+        });
+    }
+    run(accessor) {
+        withActiveSessionView(accessor, view => view.splitActiveChat("bottom"));
+    }
+});
+registerAction2(class MoveChatToPreviousGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: MOVE_CHAT_TO_PREVIOUS_GROUP_COMMAND_ID,
+            title: ( localize2(4552, "Move Chat to Previous Group")),
+            f1: true,
+            category: SessionsCategories.Sessions
+        });
+    }
+    run(accessor) {
+        withActiveSessionView(accessor, view => view.moveActiveChatToAdjacentGroup("previous"));
+    }
+});
+registerAction2(class MoveChatToNextGroupAction extends Action2 {
+    constructor() {
+        super({
+            id: MOVE_CHAT_TO_NEXT_GROUP_COMMAND_ID,
+            title: ( localize2(4553, "Move Chat to Next Group")),
+            f1: true,
+            category: SessionsCategories.Sessions
+        });
+    }
+    run(accessor) {
+        withActiveSessionView(accessor, view => view.moveActiveChatToAdjacentGroup("next"));
+    }
+});
+for (let index = 0; index < 9; index++) {
+    const position = index + 1;
+    const isLast = position === 9;
+    registerAction2(class FocusSessionByPositionAction extends Action2 {
+        constructor() {
+            super({
+                id: `sessions.focusSessionInGrid${position}`,
+                title: isLast ? ( localize2(4554, "Focus Last Session in Grid")) : ( localize2(4555, "Focus Session {0} in Grid", position)),
+                f1: true,
+                category: SessionsCategories.Sessions,
+                keybinding: {
+                    weight: KeybindingWeight.SessionsContrib,
+                    primary: KeyMod.CtrlCmd | (KeyCode.Digit1 + index),
+                    when: IsSessionsWindowContext
+                }
+            });
+        }
+        async run(accessor) {
+            const sessionsService = accessor.get(ISessionsService);
+            const sessionsPartService = accessor.get(ISessionsPartService);
+            const visible = sessionsService.visibleSessions.get();
+            const targetIndex = isLast ? visible.length - 1 : index;
+            if (targetIndex < 0 || targetIndex >= visible.length) {
+                return;
+            }
+            const session = visible[targetIndex];
+            sessionsService.setActive(session);
+            sessionsPartService.focusSession(session);
+        }
+    });
+}
+registerAction2(class CloseAllSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.closeAllSessions",
+            title: ( localize2(4556, "Close All Sessions")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            precondition: IsSessionsWindowContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyMod.CtrlCmd | KeyCode.KeyW),
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, SessionsFocusContext))
+            }
+        });
+    }
+    async run(accessor) {
+        accessor.get(ISessionsService).closeAllSessions();
+    }
+});
+const CHAT_TAB_KEYBINDING_WEIGHT = KeybindingWeight.SessionsContrib + 10;
+function getSessionsList(accessor) {
+    return accessor.get(IViewsService).getViewWithId(SessionsViewId)?.sessionsControl;
+}
+function getChatRenameContext(accessor, context) {
+    if (context) {
+        return context;
+    }
+    const sessionsList = getSessionsList(accessor);
+    const focusedChat = sessionsList?.getFocusedChatItem();
+    if (focusedChat) {
+        return focusedChat;
+    }
+    if (sessionsList?.getFocusedSessions() !== undefined) {
+        return undefined;
+    }
+    const sessionView = accessor.get(ISessionsPartService).getFocusedSessionView();
+    const session = sessionView?.getSession();
+    const chat = sessionView?.getFocusedChat();
+    return session && chat ? {
+        session,
+        chat
+    } : undefined;
+}
+async function renameChatWithQuickInput(accessor, context) {
+    const extUri = accessor.get(IUriIdentityService).extUri;
+    const quickInputService = accessor.get(IQuickInputService);
+    const sessionsManagementService = accessor.get(ISessionsManagementService);
+    const {
+        session,
+        chat
+    } = context;
+    const resource = chat.resource;
+    const initialChat = session.chats.get().find(candidate => extUri.isEqual(candidate.resource, resource));
+    if (!initialChat || extUri.isEqual(resource, session.mainChat.get().resource) || initialChat.status.get() === SessionStatus.Untitled || !getChatCapabilities(initialChat, session, undefined).canRename) {
+        return;
+    }
+    const initialTitle = initialChat.title.get().trim() || ( localize(4557, "Untitled Chat"));
+    const newTitle = await quickInputService.input({
+        value: initialTitle,
+        prompt: ( localize(4558, "New chat title")),
+        validateInput: async value => value.trim() ? undefined : ( localize(4559, "Title cannot be empty"))
+    });
+    const trimmedTitle = newTitle?.trim();
+    if (!trimmedTitle || trimmedTitle === initialTitle) {
+        return;
+    }
+    const currentChat = session.chats.get().find(candidate => extUri.isEqual(candidate.resource, resource));
+    if (!currentChat || extUri.isEqual(resource, session.mainChat.get().resource) || currentChat.status.get() === SessionStatus.Untitled || !getChatCapabilities(currentChat, session, undefined).canRename) {
+        return;
+    }
+    await sessionsManagementService.renameChat(session, resource, trimmedTitle);
+}
+registerAction2(class RenameChatAction extends Action2 {
+    constructor() {
+        super({
+            id: RENAME_CHAT_COMMAND_ID,
+            title: ( localize2(4560, "Rename...")),
+            f1: false,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                primary: KeyCode.F2,
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( ContextKeyExpr.or(( ContextKeyExpr.and(ChatContextKeys.inChatSession, SessionFocusedChatIsRenameTargetContext)), ( ContextKeyExpr.and(( FocusedViewContext.isEqualTo(SessionsViewId)), WorkbenchListFocusContextKey, SessionsListFocusedChatItemContext))))))
+            }
+        });
+    }
+    async run(accessor, context) {
+        const target = getChatRenameContext(accessor, context);
+        if (target) {
+            await renameChatWithQuickInput(accessor, target);
+        }
+    }
+});
+registerAction2(class RenameSessionListChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.list.renameChat",
+            title: ( localize2(4561, "Rename...")),
+            f1: false,
+            menu: {
+                id: Menus.SessionChatItemContext,
+                group: "1_chat",
+                order: 1,
+                when: ( ContextKeyExpr.and(SessionChatItemCanRenameContext, ( SessionChatItemIsUntitledContext.negate())))
+            }
+        });
+    }
+    async run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        await renameChatWithQuickInput(accessor, context);
+    }
+});
+registerAction2(class OpenSessionListChatToSideAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.list.openChatToSide",
+            title: ( localize2(4562, "Open to the Side")),
+            f1: false,
+            menu: {
+                id: Menus.SessionChatItemContext,
+                group: "1_chat",
+                order: 2
+            }
+        });
+    }
+    async run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const sessionsService = accessor.get(ISessionsService);
+        if (!(await sessionsService.canOpenSession(context.session))) {
+            return;
+        }
+        await sessionsService.openChatToSide(context.session, context.chat.resource);
+    }
+});
+registerAction2(class DeleteSessionListChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.list.deleteChat",
+            title: ( localize2(4563, "Delete...")),
+            f1: false,
+            menu: {
+                id: Menus.SessionChatItemContext,
+                group: "2_delete",
+                order: 1,
+                when: SessionChatItemCanDeleteContext
+            }
+        });
+    }
+    async run(accessor, context) {
+        if (!context || !getChatCapabilities(context.chat, context.session, undefined).canDelete) {
+            return;
+        }
+        await accessor.get(ISessionsManagementService).deleteChat(context.session, context.chat.resource);
+    }
+});
+const ADD_CHAT_TO_SESSION_ACTION_ID = "sessions.chatCompositeBar.addChat";
+registerAction2(class AddChatToSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: ADD_CHAT_TO_SESSION_ACTION_ID,
+            title: ( localize2(4564, "New Chat in This Session")),
+            icon: Codicon.add,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()), SessionIsCreatedContext, SessionSupportsMultipleChatsContext, ( IsQuickChatSessionContext.negate()), ( SessionIsArchivedContext.negate()))),
+                primary: KeyMod.CtrlCmd | KeyCode.KeyT
+            },
+            menu: [{
+                id: Menus.SessionBarToolbar,
+                group: "secondary/3_newChat",
+                order: 10,
+                when: ( ContextKeyExpr.and(
+                    SessionIsCreatedContext,
+                    SessionSupportsMultipleChatsContext,
+                    ( IsQuickChatSessionContext.negate()),
+                    ( SessionIsArchivedContext.negate())
+                ))
+            }, {
+                id: Menus.SessionItemContextMenu,
+                group: "1_newChat",
+                order: 0,
+                when: ( ContextKeyExpr.and(
+                    SessionIsCreatedContext,
+                    SessionSupportsMultipleChatsContext,
+                    ( IsQuickChatSessionContext.negate()),
+                    ( SessionIsArchivedContext.negate())
+                ))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const target = Array.isArray(context) ? context[0] : context ?? sessionsService.activeSession.get();
+        if (!target) {
+            return;
+        }
+        if (target.isQuickChat?.get()) {
+            return;
+        }
+        await sessionsService.openNewChatInSession(target);
+        const activeSession = sessionsService.activeSession.get();
+        sessionsPartService.focusSession(activeSession?.sessionId === target.sessionId ? activeSession : undefined);
+    }
+});
+function navigateChatTab(accessor, direction) {
+    const sessionsService = accessor.get(ISessionsService);
+    const sessionsPartService = accessor.get(ISessionsPartService);
+    const extUri = accessor.get(IUriIdentityService).extUri;
+    const session = sessionsService.activeSession.get();
+    if (!session) {
+        return;
+    }
+    const tabs = session.visibleChatTabs.get();
+    if (tabs.length < 2) {
+        return;
+    }
+    const activeChat = session.activeChat.get();
+    const currentIndex = activeChat ? tabs.findIndex(chat => extUri.isEqual(chat.resource, activeChat.resource)) : -1;
+    const from = currentIndex === -1 ? 0 : currentIndex;
+    const delta = direction === "next" ? 1 : -1;
+    const target = tabs[(from + delta + tabs.length) % tabs.length];
+    sessionsService.openChat(session, target.resource);
+    sessionsPartService.focusSession(session);
+}
+registerAction2(class NavigateNextChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.navigateNextChat",
+            title: ( localize2(4565, "Go to Next Chat")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            precondition: SessionHasMultipleOpenChatsContext,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()), SessionHasMultipleOpenChatsContext)),
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.BracketRight
+            }
+        });
+    }
+    run(accessor) {
+        navigateChatTab(accessor, "next");
+    }
+});
+registerAction2(class NavigatePreviousChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.navigatePreviousChat",
+            title: ( localize2(4566, "Go to Previous Chat")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            precondition: SessionHasMultipleOpenChatsContext,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()), SessionHasMultipleOpenChatsContext)),
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.BracketLeft
+            }
+        });
+    }
+    run(accessor) {
+        navigateChatTab(accessor, "previous");
+    }
+});
+registerAction2(class CloseChatAction extends Action2 {
+    constructor() {
+        super({
+            id: CLOSE_CHAT_COMMAND_ID,
+            title: ( localize2(4567, "Close Chat")),
+            icon: Codicon.close,
+            f1: false,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()), SessionActiveChatIsClosableContext)),
+                primary: KeyMod.CtrlCmd | KeyCode.KeyW,
+                win: {
+                    primary: KeyMod.CtrlCmd | KeyCode.F4,
+                    secondary: [KeyMod.CtrlCmd | KeyCode.KeyW]
+                }
+            },
+            menu: {
+                id: Menus.SessionChatTab,
+                group: "navigation",
+                order: 10
+            }
+        });
+    }
+    async run(accessor, context) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const extUri = accessor.get(IUriIdentityService).extUri;
+        const session = context?.session ?? sessionsService.activeSession.get();
+        if (!session) {
+            return;
+        }
+        const chat = context?.chat ?? session.activeChat.get();
+        if (!chat || extUri.isEqual(chat.resource, session.mainChat.get().resource)) {
+            return;
+        }
+        if (chat.status.get() === SessionStatus.Untitled) {
+            await sessionsManagementService.deleteChat(session, chat.resource, {
+                skipConfirmation: true
+            });
+        } else {
+            await sessionsService.closeChat(session, chat);
+        }
+    }
+});
+registerAction2(class CloseAllChatsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.closeAllChats",
+            title: ( localize2(4568, "Close All Chats")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            precondition: SessionHasMultipleOpenChatsContext,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, (
+                EditorAreaFocusContext.toNegated()), SessionHasMultipleOpenChatsContext)),
+                primary: KeyChord(KeyMod.CtrlCmd | KeyCode.KeyK, KeyCode.KeyW)
+            }
+        });
+    }
+    async run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const extUri = accessor.get(IUriIdentityService).extUri;
+        const session = sessionsService.activeSession.get();
+        if (!session) {
+            return;
+        }
+        const mainResource = session.mainChat.get().resource;
+        const chatsToClose = session.openChats.get().filter(chat => !extUri.isEqual(chat.resource, mainResource));
+        for (const chat of chatsToClose) {
+            if (chat.status.get() === SessionStatus.Untitled) {
+                await sessionsManagementService.deleteChat(session, chat.resource, {
+                    skipConfirmation: true
+                });
+            } else {
+                await sessionsService.closeChat(session, chat, {
+                    skipHistory: true
+                });
+            }
+        }
+    }
+});
+registerAction2(class DeleteChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.deleteChat",
+            title: ( localize2(4569, "Delete Chat")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, SessionsFocusContext, ( EditorAreaFocusContext.toNegated()), ( InputFocusedContext.toNegated()), SessionActiveChatIsDeletableContext)),
+                primary: KeyCode.Delete,
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyCode.Backspace,
+                    secondary: [KeyCode.Delete]
+                }
+            }
+        });
+    }
+    async run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsManagementService = accessor.get(ISessionsManagementService);
+        const session = sessionsService.activeSession.get();
+        if (!session) {
+            return;
+        }
+        const chat = session.activeChat.get();
+        if (!chat || !getChatCapabilities(chat, session, undefined).canDelete) {
+            return;
+        }
+        await sessionsManagementService.deleteChat(session, chat.resource);
+    }
+});
+registerAction2(class ReopenLastClosedChatAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.reopenLastClosedChat",
+            title: ( localize2(4570, "Reopen Last Closed Chat")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            precondition: SessionSupportsMultipleChatsContext
+        });
+    }
+    async run(accessor) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        const session = sessionsService.activeSession.get();
+        if (!session) {
+            return;
+        }
+        const lastClosed = session.lastClosedChat;
+        if (!lastClosed) {
+            return;
+        }
+        await sessionsService.openChat(session, lastClosed.resource);
+        sessionsPartService.focusSession(session);
+    }
+});
+registerAction2(class ReopenLastClosedItemAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.reopenLastClosedItem",
+            title: ( localize2(4571, "Reopen Closed Chat or Session")),
+            category: SessionsCategories.Sessions,
+            keybinding: {
+                weight: CHAT_TAB_KEYBINDING_WEIGHT,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( SessionsEditorScopeContext.negate()))),
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyT
+            },
+            menu: {
+                id: MenuId.CommandPalette,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, SessionsHasClosedItemContext))
+            }
+        });
+    }
+    async run(accessor) {
+        await accessor.get(ISessionsService).reopenLastClosedItem();
+    }
+});
+const SHOW_CHATS_PICKER_COMMAND_ID = "sessions.showChatsPicker";
+const QUICK_SWITCH_NEXT_CHAT_ID = "sessions.quickSwitchNextChat";
+const QUICK_SWITCH_PREVIOUS_CHAT_ID = "sessions.quickSwitchPreviousChat";
+const CHATS_PICKER_QUICK_NAVIGATE_NEXT_ID = "sessions.chatsPicker.quickNavigateNext";
+const CHATS_PICKER_QUICK_NAVIGATE_PREVIOUS_ID = "sessions.chatsPicker.quickNavigatePrevious";
+const ChatsPickerScopeContext = ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()), SessionHasMultipleOpenChatsContext, ( inQuickPickContext.negate())));
+function openChatsPicker(accessor, mru) {
+    const sessionsService = accessor.get(ISessionsService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const sessionsPartService = accessor.get(ISessionsPartService);
+    const contextKeyService = accessor.get(IContextKeyService);
+    const keybindingService = accessor.get(IKeybindingService);
+    const session = sessionsService.activeSession.get();
+    if (!session) {
+        return;
+    }
+    const extUri = accessor.get(IUriIdentityService).extUri;
+    const toItem = chat => ({
+        label: chat.title.get()?.trim() || ( localize(4557, "Untitled Chat")),
+        description: fromNow(chat.updatedAt.get(), true, true),
+        iconClass: ThemeIcon.asClassName(Codicon.commentDiscussion),
+        chat
+    });
+    const openItems = (mru ? session.visibleChatTabs.get() : session.visibleChatTabs.get().filter(chat => chat.status.get() !== SessionStatus.Untitled)).map(toItem);
+    const closedItems = mru ? [] : session.closedChats.get().filter(
+        chat => chat.status.get() !== SessionStatus.Untitled && chat.origin?.kind !== ChatOriginKind.Tool
+    ).map(toItem);
+    const pickItems = [...openItems, ...closedItems];
+    if (pickItems.length === 0) {
+        return;
+    }
+    const displayItems = closedItems.length === 0 ? openItems : [{
+        type: "separator",
+        label: ( localize(4572, "Open"))
+    }, ...openItems, {
+        type: "separator",
+        label: ( localize(4573, "Closed"))
+    }, ...closedItems];
+    const activeChat = session.activeChat.get();
+    const activeIndex = Math.max(
+        0,
+        activeChat ? pickItems.findIndex(item => extUri.isEqual(item.chat.resource, activeChat.resource)) : -1
+    );
+    const startIndex = mru ? (activeIndex + (mru.backward ? -1 : 1) + pickItems.length) % pickItems.length : activeIndex;
+    const disposables = ( new DisposableStore());
+    const picker = disposables.add(quickInputService.createQuickPick({
+        useSeparators: true
+    }));
+    picker.items = displayItems;
+    picker.activeItems = [pickItems[startIndex]];
+    if (mru) {
+        picker.hideInput = true;
+        picker.quickNavigate = {
+            keybindings: keybindingService.lookupKeybindings(CHATS_PICKER_QUICK_NAVIGATE_NEXT_ID)
+        };
+    } else {
+        picker.placeholder = ( localize(4574, "Search chats by name"));
+        picker.matchOnDescription = true;
+    }
+    const pickerVisibleContext = SessionChatsPickerVisibleContext.bindTo(contextKeyService);
+    pickerVisibleContext.set(true);
+    disposables.add(toDisposable(() => pickerVisibleContext.reset()));
+    disposables.add(picker.onDidAccept(() => {
+        const [selected] = picker.selectedItems;
+        if (selected) {
+            sessionsService.openChat(session, selected.chat.resource);
+            sessionsPartService.focusSession(session);
+        }
+        picker.hide();
+    }));
+    disposables.add(picker.onDidHide(() => disposables.dispose()));
+    picker.show();
+}
+registerAction2(class ShowChatsPickerAction extends Action2 {
+    constructor() {
+        super({
+            id: SHOW_CHATS_PICKER_COMMAND_ID,
+            title: ( localize2(4575, "Go to Chat in Session")),
+            f1: true,
+            category: SessionsCategories.Sessions,
+            precondition: SessionHasMultipleCommittedChatsContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( EditorAreaFocusContext.toNegated()), ( inQuickPickContext.negate()))),
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.KeyO
+            }
+        });
+    }
+    run(accessor) {
+        openChatsPicker(accessor);
+    }
+});
+registerAction2(class QuickSwitchNextChatAction extends Action2 {
+    constructor() {
+        super({
+            id: QUICK_SWITCH_NEXT_CHAT_ID,
+            title: ( localize2(4576, "Quick Switch to Next Chat")),
+            f1: false,
+            category: SessionsCategories.Sessions,
+            precondition: SessionHasMultipleOpenChatsContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib + 1,
+                when: ChatsPickerScopeContext,
+                primary: KeyMod.CtrlCmd | KeyCode.Tab,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyCode.Tab
+                }
+            }
+        });
+    }
+    run(accessor) {
+        openChatsPicker(accessor, {
+            backward: false
+        });
+    }
+});
+registerAction2(class QuickSwitchPreviousChatAction extends Action2 {
+    constructor() {
+        super({
+            id: QUICK_SWITCH_PREVIOUS_CHAT_ID,
+            title: ( localize2(4577, "Quick Switch to Previous Chat")),
+            f1: false,
+            category: SessionsCategories.Sessions,
+            precondition: SessionHasMultipleOpenChatsContext,
+            keybinding: {
+                weight: KeybindingWeight.SessionsContrib + 1,
+                when: ChatsPickerScopeContext,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Tab,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Tab
+                }
+            }
+        });
+    }
+    run(accessor) {
+        openChatsPicker(accessor, {
+            backward: true
+        });
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: CHATS_PICKER_QUICK_NAVIGATE_NEXT_ID,
+    weight: KeybindingWeight.SessionsContrib + 50,
+    handler: getQuickNavigateHandler(CHATS_PICKER_QUICK_NAVIGATE_NEXT_ID, true),
+    when: SessionChatsPickerVisibleContext,
+    primary: KeyMod.CtrlCmd | KeyCode.Tab,
+    mac: {
+        primary: KeyMod.WinCtrl | KeyCode.Tab
+    }
+});
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: CHATS_PICKER_QUICK_NAVIGATE_PREVIOUS_ID,
+    weight: KeybindingWeight.SessionsContrib + 50,
+    handler: getQuickNavigateHandler(CHATS_PICKER_QUICK_NAVIGATE_PREVIOUS_ID, false),
+    when: SessionChatsPickerVisibleContext,
+    primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Tab,
+    mac: {
+        primary: KeyMod.WinCtrl | KeyMod.Shift | KeyCode.Tab
+    }
+});
+let CompactButtonActionViewItem = class CompactButtonActionViewItem extends BaseActionViewItem {
+    constructor(action, keybindingService, hoverService, contextKeyService) {
+        super(undefined, action);
+        this.keybindingService = keybindingService;
+        this.hoverService = hoverService;
+        this.contextKeyService = contextKeyService;
+    }
+    get onboardingTargetId() {
+        return undefined;
+    }
+    get showKeybindingHint() {
+        return true;
+    }
+    onRun() {}
+    runAction(_event) {
+        void this.actionRunner.run(this.action, this._context);
+    }
+    configureButton(_button) {}
+    render(container) {
+        super.render(container);
+        if (!this.element) {
+            return;
+        }
+        const button = this._register(( new Button(this.element, {
+            ...defaultButtonStyles,
+            buttonSecondaryBackground: asCssVariable(agentsNewSessionButtonBackground),
+            buttonSecondaryForeground: asCssVariable(agentsNewSessionButtonForeground),
+            buttonSecondaryHoverBackground: asCssVariable(agentsNewSessionButtonHoverBackground),
+            buttonSecondaryBorder: asCssVariable(agentsNewSessionButtonBorder),
+            secondary: true,
+            supportIcons: true
+        })));
+        button.element.classList.add("agent-sessions-compact-new-button");
+        this.configureButton(button);
+        const onboardingTargetId = this.onboardingTargetId;
+        if (onboardingTargetId) {
+            this._register(markOnboardingTarget(button.element, onboardingTargetId));
+        }
+        this._register(button.onDidClick(e => {
+            EventHelper.stop(e, true);
+            if (!this.action.enabled) {
+                return;
+            }
+            this.onRun();
+            this.runAction(isMouseEvent(e) ? e : undefined);
+        }));
+        const buttonLabel = $("span.new-session-button-label", undefined, this.label);
+        const keybindingHint = $("span.new-session-keybinding-hint");
+        const keybindingHintLabel = this.showKeybindingHint ? this._register(( new KeybindingLabel(keybindingHint, OS, {
+            disableTitle: true,
+            keybindingLabelBackground: "transparent",
+            keybindingLabelForeground: "inherit",
+            keybindingLabelBorder: "transparent",
+            keybindingLabelBottomBorder: undefined,
+            keybindingLabelShadow: undefined
+        }))) : undefined;
+        reset(button.element, buttonLabel);
+        const getKeybinding = () => {
+            const primaryKeybinding = this.keybindingService.lookupKeybinding(this.commandId, this.contextKeyService, true);
+            const resolvedKeybindings = this.keybindingService.lookupKeybindings(this.commandId);
+            return primaryKeybinding ?? resolvedKeybindings[0];
+        };
+        this._register(this.hoverService.setupDelayedHover(button.element, () => ({
+            content: this.getHoverContent(getKeybinding()?.getLabel() ?? undefined),
+            appearance: {
+                compact: true
+            },
+            position: {
+                hoverPosition: HoverPosition.BELOW
+            }
+        })));
+        let lastRenderedKeybindingLabel = null;
+        let lastRenderedKeybindingAriaLabel = null;
+        const updateButton = () => {
+            const keybinding = getKeybinding();
+            const keybindingLabel = keybinding?.getLabel() ?? undefined;
+            const keybindingAriaLabel = keybinding?.getAriaLabel() ?? undefined;
+            if (lastRenderedKeybindingLabel === keybindingLabel && lastRenderedKeybindingAriaLabel === keybindingAriaLabel) {
+                return;
+            }
+            lastRenderedKeybindingLabel = keybindingLabel;
+            lastRenderedKeybindingAriaLabel = keybindingAriaLabel;
+            keybindingHintLabel?.set(keybinding);
+            if (keybindingHintLabel && keybinding) {
+                if (keybindingHint.parentElement !== button.element) {
+                    append(button.element, keybindingHint);
+                }
+            } else {
+                keybindingHint.remove();
+            }
+            button.element.setAttribute("aria-label", this.getAriaLabel(keybindingAriaLabel));
+        };
+        this._register(
+            Event.runAndSubscribe(this.keybindingService.onDidUpdateKeybindings, updateButton)
+        );
+    }
+};
+CompactButtonActionViewItem = ( __decorate([( __param(1, IKeybindingService)), ( __param(2, IHoverService)), ( __param(3, IContextKeyService))], CompactButtonActionViewItem));
+let NewSessionActionViewItem = class NewSessionActionViewItem extends CompactButtonActionViewItem {
+    constructor(
+        action,
+        telemetrySource,
+        newSessionButtonStyle,
+        keybindingService,
+        hoverService,
+        telemetryService,
+        contextKeyService,
+        commandService
+    ) {
+        super(action, keybindingService, hoverService, contextKeyService);
+        this.telemetrySource = telemetrySource;
+        this.newSessionButtonStyle = newSessionButtonStyle;
+        this.telemetryService = telemetryService;
+        this.commandService = commandService;
+    }
+    get commandId() {
+        return NEW_SESSION_ACTION_ID;
+    }
+    get label() {
+        return localize(4578, "New");
+    }
+    get onboardingTargetId() {
+        return "sessions.newSession.button";
+    }
+    configureButton(button) {
+        this._register(autorun(reader => {
+            const style = this.newSessionButtonStyle.read(reader);
+            button.element.classList.toggle(
+                "lightweight",
+                style === "lightweight" || style === "lightweightWithKeybindingBackground"
+            );
+            button.element.classList.toggle(
+                "lightweight-keybinding-background",
+                style === "lightweightWithKeybindingBackground"
+            );
+        }));
+    }
+    getHoverContent(keybindingLabel) {
+        return keybindingLabel ? ( localize(4579, "New Session ({0})", keybindingLabel)) : ( localize(4580, "New Session"));
+    }
+    getAriaLabel(keybindingAriaLabel) {
+        return keybindingAriaLabel ? ( localize(4581, "New Session ({0})", keybindingAriaLabel)) : ( localize(4582, "New Session"));
+    }
+    onRun() {
+        logSessionsInteraction(this.telemetryService, "newSession", this.telemetrySource);
+    }
+    runAction(event) {
+        if (event?.altKey) {
+            this.commandService.executeCommand(NEW_SESSION_ACTION_ID, {
+                toSide: true
+            }).catch(onUnexpectedError);
+        } else {
+            super.runAction(event);
+        }
+    }
+};
+NewSessionActionViewItem = ( __decorate([( __param(3, IKeybindingService)), ( __param(4, IHoverService)), ( __param(5, ITelemetryService)), ( __param(6, IContextKeyService)), ( __param(7, ICommandService))], NewSessionActionViewItem));
+let NewSessionActionViewItemContribution = class NewSessionActionViewItemContribution extends Disposable {
+    static {
+        NewSessionActionViewItemContribution_1 = this;
+    }
+    static {
+        this.ID = "workbench.contrib.sessions.newSessionActionViewItem";
+    }
+    static {
+        this.NEW_SESSION_TITLEBAR_TREATMENT = "agentSessionsTitleBarNewSession";
+    }
+    constructor(
+        actionViewItemService,
+        contextKeyService,
+        assignmentService,
+        environmentService,
+        productService,
+        configurationService,
+        logService
+    ) {
+        super();
+        this.assignmentService = assignmentService;
+        this.environmentService = environmentService;
+        this.productService = productService;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.newSessionButtonStyle = observableValue(this, "default");
+        this.newSessionButtonStyleRequest = 0;
+        this.titleBarEnabledContext = SessionsTitleBarNewSessionEnabledContext.bindTo(contextKeyService);
+        const configuredStyle = observableConfigValue(NEW_SESSION_BUTTON_STYLE_SETTING, "default", this.configurationService);
+        const assignmentsChanged = observableSignalFromEvent(this, this.assignmentService.onDidRefetchAssignments);
+        this._register(autorun(reader => {
+            configuredStyle.read(reader);
+            assignmentsChanged.read(reader);
+            void this.updateNewSessionButtonStyle().catch(onUnexpectedError);
+        }));
+        const onDidRegister = this._register(( new Emitter()));
+        const menus = [Menus.SidebarSessionsHeader, Menus.TitleBarLeftLayout];
+        for (const menu of menus) {
+            const source = menu === Menus.TitleBarLeftLayout ? "titleBar" : "sidebar";
+            this._register(
+                actionViewItemService.register(menu, NEW_SESSION_ACTION_ID, (action, _options, instantiationService) => {
+                    if (!(action instanceof MenuItemAction)) {
+                        return undefined;
+                    }
+                    return instantiationService.createInstance(NewSessionActionViewItem, action, source, this.newSessionButtonStyle);
+                }, onDidRegister.event)
+            );
+        }
+        onDidRegister.fire();
+        this._register(
+            this.assignmentService.onDidRefetchAssignments(() => this.updateTitleBarTreatment())
+        );
+        this.updateTitleBarTreatment();
+    }
+    async updateNewSessionButtonStyle() {
+        const request = ++this.newSessionButtonStyleRequest;
+        const inspection = this.configurationService.inspect(NEW_SESSION_BUTTON_STYLE_SETTING);
+        let value;
+        if (isConfigured(inspection)) {
+            value = inspection.value;
+        } else {
+            try {
+                value = await this.assignmentService.getTreatment(NEW_SESSION_BUTTON_STYLE_TREATMENT);
+            } catch (error) {
+                this.logService.warn(
+                    "[NewSessionActionViewItemContribution] Failed to resolve the New Session button style treatment; using default.",
+                    error
+                );
+            }
+        }
+        if (request !== this.newSessionButtonStyleRequest) {
+            return;
+        }
+        this.newSessionButtonStyle.set(this.normalizeNewSessionButtonStyle(value), undefined);
+    }
+    normalizeNewSessionButtonStyle(value) {
+        if (value === undefined || value === "default" || value === "lightweight" || value === "lightweightWithKeybindingBackground") {
+            return value ?? "default";
+        }
+        this.logService.warn(
+            `[NewSessionActionViewItemContribution] Unsupported New Session button style treatment '${value}'; using 'default'.`
+        );
+        return "default";
+    }
+    async updateTitleBarTreatment() {
+        if (!this.environmentService.isBuilt) {
+            this.titleBarEnabledContext.set(true);
+            return;
+        }
+        const enabled = await this.assignmentService.getTreatment(NewSessionActionViewItemContribution_1.NEW_SESSION_TITLEBAR_TREATMENT);
+        this.titleBarEnabledContext.set(enabled ?? this.productService.quality === "insider");
+    }
+};
+NewSessionActionViewItemContribution = NewSessionActionViewItemContribution_1 = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, IContextKeyService)), ( __param(2, IWorkbenchAssignmentService)), ( __param(3, IEnvironmentService)), ( __param(4, IProductService)), ( __param(5, IConfigurationService)), ( __param(6, ILogService))], NewSessionActionViewItemContribution));
+let SessionConversationActionsContribution = class SessionConversationActionsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.sessions.conversationActions";
+    }
+    constructor(_sessionsService, _uriIdentityService) {
+        super();
+        this._sessionsService = _sessionsService;
+        this._uriIdentityService = _uriIdentityService;
+        this._register(autorun(reader => {
+            for (const session of this._sessionsService.visibleSessions.read(reader)) {
+                if (session) {
+                    reader.store.add(this._registerSessionConversationActions(session, reader));
+                }
+            }
+        }));
+    }
+    _registerSessionConversationActions(session, reader) {
+        const store = ( new DisposableStore());
+        const that = this;
+        const extUri = this._uriIdentityService.extUri;
+        const scopedToSession = ( ContextKeyExpr.equals(SessionIdContext.key, session.sessionId));
+        const conversationsVisible = ( ContextKeyExpr.and(scopedToSession, SessionIsCreatedContext, ( SessionIsArchivedContext.negate()), SessionHasSideChatsContext));
+        const allChats = session.chats.read(reader);
+        const registerOpen = (chat, order) => {
+            const chatResource = chat.resource;
+            const title = chat.title.read(reader) || ( localize(4557, "Untitled Chat"));
+            store.add(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: getSessionConversationActionId(session.sessionId, chatResource),
+                        title,
+                        menu: {
+                            id: Menus.SessionConversations,
+                            group: SESSION_CONVERSATION_SIDE_CHATS_GROUP,
+                            order,
+                            when: conversationsVisible
+                        }
+                    });
+                }
+                async run(accessor, forwardedSession) {
+                    const target = forwardedSession ?? session;
+                    const targetChat = target.chats.get().find(c => extUri.isEqual(c.resource, chatResource));
+                    if (!targetChat) {
+                        return;
+                    }
+                    if (ModifierKeyEmitter.getInstance().keyStatus.altKey) {
+                        const view = accessor.get(ISessionsPartService).getSessionView(target.sessionId);
+                        if (view) {
+                            await view.openChatToSide(targetChat.resource);
+                            return;
+                        }
+                    }
+                    await that._sessionsService.openChat(target, targetChat.resource);
+                }
+            }));
+        };
+        allChats.forEach((chat, index) => {
+            if (chat.status.read(reader) === SessionStatus.Untitled) {
+                return;
+            }
+            if (isSessionConversationSideChat(chat)) {
+                registerOpen(chat, index);
+            }
+        });
+        return store;
+    }
+};
+SessionConversationActionsContribution = ( __decorate([( __param(0, ISessionsService)), ( __param(1, IUriIdentityService))], SessionConversationActionsContribution));
+MenuRegistry.appendMenuItem(Menus.SessionBarToolbar, {
+    submenu: Menus.SessionConversations,
+    title: ( localize2(4583, "Side Chats")),
+    icon: Codicon.commentDiscussion,
+    group: "secondary/2_chats",
+    order: 10,
+    when: ( ContextKeyExpr.and(SessionIsCreatedContext, ( SessionIsArchivedContext.negate()), SessionHasSideChatsContext))
+});
+registerAction2(class TogglePinSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.togglePin",
+            title: ( localize2(4584, "Pin")),
+            icon: Codicon.pin,
+            toggled: {
+                condition: SessionIsStickyContext,
+                icon: Codicon.pinned,
+                title: ( localize(4585, "Unpin"))
+            },
+            menu: [{
+                id: Menus.SessionBarToolbar,
+                group: "navigation",
+                order: 10,
+                when: ( ContextKeyExpr.and(SessionIsCreatedContext, SessionIsStickyContext, ( SessionIsArchivedContext.negate())))
+            }, {
+                id: Menus.SessionBarToolbar,
+                group: "secondary/4_pin",
+                order: 10,
+                when: ( ContextKeyExpr.and(SessionIsCreatedContext, ( SessionIsArchivedContext.negate())))
+            }]
+        });
+    }
+    async run(accessor, session) {
+        if (!session) {
+            return;
+        }
+        accessor.get(ISessionsService).toggleSessionStickiness(session);
+    }
+});
+MenuRegistry.appendMenuItem(Menus.SessionHeaderContext, {
+    command: {
+        id: "sessions.chatCompositeBar.togglePin",
+        title: ( localize(4586, "Pin")),
+        toggled: {
+            condition: SessionIsStickyContext,
+            title: ( localize(4587, "Unpin"))
+        }
+    },
+    group: "1_view",
+    order: 1,
+    when: SessionIsCreatedContext
+});
+registerAction2(class RenameSessionHeaderAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.sessionHeader.rename",
+            title: ( localize2(4588, "Rename...")),
+            icon: Codicon.edit,
+            menu: [{
+                id: Menus.SessionHeaderContext,
+                group: "2_edit",
+                order: 1,
+                when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
+            }, {
+                id: Menus.SessionBarToolbar,
+                group: "secondary/1_session",
+                order: 20,
+                when: ( ContextKeyExpr.and(SessionIsCreatedContext, SessionSupportsRenameContext, ( SessionIsArchivedContext.negate())))
+            }]
+        });
+    }
+    async run(accessor, session) {
+        if (!session) {
+            return;
+        }
+        if (accessor.get(ISessionsPartService).getSessionView(session.sessionId)?.startTitleEditing()) {
+            return;
+        }
+        await accessor.get(ICommandService).executeCommand(RENAME_SESSION_COMMAND_ID, session);
+    }
+});
+registerAction2(class CloseSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.close",
+            title: ( localize2(4589, "Close")),
+            icon: Codicon.close,
+            menu: [{
+                id: Menus.SessionBarToolbar,
+                when: ( ContextKeyExpr.or(SessionIsCreatedContext, MultipleSessionsVisibleContext)),
+                group: "secondary/4_pin",
+                order: 30
+            }, {
+                id: Menus.SessionHeaderContext,
+                when: ( ContextKeyExpr.or(SessionIsCreatedContext, MultipleSessionsVisibleContext)),
+                group: "1_view",
+                order: 2
+            }]
+        });
+    }
+    async run(accessor, session) {
+        const sessionsService = accessor.get(ISessionsService);
+        const sessionsPartService = accessor.get(ISessionsPartService);
+        sessionsService.closeSession(session);
+        sessionsPartService.focusSession(sessionsService.activeSession.get());
+    }
+});
+registerAction2(class ToggleMaximizeSessionViewAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.chatCompositeBar.toggleMaximize",
+            title: ( localize2(4590, "Maximize")),
+            icon: Codicon.screenFull,
+            toggled: {
+                condition: SessionIsMaximizedContext,
+                icon: Codicon.screenNormal,
+                title: ( localize(4591, "Restore"))
+            },
+            menu: {
+                id: Menus.SessionBarToolbar,
+                when: MultipleSessionsVisibleContext,
+                group: "secondary/4_pin",
+                order: 20
+            }
+        });
+    }
+    async run(accessor, session) {
+        accessor.get(ISessionsPartService).toggleMaximizeSession(session);
+        accessor.get(ISessionsService).setActive(session);
+    }
+});
+registerAction2(class CloseEditorAreaAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.closeEditorArea",
+            title: ( localize2(4592, "Close Editor Area")),
+            icon: Codicon.close,
+            category: SessionsCategories.Sessions,
+            menu: {
+                id: MenuId.EditorGroupWatermarkToolbar,
+                group: "navigation",
+                order: 10,
+                when: IsSessionsWindowContext
+            }
+        });
+    }
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        layoutService.setPartHidden(true, Parts.EDITOR_PART);
+    }
+});
+
+export { CompactButtonActionViewItem, NEW_SESSION_BUTTON_STYLE_SETTING, NEW_SESSION_BUTTON_STYLE_TREATMENT, NewSessionActionViewItem, NewSessionActionViewItemContribution, SHOW_CHATS_PICKER_COMMAND_ID, SHOW_SESSIONS_PICKER_COMMAND_ID, SessionConversationActionsContribution };