@codingame/monaco-vscode-chat-service-override 23.3.0 → 24.1.0

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

@@ -0,0 +1,358 @@
+
+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 { 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 { 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';
+import { ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { getPartByLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/browser/viewsService';
+import { Position } 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 { 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 { 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';
+
+class BaseAgentSessionAction extends Action2 {
+    run(accessor, context) {
+        const agentSessionsService = accessor.get(IAgentSessionsService);
+        let session;
+        if (isMarshalledChatSessionContext(context)) {
+            session = agentSessionsService.getSession(context.session.resource);
+        }
+        else {
+            session = context;
+        }
+        if (session) {
+            this.runWithSession(session, accessor);
+        }
+    }
+}
+class ArchiveAgentSessionAction extends BaseAgentSessionAction {
+    constructor() {
+        super({
+            id: 'agentSession.archive',
+            title: ( localize2(4839, "Archive")),
+            icon: Codicon.archive,
+            menu: [{
+                    id: MenuId.AgentSessionItemToolbar,
+                    group: 'navigation',
+                    order: 1,
+                    when: ( ChatContextKeys.isArchivedAgentSession.negate()),
+                }, {
+                    id: MenuId.AgentSessionsContext,
+                    group: 'edit',
+                    order: 2,
+                    when: ( ChatContextKeys.isArchivedAgentSession.negate())
+                }]
+        });
+    }
+    async runWithSession(session, accessor) {
+        const chatService = accessor.get(IChatService);
+        const chatModel = chatService.getSession(session.resource);
+        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."))
+        }))) {
+            return;
+        }
+        session.setArchived(true);
+    }
+}
+class UnarchiveAgentSessionAction extends BaseAgentSessionAction {
+    constructor() {
+        super({
+            id: 'agentSession.unarchive',
+            title: ( localize2(4842, "Unarchive")),
+            icon: Codicon.unarchive,
+            menu: [{
+                    id: MenuId.AgentSessionItemToolbar,
+                    group: 'navigation',
+                    order: 1,
+                    when: ChatContextKeys.isArchivedAgentSession,
+                }, {
+                    id: MenuId.AgentSessionsContext,
+                    group: 'edit',
+                    order: 2,
+                    when: ChatContextKeys.isArchivedAgentSession,
+                }]
+        });
+    }
+    runWithSession(session) {
+        session.setArchived(false);
+    }
+}
+class BaseOpenAgentSessionAction extends Action2 {
+    async run(accessor, context) {
+        if (!context) {
+            return;
+        }
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const uri = context.session.resource;
+        await chatWidgetService.openSession(uri, this.getTargetGroup(), {
+            ...this.getOptions(),
+            ignoreInView: true,
+            pinned: true
+        });
+    }
+}
+class OpenAgentSessionInEditorGroupAction extends BaseOpenAgentSessionAction {
+    static { this.id = 'workbench.action.chat.openSessionInEditorGroup'; }
+    constructor() {
+        super({
+            id: OpenAgentSessionInEditorGroupAction.id,
+            title: ( localize(4843, "Open as Editor")),
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                order: 1,
+                group: 'navigation'
+            }
+        });
+    }
+    getTargetGroup() {
+        return ACTIVE_GROUP;
+    }
+    getOptions() {
+        return {};
+    }
+}
+class OpenAgentSessionInNewEditorGroupAction extends BaseOpenAgentSessionAction {
+    static { this.id = 'workbench.action.chat.openSessionInNewEditorGroup'; }
+    constructor() {
+        super({
+            id: OpenAgentSessionInNewEditorGroupAction.id,
+            title: ( localize(4844, "Open to the Side")),
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                order: 2,
+                group: 'navigation'
+            }
+        });
+    }
+    getTargetGroup() {
+        return SIDE_GROUP;
+    }
+    getOptions() {
+        return {};
+    }
+}
+class OpenAgentSessionInNewWindowAction extends BaseOpenAgentSessionAction {
+    static { this.id = 'workbench.action.chat.openSessionInNewWindow'; }
+    constructor() {
+        super({
+            id: OpenAgentSessionInNewWindowAction.id,
+            title: ( localize(4845, "Open in New Window")),
+            menu: {
+                id: MenuId.AgentSessionsContext,
+                order: 3,
+                group: 'navigation'
+            }
+        });
+    }
+    getTargetGroup() {
+        return AUX_WINDOW_GROUP;
+    }
+    getOptions() {
+        return {
+            auxiliary: { compact: true, bounds: { width: 800, height: 640 } }
+        };
+    }
+}
+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")),
+            icon: Codicon.refresh,
+            menu: {
+                id: MenuId.AgentSessionsToolbar,
+                group: 'navigation',
+                order: 1,
+                when: ( ChatContextKeys.agentSessionsViewerLimited.negate())
+            },
+        });
+    }
+    run(accessor, agentSessionsControl) {
+        agentSessionsControl.refresh();
+    }
+}
+class FindAgentSessionInViewerAction extends Action2 {
+    constructor() {
+        super({
+            id: 'agentSessionsViewer.find',
+            title: ( localize2(4849, "Find Agent Session")),
+            icon: Codicon.search,
+            menu: {
+                id: MenuId.AgentSessionsToolbar,
+                group: 'navigation',
+                order: 2,
+                when: ( ChatContextKeys.agentSessionsViewerLimited.negate())
+            }
+        });
+    }
+    run(accessor, agentSessionsControl) {
+        return agentSessionsControl.openFind();
+    }
+}
+class UpdateChatViewWidthAction extends Action2 {
+    async run(accessor) {
+        const layoutService = accessor.get(IWorkbenchLayoutService);
+        const viewDescriptorService = accessor.get(IViewDescriptorService);
+        const configurationService = accessor.get(IConfigurationService);
+        const orientation = this.getOrientation();
+        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');
+        }
+        else if ((!canResizeView || configuredSessionsViewerOrientation === 'stacked') && orientation === AgentSessionsViewerOrientation.SideBySide) {
+            await configurationService.updateValue(ChatConfiguration.ChatViewSessionsOrientation, 'sideBySide');
+        }
+        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 (!canResizeView) {
+            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));
+        }
+        else {
+            newWidth = stackedMaxWidth;
+        }
+        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")); }
+    constructor() {
+        super({
+            id: ShowAgentSessionsSidebar.ID,
+            title: ShowAgentSessionsSidebar.TITLE,
+        });
+    }
+    getOrientation() {
+        return AgentSessionsViewerOrientation.SideBySide;
+    }
+}
+class HideAgentSessionsSidebar extends UpdateChatViewWidthAction {
+    static { this.ID = 'agentSessions.hideAgentSessionsSidebar'; }
+    static { this.TITLE = ( localize2(4851, "Hide Agent Sessions Sidebar")); }
+    constructor() {
+        super({
+            id: HideAgentSessionsSidebar.ID,
+            title: HideAgentSessionsSidebar.TITLE,
+            icon: Codicon.layoutSidebarRightOff,
+        });
+    }
+    getOrientation() {
+        return AgentSessionsViewerOrientation.Stacked;
+    }
+}
+
+export { ArchiveAgentSessionAction, FindAgentSessionAction, FindAgentSessionInViewerAction, HideAgentSessionsSidebar, MarkAgentSessionReadAction, MarkAgentSessionUnreadAction, OpenAgentSessionInEditorGroupAction, OpenAgentSessionInNewEditorGroupAction, OpenAgentSessionInNewWindowAction, RefreshAgentSessionsViewAction, RefreshAgentSessionsViewerAction, ShowAgentSessionsSidebar, UnarchiveAgentSessionAction };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsControl.d.ts

@@ -0,0 +1,55 @@
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IAgentSessionsFilter } from "./agentSessionsViewer.js";
+import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IListStyles } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/listWidget";
+import { IStyleOverride } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles";
+import { IAgentSessionsControl } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+export interface IAgentSessionsControlOptions {
+    readonly overrideStyles?: IStyleOverride<IListStyles>;
+    readonly filter?: IAgentSessionsFilter;
+    readonly allowOpenSessionsInPanel?: boolean;
+    readonly trackActiveEditor?: boolean;
+}
+export declare class AgentSessionsControl extends Disposable implements IAgentSessionsControl {
+    private readonly container;
+    private readonly options;
+    private readonly contextMenuService;
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    private readonly chatSessionsService;
+    private readonly commandService;
+    private readonly editorGroupsService;
+    private readonly chatService;
+    private readonly menuService;
+    private readonly chatWidgetService;
+    private readonly agentSessionsService;
+    private readonly telemetryService;
+    private readonly editorService;
+    private sessionsContainer;
+    private sessionsList;
+    private visible;
+    constructor(container: HTMLElement, options: IAgentSessionsControlOptions | undefined, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService, chatSessionsService: IChatSessionsService, commandService: ICommandService, editorGroupsService: IEditorGroupsService, chatService: IChatService, menuService: IMenuService, chatWidgetService: IChatWidgetService, agentSessionsService: IAgentSessionsService, telemetryService: ITelemetryService, editorService: IEditorService);
+    private registerListeners;
+    private revealAndFocusActiveEditorSession;
+    private createList;
+    private openAgentSession;
+    private showContextMenu;
+    openFind(): void;
+    refresh(): Promise<void>;
+    update(): void;
+    setVisible(visible: boolean): void;
+    layout(height: number, width: number): void;
+    focus(): void;
+    clearFocus(): void;
+}

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

@@ -0,0 +1,222 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { WorkbenchCompressibleAsyncDataTree } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { append, $, EventHelper } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { isLocalAgentSessionItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { AgentSessionsSorter, AgentSessionsListDelegate, AgentSessionsCompressionDelegate, AgentSessionRenderer, AgentSessionsDataSource, AgentSessionsKeyboardNavigationLabelProvider, AgentSessionsIdentityProvider, AgentSessionsDragAndDrop, AgentSessionsAccessibilityProvider } from './agentSessionsViewer.js';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { getSessionItemContextOverlay } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatSessions/common';
+import { ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatViewPaneTarget } 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 { TreeFindMode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/abstractTree';
+import { ACTIVE_GROUP, SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+
+let AgentSessionsControl = class AgentSessionsControl extends Disposable {
+    constructor(container, options, contextMenuService, contextKeyService, instantiationService, chatSessionsService, commandService, editorGroupsService, chatService, menuService, chatWidgetService, agentSessionsService, telemetryService, editorService) {
+        super();
+        this.container = container;
+        this.options = options;
+        this.contextMenuService = contextMenuService;
+        this.contextKeyService = contextKeyService;
+        this.instantiationService = instantiationService;
+        this.chatSessionsService = chatSessionsService;
+        this.commandService = commandService;
+        this.editorGroupsService = editorGroupsService;
+        this.chatService = chatService;
+        this.menuService = menuService;
+        this.chatWidgetService = chatWidgetService;
+        this.agentSessionsService = agentSessionsService;
+        this.telemetryService = telemetryService;
+        this.editorService = editorService;
+        this.visible = true;
+        this.createList(this.container);
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.options?.trackActiveEditor) {
+            this._register(this.editorService.onDidActiveEditorChange(() => this.revealAndFocusActiveEditorSession()));
+        }
+    }
+    revealAndFocusActiveEditorSession() {
+        if (!this.visible) {
+            return;
+        }
+        const input = this.editorService.activeEditor;
+        if (!(input instanceof ChatEditorInput)) {
+            return;
+        }
+        const sessionResource = input.sessionResource;
+        if (!sessionResource) {
+            return;
+        }
+        const matchingSession = this.agentSessionsService.model.getSession(sessionResource);
+        if (matchingSession && this.sessionsList?.hasNode(matchingSession)) {
+            if (this.sessionsList.getRelativeTop(matchingSession) === null) {
+                this.sessionsList.reveal(matchingSession, 0.5);
+            }
+            this.sessionsList.setFocus([matchingSession]);
+            this.sessionsList.setSelection([matchingSession]);
+        }
+    }
+    createList(container) {
+        this.sessionsContainer = append(container, $('.agent-sessions-viewer'));
+        const sorter = this.instantiationService.createInstance(AgentSessionsSorter);
+        const list = this.sessionsList = this._register(this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'AgentSessionsView', this.sessionsContainer, ( new AgentSessionsListDelegate()), ( new AgentSessionsCompressionDelegate()), [
+            this.instantiationService.createInstance(AgentSessionRenderer)
+        ], ( new AgentSessionsDataSource(this.options?.filter, sorter)), {
+            accessibilityProvider: ( new AgentSessionsAccessibilityProvider()),
+            dnd: this.instantiationService.createInstance(AgentSessionsDragAndDrop),
+            identityProvider: ( new AgentSessionsIdentityProvider()),
+            horizontalScrolling: false,
+            multipleSelectionSupport: false,
+            findWidgetEnabled: true,
+            defaultFindMode: TreeFindMode.Filter,
+            keyboardNavigationLabelProvider: ( new AgentSessionsKeyboardNavigationLabelProvider()),
+            sorter,
+            overrideStyles: this.options?.overrideStyles,
+            twistieAdditionalCssClass: () => 'force-no-twistie',
+        }));
+        const model = this.agentSessionsService.model;
+        this._register(Event.any(this.options?.filter?.onDidChange ?? Event.None, model.onDidChangeSessions)(() => {
+            if (this.visible) {
+                list.updateChildren();
+            }
+        }));
+        list.setInput(model);
+        this._register(list.onDidOpen(e => this.openAgentSession(e)));
+        this._register(list.onContextMenu(e => this.showContextMenu(e)));
+        this._register(list.onMouseDblClick(({ element }) => {
+            if (element === null) {
+                this.commandService.executeCommand(ACTION_ID_NEW_CHAT);
+            }
+        }));
+    }
+    async openAgentSession(e) {
+        const session = e.element;
+        if (!session) {
+            return;
+        }
+        this.telemetryService.publicLog2('agentSessionOpened', {
+            source: this.options?.allowOpenSessionsInPanel ? 'chatView' : 'agentsView',
+            providerType: session.providerType
+        });
+        session.setRead(true);
+        let sessionOptions;
+        if (isLocalAgentSessionItem(session)) {
+            sessionOptions = {};
+        }
+        else {
+            sessionOptions = { title: { preferred: session.label } };
+        }
+        sessionOptions.ignoreInView = true;
+        const options = {
+            ...sessionOptions,
+            ...e.editorOptions,
+            revealIfOpened: this.options?.allowOpenSessionsInPanel
+        };
+        await this.chatSessionsService.activateChatSessionItemProvider(session.providerType);
+        let target;
+        if (e.sideBySide) {
+            target = this.options?.allowOpenSessionsInPanel ? ACTIVE_GROUP : SIDE_GROUP;
+        }
+        else if (this.options?.allowOpenSessionsInPanel) {
+            target = ChatViewPaneTarget;
+        }
+        else {
+            target = ACTIVE_GROUP;
+        }
+        const isLocalChatSession = session.resource.scheme === Schemas.vscodeChatEditor ||
+            session.resource.scheme === Schemas.vscodeLocalChatSession;
+        if (!isLocalChatSession && !(await this.chatSessionsService.canResolveChatSession(session.resource))) {
+            const editorTarget = target === ChatViewPaneTarget ? undefined : target;
+            await this.editorService.openEditor({
+                resource: session.resource,
+                options: {
+                    ...options,
+                    revealIfOpened: options?.revealIfOpened ?? true
+                }
+            }, editorTarget);
+            return;
+        }
+        await this.chatWidgetService.openSession(session.resource, target, options);
+    }
+    async showContextMenu({ element: session, anchor, browserEvent }) {
+        if (!session) {
+            return;
+        }
+        EventHelper.stop(browserEvent, true);
+        const provider = await this.chatSessionsService.activateChatSessionItemProvider(session.providerType);
+        const contextOverlay = getSessionItemContextOverlay(session, provider, this.chatService, this.editorGroupsService);
+        contextOverlay.push([ChatContextKeys.isCombinedAgentSessionsViewer.key, true]);
+        contextOverlay.push([ChatContextKeys.isReadAgentSession.key, session.isRead()]);
+        contextOverlay.push([ChatContextKeys.isArchivedAgentSession.key, session.isArchived()]);
+        const menu = this.menuService.createMenu(MenuId.AgentSessionsContext, this.contextKeyService.createOverlay(contextOverlay));
+        const marshalledSession = { session, $mid: MarshalledId.ChatSessionContext };
+        this.contextMenuService.showContextMenu({
+            getActions: () => Separator.join(...( menu.getActions({ arg: marshalledSession, shouldForwardArgs: true }).map(([, actions]) => actions))),
+            getAnchor: () => anchor,
+            getActionsContext: () => marshalledSession,
+        });
+        menu.dispose();
+    }
+    openFind() {
+        this.sessionsList?.openFind();
+    }
+    refresh() {
+        return this.agentSessionsService.model.resolve(undefined);
+    }
+    update() {
+        this.sessionsList?.updateChildren();
+    }
+    setVisible(visible) {
+        this.visible = visible;
+        if (this.visible) {
+            this.sessionsList?.updateChildren();
+        }
+    }
+    layout(height, width) {
+        this.sessionsList?.layout(height, width);
+    }
+    focus() {
+        this.sessionsList?.domFocus();
+    }
+    clearFocus() {
+        this.sessionsList?.setFocus([]);
+        this.sessionsList?.setSelection([]);
+    }
+};
+AgentSessionsControl = ( __decorate([
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IChatSessionsService)),
+    ( __param(6, ICommandService)),
+    ( __param(7, IEditorGroupsService)),
+    ( __param(8, IChatService)),
+    ( __param(9, IMenuService)),
+    ( __param(10, IChatWidgetService)),
+    ( __param(11, IAgentSessionsService)),
+    ( __param(12, ITelemetryService)),
+    ( __param(13, IEditorService))
+], AgentSessionsControl));
+
+export { AgentSessionsControl };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsFilter.d.ts

@@ -0,0 +1,37 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IAgentSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel";
+import { IAgentSessionsFilter } from "./agentSessionsViewer.js";
+export interface IAgentSessionsFilterOptions extends Partial<IAgentSessionsFilter> {
+    readonly filterMenuId: MenuId;
+    readonly limitResults?: () => number | undefined;
+    notifyResults?(count: number): void;
+    overrideExclude?(session: IAgentSession): boolean | undefined;
+}
+export declare class AgentSessionsFilter extends Disposable implements Required<IAgentSessionsFilter> {
+    private readonly options;
+    private readonly chatSessionsService;
+    private readonly storageService;
+    private readonly STORAGE_KEY;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    readonly limitResults: () => number | undefined;
+    private excludes;
+    private readonly actionDisposables;
+    constructor(options: IAgentSessionsFilterOptions, chatSessionsService: IChatSessionsService, storageService: IStorageService);
+    private registerListeners;
+    private updateExcludes;
+    private resetExcludes;
+    private storeExcludes;
+    private updateFilterActions;
+    private registerProviderActions;
+    private registerStateActions;
+    private registerArchivedActions;
+    private registerReadActions;
+    private registerResetAction;
+    isDefault(): boolean;
+    exclude(session: IAgentSession): boolean;
+    notifyResults(count: number): void;
+}