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

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

@@ -0,0 +1,677 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as agentsessionsviewer from './media/agentsessionsviewer.css';
+import { h } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { NotSelectableGroupId } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/list';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { hasValidDiff, getAgentChangesSummary, isAgentSessionSection, isAgentSessionsModel, AgentSessionSection, isAgentSession } 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 { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { getDurationString, fromNow } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import { createMatches } 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 { allowedChatMarkdownHtmlTags } from '../widget/chatContentMarkdownRenderer.js';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { fillEditorsDragData } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/dnd';
+import { HoverStyle } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hover';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { IntervalTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+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 { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { AgentSessionHoverWidget } from './agentSessionHoverWidget.js';
+import { AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { AgentSessionsGrouping } from './agentSessionsFilter.js';
+import { isSessionInProgressStatus, ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+var AgentSessionRenderer_1, AgentSessionSectionRenderer_1;
+registerCss(agentsessionsviewer);
+let AgentSessionRenderer = class AgentSessionRenderer extends Disposable {
+    static {
+        AgentSessionRenderer_1 = this;
+    }
+    static {
+        this.TEMPLATE_ID = "agent-session";
+    }
+    constructor(
+        options,
+        markdownRendererService,
+        productService,
+        hoverService,
+        instantiationService,
+        contextKeyService
+    ) {
+        super();
+        this.options = options;
+        this.markdownRendererService = markdownRendererService;
+        this.productService = productService;
+        this.hoverService = hoverService;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = AgentSessionRenderer_1.TEMPLATE_ID;
+        this.sessionHover = this._register(( new MutableDisposable()));
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elementDisposable = disposables.add(( new DisposableStore()));
+        const elements = h("div.agent-session-item@item", [
+            h("div.agent-session-icon-col", [h("div.agent-session-icon@icon")]),
+            h("div.agent-session-main-col", [h("div.agent-session-title-row", [
+                h("div.agent-session-title@title"),
+                h("div.agent-session-title-toolbar@titleToolbar")
+            ]), h(
+                "div.agent-session-details-row",
+                [h("div.agent-session-diff-container@diffContainer", [
+                    h("span.agent-session-diff-added@addedSpan"),
+                    h("span.agent-session-diff-removed@removedSpan")
+                ]), h("div.agent-session-badge@badge"), h("div.agent-session-description@description"), h("div.agent-session-status@statusContainer", [
+                    h("span.agent-session-status-provider-icon@statusProviderIcon"),
+                    h("span.agent-session-status-time@statusTime")
+                ])]
+            )])
+        ]);
+        const contextKeyService = disposables.add(this.contextKeyService.createScoped(elements.item));
+        const scopedInstantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+        const titleToolbar = disposables.add(scopedInstantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            elements.titleToolbar,
+            MenuId.AgentSessionItemToolbar,
+            {
+                menuOptions: {
+                    shouldForwardArgs: true
+                }
+            }
+        ));
+        container.appendChild(elements.item);
+        return {
+            element: elements.item,
+            icon: elements.icon,
+            title: disposables.add(( new IconLabel(elements.title, {
+                supportHighlights: true,
+                supportIcons: true
+            }))),
+            titleToolbar,
+            diffContainer: elements.diffContainer,
+            diffAddedSpan: elements.addedSpan,
+            diffRemovedSpan: elements.removedSpan,
+            badge: elements.badge,
+            description: elements.description,
+            statusContainer: elements.statusContainer,
+            statusProviderIcon: elements.statusProviderIcon,
+            statusTime: elements.statusTime,
+            contextKeyService,
+            elementDisposable,
+            disposables
+        };
+    }
+    renderElement(session, index, template, details) {
+        template.elementDisposable.clear();
+        template.diffAddedSpan.textContent = "";
+        template.diffRemovedSpan.textContent = "";
+        template.badge.textContent = "";
+        template.description.textContent = "";
+        template.element.classList.toggle("archived", session.element.isArchived());
+        template.icon.className = `agent-session-icon ${ThemeIcon.asClassName(this.getIcon(session.element))}`;
+        const markdownTitle = ( new MarkdownString(session.element.label));
+        template.title.setLabel(renderAsPlaintext(markdownTitle), undefined, {
+            matches: createMatches(session.filterData)
+        });
+        ChatContextKeys.isArchivedAgentSession.bindTo(template.contextKeyService).set(session.element.isArchived());
+        ChatContextKeys.isReadAgentSession.bindTo(template.contextKeyService).set(session.element.isRead());
+        ChatContextKeys.agentSessionType.bindTo(template.contextKeyService).set(session.element.providerType);
+        template.titleToolbar.context = session.element;
+        let hasDiff = false;
+        const {
+            changes: diff
+        } = session.element;
+        if (!isSessionInProgressStatus(session.element.status) && diff && hasValidDiff(diff)) {
+            if (this.renderDiff(session, template)) {
+                hasDiff = true;
+            }
+        }
+        template.diffContainer.classList.toggle("has-diff", hasDiff);
+        let hasAgentSessionChanges = false;
+        if (session.element.providerType === AgentSessionProviders.Background || session.element.providerType === AgentSessionProviders.Cloud) {
+            hasAgentSessionChanges = Array.isArray(diff) && diff.length > 0;
+        } else {
+            hasAgentSessionChanges = hasDiff;
+        }
+        ChatContextKeys.hasAgentSessionChanges.bindTo(template.contextKeyService).set(hasAgentSessionChanges);
+        let hasBadge = false;
+        if (!isSessionInProgressStatus(session.element.status)) {
+            hasBadge = this.renderBadge(session, template);
+        }
+        template.badge.classList.toggle("has-badge", hasBadge);
+        if (!hasDiff) {
+            this.renderDescription(session, template, hasBadge);
+        }
+        this.renderStatus(session, template);
+        this.renderHover(session, template);
+    }
+    renderBadge(session, template) {
+        const badge = session.element.badge;
+        if (badge) {
+            this.renderMarkdownOrText(badge, template.badge, template.elementDisposable);
+        }
+        return !!badge;
+    }
+    renderMarkdownOrText(content, container, disposables) {
+        if (typeof content === "string") {
+            container.textContent = content;
+        } else {
+            disposables.add(this.markdownRendererService.render(content, {
+                sanitizerConfig: {
+                    replaceWithPlaintext: true,
+                    allowedTags: {
+                        override: allowedChatMarkdownHtmlTags
+                    },
+                    allowedLinkSchemes: {
+                        augment: [this.productService.urlProtocol]
+                    }
+                }
+            }, container));
+        }
+    }
+    renderDiff(session, template) {
+        const diff = getAgentChangesSummary(session.element.changes);
+        if (!diff) {
+            return false;
+        }
+        if (diff.insertions >= 0 ) {
+            template.diffAddedSpan.textContent = `+${diff.insertions}`;
+        }
+        if (diff.deletions >= 0 ) {
+            template.diffRemovedSpan.textContent = `-${diff.deletions}`;
+        }
+        return true;
+    }
+    getIcon(session) {
+        if (session.status === ChatSessionStatus.InProgress) {
+            return Codicon.sessionInProgress;
+        }
+        if (session.status === ChatSessionStatus.NeedsInput) {
+            return Codicon.report;
+        }
+        if (session.status === ChatSessionStatus.Failed) {
+            return Codicon.error;
+        }
+        if (!session.isRead() && !session.isArchived()) {
+            return Codicon.circleFilled;
+        }
+        return Codicon.circleSmallFilled;
+    }
+    renderDescription(session, template, hasBadge) {
+        const description = session.element.description;
+        if (description) {
+            this.renderMarkdownOrText(description, template.description, template.elementDisposable);
+        }
+        else {
+            if (session.element.status === ChatSessionStatus.InProgress) {
+                template.description.textContent = ( localize(4974, "Working..."));
+            } else if (session.element.status === ChatSessionStatus.NeedsInput) {
+                template.description.textContent = ( localize(4975, "Input needed."));
+            } else if (hasBadge && session.element.status === ChatSessionStatus.Completed) {
+                template.description.textContent = "";
+            } else if (session.element.timing.lastRequestEnded && session.element.timing.lastRequestStarted && session.element.timing.lastRequestEnded > session.element.timing.lastRequestStarted) {
+                const duration = this.toDuration(
+                    session.element.timing.lastRequestStarted,
+                    session.element.timing.lastRequestEnded,
+                    false,
+                    true
+                );
+                template.description.textContent = session.element.status === ChatSessionStatus.Failed ? ( localize(4976, "Failed after {0}.", duration)) : ( localize(4977, "Completed in {0}.", duration));
+            } else {
+                template.description.textContent = session.element.status === ChatSessionStatus.Failed ? ( localize(4978, "Failed")) : ( localize(4979, "Completed"));
+            }
+        }
+    }
+    toDuration(startTime, endTime, useFullTimeWords, disallowNow) {
+        const elapsed = Math.max(Math.round((endTime - startTime) / 1000) * 1000, 1000 );
+        if (!disallowNow && elapsed < 60000) {
+            return localize(4980, "now");
+        }
+        return getDurationString(elapsed, useFullTimeWords);
+    }
+    renderStatus(session, template) {
+        const getTimeLabel = session => {
+            let timeLabel;
+            if (session.status === ChatSessionStatus.InProgress && session.timing.lastRequestStarted) {
+                timeLabel = this.toDuration(session.timing.lastRequestStarted, Date.now(), false, false);
+            }
+            if (!timeLabel) {
+                const date = session.timing.lastRequestEnded ?? session.timing.lastRequestStarted ?? session.timing.created;
+                const seconds = Math.round((( new Date()).getTime() - date) / 1000);
+                if (seconds < 60) {
+                    timeLabel = ( localize(4980, "now"));
+                } else {
+                    timeLabel = fromNow(date, true);
+                }
+            }
+            return timeLabel;
+        };
+        template.statusProviderIcon.className = `agent-session-status-provider-icon ${ThemeIcon.asClassName(session.element.icon)}`;
+        template.statusTime.textContent = getTimeLabel(session.element);
+        const timer = template.elementDisposable.add(( new IntervalTimer()));
+        timer.cancelAndSet(
+            () => template.statusTime.textContent = getTimeLabel(session.element),
+            session.element.status === ChatSessionStatus.InProgress ? 1000  : 60 * 1000
+        );
+    }
+    renderHover(session, template) {
+        if (!isSessionInProgressStatus(session.element.status) && session.element.isRead()) {
+            return;
+        }
+        const reducedDelay = session.element.status === ChatSessionStatus.NeedsInput;
+        template.elementDisposable.add(
+            this.hoverService.setupDelayedHover(template.element, () => this.buildHoverContent(session.element), {
+                groupId: "agent.sessions",
+                reducedDelay
+            })
+        );
+    }
+    buildHoverContent(session) {
+        if (this.sessionHover.value?.session.resource.toString() !== ( session.resource.toString())) {
+            this.sessionHover.value = this.instantiationService.createInstance(AgentSessionHoverWidget, session);
+        }
+        const widget = this.sessionHover.value;
+        return {
+            id: `agent.session.hover.${( session.resource.toString())}`,
+            content: widget.domNode,
+            style: HoverStyle.Pointer,
+            onDidShow: () => widget.onRendered(),
+            position: {
+                hoverPosition: this.options.getHoverPosition()
+            }
+        };
+    }
+    renderCompressedElements(node, index, templateData, details) {
+        throw ( new Error("Should never happen since session is incompressible"));
+    }
+    disposeElement(element, index, template, details) {
+        template.elementDisposable.clear();
+    }
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+AgentSessionRenderer = AgentSessionRenderer_1 = ( __decorate([( __param(1, IMarkdownRendererService)), ( __param(2, IProductService)), ( __param(3, IHoverService)), ( __param(4, IInstantiationService)), ( __param(5, IContextKeyService))], AgentSessionRenderer));
+function toStatusLabel(status) {
+    let statusLabel;
+    switch (status) {
+    case ChatSessionStatus.NeedsInput:
+        statusLabel = ( localize(4981, "Needs Input"));
+        break;
+    case ChatSessionStatus.InProgress:
+        statusLabel = ( localize(4982, "In Progress"));
+        break;
+    case ChatSessionStatus.Failed:
+        statusLabel = ( localize(4983, "Failed"));
+        break;
+    default:
+        statusLabel = ( localize(4984, "Completed"));
+    }
+    return statusLabel;
+}
+let AgentSessionSectionRenderer = class AgentSessionSectionRenderer {
+    static {
+        AgentSessionSectionRenderer_1 = this;
+    }
+    static {
+        this.TEMPLATE_ID = "agent-session-section";
+    }
+    constructor(instantiationService, contextKeyService) {
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.templateId = AgentSessionSectionRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const disposables = ( new DisposableStore());
+        const elements = h("div.agent-session-section@container", [
+            h("span.agent-session-section-label@label"),
+            h("div.agent-session-section-toolbar@toolbar")
+        ]);
+        const contextKeyService = disposables.add(this.contextKeyService.createScoped(elements.container));
+        const scopedInstantiationService = disposables.add(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, contextKeyService]))));
+        const toolbar = disposables.add(scopedInstantiationService.createInstance(
+            MenuWorkbenchToolBar,
+            elements.toolbar,
+            MenuId.AgentSessionSectionToolbar,
+            {
+                menuOptions: {
+                    shouldForwardArgs: true
+                }
+            }
+        ));
+        container.appendChild(elements.container);
+        return {
+            container: elements.container,
+            label: elements.label,
+            toolbar,
+            contextKeyService,
+            disposables
+        };
+    }
+    renderElement(element, index, template, details) {
+        template.label.textContent = element.element.label;
+        ChatContextKeys.agentSessionSection.bindTo(template.contextKeyService).set(element.element.section);
+        template.toolbar.context = element.element;
+    }
+    renderCompressedElements(node, index, templateData, details) {
+        throw ( new Error("Should never happen since section header is incompressible"));
+    }
+    disposeElement(element, index, template, details) {}
+    disposeTemplate(templateData) {
+        templateData.disposables.dispose();
+    }
+};
+AgentSessionSectionRenderer = AgentSessionSectionRenderer_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IContextKeyService))], AgentSessionSectionRenderer));
+class AgentSessionsListDelegate {
+    static {
+        this.ITEM_HEIGHT = 52;
+    }
+    static {
+        this.SECTION_HEIGHT = 26;
+    }
+    getHeight(element) {
+        if (isAgentSessionSection(element)) {
+            return AgentSessionsListDelegate.SECTION_HEIGHT;
+        }
+        return AgentSessionsListDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        if (isAgentSessionSection(element)) {
+            return AgentSessionSectionRenderer.TEMPLATE_ID;
+        }
+        return AgentSessionRenderer.TEMPLATE_ID;
+    }
+}
+class AgentSessionsAccessibilityProvider {
+    getWidgetRole() {
+        return "list";
+    }
+    getRole(element) {
+        return "listitem";
+    }
+    getWidgetAriaLabel() {
+        return localize(4985, "Agent Sessions");
+    }
+    getAriaLabel(element) {
+        if (isAgentSessionSection(element)) {
+            return localize(4986, "{0} sessions section", element.label);
+        }
+        return localize(
+            4987,
+            "{0} session {1} ({2}), created {3}",
+            element.providerLabel,
+            element.label,
+            toStatusLabel(element.status),
+            ( new Date(element.timing.created)).toLocaleString()
+        );
+    }
+}
+class AgentSessionsDataSource {
+    static {
+        this.CAPPED_SESSIONS_LIMIT = 3;
+    }
+    constructor(filter, sorter) {
+        this.filter = filter;
+        this.sorter = sorter;
+    }
+    hasChildren(element) {
+        if (isAgentSessionsModel(element)) {
+            return true;
+        }
+        else if (isAgentSessionSection(element)) {
+            return element.sessions.length > 0;
+        }
+        else {
+            return false;
+        }
+    }
+    getChildren(element) {
+        if (isAgentSessionsModel(element)) {
+            let filteredSessions = element.sessions.filter(session => !this.filter?.exclude(session));
+            const limitResultsCount = this.filter?.limitResults?.();
+            if (!this.filter?.groupResults?.() || typeof limitResultsCount === "number") {
+                filteredSessions.sort(this.sorter.compare.bind(this.sorter));
+            }
+            if (typeof limitResultsCount === "number") {
+                filteredSessions = filteredSessions.slice(0, limitResultsCount);
+            }
+            this.filter?.notifyResults?.(filteredSessions.length);
+            if (this.filter?.groupResults?.()) {
+                return this.groupSessionsIntoSections(filteredSessions);
+            }
+            return filteredSessions;
+        }
+        else if (isAgentSessionSection(element)) {
+            return element.sessions;
+        }
+        else {
+            return [];
+        }
+    }
+    groupSessionsIntoSections(sessions) {
+        const sortedSessions = sessions.sort(this.sorter.compare.bind(this.sorter));
+        if (this.filter?.groupResults?.() === AgentSessionsGrouping.Capped) {
+            return this.groupSessionsCapped(sortedSessions);
+        } else {
+            return this.groupSessionsByDate(sortedSessions);
+        }
+    }
+    groupSessionsCapped(sortedSessions) {
+        const result = [];
+        const firstArchivedIndex = sortedSessions.findIndex(session => session.isArchived());
+        const nonArchivedCount = firstArchivedIndex === -1 ? sortedSessions.length : firstArchivedIndex;
+        const topSessions = sortedSessions.slice(
+            0,
+            Math.min(AgentSessionsDataSource.CAPPED_SESSIONS_LIMIT, nonArchivedCount)
+        );
+        const othersSessions = sortedSessions.slice(topSessions.length);
+        result.push(...topSessions);
+        if (othersSessions.length > 0) {
+            result.push({
+                section: AgentSessionSection.More,
+                label: ( localize(4988, "More ({0})", othersSessions.length)),
+                sessions: othersSessions
+            });
+        }
+        return result;
+    }
+    groupSessionsByDate(sortedSessions) {
+        const result = [];
+        const groupedSessions = groupAgentSessionsByDate(sortedSessions);
+        for (const {
+            sessions,
+            section,
+            label
+        } of ( groupedSessions.values())) {
+            if (sessions.length === 0) {
+                continue;
+            }
+            result.push({
+                section,
+                label,
+                sessions
+            });
+        }
+        return result;
+    }
+}
+const DAY_THRESHOLD = 24 * 60 * 60 * 1000;
+const WEEK_THRESHOLD = 7 * DAY_THRESHOLD;
+const AgentSessionSectionLabels = {
+    [AgentSessionSection.InProgress]: ( localize(4989, "In Progress")),
+    [AgentSessionSection.Today]: ( localize(4990, "Today")),
+    [AgentSessionSection.Yesterday]: ( localize(4991, "Yesterday")),
+    [AgentSessionSection.Week]: ( localize(4992, "Last Week")),
+    [AgentSessionSection.Older]: ( localize(4993, "Older")),
+    [AgentSessionSection.Archived]: ( localize(4994, "Archived")),
+    [AgentSessionSection.More]: ( localize(4995, "More"))
+};
+function groupAgentSessionsByDate(sessions) {
+    const now = Date.now();
+    const startOfToday = ( new Date(now)).setHours(0, 0, 0, 0);
+    const startOfYesterday = startOfToday - DAY_THRESHOLD;
+    const weekThreshold = now - WEEK_THRESHOLD;
+    const inProgressSessions = [];
+    const todaySessions = [];
+    const yesterdaySessions = [];
+    const weekSessions = [];
+    const olderSessions = [];
+    const archivedSessions = [];
+    for (const session of sessions) {
+        if (session.isArchived()) {
+            archivedSessions.push(session);
+        } else if (isSessionInProgressStatus(session.status)) {
+            inProgressSessions.push(session);
+        } else {
+            const sessionTime = session.timing.lastRequestEnded ?? session.timing.lastRequestStarted ?? session.timing.created;
+            if (sessionTime >= startOfToday) {
+                todaySessions.push(session);
+            } else if (sessionTime >= startOfYesterday) {
+                yesterdaySessions.push(session);
+            } else if (sessionTime >= weekThreshold) {
+                weekSessions.push(session);
+            } else {
+                olderSessions.push(session);
+            }
+        }
+    }
+    return (new Map([[AgentSessionSection.InProgress, {
+        section: AgentSessionSection.InProgress,
+        label: AgentSessionSectionLabels[AgentSessionSection.InProgress],
+        sessions: inProgressSessions
+    }], [AgentSessionSection.Today, {
+        section: AgentSessionSection.Today,
+        label: AgentSessionSectionLabels[AgentSessionSection.Today],
+        sessions: todaySessions
+    }], [AgentSessionSection.Yesterday, {
+        section: AgentSessionSection.Yesterday,
+        label: AgentSessionSectionLabels[AgentSessionSection.Yesterday],
+        sessions: yesterdaySessions
+    }], [AgentSessionSection.Week, {
+        section: AgentSessionSection.Week,
+        label: AgentSessionSectionLabels[AgentSessionSection.Week],
+        sessions: weekSessions
+    }], [AgentSessionSection.Older, {
+        section: AgentSessionSection.Older,
+        label: AgentSessionSectionLabels[AgentSessionSection.Older],
+        sessions: olderSessions
+    }], [AgentSessionSection.Archived, {
+        section: AgentSessionSection.Archived,
+        label: ( localize(4996, "Archived ({0})", archivedSessions.length)),
+        sessions: archivedSessions
+    }]]));
+}
+class AgentSessionsIdentityProvider {
+    getId(element) {
+        if (isAgentSessionSection(element)) {
+            return `section-${element.section}`;
+        }
+        if (isAgentSession(element)) {
+            return ( element.resource.toString());
+        }
+        return "agent-sessions-id";
+    }
+    getGroupId(element) {
+        if (isAgentSessionSection(element) || isAgentSessionsModel(element)) {
+            return NotSelectableGroupId;
+        }
+        return 1;
+    }
+}
+class AgentSessionsCompressionDelegate {
+    isIncompressible(element) {
+        return true;
+    }
+}
+class AgentSessionsSorter {
+    constructor(options) {
+        this.options = options;
+    }
+    compare(sessionA, sessionB) {
+        const aNeedsInput = sessionA.status === ChatSessionStatus.NeedsInput;
+        const bNeedsInput = sessionB.status === ChatSessionStatus.NeedsInput;
+        if (aNeedsInput && !bNeedsInput) {
+            return -1;
+        }
+        if (!aNeedsInput && bNeedsInput) {
+            return 1;
+        }
+        const aInProgress = sessionA.status === ChatSessionStatus.InProgress;
+        const bInProgress = sessionB.status === ChatSessionStatus.InProgress;
+        if (aInProgress && !bInProgress) {
+            return -1;
+        }
+        if (!aInProgress && bInProgress) {
+            return 1;
+        }
+        const aArchived = sessionA.isArchived();
+        const bArchived = sessionB.isArchived();
+        if (!aArchived && bArchived) {
+            return -1;
+        }
+        if (aArchived && !bArchived) {
+            return 1;
+        }
+        const override = this.options?.overrideCompare?.(sessionA, sessionB);
+        if (typeof override === "number") {
+            return override;
+        }
+        const timeA = sessionA.timing.lastRequestEnded ?? sessionA.timing.lastRequestStarted ?? sessionA.timing.created;
+        const timeB = sessionB.timing.lastRequestEnded ?? sessionB.timing.lastRequestStarted ?? sessionB.timing.created;
+        return timeB - timeA;
+    }
+}
+class AgentSessionsKeyboardNavigationLabelProvider {
+    getKeyboardNavigationLabel(element) {
+        if (isAgentSessionSection(element)) {
+            return element.label;
+        }
+        return element.label;
+    }
+    getCompressedNodeKeyboardNavigationLabel(elements) {
+        return undefined;
+    }
+}
+let AgentSessionsDragAndDrop = class AgentSessionsDragAndDrop extends Disposable {
+    constructor(instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+    }
+    onDragStart(data, originalEvent) {
+        const elements = data.getData().filter(e => isAgentSession(e));
+        const uris = coalesce(( elements.map(e => e.resource)));
+        this.instantiationService.invokeFunction(accessor => fillEditorsDragData(accessor, uris, originalEvent));
+    }
+    getDragURI(element) {
+        if (isAgentSessionSection(element)) {
+            return null;
+        }
+        return ( element.resource.toString());
+    }
+    getDragLabel(elements, originalEvent) {
+        const sessions = elements.filter(e => isAgentSession(e));
+        if (sessions.length === 1) {
+            return sessions[0].label;
+        }
+        return localize(4997, "{0} agent sessions", sessions.length);
+    }
+    onDragOver(data, targetElement, targetIndex, targetSector, originalEvent) {
+        return false;
+    }
+    drop(data, targetElement, targetIndex, targetSector, originalEvent) {}
+};
+AgentSessionsDragAndDrop = ( __decorate([( __param(0, IInstantiationService))], AgentSessionsDragAndDrop));
+
+export { AgentSessionRenderer, AgentSessionSectionLabels, AgentSessionSectionRenderer, AgentSessionsAccessibilityProvider, AgentSessionsCompressionDelegate, AgentSessionsDataSource, AgentSessionsDragAndDrop, AgentSessionsIdentityProvider, AgentSessionsKeyboardNavigationLabelProvider, AgentSessionsListDelegate, AgentSessionsSorter, groupAgentSessionsByDate, toStatusLabel };