@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions.js

@@ -0,0 +1,738 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatSessions from './media/chatSessions.css';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextMenuService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IHoverService } from '@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service';
+import { ViewPaneContainer } from '@codingame/monaco-vscode-a8d3bd74-e63e-5327-96e8-4f931661e329-common/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { ViewPane } from '@codingame/monaco-vscode-501b06ab-3f58-516b-8a1a-c29d375d3da4-common/vscode/vs/workbench/browser/parts/views/viewPane';
+import { Extensions, ViewContainerLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IWorkbenchLayoutService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService.service';
+import { WorkbenchAsyncDataTree } from '@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { ResourceLabels } from '@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/workbench/browser/labels';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { getActiveWindow, append, $, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { GroupModelChangeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatConfiguration, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { MenuRegistry, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { registerIcon } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/iconRegistry';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
+
+var LocalChatSessionsProvider_1, SessionsRenderer_1;
+registerCss(chatSessions);
+const VIEWLET_ID = 'workbench.view.chat.sessions';
+let ChatSessionsView = class ChatSessionsView extends Disposable {
+    static { this.ID = 'workbench.contrib.chatSessions'; }
+    constructor(configurationService) {
+        super();
+        this.configurationService = configurationService;
+        this.isViewContainerRegistered = false;
+        this.updateViewContainerRegistration();
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.AgentSessionsViewLocation)) {
+                this.updateViewContainerRegistration();
+            }
+        }));
+    }
+    updateViewContainerRegistration() {
+        const location = this.configurationService.getValue(ChatConfiguration.AgentSessionsViewLocation);
+        if (location === 'view' && !this.isViewContainerRegistered) {
+            this.registerViewContainer();
+        }
+    }
+    registerViewContainer() {
+        if (this.isViewContainerRegistered) {
+            return;
+        }
+        ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+            id: VIEWLET_ID,
+            title: ( localize2(5080, "Chat Sessions")),
+            ctorDescriptor: ( new SyncDescriptor(ChatSessionsViewPaneContainer)),
+            hideIfEmpty: false,
+            icon: registerIcon('chat-sessions-icon', Codicon.commentDiscussion, 'Icon for Chat Sessions View'),
+            order: 10
+        }, ViewContainerLocation.Sidebar);
+    }
+};
+ChatSessionsView = ( __decorate([
+    ( __param(0, IConfigurationService))
+], ChatSessionsView));
+let LocalChatSessionsProvider = class LocalChatSessionsProvider extends Disposable {
+    static { LocalChatSessionsProvider_1 = this; }
+    static { this.CHAT_WIDGET_VIEW_ID = 'workbench.panel.chat.view.copilot'; }
+    constructor(editorGroupService, chatWidgetService) {
+        super();
+        this.editorGroupService = editorGroupService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatSessionType = 'local';
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this.currentEditorSet = ( new Set());
+        this.editorOrder = [];
+        this.initializeCurrentEditorSet();
+        this.registerEditorListeners();
+        this.registerWidgetListeners();
+    }
+    registerWidgetListeners() {
+        this._register(this.chatWidgetService.onDidAddWidget(widget => {
+            if (widget.location === ChatAgentLocation.Panel &&
+                typeof widget.viewContext === 'object' &&
+                'viewId' in widget.viewContext &&
+                widget.viewContext.viewId === LocalChatSessionsProvider_1.CHAT_WIDGET_VIEW_ID) {
+                this._onDidChange.fire();
+                this._register(widget.onDidChangeViewModel(() => {
+                    this._onDidChange.fire();
+                }));
+                this.registerModelTitleListener(widget);
+            }
+        }));
+        const existingWidgets = this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Panel)
+            .filter(widget => typeof widget.viewContext === 'object' && 'viewId' in widget.viewContext && widget.viewContext.viewId === LocalChatSessionsProvider_1.CHAT_WIDGET_VIEW_ID);
+        existingWidgets.forEach(widget => {
+            this._register(widget.onDidChangeViewModel(() => {
+                this._onDidChange.fire();
+                this.registerModelTitleListener(widget);
+            }));
+            this.registerModelTitleListener(widget);
+        });
+    }
+    registerModelTitleListener(widget) {
+        const model = widget.viewModel?.model;
+        if (model) {
+            this._register(model.onDidChange(() => {
+                this._onDidChange.fire();
+            }));
+        }
+    }
+    initializeCurrentEditorSet() {
+        this.currentEditorSet.clear();
+        this.editorOrder = [];
+        this.editorGroupService.groups.forEach(group => {
+            group.editors.forEach(editor => {
+                if (this.isLocalChatSession(editor)) {
+                    const key = this.getEditorKey(editor, group);
+                    this.currentEditorSet.add(key);
+                    this.editorOrder.push(key);
+                }
+            });
+        });
+    }
+    getEditorKey(editor, group) {
+        return `${group.id}-${editor.typeId}-${editor.resource?.toString() || editor.getName()}`;
+    }
+    registerEditorListeners() {
+        this.editorGroupService.groups.forEach(group => this.registerGroupListeners(group));
+        this._register(this.editorGroupService.onDidAddGroup(group => {
+            this.registerGroupListeners(group);
+            this.initializeCurrentEditorSet();
+            this._onDidChange.fire();
+        }));
+        this._register(this.editorGroupService.onDidRemoveGroup(() => {
+            this.initializeCurrentEditorSet();
+            this._onDidChange.fire();
+        }));
+    }
+    isLocalChatSession(editor) {
+        if (!(editor instanceof ChatEditorInput)) {
+            return false;
+        }
+        return editor.resource?.scheme === 'vscode-chat-editor';
+    }
+    registerGroupListeners(group) {
+        this._register(group.onDidModelChange(e => {
+            if (!this.isLocalChatSession(e.editor)) {
+                return;
+            }
+            switch (e.kind) {
+                case GroupModelChangeKind.EDITOR_OPEN:
+                    if (e.editor) {
+                        const editorKey = this.getEditorKey(e.editor, group);
+                        if (!( this.currentEditorSet.has(editorKey))) {
+                            this.currentEditorSet.add(editorKey);
+                            this.editorOrder.push(editorKey);
+                            this._onDidChange.fire();
+                        }
+                    }
+                    break;
+                case GroupModelChangeKind.EDITOR_CLOSE:
+                    if (e.editor) {
+                        const editorKey = this.getEditorKey(e.editor, group);
+                        this.currentEditorSet.delete(editorKey);
+                        const index = this.editorOrder.indexOf(editorKey);
+                        if (index > -1) {
+                            this.editorOrder.splice(index, 1);
+                        }
+                    }
+                    this._onDidChange.fire();
+                    break;
+                case GroupModelChangeKind.EDITOR_MOVE:
+                    this.currentEditorSet.clear();
+                    this.editorGroupService.groups.forEach(group => {
+                        group.editors.forEach(editor => {
+                            const key = this.getEditorKey(editor, group);
+                            this.currentEditorSet.add(key);
+                        });
+                    });
+                    this._onDidChange.fire();
+                    break;
+                case GroupModelChangeKind.EDITOR_ACTIVE:
+                    break;
+                case GroupModelChangeKind.EDITOR_LABEL:
+                    this._onDidChange.fire();
+                    break;
+            }
+        }));
+    }
+    async provideChatSessionItems(token) {
+        const sessions = [];
+        const editorMap = ( new Map());
+        this.editorGroupService.groups.forEach(group => {
+            group.editors.forEach(editor => {
+                if (editor instanceof ChatEditorInput) {
+                    const key = this.getEditorKey(editor, group);
+                    editorMap.set(key, { editor, group });
+                }
+            });
+        });
+        const chatWidget = this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Panel)
+            .find(widget => typeof widget.viewContext === 'object' && 'viewId' in widget.viewContext && widget.viewContext.viewId === LocalChatSessionsProvider_1.CHAT_WIDGET_VIEW_ID);
+        if (chatWidget) {
+            sessions.push({
+                id: LocalChatSessionsProvider_1.CHAT_WIDGET_VIEW_ID,
+                label: chatWidget.viewModel?.model.title || ( localize2(5081, "Chat")).value,
+                description: ( localize(5082, "Chat View")),
+                iconPath: Codicon.chatSparkle,
+                widget: chatWidget,
+                sessionType: 'widget'
+            });
+        }
+        this.editorOrder.forEach((editorKey, index) => {
+            const editorInfo = editorMap.get(editorKey);
+            if (editorInfo) {
+                const sessionId = `local-${editorInfo.group.id}-${index}`;
+                sessions.push({
+                    id: sessionId,
+                    label: editorInfo.editor.getName(),
+                    iconPath: Codicon.commentDiscussion,
+                    editor: editorInfo.editor,
+                    group: editorInfo.group,
+                    sessionType: 'editor'
+                });
+            }
+        });
+        return sessions;
+    }
+};
+LocalChatSessionsProvider = LocalChatSessionsProvider_1 = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IChatWidgetService))
+], LocalChatSessionsProvider));
+let ChatSessionsViewPaneContainer = class ChatSessionsViewPaneContainer extends ViewPaneContainer {
+    constructor(instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService, logService, chatSessionsService) {
+        super(VIEWLET_ID, {
+            mergeViewWithContainerWhenSingleView: false,
+        }, instantiationService, configurationService, layoutService, contextMenuService, telemetryService, extensionService, themeService, storageService, contextService, viewDescriptorService, logService);
+        this.chatSessionsService = chatSessionsService;
+        this.registeredViewDescriptors = ( new Map());
+        this.localProvider = this._register(this.instantiationService.createInstance(LocalChatSessionsProvider));
+        this._register(this.chatSessionsService.registerChatSessionItemProvider(this.localProvider));
+        this.updateViewRegistration();
+        this._register(this.chatSessionsService.onDidChangeItemsProviders(() => {
+            this.updateViewRegistration();
+        }));
+        this._register(this.chatSessionsService.onDidChangeSessionItems((chatSessionType) => {
+            this.refreshProviderTree(chatSessionType);
+        }));
+        this._register(this.chatSessionsService.onDidChangeAvailability(() => {
+            this.updateViewRegistration();
+        }));
+    }
+    getTitle() {
+        const title = ( localize(5083, "Chat Sessions"));
+        return title;
+    }
+    getAllChatSessionProviders() {
+        if (this.localProvider) {
+            return [this.localProvider, ...this.chatSessionsService.getChatSessionItemProviders()];
+        }
+        else {
+            return this.chatSessionsService.getChatSessionItemProviders();
+        }
+    }
+    refreshProviderTree(chatSessionType) {
+        const providers = this.getAllChatSessionProviders();
+        const targetProvider = providers.find(provider => provider.chatSessionType === chatSessionType);
+        if (targetProvider) {
+            const viewId = `${VIEWLET_ID}.${chatSessionType}`;
+            const view = this.getView(viewId);
+            if (view) {
+                view.refreshTree();
+            }
+        }
+    }
+    async updateViewRegistration() {
+        const contributions = await this.chatSessionsService.getChatSessionContributions();
+        await Promise.all(( contributions.map(contrib => this.chatSessionsService.canResolveItemProvider(contrib.type))));
+        const currentProviders = this.getAllChatSessionProviders();
+        const currentProviderIds = ( new Set(( currentProviders.map(p => p.chatSessionType))));
+        const viewsToUnregister = [];
+        for (const [providerId, viewDescriptor] of this.registeredViewDescriptors.entries()) {
+            if (!( currentProviderIds.has(providerId))) {
+                viewsToUnregister.push(viewDescriptor);
+                this.registeredViewDescriptors.delete(providerId);
+            }
+        }
+        if (viewsToUnregister.length > 0) {
+            const container = ( Registry.as(Extensions.ViewContainersRegistry)).get(VIEWLET_ID);
+            if (container) {
+                ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(viewsToUnregister, container);
+            }
+        }
+        this.registerViews(contributions);
+    }
+    async registerViews(extensionPointContributions) {
+        const container = ( Registry.as(Extensions.ViewContainersRegistry)).get(VIEWLET_ID);
+        const providers = this.getAllChatSessionProviders();
+        if (container && providers.length > 0) {
+            const viewDescriptorsToRegister = [];
+            let index = 1;
+            providers.forEach(provider => {
+                if (!( this.registeredViewDescriptors.has(provider.chatSessionType))) {
+                    let displayName = '';
+                    if (provider.chatSessionType === 'local') {
+                        displayName = 'Local Chat Sessions';
+                    }
+                    else {
+                        const extContribution = extensionPointContributions.find(c => c.type === provider.chatSessionType);
+                        if (!extContribution) {
+                            this.logService.warn(`No extension contribution found for chat session type: ${provider.chatSessionType}`);
+                            return;
+                        }
+                        displayName = extContribution.displayName;
+                    }
+                    const viewDescriptor = {
+                        id: `${VIEWLET_ID}.${provider.chatSessionType}`,
+                        name: {
+                            value: displayName,
+                            original: displayName,
+                        },
+                        ctorDescriptor: ( new SyncDescriptor(SessionsViewPane, [provider])),
+                        canToggleVisibility: true,
+                        canMoveView: true,
+                        order: provider.chatSessionType === 'local' ? 0 : index++,
+                    };
+                    viewDescriptorsToRegister.push(viewDescriptor);
+                    this.registeredViewDescriptors.set(provider.chatSessionType, viewDescriptor);
+                }
+            });
+            if (viewDescriptorsToRegister.length > 0) {
+                ( Registry.as(Extensions.ViewsRegistry)).registerViews(viewDescriptorsToRegister, container);
+            }
+        }
+    }
+    dispose() {
+        if (this.registeredViewDescriptors.size > 0) {
+            const container = ( Registry.as(Extensions.ViewContainersRegistry)).get(VIEWLET_ID);
+            if (container) {
+                const allRegisteredViews = Array.from(( this.registeredViewDescriptors.values()));
+                ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(allRegisteredViews, container);
+            }
+            this.registeredViewDescriptors.clear();
+        }
+        super.dispose();
+    }
+};
+ChatSessionsViewPaneContainer = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IWorkbenchLayoutService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, ITelemetryService)),
+    ( __param(5, IExtensionService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IWorkspaceContextService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, ILogService)),
+    ( __param(11, IChatSessionsService))
+], ChatSessionsViewPaneContainer));
+class SessionsDataSource {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    hasChildren(element) {
+        return element === this.provider;
+    }
+    async getChildren(element) {
+        if (element === this.provider) {
+            try {
+                const items = await this.provider.provideChatSessionItems(CancellationToken.None);
+                return ( items.map(item => ({ ...item, provider: this.provider })));
+            }
+            catch (error) {
+                return [];
+            }
+        }
+        return [];
+    }
+}
+class SessionsDelegate {
+    static { this.ITEM_HEIGHT = 22; }
+    getHeight(element) {
+        return SessionsDelegate.ITEM_HEIGHT;
+    }
+    getTemplateId(element) {
+        return SessionsRenderer.TEMPLATE_ID;
+    }
+}
+let SessionsRenderer = class SessionsRenderer extends Disposable {
+    static { SessionsRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'session'; }
+    constructor(labels, themeService, logService) {
+        super();
+        this.labels = labels;
+        this.themeService = themeService;
+        this.logService = logService;
+        this.appliedIconColorStyles = ( new Set());
+        this._register(this.themeService.onDidColorThemeChange(() => {
+            this.appliedIconColorStyles.clear();
+        }));
+    }
+    applyIconColorStyle(iconId, colorId) {
+        const styleKey = `${iconId}-${colorId}`;
+        if (( this.appliedIconColorStyles.has(styleKey))) {
+            return;
+        }
+        const colorTheme = this.themeService.getColorTheme();
+        const color = colorTheme.getColor(colorId);
+        if (color) {
+            const css = `.monaco-workbench .chat-session-item .monaco-icon-label.codicon-${iconId}::before { color: ${color} !important; }`;
+            const activeWindow = getActiveWindow();
+            const styleId = `chat-sessions-icon-${styleKey}`;
+            const existingStyle = activeWindow.document.getElementById(styleId);
+            if (existingStyle) {
+                existingStyle.textContent = css;
+            }
+            else {
+                const styleElement = activeWindow.document.createElement('style');
+                styleElement.setAttribute('data-vscode', 'true');
+                styleElement.id = styleId;
+                styleElement.textContent = css;
+                activeWindow.document.head.appendChild(styleElement);
+                this._register({
+                    dispose: () => {
+                        const activeWin = getActiveWindow();
+                        const style = activeWin.document.getElementById(styleId);
+                        if (style) {
+                            style.remove();
+                        }
+                    }
+                });
+            }
+            this.appliedIconColorStyles.add(styleKey);
+        }
+        else {
+            this.logService.debug('No color found for colorId:', colorId);
+        }
+    }
+    get templateId() {
+        return SessionsRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const element = append(container, $('.chat-session-item'));
+        const resourceLabel = this.labels.create(element, { supportHighlights: true });
+        const actionBar = ( new ActionBar(container));
+        return {
+            container: element,
+            resourceLabel,
+            actionBar
+        };
+    }
+    renderElement(element, index, templateData) {
+        const session = element.element;
+        let iconResource;
+        let iconTheme;
+        let iconUri;
+        if (session.iconPath) {
+            if (session.iconPath instanceof URI) {
+                if (session.iconPath.scheme === 'data') {
+                    iconUri = session.iconPath;
+                }
+                else {
+                    iconResource = session.iconPath;
+                }
+            }
+            else if (ThemeIcon.isThemeIcon(session.iconPath)) {
+                iconTheme = session.iconPath;
+            }
+            else {
+                iconResource = session.iconPath.light;
+            }
+        }
+        if (iconTheme?.color?.id) {
+            this.applyIconColorStyle(iconTheme.id, iconTheme.color.id);
+        }
+        templateData.resourceLabel.setResource({
+            name: session.label,
+            description: 'description' in session && typeof session.description === 'string' ? session.description : '',
+            resource: iconResource
+        }, {
+            fileKind: undefined,
+            icon: iconTheme || iconUri
+        });
+    }
+    disposeTemplate(templateData) {
+        templateData.resourceLabel.dispose();
+        templateData.actionBar.dispose();
+    }
+};
+SessionsRenderer = SessionsRenderer_1 = ( __decorate([
+    ( __param(1, IThemeService)),
+    ( __param(2, ILogService))
+], SessionsRenderer));
+let SessionsViewPane = class SessionsViewPane extends ViewPane {
+    constructor(provider, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService, editorService, viewsService, logService, progressService, chatSessionsService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, hoverService);
+        this.provider = provider;
+        this.instantiationService = instantiationService;
+        this.editorService = editorService;
+        this.viewsService = viewsService;
+        this.logService = logService;
+        this.progressService = progressService;
+        this.chatSessionsService = chatSessionsService;
+        if (provider instanceof LocalChatSessionsProvider) {
+            this._register(provider.onDidChange(() => {
+                if (this.tree && this.isBodyVisible()) {
+                    this.refreshTreeWithProgress();
+                }
+            }));
+        }
+    }
+    isLocalChatSessionItem(item) {
+        return ('editor' in item && 'group' in item) || ('widget' in item && 'sessionType' in item);
+    }
+    refreshTree() {
+        if (this.tree && this.isBodyVisible()) {
+            this.refreshTreeWithProgress();
+        }
+    }
+    getProviderDisplayName() {
+        const contributions = this.chatSessionsService.getChatSessionContributions();
+        const contribution = contributions.find(c => c.type === this.provider.chatSessionType);
+        if (contribution) {
+            return contribution.displayName;
+        }
+        return '';
+    }
+    showEmptyMessage() {
+        if (!this.messageElement) {
+            return;
+        }
+        if (this.provider.chatSessionType === 'local') {
+            this.hideMessage();
+            return;
+        }
+        const providerName = this.getProviderDisplayName();
+        if (!providerName) {
+            return;
+        }
+        const messageText = ( localize(5084, "No sessions found from {0}", providerName));
+        clearNode(this.messageElement);
+        const messageContainer = append(this.messageElement, $('.no-sessions-message'));
+        append(messageContainer, $('.codicon.codicon-info'));
+        const textElement = append(messageContainer, $('span'));
+        textElement.textContent = messageText;
+        this.messageElement.style.display = 'block';
+        if (this.treeContainer) {
+            this.treeContainer.style.display = 'none';
+        }
+    }
+    hideMessage() {
+        if (this.messageElement) {
+            this.messageElement.style.display = 'none';
+        }
+        if (this.treeContainer) {
+            this.treeContainer.style.display = 'block';
+        }
+    }
+    updateEmptyStateMessage() {
+        try {
+            if (this.tree?.hasNode(this.provider)) {
+                const providerNode = this.tree.getNode(this.provider);
+                const childCount = providerNode.children?.length || 0;
+                if (childCount === 0) {
+                    this.showEmptyMessage();
+                }
+                else {
+                    this.hideMessage();
+                }
+            }
+        }
+        catch (error) {
+            this.logService.error('Error checking tree data for empty state:', error);
+        }
+    }
+    async refreshTreeWithProgress() {
+        if (!this.tree) {
+            return;
+        }
+        try {
+            await this.progressService.withProgress({
+                location: this.id,
+                title: ( localize(5085, 'Refreshing chat sessions...')),
+            }, async () => {
+                await this.tree.updateChildren(this.provider);
+            });
+            this.updateEmptyStateMessage();
+        }
+        catch (error) {
+            this.logService.error('Error refreshing chat sessions tree:', error);
+        }
+    }
+    async loadDataWithProgress() {
+        if (!this.tree) {
+            return;
+        }
+        try {
+            await this.progressService.withProgress({
+                location: this.id,
+                title: ( localize(5086, 'Loading chat sessions...')),
+            }, async () => {
+                await this.tree.setInput(this.provider);
+            });
+            this.updateEmptyStateMessage();
+        }
+        catch (error) {
+            this.logService.error('Error loading chat sessions data:', error);
+        }
+    }
+    renderBody(container) {
+        super.renderBody(container);
+        this.messageElement = append(container, $('.chat-sessions-message'));
+        this.messageElement.style.display = 'none';
+        this.treeContainer = append(container, $('.chat-sessions-tree.show-file-icons'));
+        this.treeContainer.classList.add('file-icon-themable-tree');
+        this.labels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
+        this._register(this.labels);
+        this.dataSource = ( new SessionsDataSource(this.provider));
+        const delegate = ( new SessionsDelegate());
+        const renderer = ( new SessionsRenderer(this.labels, this.themeService, this.logService));
+        this._register(renderer);
+        this.tree = this.instantiationService.createInstance(WorkbenchAsyncDataTree, 'SessionsTree', this.treeContainer, delegate, [renderer], this.dataSource, {
+            horizontalScrolling: false,
+            setRowLineHeight: false,
+            transformOptimization: false,
+            identityProvider: {
+                getId: (element) => element.id
+            },
+            accessibilityProvider: {
+                getAriaLabel: (element) => element.label,
+                getWidgetAriaLabel: () => ( localize(5087, "Chat Sessions"))
+            },
+            hideTwistiesOfChildlessElements: true,
+            allowNonCollapsibleParents: true
+        });
+        this.logService.debug('Tree created with hideTwistiesOfChildlessElements: true');
+        this._register(this.tree);
+        this._register(this.tree.onDidOpen(async (e) => {
+            const element = e.element;
+            if (element && this.isLocalChatSessionItem(element)) {
+                if (element.sessionType === 'editor' && element.editor && element.group) {
+                    await this.editorService.openEditor(element.editor, element.group);
+                }
+                else if (element.sessionType === 'widget' && element.widget) {
+                    this.viewsService.openView(element.id, true);
+                }
+            }
+            else {
+                const ckey = this.contextKeyService.createKey('chatSessionType', element.provider.chatSessionType);
+                ckey.reset();
+                const options = {
+                    pinned: true,
+                    preferredTitle: element.label
+                };
+                await this.editorService.openEditor({
+                    resource: ChatSessionUri.forSession(element.provider.chatSessionType, element.id),
+                    options,
+                });
+            }
+        }));
+        this._register(this.onDidChangeBodyVisibility(async (visible) => {
+            if (visible && this.tree) {
+                await this.loadDataWithProgress();
+            }
+        }));
+        if (this.isBodyVisible() && this.tree) {
+            this.loadDataWithProgress();
+        }
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        if (this.tree) {
+            this.tree.layout(height, width);
+        }
+    }
+    focus() {
+        super.focus();
+        if (this.tree) {
+            this.tree.domFocus();
+        }
+    }
+};
+SessionsViewPane = ( __decorate([
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IViewDescriptorService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, IHoverService)),
+    ( __param(11, IEditorService)),
+    ( __param(12, IViewsService)),
+    ( __param(13, ILogService)),
+    ( __param(14, IProgressService)),
+    ( __param(15, IChatSessionsService))
+], SessionsViewPane));
+MenuRegistry.appendMenuItem(MenuId.ViewTitle, {
+    command: {
+        id: 'workbench.action.openChat',
+        title: ( localize2(5088, "New Chat Editor")),
+        icon: Codicon.plus
+    },
+    group: 'navigation',
+    order: 1,
+    when: ( ContextKeyExpr.equals('view', `${VIEWLET_ID}.local`)),
+});
+
+export { ChatSessionsView, VIEWLET_ID };