@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.0

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

@@ -0,0 +1,247 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { fromNow, getDurationString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatViewModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel';
+import { CodeBlockModelCollection } from '../../common/widget/codeBlockModelCollection.js';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatListWidget } from '../widget/chatListWidget.js';
+import { getAgentSessionProvider, AgentSessionProviders, getAgentSessionProviderIcon, getAgentSessionProviderName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { getAgentChangesSummary, hasValidDiff } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import * as agentSessionHoverWidget from './media/agentSessionHoverWidget.css';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+registerCss(agentSessionHoverWidget);
+const HEADER_HEIGHT = 60;
+const CHAT_LIST_HEIGHT = 240;
+const CHAT_HOVER_WIDTH = 500;
+let AgentSessionHoverWidget = class AgentSessionHoverWidget extends Disposable {
+    constructor(session, chatService, instantiationService, chatWidgetService) {
+        super();
+        this.session = session;
+        this.chatService = chatService;
+        this.instantiationService = instantiationService;
+        this.chatWidgetService = chatWidgetService;
+        this.hasRendered = false;
+        this.domNode = $(".agent-session-hover.interactive-session");
+        this.domNode.style.width = `${CHAT_HOVER_WIDTH}px`;
+        this.domNode.style.height = `${HEADER_HEIGHT + CHAT_LIST_HEIGHT}px`;
+        this.domNode.style.overflow = "hidden";
+        this.cts = ( new CancellationTokenSource());
+        this._register(toDisposable(() => this.cts.cancel()));
+        this.buildHeader();
+        this.contentElement = append(this.domNode, $(".agent-session-hover-content"));
+        this.loadingElement = append(this.contentElement, $(".agent-session-hover-loading"));
+        append(this.loadingElement, renderIcon(ThemeIcon.modify(Codicon.loading, "spin")));
+        this.renderScheduler = this._register(( new RunOnceScheduler(() => this.render(), 200)));
+    }
+    onRendered() {
+        this.modelRef ??= this.loadModel();
+        if (!this.hasRendered) {
+            this.hasRendered = true;
+            this.renderScheduler.schedule();
+        } else {
+            this.listWidget?.layout(CHAT_LIST_HEIGHT, CHAT_HOVER_WIDTH);
+        }
+    }
+    async loadModel() {
+        const modelRef = await this.chatService.loadSessionForResource(this.session.resource, ChatAgentLocation.Chat, this.cts.token);
+        if (this._store.isDisposed) {
+            modelRef?.dispose();
+            return;
+        }
+        if (!modelRef) {
+            this.loadingElement.remove();
+            const tooltip = this.buildFallbackTooltip(this.session);
+            this.domNode.textContent = typeof tooltip === "string" ? tooltip : tooltip.value;
+            return;
+        }
+        this._register(modelRef);
+        return modelRef.object;
+    }
+    async render() {
+        this.modelRef ??= this.loadModel();
+        const model = await this.modelRef;
+        if (!model || this._store.isDisposed) {
+            return;
+        }
+        this.loadingElement.remove();
+        const codeBlockCollection = this._register(
+            this.instantiationService.createInstance(CodeBlockModelCollection, "agentSessionHover")
+        );
+        const viewModel = this._register(
+            this.instantiationService.createInstance(ChatViewModel, model, codeBlockCollection, {
+                maxVisibleItems: 2
+            })
+        );
+        const container = append(this.contentElement, $(".interactive-list"));
+        const listWidget = this._register(this.instantiationService.createInstance(ChatListWidget, container, {
+            rendererOptions: {
+                renderStyle: "compact",
+                noHeader: true,
+                editable: false
+            },
+            currentChatMode: () => ChatModeKind.Ask
+        }));
+        listWidget.layout(CHAT_LIST_HEIGHT, CHAT_HOVER_WIDTH);
+        listWidget.setScrollLock(true);
+        listWidget.setViewModel(viewModel);
+        listWidget.refresh();
+        const viewModelScheudler = this._register(( new RunOnceScheduler(() => listWidget.refresh(), 500)));
+        this._register(viewModel.onDidChange(() => {
+            if (!viewModelScheudler.isScheduled()) {
+                viewModelScheudler.schedule();
+            }
+        }));
+        this._register(listWidget.onDidClickFollowup(async followup => {
+            const widget = await this.chatWidgetService.openSession(model.sessionResource);
+            if (widget) {
+                widget.acceptInput(followup.message);
+            }
+        }));
+    }
+    buildHeader() {
+        const session = this.session;
+        const header = append(this.domNode, $(".agent-session-hover-header"));
+        const titleRow = append(header, $(".agent-session-hover-title"));
+        append(titleRow, $("span", undefined, session.label));
+        const detailsRow = append(header, $(".agent-session-hover-details"));
+        const providerType = getAgentSessionProvider(session.providerType);
+        const provider = providerType ?? AgentSessionProviders.Local;
+        const providerIcon = getAgentSessionProviderIcon(provider);
+        append(detailsRow, renderIcon(providerIcon));
+        append(
+            detailsRow,
+            $("span", undefined, getAgentSessionProviderName(provider))
+        );
+        append(detailsRow, $("span.separator", undefined, "•"));
+        if (session.timing.lastRequestEnded && session.timing.lastRequestStarted) {
+            const duration = this.toDuration(session.timing.lastRequestStarted, session.timing.lastRequestEnded, true);
+            if (duration) {
+                append(detailsRow, $("span", undefined, duration));
+            }
+        } else {
+            const startTime = session.timing.lastRequestStarted ?? session.timing.created;
+            append(detailsRow, $("span", undefined, fromNow(startTime, true, true)));
+        }
+        const diff = getAgentChangesSummary(session.changes);
+        if (diff && hasValidDiff(session.changes)) {
+            append(detailsRow, $("span.separator", undefined, "•"));
+            const diffContainer = append(detailsRow, $(".agent-session-hover-diff"));
+            if (diff.files > 0) {
+                append(diffContainer, $("span", undefined, diff.files === 1 ? ( localize(4888, "1 file")) : ( localize(4889, "{0} files", diff.files))));
+            }
+            if (diff.insertions > 0) {
+                append(diffContainer, $("span.insertions", undefined, `+${diff.insertions}`));
+            }
+            if (diff.deletions > 0) {
+                append(diffContainer, $("span.deletions", undefined, `-${diff.deletions}`));
+            }
+        }
+        if (session.status !== ChatSessionStatus.Completed) {
+            append(detailsRow, $("span.separator", undefined, "•"));
+            append(detailsRow, $("span", undefined, this.toStatusLabel(session.status)));
+        }
+        if (session.isArchived()) {
+            append(detailsRow, $("span.separator", undefined, "•"));
+            append(detailsRow, renderIcon(Codicon.archive));
+            append(detailsRow, $("span", undefined, ( localize(4890, "Archived"))));
+        }
+    }
+    buildFallbackTooltip(session) {
+        const lines = [];
+        lines.push(`**${session.label}**`);
+        if (session.tooltip) {
+            const tooltip = typeof session.tooltip === "string" ? session.tooltip : session.tooltip.value;
+            lines.push(tooltip);
+        } else {
+            if (session.description) {
+                const description = typeof session.description === "string" ? session.description : session.description.value;
+                lines.push(description);
+            }
+            if (session.badge) {
+                const badge = typeof session.badge === "string" ? session.badge : session.badge.value;
+                lines.push(badge);
+            }
+        }
+        const details = [];
+        const providerType = getAgentSessionProvider(session.providerType);
+        const provider = providerType ?? AgentSessionProviders.Local;
+        const providerIcon = getAgentSessionProviderIcon(provider);
+        const providerName = getAgentSessionProviderName(provider);
+        let timeLabel;
+        if (session.timing.lastRequestEnded && session.timing.lastRequestStarted) {
+            const duration = this.toDuration(session.timing.lastRequestStarted, session.timing.lastRequestEnded, true);
+            timeLabel = duration ?? fromNow(session.timing.lastRequestStarted, true, true);
+        } else {
+            const startTime = session.timing.lastRequestStarted ?? session.timing.created;
+            timeLabel = fromNow(startTime, true, true);
+        }
+        details.push(`$(${providerIcon.id}) ${providerName} • ${timeLabel}`);
+        const diff = getAgentChangesSummary(session.changes);
+        if (diff && hasValidDiff(session.changes)) {
+            const diffParts = [];
+            if (diff.files > 0) {
+                diffParts.push(diff.files === 1 ? ( localize(4888, "1 file")) : ( localize(4889, "{0} files", diff.files)));
+            }
+            if (diff.insertions > 0) {
+                diffParts.push(`+${diff.insertions}`);
+            }
+            if (diff.deletions > 0) {
+                diffParts.push(`-${diff.deletions}`);
+            }
+            if (diffParts.length > 0) {
+                details.push(diffParts.join(" "));
+            }
+        }
+        if (session.status !== ChatSessionStatus.Completed) {
+            details.push(this.toStatusLabel(session.status));
+        }
+        lines.push(details.join(" • "));
+        if (session.isArchived()) {
+            lines.push(`$(archive) ${( localize(4890, "Archived"))}`);
+        }
+        return ( new MarkdownString(lines.join("\n\n"), {
+            supportThemeIcons: true
+        }));
+    }
+    toDuration(startTime, endTime, useFullTimeWords) {
+        const elapsed = Math.round((endTime - startTime) / 1000) * 1000;
+        if (elapsed < 1000) {
+            return undefined;
+        }
+        return getDurationString(elapsed, useFullTimeWords);
+    }
+    toStatusLabel(status) {
+        let statusLabel;
+        switch (status) {
+        case ChatSessionStatus.NeedsInput:
+            statusLabel = ( localize(4891, "Needs Input"));
+            break;
+        case ChatSessionStatus.InProgress:
+            statusLabel = ( localize(4892, "In Progress"));
+            break;
+        case ChatSessionStatus.Failed:
+            statusLabel = ( localize(4893, "Failed"));
+            break;
+        default:
+            statusLabel = ( localize(4894, "Completed"));
+        }
+        return statusLabel;
+    }
+};
+AgentSessionHoverWidget = ( __decorate([( __param(1, IChatService)), ( __param(2, IInstantiationService)), ( __param(3, IChatWidgetService))], AgentSessionHoverWidget));
+
+export { AgentSessionHoverWidget };

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

@@ -0,0 +1,71 @@
+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 { IOpenEvent } from "@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService";
+import { IAgentSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel";
+import { AgentSessionListItem, IAgentSessionsFilter, IAgentSessionsSorterOptions } 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 { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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";
+import { HoverPosition } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ISessionOpenOptions } from "./agentSessionsOpener.js";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+export interface IAgentSessionsControlOptions extends IAgentSessionsSorterOptions {
+    readonly overrideStyles: IStyleOverride<IListStyles>;
+    readonly filter: IAgentSessionsFilter;
+    readonly source: string;
+    getHoverPosition(): HoverPosition;
+    trackActiveEditorSession(): boolean;
+    overrideSessionOpenOptions?(openEvent: IOpenEvent<AgentSessionListItem | undefined>): ISessionOpenOptions;
+    notifySessionOpened?(resource: URI, widget: IChatWidget): void;
+}
+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 menuService;
+    private readonly agentSessionsService;
+    private readonly telemetryService;
+    private readonly editorService;
+    private sessionsContainer;
+    get element(): HTMLElement | undefined;
+    private sessionsList;
+    private sessionsListFindIsOpen;
+    private visible;
+    private focusedAgentSessionArchivedContextKey;
+    private focusedAgentSessionReadContextKey;
+    private focusedAgentSessionTypeContextKey;
+    private hasMultipleAgentSessionsSelectedContextKey;
+    constructor(container: HTMLElement, options: IAgentSessionsControlOptions, contextMenuService: IContextMenuService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService, chatSessionsService: IChatSessionsService, commandService: ICommandService, menuService: IMenuService, agentSessionsService: IAgentSessionsService, telemetryService: ITelemetryService, editorService: IEditorService);
+    private registerListeners;
+    private revealAndFocusActiveEditorSession;
+    private createList;
+    private openAgentSession;
+    private showContextMenu;
+    private showAgentSessionSectionContextMenu;
+    private showAgentSessionContextMenu;
+    openFind(): void;
+    private updateSectionCollapseStates;
+    refresh(): Promise<void>;
+    update(): Promise<void>;
+    setVisible(visible: boolean): void;
+    layout(height: number, width: number): void;
+    focus(): void;
+    clearFocus(): void;
+    hasFocusOrSelection(): boolean;
+    scrollToTop(): void;
+    getFocus(): IAgentSession[];
+    reveal(sessionResource: URI): boolean;
+}

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

@@ -0,0 +1,347 @@
+
+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/actions/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 { isAgentSessionSection, AgentSessionSection, isAgentSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { AgentSessionsSorter, AgentSessionsListDelegate, AgentSessionsCompressionDelegate, AgentSessionRenderer, AgentSessionSectionRenderer, 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 { ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+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 { RenderIndentGuides, TreeFindMode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/abstractTree';
+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 { openSession } from './agentSessionsOpener.js';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
+
+let AgentSessionsControl = class AgentSessionsControl extends Disposable {
+    get element() {
+        return this.sessionsContainer;
+    }
+    constructor(
+        container,
+        options,
+        contextMenuService,
+        contextKeyService,
+        instantiationService,
+        chatSessionsService,
+        commandService,
+        menuService,
+        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.menuService = menuService;
+        this.agentSessionsService = agentSessionsService;
+        this.telemetryService = telemetryService;
+        this.editorService = editorService;
+        this.sessionsListFindIsOpen = false;
+        this.visible = true;
+        this.focusedAgentSessionArchivedContextKey = ChatContextKeys.isArchivedAgentSession.bindTo(this.contextKeyService);
+        this.focusedAgentSessionReadContextKey = ChatContextKeys.isReadAgentSession.bindTo(this.contextKeyService);
+        this.focusedAgentSessionTypeContextKey = ChatContextKeys.agentSessionType.bindTo(this.contextKeyService);
+        this.hasMultipleAgentSessionsSelectedContextKey = ChatContextKeys.hasMultipleAgentSessionsSelected.bindTo(this.contextKeyService);
+        this.createList(this.container);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(
+            this.editorService.onDidActiveEditorChange(() => this.revealAndFocusActiveEditorSession())
+        );
+    }
+    revealAndFocusActiveEditorSession() {
+        if (!this.options.trackActiveEditorSession() || !this.visible) {
+            return;
+        }
+        const input = this.editorService.activeEditor;
+        const resource = (input instanceof ChatEditorInput) ? input.sessionResource : input?.resource;
+        if (!resource) {
+            return;
+        }
+        const matchingSession = this.agentSessionsService.model.getSession(resource);
+        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 collapseByDefault = element => {
+            if (isAgentSessionSection(element)) {
+                if (element.section === AgentSessionSection.More && !this.options.filter.getExcludes().read) {
+                    return true;
+                }
+                if (element.section === AgentSessionSection.Archived && this.options.filter.getExcludes().archived) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const sorter = ( new AgentSessionsSorter(this.options));
+        const list = this.sessionsList = this._register(this.instantiationService.createInstance(
+            WorkbenchCompressibleAsyncDataTree,
+            "AgentSessionsView",
+            this.sessionsContainer,
+            ( new AgentSessionsListDelegate()),
+            ( new AgentSessionsCompressionDelegate()),
+            [this._register(
+                this.instantiationService.createInstance(AgentSessionRenderer, this.options)
+            ), this.instantiationService.createInstance(AgentSessionSectionRenderer)],
+            ( new AgentSessionsDataSource(this.options.filter, sorter)),
+            {
+                accessibilityProvider: ( new AgentSessionsAccessibilityProvider()),
+                dnd: this.instantiationService.createInstance(AgentSessionsDragAndDrop),
+                identityProvider: ( new AgentSessionsIdentityProvider()),
+                horizontalScrolling: false,
+                multipleSelectionSupport: true,
+                findWidgetEnabled: true,
+                defaultFindMode: TreeFindMode.Filter,
+                keyboardNavigationLabelProvider: ( new AgentSessionsKeyboardNavigationLabelProvider()),
+                overrideStyles: this.options.overrideStyles,
+                twistieAdditionalCssClass: () => "force-no-twistie",
+                collapseByDefault: element => collapseByDefault(element),
+                renderIndentGuides: RenderIndentGuides.None
+            }
+        ));
+        ChatContextKeys.agentSessionsViewerFocused.bindTo(list.contextKeyService);
+        const model = this.agentSessionsService.model;
+        this._register(this.options.filter.onDidChange(async () => {
+            if (this.visible) {
+                this.updateSectionCollapseStates();
+                list.updateChildren();
+            }
+        }));
+        this._register(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);
+            }
+        }));
+        this._register(Event.any(
+            list.onDidChangeFocus,
+            list.onDidChangeSelection,
+            model.onDidChangeSessions
+        )(() => {
+            const focused = list.getFocus().at(0);
+            if (focused && isAgentSession(focused)) {
+                this.focusedAgentSessionArchivedContextKey.set(focused.isArchived());
+                this.focusedAgentSessionReadContextKey.set(focused.isRead());
+                this.focusedAgentSessionTypeContextKey.set(focused.providerType);
+            } else {
+                this.focusedAgentSessionArchivedContextKey.reset();
+                this.focusedAgentSessionReadContextKey.reset();
+                this.focusedAgentSessionTypeContextKey.reset();
+            }
+            const selection = list.getSelection().filter(isAgentSession);
+            this.hasMultipleAgentSessionsSelectedContextKey.set(selection.length > 1);
+        }));
+        this._register(list.onDidChangeFindOpenState(open => {
+            this.sessionsListFindIsOpen = open;
+            this.updateSectionCollapseStates();
+        }));
+    }
+    async openAgentSession(e) {
+        const element = e.element;
+        if (!element || isAgentSessionSection(element)) {
+            return;
+        }
+        this.telemetryService.publicLog2("agentSessionOpened", {
+            providerType: element.providerType,
+            source: this.options.source
+        });
+        const options = this.options.overrideSessionOpenOptions?.(e) ?? e;
+        const widget = await this.instantiationService.invokeFunction(openSession, element, options);
+        if (widget) {
+            this.options.notifySessionOpened?.(element.resource, widget);
+        }
+    }
+    async showContextMenu(
+        {
+            element,
+            anchor,
+            browserEvent
+        }
+    ) {
+        if (!element) {
+            return;
+        }
+        EventHelper.stop(browserEvent, true);
+        if (isAgentSessionSection(element)) {
+            this.showAgentSessionSectionContextMenu(element, anchor);
+        } else {
+            this.showAgentSessionContextMenu(element, anchor);
+        }
+    }
+    async showAgentSessionSectionContextMenu(section, anchor) {
+        const contextOverlay = [];
+        contextOverlay.push([ChatContextKeys.agentSessionSection.key, section.section]);
+        const menu = this.menuService.createMenu(
+            MenuId.AgentSessionSectionContext,
+            this.contextKeyService.createOverlay(contextOverlay)
+        );
+        this.contextMenuService.showContextMenu({
+            getActions: () => Separator.join(...( menu.getActions({
+                arg: section,
+                shouldForwardArgs: true
+            }).map(([, actions]) => actions))),
+            getAnchor: () => anchor,
+            getActionsContext: () => section
+        });
+        menu.dispose();
+    }
+    async showAgentSessionContextMenu(session, anchor) {
+        await this.chatSessionsService.activateChatSessionItemProvider(session.providerType);
+        const contextOverlay = [];
+        contextOverlay.push([ChatContextKeys.isArchivedAgentSession.key, session.isArchived()]);
+        contextOverlay.push([ChatContextKeys.isReadAgentSession.key, session.isRead()]);
+        contextOverlay.push([ChatContextKeys.agentSessionType.key, session.providerType]);
+        const menu = this.menuService.createMenu(
+            MenuId.AgentSessionsContext,
+            this.contextKeyService.createOverlay(contextOverlay)
+        );
+        const selection = this.sessionsList?.getSelection().filter(isAgentSession) ?? [];
+        const marshalledContext = {
+            session,
+            sessions: selection.length > 1 && selection.includes(session) ? selection : [session],
+            $mid: MarshalledId.AgentSessionContext
+        };
+        this.contextMenuService.showContextMenu({
+            getActions: () => Separator.join(...( menu.getActions({
+                arg: marshalledContext,
+                shouldForwardArgs: true
+            }).map(([, actions]) => actions))),
+            getAnchor: () => anchor,
+            getActionsContext: () => marshalledContext
+        });
+        menu.dispose();
+    }
+    openFind() {
+        this.sessionsList?.openFind();
+    }
+    updateSectionCollapseStates() {
+        if (!this.sessionsList) {
+            return;
+        }
+        const model = this.agentSessionsService.model;
+        for (const child of this.sessionsList.getNode(model).children) {
+            if (!isAgentSessionSection(child.element)) {
+                continue;
+            }
+            switch (child.element.section) {
+            case AgentSessionSection.Archived:
+                {
+                    const shouldCollapseArchived =
+                    !this.sessionsListFindIsOpen && this.options.filter.getExcludes().archived;
+                    if (shouldCollapseArchived && !child.collapsed) {
+                        this.sessionsList.collapse(child.element);
+                    } else if (!shouldCollapseArchived && child.collapsed) {
+                        this.sessionsList.expand(child.element);
+                    }
+                    break;
+                }
+            case AgentSessionSection.More:
+                {
+                    if (child.collapsed) {
+                        let autoExpandMore = false;
+                        if (this.sessionsListFindIsOpen) {
+                            autoExpandMore = true;
+                        } else if (this.options.filter.getExcludes().read && ( child.element.sessions.some(session => !session.isRead()))) {
+                            autoExpandMore = true;
+                        }
+                        if (autoExpandMore) {
+                            this.sessionsList.expand(child.element);
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    refresh() {
+        return this.agentSessionsService.model.resolve(undefined);
+    }
+    async update() {
+        await this.sessionsList?.updateChildren();
+    }
+    setVisible(visible) {
+        if (this.visible === visible) {
+            return;
+        }
+        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([]);
+    }
+    hasFocusOrSelection() {
+        return (this.sessionsList?.getFocus().length ?? 0) > 0 || (this.sessionsList?.getSelection().length ?? 0) > 0;
+    }
+    scrollToTop() {
+        if (this.sessionsList) {
+            this.sessionsList.scrollTop = 0;
+        }
+    }
+    getFocus() {
+        const focused = this.sessionsList?.getFocus() ?? [];
+        return focused.filter(e => isAgentSession(e));
+    }
+    reveal(sessionResource) {
+        if (!this.sessionsList) {
+            return false;
+        }
+        const session = this.agentSessionsService.model.getSession(sessionResource);
+        if (!session || !this.sessionsList.hasNode(session)) {
+            return false;
+        }
+        if (this.sessionsList.getRelativeTop(session) === null) {
+            this.sessionsList.reveal(session, 0.5);
+        }
+        this.sessionsList.setFocus([session]);
+        this.sessionsList.setSelection([session]);
+        return true;
+    }
+};
+AgentSessionsControl = ( __decorate([( __param(2, IContextMenuService)), ( __param(3, IContextKeyService)), ( __param(4, IInstantiationService)), ( __param(5, IChatSessionsService)), ( __param(6, ICommandService)), ( __param(7, IMenuService)), ( __param(8, IAgentSessionsService)), ( __param(9, ITelemetryService)), ( __param(10, IEditorService))], AgentSessionsControl));
+
+export { AgentSessionsControl };