@codingame/monaco-vscode-chat-service-override 24.3.0 → 25.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsActions.js

@@ -1,12 +1,11 @@
 
 import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { AgentSessionSection, isAgentSessionSection, isMarshalledAgentSessionContext, isLocalAgentSessionItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { Action2, MenuId, MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
-import { ViewAction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/views/viewPane';
-import { AGENT_SESSIONS_VIEW_ID, AgentSessionsViewerOrientation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
-import { isMarshalledChatSessionContext } from '../actions/chatSessionActions.js';
+import { AgentSessionProviders, AGENT_SESSION_RENAME_ACTION_ID, AGENT_SESSION_DELETE_ACTION_ID, AgentSessionsViewerOrientation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
 import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ACTIVE_GROUP, SIDE_GROUP, AUX_WINDOW_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
@@ -17,32 +16,268 @@ import { Position } from '@codingame/monaco-vscode-api/vscode/vs/workbench/servi
 import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
 import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
-import { showClearEditingSessionConfirmation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { ChatEditorInput, showClearEditingSessionConfirmation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
 import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { CHAT_CATEGORY, ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { AgentSessionsPicker } from './agentSessionsPicker.js';
+import { ActiveEditorContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
 
+class ToggleChatViewSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.toggleChatViewSessions',
+            title: ( localize2(4855, "Show Sessions")),
+            toggled: ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsEnabled}`, true)),
+            menu: {
+                id: MenuId.ChatWelcomeContext,
+                group: '0_sessions',
+                order: 1,
+                when: ( ChatContextKeys.inChatEditor.negate())
+            }
+        });
+    }
+    async run(accessor) {
+        const configurationService = accessor.get(IConfigurationService);
+        const chatViewSessionsEnabled = configurationService.getValue(ChatConfiguration.ChatViewSessionsEnabled);
+        await configurationService.updateValue(ChatConfiguration.ChatViewSessionsEnabled, !chatViewSessionsEnabled);
+    }
+}
+const agentSessionsOrientationSubmenu = ( new MenuId('chatAgentSessionsOrientationSubmenu'));
+MenuRegistry.appendMenuItem(MenuId.ChatWelcomeContext, {
+    submenu: agentSessionsOrientationSubmenu,
+    title: ( localize2(4856, "Sessions Orientation")),
+    group: '0_sessions',
+    order: 2,
+    when: ( ChatContextKeys.inChatEditor.negate())
+});
+class SetAgentSessionsOrientationStackedAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.setAgentSessionsOrientationStacked',
+            title: ( localize2(4857, "Stacked")),
+            toggled: ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsOrientation}`, 'stacked')),
+            precondition: ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsEnabled}`, true)),
+            menu: {
+                id: agentSessionsOrientationSubmenu,
+                group: 'navigation',
+                order: 2
+            }
+        });
+    }
+    async run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        await commandService.executeCommand(HideAgentSessionsSidebar.ID);
+    }
+}
+class SetAgentSessionsOrientationSideBySideAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.setAgentSessionsOrientationSideBySide',
+            title: ( localize2(4858, "Side by Side")),
+            toggled: ( ContextKeyExpr.notEquals(`config.${ChatConfiguration.ChatViewSessionsOrientation}`, 'stacked')),
+            precondition: ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsEnabled}`, true)),
+            menu: {
+                id: agentSessionsOrientationSubmenu,
+                group: 'navigation',
+                order: 1
+            }
+        });
+    }
+    async run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        await commandService.executeCommand(ShowAgentSessionsSidebar.ID);
+    }
+}
+class PickAgentSessionAction extends Action2 {
+    constructor() {
+        super({
+            id: `workbench.action.chat.history`,
+            title: ( localize2(4859, "Open Agent Session...")),
+            menu: [
+                {
+                    id: MenuId.ViewTitle,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', ChatViewId)), ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsEnabled}`, false)))),
+                    group: 'navigation',
+                    order: 2
+                },
+                {
+                    id: MenuId.ViewTitle,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', ChatViewId)), ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsEnabled}`, true)))),
+                    group: '2_history',
+                    order: 1
+                },
+                {
+                    id: MenuId.EditorTitle,
+                    when: ( ActiveEditorContext.isEqualTo(ChatEditorInput.EditorID)),
+                }
+            ],
+            category: CHAT_CATEGORY,
+            icon: Codicon.history,
+            f1: true,
+            precondition: ChatContextKeys.enabled
+        });
+    }
+    async run(accessor) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const agentSessionsPicker = instantiationService.createInstance(AgentSessionsPicker);
+        await agentSessionsPicker.pickAgentSession();
+    }
+}
+class ArchiveAllAgentSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.archiveAllAgentSessions',
+            title: ( localize2(4860, "Archive All Workspace Agent Sessions")),
+            precondition: ChatContextKeys.enabled,
+            category: CHAT_CATEGORY,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const agentSessionsService = accessor.get(IAgentSessionsService);
+        const dialogService = accessor.get(IDialogService);
+        const sessionsToArchive = agentSessionsService.model.sessions.filter(session => !session.isArchived());
+        if (sessionsToArchive.length === 0) {
+            return;
+        }
+        const confirmed = await dialogService.confirm({
+            message: sessionsToArchive.length === 1
+                ? ( localize(4861, "Are you sure you want to archive 1 agent session?"))
+                : ( localize(
+                4862,
+                "Are you sure you want to archive {0} agent sessions?",
+                sessionsToArchive.length
+            )),
+            detail: ( localize(4863, "You can unarchive sessions later if needed from the Chat view.")),
+            primaryButton: ( localize(4864, "Archive"))
+        });
+        if (!confirmed.confirmed) {
+            return;
+        }
+        for (const session of sessionsToArchive) {
+            session.setArchived(true);
+        }
+    }
+}
+class ArchiveAgentSessionSectionAction extends Action2 {
+    constructor() {
+        super({
+            id: 'agentSessionSection.archive',
+            title: ( localize2(4865, "Archive All")),
+            icon: Codicon.archive,
+            menu: {
+                id: MenuId.AgentSessionSectionToolbar,
+                group: 'navigation',
+                order: 1,
+                when: ( ChatContextKeys.agentSessionSection.notEqualsTo(AgentSessionSection.Archived)),
+            }
+        });
+    }
+    async run(accessor, context) {
+        if (!context || !isAgentSessionSection(context)) {
+            return;
+        }
+        const dialogService = accessor.get(IDialogService);
+        const confirmed = await dialogService.confirm({
+            message: context.sessions.length === 1
+                ? ( localize(
+                4866,
+                "Are you sure you want to archive 1 agent session from '{0}'?",
+                context.label
+            ))
+                : ( localize(
+                4867,
+                "Are you sure you want to archive {0} agent sessions from '{1}'?",
+                context.sessions.length,
+                context.label
+            )),
+            detail: ( localize(4868, "You can unarchive sessions later if needed from the sessions view.")),
+            primaryButton: ( localize(4869, "Archive All"))
+        });
+        if (!confirmed.confirmed) {
+            return;
+        }
+        for (const session of context.sessions) {
+            session.setArchived(true);
+        }
+    }
+}
 class BaseAgentSessionAction extends Action2 {
-    run(accessor, context) {
+    async run(accessor, context) {
         const agentSessionsService = accessor.get(IAgentSessionsService);
+        const viewsService = accessor.get(IViewsService);
         let session;
-        if (isMarshalledChatSessionContext(context)) {
+        if (isMarshalledAgentSessionContext(context)) {
             session = agentSessionsService.getSession(context.session.resource);
         }
         else {
             session = context;
         }
+        if (!session) {
+            const chatView = viewsService.getActiveViewWithId(ChatViewId);
+            session = chatView?.getFocusedSessions().at(0);
+        }
         if (session) {
-            this.runWithSession(session, accessor);
+            await this.runWithSession(session, accessor);
         }
     }
 }
+class MarkAgentSessionUnreadAction extends BaseAgentSessionAction {
+    constructor() {
+        super({
+            id: 'agentSession.markUnread',
+            title: ( localize2(4870, "Mark as Unread")),
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                group: '1_edit',
+                order: 1,
+                when: ( ContextKeyExpr.and(ChatContextKeys.isReadAgentSession, (
+                ChatContextKeys.isArchivedAgentSession.negate()))),
+            }
+        });
+    }
+    runWithSession(session) {
+        session.setRead(false);
+    }
+}
+class MarkAgentSessionReadAction extends BaseAgentSessionAction {
+    constructor() {
+        super({
+            id: 'agentSession.markRead',
+            title: ( localize2(4871, "Mark as Read")),
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                group: '1_edit',
+                order: 1,
+                when: ( ContextKeyExpr.and(( ChatContextKeys.isReadAgentSession.negate()), (
+                ChatContextKeys.isArchivedAgentSession.negate()))),
+            }
+        });
+    }
+    runWithSession(session) {
+        session.setRead(true);
+    }
+}
 class ArchiveAgentSessionAction extends BaseAgentSessionAction {
     constructor() {
         super({
             id: 'agentSession.archive',
-            title: ( localize2(4839, "Archive")),
+            title: ( localize2(4872, "Archive")),
             icon: Codicon.archive,
+            keybinding: {
+                primary: KeyCode.Delete,
+                mac: { primary: KeyMod.CtrlCmd | KeyCode.Backspace },
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+                when: ( ContextKeyExpr.and(ChatContextKeys.agentSessionsViewerFocused, ( ChatContextKeys.isArchivedAgentSession.negate())))
+            },
             menu: [{
                     id: MenuId.AgentSessionItemToolbar,
                     group: 'navigation',
@@ -50,7 +285,7 @@ class ArchiveAgentSessionAction extends BaseAgentSessionAction {
                     when: ( ChatContextKeys.isArchivedAgentSession.negate()),
                 }, {
                     id: MenuId.AgentSessionsContext,
-                    group: 'edit',
+                    group: '1_edit',
                     order: 2,
                     when: ( ChatContextKeys.isArchivedAgentSession.negate())
                 }]
@@ -62,8 +297,8 @@ class ArchiveAgentSessionAction extends BaseAgentSessionAction {
         const dialogService = accessor.get(IDialogService);
         if (chatModel && !(await showClearEditingSessionConfirmation(chatModel, dialogService, {
             isArchiveAction: true,
-            titleOverride: ( localize(4840, "Archive chat with pending edits?")),
-            messageOverride: ( localize(4841, "You have pending changes in this chat session."))
+            titleOverride: ( localize(4873, "Archive chat with pending edits?")),
+            messageOverride: ( localize(4874, "You have pending changes in this chat session."))
         }))) {
             return;
         }
@@ -74,8 +309,19 @@ class UnarchiveAgentSessionAction extends BaseAgentSessionAction {
     constructor() {
         super({
             id: 'agentSession.unarchive',
-            title: ( localize2(4842, "Unarchive")),
+            title: ( localize2(4875, "Unarchive")),
             icon: Codicon.unarchive,
+            keybinding: {
+                primary: KeyMod.Shift | KeyCode.Delete,
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Backspace,
+                },
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+                when: ( ContextKeyExpr.and(
+                    ChatContextKeys.agentSessionsViewerFocused,
+                    ChatContextKeys.isArchivedAgentSession
+                ))
+            },
             menu: [{
                     id: MenuId.AgentSessionItemToolbar,
                     group: 'navigation',
@@ -83,7 +329,7 @@ class UnarchiveAgentSessionAction extends BaseAgentSessionAction {
                     when: ChatContextKeys.isArchivedAgentSession,
                 }, {
                     id: MenuId.AgentSessionsContext,
-                    group: 'edit',
+                    group: '1_edit',
                     order: 2,
                     when: ChatContextKeys.isArchivedAgentSession,
                 }]
@@ -93,16 +339,108 @@ class UnarchiveAgentSessionAction extends BaseAgentSessionAction {
         session.setArchived(false);
     }
 }
-class BaseOpenAgentSessionAction extends Action2 {
-    async run(accessor, context) {
-        if (!context) {
+class RenameAgentSessionAction extends BaseAgentSessionAction {
+    constructor() {
+        super({
+            id: AGENT_SESSION_RENAME_ACTION_ID,
+            title: ( localize2(4876, "Rename...")),
+            keybinding: {
+                primary: KeyCode.F2,
+                mac: {
+                    primary: KeyCode.Enter
+                },
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+                when: ( ContextKeyExpr.and(ChatContextKeys.agentSessionsViewerFocused, ( ChatContextKeys.agentSessionType.isEqualTo(AgentSessionProviders.Local)))),
+            },
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                group: '1_edit',
+                order: 3,
+                when: ( ChatContextKeys.agentSessionType.isEqualTo(AgentSessionProviders.Local))
+            }
+        });
+    }
+    async runWithSession(session, accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const chatService = accessor.get(IChatService);
+        const title = await quickInputService.input({ prompt: ( localize(4877, "New agent session title")), value: session.label });
+        if (title) {
+            chatService.setChatSessionTitle(session.resource, title);
+        }
+    }
+}
+class DeleteAgentSessionAction extends BaseAgentSessionAction {
+    constructor() {
+        super({
+            id: AGENT_SESSION_DELETE_ACTION_ID,
+            title: ( localize2(4878, "Delete...")),
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                group: '1_edit',
+                order: 4,
+                when: ( ChatContextKeys.agentSessionType.isEqualTo(AgentSessionProviders.Local))
+            }
+        });
+    }
+    async runWithSession(session, accessor) {
+        const chatService = accessor.get(IChatService);
+        const dialogService = accessor.get(IDialogService);
+        const widgetService = accessor.get(IChatWidgetService);
+        const confirmed = await dialogService.confirm({
+            message: ( localize(4879, "Are you sure you want to delete this chat session?")),
+            detail: ( localize(4880, "This action cannot be undone.")),
+            primaryButton: ( localize(4881, "Delete"))
+        });
+        if (!confirmed.confirmed) {
             return;
         }
+        await widgetService.getWidgetBySessionResource(session.resource)?.clear();
+        await chatService.removeHistoryEntry(session.resource);
+    }
+}
+class DeleteAllLocalSessionsAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.clearHistory',
+            title: ( localize2(4882, "Delete All Local Workspace Chat Sessions")),
+            precondition: ChatContextKeys.enabled,
+            category: CHAT_CATEGORY,
+            f1: true,
+        });
+    }
+    async run(accessor, ...args) {
+        const chatService = accessor.get(IChatService);
+        const widgetService = accessor.get(IChatWidgetService);
+        const dialogService = accessor.get(IDialogService);
+        const agentSessionsService = accessor.get(IAgentSessionsService);
+        const localSessionsCount = agentSessionsService.model.sessions.filter(session => isLocalAgentSessionItem(session)).length;
+        if (localSessionsCount === 0) {
+            return;
+        }
+        const confirmed = await dialogService.confirm({
+            message: localSessionsCount === 1
+                ? ( localize(4883, "Are you sure you want to delete 1 local workspace chat session?"))
+                : ( localize(
+                4884,
+                "Are you sure you want to delete {0} local workspace chat sessions?",
+                localSessionsCount
+            )),
+            detail: ( localize(4885, "This action cannot be undone.")),
+            primaryButton: ( localize(4886, "Delete All"))
+        });
+        if (!confirmed.confirmed) {
+            return;
+        }
+        await Promise.all(( widgetService.getAllWidgets().map(widget => widget.clear())));
+        await chatService.clearAllHistoryEntries();
+    }
+}
+class BaseOpenAgentSessionAction extends BaseAgentSessionAction {
+    async runWithSession(session, accessor) {
         const chatWidgetService = accessor.get(IChatWidgetService);
-        const uri = context.session.resource;
+        const uri = session.resource;
         await chatWidgetService.openSession(uri, this.getTargetGroup(), {
             ...this.getOptions(),
-            ignoreInView: true,
             pinned: true
         });
     }
@@ -112,7 +450,15 @@ class OpenAgentSessionInEditorGroupAction extends BaseOpenAgentSessionAction {
     constructor() {
         super({
             id: OpenAgentSessionInEditorGroupAction.id,
-            title: ( localize(4843, "Open as Editor")),
+            title: ( localize2(4887, "Open as Editor")),
+            keybinding: {
+                primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyCode.Enter
+                },
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+                when: ChatContextKeys.agentSessionsViewerFocused,
+            },
             menu: {
                 id: MenuId.AgentSessionsContext,
                 order: 1,
@@ -132,7 +478,15 @@ class OpenAgentSessionInNewEditorGroupAction extends BaseOpenAgentSessionAction
     constructor() {
         super({
             id: OpenAgentSessionInNewEditorGroupAction.id,
-            title: ( localize(4844, "Open to the Side")),
+            title: ( localize2(4888, "Open to the Side")),
+            keybinding: {
+                primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.Enter,
+                mac: {
+                    primary: KeyMod.WinCtrl | KeyMod.Alt | KeyCode.Enter
+                },
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+                when: ChatContextKeys.agentSessionsViewerFocused,
+            },
             menu: {
                 id: MenuId.AgentSessionsContext,
                 order: 2,
@@ -152,7 +506,7 @@ class OpenAgentSessionInNewWindowAction extends BaseOpenAgentSessionAction {
     constructor() {
         super({
             id: OpenAgentSessionInNewWindowAction.id,
-            title: ( localize(4845, "Open in New Window")),
+            title: ( localize2(4889, "Open in New Window")),
             menu: {
                 id: MenuId.AgentSessionsContext,
                 order: 3,
@@ -169,83 +523,11 @@ class OpenAgentSessionInNewWindowAction extends BaseOpenAgentSessionAction {
         };
     }
 }
-class MarkAgentSessionUnreadAction extends BaseAgentSessionAction {
-    constructor() {
-        super({
-            id: 'agentSession.markUnread',
-            title: ( localize2(4846, "Mark as Unread")),
-            menu: {
-                id: MenuId.AgentSessionsContext,
-                group: 'edit',
-                order: 1,
-                when: ( ContextKeyExpr.and(ChatContextKeys.isReadAgentSession, (
-                ChatContextKeys.isArchivedAgentSession.negate()))),
-            }
-        });
-    }
-    runWithSession(session) {
-        session.setRead(false);
-    }
-}
-class MarkAgentSessionReadAction extends BaseAgentSessionAction {
-    constructor() {
-        super({
-            id: 'agentSession.markRead',
-            title: ( localize2(4847, "Mark as Read")),
-            menu: {
-                id: MenuId.AgentSessionsContext,
-                group: 'edit',
-                order: 1,
-                when: ( ContextKeyExpr.and(( ChatContextKeys.isReadAgentSession.negate()), (
-                ChatContextKeys.isArchivedAgentSession.negate()))),
-            }
-        });
-    }
-    runWithSession(session) {
-        session.setRead(true);
-    }
-}
-class RefreshAgentSessionsViewAction extends ViewAction {
-    constructor() {
-        super({
-            id: 'agentSessionsView.refresh',
-            title: ( localize2(4848, "Refresh Agent Sessions")),
-            icon: Codicon.refresh,
-            menu: {
-                id: MenuId.AgentSessionsViewTitle,
-                group: 'navigation',
-                order: 1
-            },
-            viewId: AGENT_SESSIONS_VIEW_ID
-        });
-    }
-    runInView(accessor, view) {
-        view.refresh();
-    }
-}
-class FindAgentSessionAction extends ViewAction {
-    constructor() {
-        super({
-            id: 'agentSessionsView.find',
-            title: ( localize2(4849, "Find Agent Session")),
-            icon: Codicon.search,
-            menu: {
-                id: MenuId.AgentSessionsViewTitle,
-                group: 'navigation',
-                order: 2
-            },
-            viewId: AGENT_SESSIONS_VIEW_ID
-        });
-    }
-    runInView(accessor, view) {
-        view.openFind();
-    }
-}
 class RefreshAgentSessionsViewerAction extends Action2 {
     constructor() {
         super({
             id: 'agentSessionsViewer.refresh',
-            title: ( localize2(4848, "Refresh Agent Sessions")),
+            title: ( localize2(4890, "Refresh Agent Sessions")),
             icon: Codicon.refresh,
             menu: {
                 id: MenuId.AgentSessionsToolbar,
@@ -263,7 +545,7 @@ class FindAgentSessionInViewerAction extends Action2 {
     constructor() {
         super({
             id: 'agentSessionsViewer.find',
-            title: ( localize2(4849, "Find Agent Session")),
+            title: ( localize2(4891, "Find Agent Session")),
             icon: Codicon.search,
             menu: {
                 id: MenuId.AgentSessionsToolbar,
@@ -282,58 +564,76 @@ class UpdateChatViewWidthAction extends Action2 {
         const layoutService = accessor.get(IWorkbenchLayoutService);
         const viewDescriptorService = accessor.get(IViewDescriptorService);
         const configurationService = accessor.get(IConfigurationService);
-        const orientation = this.getOrientation();
+        const viewsService = accessor.get(IViewsService);
         const chatLocation = viewDescriptorService.getViewLocationById(ChatViewId);
         if (typeof chatLocation !== 'number') {
             return;
         }
         const panelPosition = layoutService.getPanelPosition();
         const canResizeView = chatLocation !== ViewContainerLocation.Panel || (panelPosition === Position.LEFT || panelPosition === Position.RIGHT);
-        const configuredSessionsViewerOrientation = configurationService.getValue(ChatConfiguration.ChatViewSessionsOrientation);
-        if ((!canResizeView || configuredSessionsViewerOrientation === 'sideBySide') && orientation === AgentSessionsViewerOrientation.Stacked) {
-            await configurationService.updateValue(ChatConfiguration.ChatViewSessionsOrientation, 'stacked');
+        const chatViewSessionsEnabled = configurationService.getValue(ChatConfiguration.ChatViewSessionsEnabled);
+        if (!chatViewSessionsEnabled) {
+            await configurationService.updateValue(ChatConfiguration.ChatViewSessionsEnabled, true);
         }
-        else if ((!canResizeView || configuredSessionsViewerOrientation === 'stacked') && orientation === AgentSessionsViewerOrientation.SideBySide) {
-            await configurationService.updateValue(ChatConfiguration.ChatViewSessionsOrientation, 'sideBySide');
+        let chatView = viewsService.getActiveViewWithId(ChatViewId);
+        if (!chatView) {
+            chatView = await viewsService.openView(ChatViewId, false);
         }
-        const part = getPartByLocation(chatLocation);
-        let currentSize = layoutService.getSize(part);
-        const sideBySideMinWidth = 600 + 1;
-        const stackedMaxWidth = 300 + 1;
-        if (configuredSessionsViewerOrientation !== 'auto') {
-            if ((orientation === AgentSessionsViewerOrientation.SideBySide && currentSize.width >= sideBySideMinWidth) ||
-                orientation === AgentSessionsViewerOrientation.Stacked
-            ) {
-                return;
-            }
+        if (!chatView) {
+            return;
+        }
+        const configuredOrientation = configurationService.getValue(ChatConfiguration.ChatViewSessionsOrientation);
+        let validatedConfiguredOrientation;
+        if (configuredOrientation === 'stacked' || configuredOrientation === 'sideBySide') {
+            validatedConfiguredOrientation = configuredOrientation;
+        }
+        else {
+            validatedConfiguredOrientation = 'sideBySide';
+        }
+        const newOrientation = this.getOrientation();
+        const lastWidthForOrientation = chatView?.getLastDimensions(newOrientation)?.width;
+        if ((!canResizeView || validatedConfiguredOrientation === 'sideBySide') && newOrientation === AgentSessionsViewerOrientation.Stacked) {
+            chatView.updateConfiguredSessionsViewerOrientation('stacked');
+        }
+        else if ((!canResizeView || validatedConfiguredOrientation === 'stacked') && newOrientation === AgentSessionsViewerOrientation.SideBySide) {
+            chatView.updateConfiguredSessionsViewerOrientation('sideBySide');
         }
         if (!canResizeView) {
             return;
         }
+        const part = getPartByLocation(chatLocation);
+        let currentSize = layoutService.getSize(part);
+        const chatViewDefaultWidth = 300;
+        const sideBySideMinWidth = (chatViewDefaultWidth * 2) + 1;
+        if ((newOrientation === AgentSessionsViewerOrientation.SideBySide && currentSize.width >= sideBySideMinWidth) ||
+            (newOrientation === AgentSessionsViewerOrientation.Stacked && chatLocation === ViewContainerLocation.AuxiliaryBar && layoutService.isAuxiliaryBarMaximized())
+        ) {
+            return;
+        }
         if (chatLocation === ViewContainerLocation.AuxiliaryBar) {
             layoutService.setAuxiliaryBarMaximized(false);
             currentSize = layoutService.getSize(part);
         }
         let newWidth;
-        if (orientation === AgentSessionsViewerOrientation.SideBySide) {
-            newWidth = Math.max(sideBySideMinWidth, Math.round(layoutService.mainContainerDimension.width / 2));
+        if (newOrientation === AgentSessionsViewerOrientation.SideBySide) {
+            newWidth = Math.max(sideBySideMinWidth, lastWidthForOrientation || Math.round(layoutService.mainContainerDimension.width / 2));
         }
         else {
-            newWidth = stackedMaxWidth;
+            newWidth = lastWidthForOrientation || chatViewDefaultWidth;
         }
-        layoutService.setSize(part, {
-            width: newWidth,
-            height: currentSize.height
-        });
+        layoutService.setSize(part, { width: newWidth, height: currentSize.height });
     }
 }
 class ShowAgentSessionsSidebar extends UpdateChatViewWidthAction {
     static { this.ID = 'agentSessions.showAgentSessionsSidebar'; }
-    static { this.TITLE = ( localize2(4850, "Show Agent Sessions Sidebar")); }
+    static { this.TITLE = ( localize2(4892, "Show Agent Sessions Sidebar")); }
     constructor() {
         super({
             id: ShowAgentSessionsSidebar.ID,
             title: ShowAgentSessionsSidebar.TITLE,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.agentSessionsViewerOrientation.isEqualTo(AgentSessionsViewerOrientation.Stacked)))),
+            f1: true,
+            category: CHAT_CATEGORY,
         });
     }
     getOrientation() {
@@ -342,17 +642,74 @@ class ShowAgentSessionsSidebar extends UpdateChatViewWidthAction {
 }
 class HideAgentSessionsSidebar extends UpdateChatViewWidthAction {
     static { this.ID = 'agentSessions.hideAgentSessionsSidebar'; }
-    static { this.TITLE = ( localize2(4851, "Hide Agent Sessions Sidebar")); }
+    static { this.TITLE = ( localize2(4893, "Hide Agent Sessions Sidebar")); }
     constructor() {
         super({
             id: HideAgentSessionsSidebar.ID,
             title: HideAgentSessionsSidebar.TITLE,
-            icon: Codicon.layoutSidebarRightOff,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.agentSessionsViewerOrientation.isEqualTo(AgentSessionsViewerOrientation.SideBySide)))),
+            f1: true,
+            category: CHAT_CATEGORY,
         });
     }
     getOrientation() {
         return AgentSessionsViewerOrientation.Stacked;
     }
 }
+class ToggleAgentSessionsSidebar extends Action2 {
+    static { this.ID = 'agentSessions.toggleAgentSessionsSidebar'; }
+    static { this.TITLE = ( localize2(4894, "Toggle Agent Sessions Sidebar")); }
+    constructor() {
+        super({
+            id: ToggleAgentSessionsSidebar.ID,
+            title: ToggleAgentSessionsSidebar.TITLE,
+            precondition: ChatContextKeys.enabled,
+            f1: true,
+            category: CHAT_CATEGORY,
+        });
+    }
+    async run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        const viewsService = accessor.get(IViewsService);
+        const chatView = viewsService.getActiveViewWithId(ChatViewId);
+        const currentOrientation = chatView?.getSessionsViewerOrientation();
+        if (currentOrientation === AgentSessionsViewerOrientation.SideBySide) {
+            await commandService.executeCommand(HideAgentSessionsSidebar.ID);
+        }
+        else {
+            await commandService.executeCommand(ShowAgentSessionsSidebar.ID);
+        }
+    }
+}
+class FocusAgentSessionsAction extends Action2 {
+    static { this.id = 'workbench.action.chat.focusAgentSessionsViewer'; }
+    constructor() {
+        super({
+            id: FocusAgentSessionsAction.id,
+            title: ( localize2(4895, "Focus Agent Sessions")),
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.equals(`config.${ChatConfiguration.ChatViewSessionsEnabled}`, true)))),
+            category: CHAT_CATEGORY,
+            f1: true,
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const configurationService = accessor.get(IConfigurationService);
+        const commandService = accessor.get(ICommandService);
+        const chatView = await viewsService.openView(ChatViewId, true);
+        const focused = chatView?.focusSessions();
+        if (focused) {
+            return;
+        }
+        const configuredSessionsViewerOrientation = configurationService.getValue(ChatConfiguration.ChatViewSessionsOrientation);
+        if (configuredSessionsViewerOrientation === 'stacked') {
+            await commandService.executeCommand(ACTION_ID_NEW_CHAT);
+        }
+        else {
+            await commandService.executeCommand(ShowAgentSessionsSidebar.ID);
+        }
+        chatView?.focusSessions();
+    }
+}
 
-export { ArchiveAgentSessionAction, FindAgentSessionAction, FindAgentSessionInViewerAction, HideAgentSessionsSidebar, MarkAgentSessionReadAction, MarkAgentSessionUnreadAction, OpenAgentSessionInEditorGroupAction, OpenAgentSessionInNewEditorGroupAction, OpenAgentSessionInNewWindowAction, RefreshAgentSessionsViewAction, RefreshAgentSessionsViewerAction, ShowAgentSessionsSidebar, UnarchiveAgentSessionAction };
+export { ArchiveAgentSessionAction, ArchiveAgentSessionSectionAction, ArchiveAllAgentSessionsAction, DeleteAgentSessionAction, DeleteAllLocalSessionsAction, FindAgentSessionInViewerAction, FocusAgentSessionsAction, HideAgentSessionsSidebar, MarkAgentSessionReadAction, MarkAgentSessionUnreadAction, OpenAgentSessionInEditorGroupAction, OpenAgentSessionInNewEditorGroupAction, OpenAgentSessionInNewWindowAction, PickAgentSessionAction, RefreshAgentSessionsViewerAction, RenameAgentSessionAction, SetAgentSessionsOrientationSideBySideAction, SetAgentSessionsOrientationStackedAction, ShowAgentSessionsSidebar, ToggleAgentSessionsSidebar, ToggleChatViewSessionsAction, UnarchiveAgentSessionAction };