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

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

@@ -0,0 +1,44 @@
+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, IAgentSessionsFilterExcludes } from "./agentSessionsViewer.js";
+export declare enum AgentSessionsGrouping {
+    Capped = "capped",
+    Date = "date"
+}
+export interface IAgentSessionsFilterOptions extends Partial<IAgentSessionsFilter> {
+    readonly filterMenuId: MenuId;
+    readonly limitResults?: () => number | undefined;
+    notifyResults?(count: number): void;
+    readonly groupResults?: () => AgentSessionsGrouping | undefined;
+    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;
+    readonly groupResults: () => AgentSessionsGrouping | undefined;
+    private excludes;
+    private isStoringExcludes;
+    private readonly actionDisposables;
+    constructor(options: IAgentSessionsFilterOptions, chatSessionsService: IChatSessionsService, storageService: IStorageService);
+    private registerListeners;
+    private updateExcludes;
+    private storeExcludes;
+    private updateFilterActions;
+    private registerProviderActions;
+    private registerStateActions;
+    private registerArchivedActions;
+    private registerReadActions;
+    private registerResetAction;
+    isDefault(): boolean;
+    getExcludes(): IAgentSessionsFilterExcludes;
+    exclude(session: IAgentSession): boolean;
+    notifyResults(count: number): void;
+}

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

@@ -0,0 +1,287 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+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 { AgentSessionProviders, getAgentSessionProviderName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+var AgentSessionsGrouping;
+(function(AgentSessionsGrouping) {
+    AgentSessionsGrouping["Capped"] = "capped";
+    AgentSessionsGrouping["Date"] = "date";
+})(AgentSessionsGrouping || (AgentSessionsGrouping = {}));
+const DEFAULT_EXCLUDES = ( Object.freeze({
+    providers: [],
+    states: [],
+    archived: true ,
+    read: false
+}));
+let AgentSessionsFilter = class AgentSessionsFilter extends Disposable {
+    constructor(options, chatSessionsService, storageService) {
+        super();
+        this.options = options;
+        this.chatSessionsService = chatSessionsService;
+        this.storageService = storageService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.limitResults = () => this.options.limitResults?.();
+        this.groupResults = () => this.options.groupResults?.();
+        this.excludes = DEFAULT_EXCLUDES;
+        this.isStoringExcludes = false;
+        this.actionDisposables = this._register(( new DisposableStore()));
+        this.STORAGE_KEY = `agentSessions.filterExcludes.${this.options.filterMenuId.id.toLowerCase()}`;
+        this.updateExcludes(false);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(
+            this.chatSessionsService.onDidChangeItemsProviders(() => this.updateFilterActions())
+        );
+        this._register(
+            this.chatSessionsService.onDidChangeAvailability(() => this.updateFilterActions())
+        );
+        this._register(
+            this.storageService.onDidChangeValue(StorageScope.PROFILE, this.STORAGE_KEY, this._store)(() => this.updateExcludes(true))
+        );
+    }
+    updateExcludes(fromEvent) {
+        if (!this.isStoringExcludes) {
+            const excludedTypesRaw = this.storageService.get(this.STORAGE_KEY, StorageScope.PROFILE);
+            if (excludedTypesRaw) {
+                try {
+                    this.excludes = JSON.parse(excludedTypesRaw);
+                } catch {
+                    this.excludes = {
+                        ...DEFAULT_EXCLUDES
+                    };
+                }
+            } else {
+                this.excludes = {
+                    ...DEFAULT_EXCLUDES
+                };
+            }
+        }
+        this.updateFilterActions();
+        if (fromEvent) {
+            this._onDidChange.fire();
+        }
+    }
+    storeExcludes(excludes) {
+        this.excludes = excludes;
+        this.isStoringExcludes = true;
+        try {
+            if (equals(this.excludes, DEFAULT_EXCLUDES)) {
+                this.storageService.remove(this.STORAGE_KEY, StorageScope.PROFILE);
+            } else {
+                this.storageService.store(
+                    this.STORAGE_KEY,
+                    JSON.stringify(this.excludes),
+                    StorageScope.PROFILE,
+                    StorageTarget.USER
+                );
+            }
+        } finally {
+            this.isStoringExcludes = false;
+        }
+    }
+    updateFilterActions() {
+        this.actionDisposables.clear();
+        this.registerProviderActions(this.actionDisposables);
+        this.registerStateActions(this.actionDisposables);
+        this.registerArchivedActions(this.actionDisposables);
+        this.registerReadActions(this.actionDisposables);
+        this.registerResetAction(this.actionDisposables);
+    }
+    registerProviderActions(disposables) {
+        const providers = ( ( Object.values(AgentSessionProviders)).map(provider => ({
+            id: provider,
+            label: getAgentSessionProviderName(provider)
+        })));
+        for (const provider of this.chatSessionsService.getAllChatSessionContributions()) {
+            if (providers.find(p => p.id === provider.type)) {
+                continue;
+            }
+            providers.push({
+                id: provider.type,
+                label: provider.name
+            });
+        }
+        const that = this;
+        let counter = 0;
+        for (const provider of providers) {
+            disposables.add(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: `agentSessions.filter.toggleExclude:${provider.id}.${that.options.filterMenuId.id.toLowerCase()}`,
+                        title: provider.label,
+                        menu: {
+                            id: that.options.filterMenuId,
+                            group: "1_providers",
+                            order: counter++
+                        },
+                        toggled: that.excludes.providers.includes(provider.id) ? ( ContextKeyExpr.false()) : ContextKeyExpr.true()
+                    });
+                }
+                run() {
+                    const providerExcludes = ( new Set(that.excludes.providers));
+                    if (!providerExcludes.delete(provider.id)) {
+                        providerExcludes.add(provider.id);
+                    }
+                    that.storeExcludes({
+                        ...that.excludes,
+                        providers: Array.from(providerExcludes)
+                    });
+                }
+            }));
+        }
+    }
+    registerStateActions(disposables) {
+        const states = [{
+            id: ChatSessionStatus.Completed,
+            label: ( localize(4959, "Completed"))
+        }, {
+            id: ChatSessionStatus.InProgress,
+            label: ( localize(4960, "In Progress"))
+        }, {
+            id: ChatSessionStatus.NeedsInput,
+            label: ( localize(4961, "Input Needed"))
+        }, {
+            id: ChatSessionStatus.Failed,
+            label: ( localize(4962, "Failed"))
+        }];
+        const that = this;
+        let counter = 0;
+        for (const state of states) {
+            disposables.add(registerAction2(class extends Action2 {
+                constructor() {
+                    super({
+                        id: `agentSessions.filter.toggleExcludeState:${state.id}.${that.options.filterMenuId.id.toLowerCase()}`,
+                        title: state.label,
+                        menu: {
+                            id: that.options.filterMenuId,
+                            group: "2_states",
+                            order: counter++
+                        },
+                        toggled: that.excludes.states.includes(state.id) ? ( ContextKeyExpr.false()) : ContextKeyExpr.true()
+                    });
+                }
+                run() {
+                    const stateExcludes = ( new Set(that.excludes.states));
+                    if (!stateExcludes.delete(state.id)) {
+                        stateExcludes.add(state.id);
+                    }
+                    that.storeExcludes({
+                        ...that.excludes,
+                        states: Array.from(stateExcludes)
+                    });
+                }
+            }));
+        }
+    }
+    registerArchivedActions(disposables) {
+        const that = this;
+        disposables.add(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `agentSessions.filter.toggleExcludeArchived.${that.options.filterMenuId.id.toLowerCase()}`,
+                    title: ( localize(4963, "Archived")),
+                    menu: {
+                        id: that.options.filterMenuId,
+                        group: "3_props",
+                        order: 1000
+                    },
+                    toggled: that.excludes.archived ? ( ContextKeyExpr.false()) : ContextKeyExpr.true()
+                });
+            }
+            run() {
+                that.storeExcludes({
+                    ...that.excludes,
+                    archived: !that.excludes.archived
+                });
+            }
+        }));
+    }
+    registerReadActions(disposables) {
+        const that = this;
+        disposables.add(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `agentSessions.filter.toggleExcludeRead.${that.options.filterMenuId.id.toLowerCase()}`,
+                    title: ( localize(4964, "Read")),
+                    menu: {
+                        id: that.options.filterMenuId,
+                        group: "3_props",
+                        order: 0
+                    },
+                    toggled: that.excludes.read ? ( ContextKeyExpr.false()) : ContextKeyExpr.true()
+                });
+            }
+            run() {
+                that.storeExcludes({
+                    ...that.excludes,
+                    read: !that.excludes.read
+                });
+            }
+        }));
+    }
+    registerResetAction(disposables) {
+        const that = this;
+        disposables.add(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: `agentSessions.filter.resetExcludes.${that.options.filterMenuId.id.toLowerCase()}`,
+                    title: ( localize(4965, "Reset")),
+                    menu: {
+                        id: that.options.filterMenuId,
+                        group: "4_reset",
+                        order: 0
+                    }
+                });
+            }
+            run() {
+                that.storeExcludes({
+                    ...DEFAULT_EXCLUDES
+                });
+            }
+        }));
+    }
+    isDefault() {
+        return equals(this.excludes, DEFAULT_EXCLUDES);
+    }
+    getExcludes() {
+        return this.excludes;
+    }
+    exclude(session) {
+        const overrideExclude = this.options?.overrideExclude?.(session);
+        if (typeof overrideExclude === "boolean") {
+            return overrideExclude;
+        }
+        if (this.excludes.read && session.isRead()) {
+            return true;
+        }
+        if (this.excludes.providers.includes(session.providerType)) {
+            return true;
+        }
+        if (this.excludes.states.includes(session.status)) {
+            return true;
+        }
+        if (this.excludes.archived && this.groupResults?.() === AgentSessionsGrouping.Capped && session.isArchived()) {
+            return true;
+        }
+        return false;
+    }
+    notifyResults(count) {
+        this.options.notifyResults?.(count);
+    }
+};
+AgentSessionsFilter = ( __decorate([( __param(1, IChatSessionsService)), ( __param(2, IStorageService))], AgentSessionsFilter));
+
+export { AgentSessionsFilter, AgentSessionsGrouping };

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

@@ -0,0 +1,20 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+export interface ISessionOpenerParticipant {
+    handleOpenSession(accessor: ServicesAccessor, session: IAgentSession, openOptions?: ISessionOpenOptions): Promise<boolean>;
+}
+export interface ISessionOpenOptions {
+    readonly sideBySide?: boolean;
+    readonly editorOptions?: IEditorOptions;
+}
+declare class SessionOpenerRegistry {
+    private readonly participants;
+    registerParticipant(participant: ISessionOpenerParticipant): IDisposable;
+    getParticipants(): readonly ISessionOpenerParticipant[];
+}
+export declare const sessionOpenerRegistry: SessionOpenerRegistry;
+export declare function openSession(accessor: ServicesAccessor, session: IAgentSession, openOptions?: ISessionOpenOptions): Promise<IChatWidget | undefined>;
+export {};

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

@@ -0,0 +1,89 @@
+
+import { isLocalAgentSessionItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+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 { ACTIVE_GROUP, SIDE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+
+class SessionOpenerRegistry {
+    constructor() {
+        this.participants = ( new Set());
+    }
+    registerParticipant(participant) {
+        this.participants.add(participant);
+        return {
+            dispose: () => {
+                this.participants.delete(participant);
+            }
+        };
+    }
+    getParticipants() {
+        return Array.from(this.participants);
+    }
+}
+const sessionOpenerRegistry = ( new SessionOpenerRegistry());
+async function openSession(accessor, session, openOptions) {
+    const instantiationService = accessor.get(IInstantiationService);
+    const logService = accessor.get(ILogService);
+    for (const participant of sessionOpenerRegistry.getParticipants()) {
+        try {
+            const handled = await instantiationService.invokeFunction(accessor => participant.handleOpenSession(accessor, session, openOptions));
+            if (handled) {
+                return undefined;
+            }
+        } catch (error) {
+            logService.error(error);
+        }
+    }
+    return instantiationService.invokeFunction(accessor => openSessionDefault(accessor, session, openOptions));
+}
+async function openSessionDefault(accessor, session, openOptions) {
+    const chatSessionsService = accessor.get(IChatSessionsService);
+    const chatWidgetService = accessor.get(IChatWidgetService);
+    const notificationService = accessor.get(INotificationService);
+    try {
+        session.setRead(true);
+        let sessionOptions;
+        if (isLocalAgentSessionItem(session)) {
+            sessionOptions = {};
+        } else {
+            sessionOptions = {
+                title: {
+                    preferred: session.label
+                }
+            };
+        }
+        let options = {
+            ...sessionOptions,
+            ...openOptions?.editorOptions,
+            revealIfOpened: true
+        };
+        await chatSessionsService.activateChatSessionItemProvider(session.providerType);
+        let target;
+        if (openOptions?.sideBySide) {
+            target = ACTIVE_GROUP;
+        } else {
+            target = ChatViewPaneTarget;
+        }
+        const isLocalChatSession = session.resource.scheme === Schemas.vscodeChatEditor || session.resource.scheme === Schemas.vscodeLocalChatSession;
+        if (!isLocalChatSession && !(await chatSessionsService.canResolveChatSession(session.resource))) {
+            target = openOptions?.sideBySide ? SIDE_GROUP : ACTIVE_GROUP;
+            options = {
+                ...options,
+                revealIfOpened: true
+            };
+        }
+        return await chatWidgetService.openSession(session.resource, target, options);
+    } catch (error) {
+        notificationService.error(( localize(4967, "Failed to open chat session: {0}", toErrorMessage(error))));
+        return undefined;
+    }
+}
+
+export { openSession, sessionOpenerRegistry };

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

@@ -0,0 +1,188 @@
+import { IIdentityProvider, IListVirtualDelegate, NotSelectableGroupIdType } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list";
+import { AriaRole } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria";
+import { IListAccessibilityProvider } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/listWidget";
+import { ITreeCompressionDelegate } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/asyncDataTree";
+import { ICompressedTreeNode } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/compressedObjectTreeModel";
+import { ICompressibleKeyboardNavigationLabelProvider, ICompressibleTreeRenderer } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/objectTree";
+import { ITreeNode, ITreeElementRenderDetails, IAsyncDataSource, ITreeSorter, ITreeDragAndDrop, ITreeDragOverReaction } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/tree/tree";
+import { Disposable, DisposableStore, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { AgentSessionSection, AgentSessionStatus, IAgentSession, IAgentSessionSection, IAgentSessionsModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel";
+import { IconLabel } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabel";
+import { FuzzyScore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/filters";
+import { IMarkdownRendererService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service";
+import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IDragAndDropData } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dnd";
+import { ListViewTargetSector } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/listView";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { HoverPosition } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverWidget";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { MenuWorkbenchToolBar } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { AgentSessionsGrouping } from "./agentSessionsFilter.js";
+export type AgentSessionListItem = IAgentSession | IAgentSessionSection;
+interface IAgentSessionItemTemplate {
+    readonly element: HTMLElement;
+    readonly icon: HTMLElement;
+    readonly title: IconLabel;
+    readonly titleToolbar: MenuWorkbenchToolBar;
+    readonly diffContainer: HTMLElement;
+    readonly diffAddedSpan: HTMLSpanElement;
+    readonly diffRemovedSpan: HTMLSpanElement;
+    readonly badge: HTMLElement;
+    readonly description: HTMLElement;
+    readonly statusContainer: HTMLElement;
+    readonly statusProviderIcon: HTMLElement;
+    readonly statusTime: HTMLElement;
+    readonly contextKeyService: IContextKeyService;
+    readonly elementDisposable: DisposableStore;
+    readonly disposables: IDisposable;
+}
+export interface IAgentSessionRendererOptions {
+    getHoverPosition(): HoverPosition;
+}
+export declare class AgentSessionRenderer extends Disposable implements ICompressibleTreeRenderer<IAgentSession, FuzzyScore, IAgentSessionItemTemplate> {
+    private readonly options;
+    private readonly markdownRendererService;
+    private readonly productService;
+    private readonly hoverService;
+    private readonly instantiationService;
+    private readonly contextKeyService;
+    static readonly TEMPLATE_ID = "agent-session";
+    readonly templateId = "agent-session";
+    private readonly sessionHover;
+    constructor(options: IAgentSessionRendererOptions, markdownRendererService: IMarkdownRendererService, productService: IProductService, hoverService: IHoverService, instantiationService: IInstantiationService, contextKeyService: IContextKeyService);
+    renderTemplate(container: HTMLElement): IAgentSessionItemTemplate;
+    renderElement(session: ITreeNode<IAgentSession, FuzzyScore>, index: number, template: IAgentSessionItemTemplate, details?: ITreeElementRenderDetails): void;
+    private renderBadge;
+    private renderMarkdownOrText;
+    private renderDiff;
+    private getIcon;
+    private renderDescription;
+    private toDuration;
+    private renderStatus;
+    private renderHover;
+    private buildHoverContent;
+    renderCompressedElements(node: ITreeNode<ICompressedTreeNode<IAgentSession>, FuzzyScore>, index: number, templateData: IAgentSessionItemTemplate, details?: ITreeElementRenderDetails): void;
+    disposeElement(element: ITreeNode<IAgentSession, FuzzyScore>, index: number, template: IAgentSessionItemTemplate, details?: ITreeElementRenderDetails): void;
+    disposeTemplate(templateData: IAgentSessionItemTemplate): void;
+}
+export declare function toStatusLabel(status: AgentSessionStatus): string;
+interface IAgentSessionSectionTemplate {
+    readonly container: HTMLElement;
+    readonly label: HTMLSpanElement;
+    readonly toolbar: MenuWorkbenchToolBar;
+    readonly contextKeyService: IContextKeyService;
+    readonly disposables: IDisposable;
+}
+export declare class AgentSessionSectionRenderer implements ICompressibleTreeRenderer<IAgentSessionSection, FuzzyScore, IAgentSessionSectionTemplate> {
+    private readonly instantiationService;
+    private readonly contextKeyService;
+    static readonly TEMPLATE_ID = "agent-session-section";
+    readonly templateId = "agent-session-section";
+    constructor(instantiationService: IInstantiationService, contextKeyService: IContextKeyService);
+    renderTemplate(container: HTMLElement): IAgentSessionSectionTemplate;
+    renderElement(element: ITreeNode<IAgentSessionSection, FuzzyScore>, index: number, template: IAgentSessionSectionTemplate, details?: ITreeElementRenderDetails): void;
+    renderCompressedElements(node: ITreeNode<ICompressedTreeNode<IAgentSessionSection>, FuzzyScore>, index: number, templateData: IAgentSessionSectionTemplate, details?: ITreeElementRenderDetails): void;
+    disposeElement(element: ITreeNode<IAgentSessionSection, FuzzyScore>, index: number, template: IAgentSessionSectionTemplate, details?: ITreeElementRenderDetails): void;
+    disposeTemplate(templateData: IAgentSessionSectionTemplate): void;
+}
+export declare class AgentSessionsListDelegate implements IListVirtualDelegate<AgentSessionListItem> {
+    static readonly ITEM_HEIGHT = 52;
+    static readonly SECTION_HEIGHT = 26;
+    getHeight(element: AgentSessionListItem): number;
+    getTemplateId(element: AgentSessionListItem): string;
+}
+export declare class AgentSessionsAccessibilityProvider implements IListAccessibilityProvider<AgentSessionListItem> {
+    getWidgetRole(): AriaRole;
+    getRole(element: AgentSessionListItem): AriaRole | undefined;
+    getWidgetAriaLabel(): string;
+    getAriaLabel(element: AgentSessionListItem): string | null;
+}
+export interface IAgentSessionsFilterExcludes {
+    readonly providers: readonly string[];
+    readonly states: readonly AgentSessionStatus[];
+    readonly archived: boolean;
+    readonly read: boolean;
+}
+export interface IAgentSessionsFilter {
+    /**
+     * An event that fires when the filter changes and sessions
+     * should be re-evaluated.
+     */
+    readonly onDidChange: Event<void>;
+    /**
+     * Optional limit on the number of sessions to show.
+     */
+    readonly limitResults?: () => number | undefined;
+    /**
+     * Whether to show section headers to group sessions.
+     * When undefined, sessions are shown as a flat list.
+     */
+    readonly groupResults?: () => AgentSessionsGrouping | undefined;
+    /**
+     * A callback to notify the filter about the number of
+     * results after filtering.
+     */
+    notifyResults?(count: number): void;
+    /**
+     * The logic to exclude sessions from the view.
+     */
+    exclude(session: IAgentSession): boolean;
+    /**
+     * Get the current filter excludes for display in the UI.
+     */
+    getExcludes(): IAgentSessionsFilterExcludes;
+}
+export declare class AgentSessionsDataSource implements IAsyncDataSource<IAgentSessionsModel, AgentSessionListItem> {
+    private readonly filter;
+    private readonly sorter;
+    private static readonly CAPPED_SESSIONS_LIMIT;
+    constructor(filter: IAgentSessionsFilter | undefined, sorter: ITreeSorter<IAgentSession>);
+    hasChildren(element: IAgentSessionsModel | AgentSessionListItem): boolean;
+    getChildren(element: IAgentSessionsModel | AgentSessionListItem): Iterable<AgentSessionListItem>;
+    private groupSessionsIntoSections;
+    private groupSessionsCapped;
+    private groupSessionsByDate;
+}
+export declare const AgentSessionSectionLabels: {
+    inProgress: string;
+    today: string;
+    yesterday: string;
+    week: string;
+    older: string;
+    archived: string;
+    more: string;
+};
+export declare function groupAgentSessionsByDate(sessions: IAgentSession[]): Map<AgentSessionSection, IAgentSessionSection>;
+export declare class AgentSessionsIdentityProvider implements IIdentityProvider<IAgentSessionsModel | AgentSessionListItem> {
+    getId(element: IAgentSessionsModel | AgentSessionListItem): string;
+    getGroupId(element: IAgentSessionsModel | AgentSessionListItem): number | NotSelectableGroupIdType;
+}
+export declare class AgentSessionsCompressionDelegate implements ITreeCompressionDelegate<AgentSessionListItem> {
+    isIncompressible(element: AgentSessionListItem): boolean;
+}
+export interface IAgentSessionsSorterOptions {
+    overrideCompare?(sessionA: IAgentSession, sessionB: IAgentSession): number | undefined;
+}
+export declare class AgentSessionsSorter implements ITreeSorter<IAgentSession> {
+    private readonly options?;
+    constructor(options?: IAgentSessionsSorterOptions | undefined);
+    compare(sessionA: IAgentSession, sessionB: IAgentSession): number;
+}
+export declare class AgentSessionsKeyboardNavigationLabelProvider implements ICompressibleKeyboardNavigationLabelProvider<AgentSessionListItem> {
+    getKeyboardNavigationLabel(element: AgentSessionListItem): string;
+    getCompressedNodeKeyboardNavigationLabel(elements: AgentSessionListItem[]): {
+        toString(): string | undefined;
+    } | undefined;
+}
+export declare class AgentSessionsDragAndDrop extends Disposable implements ITreeDragAndDrop<AgentSessionListItem> {
+    private readonly instantiationService;
+    constructor(instantiationService: IInstantiationService);
+    onDragStart(data: IDragAndDropData, originalEvent: DragEvent): void;
+    getDragURI(element: AgentSessionListItem): string | null;
+    getDragLabel?(elements: AgentSessionListItem[], originalEvent: DragEvent): string | undefined;
+    onDragOver(data: IDragAndDropData, targetElement: AgentSessionListItem | undefined, targetIndex: number | undefined, targetSector: ListViewTargetSector | undefined, originalEvent: DragEvent): boolean | ITreeDragOverReaction;
+    drop(data: IDragAndDropData, targetElement: AgentSessionListItem | undefined, targetIndex: number | undefined, targetSector: ListViewTargetSector | undefined, originalEvent: DragEvent): void;
+}
+export {};