@codingame/monaco-vscode-chat-service-override 21.6.0 → 22.0.0

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

@@ -0,0 +1,127 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { isChatSession, getChatSessionType } from './common.js';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
+
+let ChatSessionTracker = class ChatSessionTracker extends Disposable {
+    constructor(editorGroupsService, chatService) {
+        super();
+        this.editorGroupsService = editorGroupsService;
+        this.chatService = chatService;
+        this._onDidChangeEditors = this._register(( new Emitter()));
+        this.onDidChangeEditors = this._onDidChangeEditors.event;
+        this.setupEditorTracking();
+    }
+    setupEditorTracking() {
+        this.editorGroupsService.groups.forEach(group => {
+            this.registerGroupListeners(group);
+        });
+        this._register(this.editorGroupsService.onDidAddGroup(group => {
+            this.registerGroupListeners(group);
+        }));
+    }
+    registerGroupListeners(group) {
+        this._register(group.onDidModelChange(e => {
+            if (!isChatSession(e.editor)) {
+                return;
+            }
+            const editor = e.editor;
+            const sessionType = getChatSessionType(editor);
+            this._onDidChangeEditors.fire({ sessionType, kind: e.kind });
+        }));
+    }
+    getLocalEditorsForSessionType(sessionType) {
+        const localEditors = [];
+        this.editorGroupsService.groups.forEach(group => {
+            group.editors.forEach(editor => {
+                if (editor instanceof ChatEditorInput && getChatSessionType(editor) === sessionType) {
+                    localEditors.push(editor);
+                }
+            });
+        });
+        return localEditors;
+    }
+    async getHybridSessionsForProvider(provider) {
+        if (provider.chatSessionType === 'local') {
+            return [];
+        }
+        const localEditors = this.getLocalEditorsForSessionType(provider.chatSessionType);
+        const hybridSessions = [];
+        localEditors.forEach((editor, index) => {
+            const group = this.findGroupForEditor(editor);
+            if (!group) {
+                return;
+            }
+            if (editor.options.ignoreInView) {
+                return;
+            }
+            let status;
+            let timestamp;
+            if (editor.sessionId) {
+                const model = this.chatService.getSession(editor.sessionId);
+                if (model) {
+                    status = this.modelToStatus(model);
+                    const requests = model.getRequests();
+                    if (requests.length > 0) {
+                        timestamp = requests[requests.length - 1].timestamp;
+                    }
+                }
+            }
+            const parsed = ChatSessionUri.parse(editor.resource);
+            const hybridSession = {
+                id: parsed?.sessionId || editor.sessionId || `${provider.chatSessionType}-local-${index}`,
+                label: editor.getName(),
+                iconPath: Codicon.chatSparkle,
+                status,
+                provider,
+                timing: {
+                    startTime: timestamp ?? Date.now()
+                }
+            };
+            hybridSessions.push(hybridSession);
+        });
+        return hybridSessions;
+    }
+    findGroupForEditor(editor) {
+        for (const group of this.editorGroupsService.groups) {
+            if (group.editors.includes(editor)) {
+                return group;
+            }
+        }
+        return undefined;
+    }
+    modelToStatus(model) {
+        if (model.requestInProgress) {
+            return ChatSessionStatus.InProgress;
+        }
+        const requests = model.getRequests();
+        if (requests.length > 0) {
+            const lastRequest = requests[requests.length - 1];
+            if (lastRequest?.response) {
+                if (lastRequest.response.isCanceled || lastRequest.response.result?.errorDetails) {
+                    return ChatSessionStatus.Failed;
+                }
+                else if (lastRequest.response.isComplete) {
+                    return ChatSessionStatus.Completed;
+                }
+                else {
+                    return ChatSessionStatus.InProgress;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+ChatSessionTracker = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IChatService))
+], ChatSessionTracker));
+
+export { ChatSessionTracker };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/common.d.ts

@@ -0,0 +1,37 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatSessionItem, IChatSessionItemProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ChatEditorInput } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput";
+export declare const NEW_CHAT_SESSION_ACTION_ID = "workbench.action.chat.openNewSessionEditor";
+export type ChatSessionItemWithProvider = IChatSessionItem & {
+    readonly provider: IChatSessionItemProvider;
+    isHistory?: boolean;
+    relativeTime?: string;
+    relativeTimeFullWord?: string;
+    hideRelativeTime?: boolean;
+    timing?: {
+        startTime: number;
+    };
+};
+export declare function isChatSession(editor?: EditorInput): boolean;
+/**
+ * Returns chat session type from a URI, or 'local' if not specified or cannot be determined.
+ */
+export declare function getChatSessionType(editor: ChatEditorInput): string;
+/**
+ * Find existing chat editors that have the same session URI (for external providers)
+ */
+export declare function findExistingChatEditorByUri(sessionUri: URI, sessionId: string, editorGroupsService: IEditorGroupsService): {
+    editor: ChatEditorInput;
+    groupId: number;
+} | undefined;
+export declare function isLocalChatSessionItem(item: ChatSessionItemWithProvider): boolean;
+export declare function extractTimestamp(item: IChatSessionItem): number | undefined;
+export declare function processSessionsWithTimeGrouping(sessions: ChatSessionItemWithProvider[]): void;
+export declare function getSessionItemContextOverlay(session: ChatSessionItemWithProvider, provider?: IChatSessionItemProvider, chatWidgetService?: IChatWidgetService, chatService?: IChatService, editorGroupsService?: IEditorGroupsService): [
+    string,
+    any
+][];

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

@@ -0,0 +1,137 @@
+
+import { fromNow } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ChatSessionUri } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatUri';
+import { ChatEditorInput } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+
+const NEW_CHAT_SESSION_ACTION_ID = 'workbench.action.chat.openNewSessionEditor';
+function isChatSession(editor) {
+    if (!(editor instanceof ChatEditorInput)) {
+        return false;
+    }
+    if (editor.resource?.scheme !== 'vscode-chat-editor' && editor.resource?.scheme !== 'vscode-chat-session') {
+        return false;
+    }
+    if (editor.options.ignoreInView) {
+        return false;
+    }
+    return true;
+}
+function getChatSessionType(editor) {
+    if (!editor.resource) {
+        return 'local';
+    }
+    const { scheme, query } = editor.resource;
+    if (scheme === Schemas.vscodeChatSession) {
+        const parsed = ChatSessionUri.parse(editor.resource);
+        if (parsed) {
+            return parsed.chatSessionType;
+        }
+    }
+    const sessionTypeFromQuery = ( new URLSearchParams(query)).get('chatSessionType');
+    if (sessionTypeFromQuery) {
+        return sessionTypeFromQuery;
+    }
+    return 'local';
+}
+function findExistingChatEditorByUri(sessionUri, sessionId, editorGroupsService) {
+    if (!sessionUri) {
+        return undefined;
+    }
+    for (const group of editorGroupsService.groups) {
+        for (const editor of group.editors) {
+            if (editor instanceof ChatEditorInput && (( editor.resource.toString()) === ( sessionUri.toString()) || editor.sessionId === sessionId)) {
+                return { editor, groupId: group.id };
+            }
+        }
+    }
+    return undefined;
+}
+function isLocalChatSessionItem(item) {
+    return item.provider.chatSessionType === 'local';
+}
+function updateRelativeTime(item, lastRelativeTime) {
+    if (item.timing?.startTime) {
+        item.relativeTime = fromNow(item.timing.startTime);
+        item.relativeTimeFullWord = fromNow(item.timing.startTime, false, true);
+        if (lastRelativeTime === undefined || item.relativeTime !== lastRelativeTime) {
+            lastRelativeTime = item.relativeTime;
+            item.hideRelativeTime = false;
+        }
+        else {
+            item.hideRelativeTime = true;
+        }
+    }
+    else {
+        item.relativeTime = undefined;
+        item.relativeTimeFullWord = undefined;
+        item.hideRelativeTime = false;
+    }
+    return lastRelativeTime;
+}
+function extractTimestamp(item) {
+    if (item.timing?.startTime) {
+        return item.timing.startTime;
+    }
+    if ('timestamp' in item) {
+        return item.timestamp;
+    }
+    return undefined;
+}
+function sortSessionsByTimestamp(sessions) {
+    sessions.sort((a, b) => {
+        const aTime = a.timing?.startTime ?? 0;
+        const bTime = b.timing?.startTime ?? 0;
+        return bTime - aTime;
+    });
+}
+function applyTimeGrouping(sessions) {
+    let lastRelativeTime;
+    sessions.forEach(session => {
+        lastRelativeTime = updateRelativeTime(session, lastRelativeTime);
+    });
+}
+function processSessionsWithTimeGrouping(sessions) {
+    if (( sessions.some(session => session.timing?.startTime !== undefined))) {
+        sortSessionsByTimestamp(sessions);
+        applyTimeGrouping(sessions);
+    }
+}
+function getSessionItemContextOverlay(session, provider, chatWidgetService, chatService, editorGroupsService) {
+    const overlay = [];
+    if (session.id === 'show-history') {
+        return overlay;
+    }
+    if (provider) {
+        overlay.push([ChatContextKeys.sessionType.key, provider.chatSessionType]);
+    }
+    overlay.push([ChatContextKeys.isHistoryItem.key, session.isHistory]);
+    let isActiveSession = false;
+    if (!session.isHistory && provider?.chatSessionType === 'local') {
+        isActiveSession = true;
+    }
+    else if (session.isHistory && chatWidgetService && chatService && editorGroupsService) {
+        const widget = chatWidgetService.getWidgetBySessionId(session.id);
+        if (widget) {
+            isActiveSession = true;
+        }
+        else {
+            for (const group of editorGroupsService.groups) {
+                for (const editor of group.editors) {
+                    if (editor instanceof ChatEditorInput && editor.sessionId === session.id) {
+                        isActiveSession = true;
+                        break;
+                    }
+                }
+                if (isActiveSession) {
+                    break;
+                }
+            }
+        }
+    }
+    overlay.push([ChatContextKeys.isActiveSession.key, isActiveSession]);
+    return overlay;
+}
+
+export { NEW_CHAT_SESSION_ACTION_ID, extractTimestamp, findExistingChatEditorByUri, getChatSessionType, getSessionItemContextOverlay, isChatSession, isLocalChatSessionItem, processSessionsWithTimeGrouping };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/localChatSessionsProvider.d.ts

@@ -0,0 +1,32 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatSessionItemProvider, IChatSessionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+export declare class LocalChatSessionsProvider extends Disposable implements IChatSessionItemProvider {
+    private readonly editorGroupService;
+    private readonly chatWidgetService;
+    private readonly chatService;
+    private readonly chatSessionsService;
+    static readonly CHAT_WIDGET_VIEW_ID = "workbench.panel.chat.view.copilot";
+    static readonly HISTORY_NODE_ID = "show-history";
+    readonly chatSessionType = "local";
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    readonly _onDidChangeChatSessionItems: Emitter<void>;
+    get onDidChangeChatSessionItems(): Event<void>;
+    private currentEditorSet;
+    private editorOrder;
+    constructor(editorGroupService: IEditorGroupsService, chatWidgetService: IChatWidgetService, chatService: IChatService, chatSessionsService: IChatSessionsService);
+    private registerWidgetListeners;
+    private registerProgressListener;
+    private registerModelTitleListener;
+    private initializeCurrentEditorSet;
+    private getEditorKey;
+    private isLocalChatSession;
+    private modelToStatus;
+    provideChatSessionItems(token: CancellationToken): Promise<IChatSessionItem[]>;
+}

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

@@ -0,0 +1,212 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatEditorInput } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { isChatSession, getChatSessionType } from './common.js';
+
+var LocalChatSessionsProvider_1;
+let LocalChatSessionsProvider = class LocalChatSessionsProvider extends Disposable {
+    static { LocalChatSessionsProvider_1 = this; }
+    static { this.CHAT_WIDGET_VIEW_ID = 'workbench.panel.chat.view.copilot'; }
+    static { this.HISTORY_NODE_ID = 'show-history'; }
+    get onDidChangeChatSessionItems() { return this._onDidChangeChatSessionItems.event; }
+    constructor(editorGroupService, chatWidgetService, chatService, chatSessionsService) {
+        super();
+        this.editorGroupService = editorGroupService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatService = chatService;
+        this.chatSessionsService = chatSessionsService;
+        this.chatSessionType = 'local';
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._onDidChangeChatSessionItems = this._register(( new Emitter()));
+        this.currentEditorSet = ( new Set());
+        this.editorOrder = [];
+        this.initializeCurrentEditorSet();
+        this.registerWidgetListeners();
+        this._register(this.chatService.onDidDisposeSession(() => {
+            this._onDidChange.fire();
+        }));
+        this._register(this.chatSessionsService.onDidChangeSessionItems((sessionType) => {
+            if (sessionType === this.chatSessionType) {
+                this.initializeCurrentEditorSet();
+                this._onDidChange.fire();
+            }
+        }));
+    }
+    registerWidgetListeners() {
+        this._register(this.chatWidgetService.onDidAddWidget(widget => {
+            if (widget.location === ChatAgentLocation.Chat &&
+                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();
+                    if (widget.viewModel) {
+                        this.registerProgressListener(widget.viewModel.model.requestInProgressObs);
+                    }
+                }));
+                this.registerModelTitleListener(widget);
+                if (widget.viewModel) {
+                    this.registerProgressListener(widget.viewModel.model.requestInProgressObs);
+                }
+            }
+        }));
+        const existingWidgets = this.chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat)
+            .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);
+            if (widget.viewModel) {
+                this.registerProgressListener(widget.viewModel.model.requestInProgressObs);
+            }
+        });
+    }
+    registerProgressListener(observable) {
+        const progressEvent = Event.fromObservableLight(observable);
+        this._register(progressEvent(() => {
+            this._onDidChangeChatSessionItems.fire();
+        }));
+    }
+    registerModelTitleListener(widget) {
+        const model = widget.viewModel?.model;
+        if (model) {
+            this._register(model.onDidChange((e) => {
+                if (!e || e.kind === 'setCustomTitle') {
+                    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()}`;
+    }
+    isLocalChatSession(editor) {
+        if (!isChatSession(editor)) {
+            return false;
+        }
+        if (!(editor instanceof ChatEditorInput)) {
+            return false;
+        }
+        const sessionType = getChatSessionType(editor);
+        return sessionType === 'local';
+    }
+    modelToStatus(model) {
+        if (model.requestInProgress) {
+            return ChatSessionStatus.InProgress;
+        }
+        else {
+            const requests = model.getRequests();
+            if (requests.length > 0) {
+                const lastRequest = requests[requests.length - 1];
+                if (lastRequest && lastRequest.response) {
+                    if (lastRequest.response.isCanceled || lastRequest.response.result?.errorDetails) {
+                        return ChatSessionStatus.Failed;
+                    }
+                    else if (lastRequest.response.isComplete) {
+                        return ChatSessionStatus.Completed;
+                    }
+                    else {
+                        return ChatSessionStatus.InProgress;
+                    }
+                }
+            }
+        }
+        return;
+    }
+    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.Chat)
+            .find(widget => typeof widget.viewContext === 'object' && 'viewId' in widget.viewContext && widget.viewContext.viewId === LocalChatSessionsProvider_1.CHAT_WIDGET_VIEW_ID);
+        const status = chatWidget?.viewModel?.model ? this.modelToStatus(chatWidget.viewModel.model) : undefined;
+        const widgetSession = {
+            id: LocalChatSessionsProvider_1.CHAT_WIDGET_VIEW_ID,
+            label: chatWidget?.viewModel?.model.title || ( localize2(5235, "Chat")).value,
+            description: ( localize(5236, "Chat View")),
+            iconPath: Codicon.chatSparkle,
+            status,
+            provider: this
+        };
+        sessions.push(widgetSession);
+        this.editorOrder.forEach((editorKey, index) => {
+            const editorInfo = editorMap.get(editorKey);
+            if (editorInfo) {
+                let status;
+                let timestamp;
+                if (editorInfo.editor instanceof ChatEditorInput && editorInfo.editor.sessionId) {
+                    const model = this.chatService.getSession(editorInfo.editor.sessionId);
+                    if (model) {
+                        status = this.modelToStatus(model);
+                        const requests = model.getRequests();
+                        if (requests.length > 0) {
+                            const lastRequest = requests[requests.length - 1];
+                            timestamp = lastRequest.timestamp;
+                        }
+                        else {
+                            timestamp = Date.now();
+                        }
+                    }
+                    const editorSession = {
+                        id: editorInfo.editor.sessionId,
+                        label: editorInfo.editor.getName(),
+                        iconPath: Codicon.chatSparkle,
+                        status,
+                        provider: this,
+                        timing: {
+                            startTime: timestamp ?? 0
+                        }
+                    };
+                    sessions.push(editorSession);
+                }
+            }
+        });
+        const historyNode = {
+            id: LocalChatSessionsProvider_1.HISTORY_NODE_ID,
+            label: ( localize(5237, "History")),
+        };
+        return [...sessions, historyNode];
+    }
+};
+LocalChatSessionsProvider = LocalChatSessionsProvider_1 = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatService)),
+    ( __param(3, IChatSessionsService))
+], LocalChatSessionsProvider));
+
+export { LocalChatSessionsProvider };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/view/chatSessionsView.d.ts

@@ -0,0 +1,22 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+export declare class ChatSessionsView extends Disposable implements IWorkbenchContribution {
+    private readonly configurationService;
+    private readonly instantiationService;
+    private readonly chatSessionsService;
+    private readonly chatEntitlementService;
+    static readonly ID = "workbench.contrib.chatSessions";
+    private isViewContainerRegistered;
+    private localProvider;
+    private readonly sessionTracker;
+    private viewContainer;
+    constructor(configurationService: IConfigurationService, instantiationService: IInstantiationService, chatSessionsService: IChatSessionsService, chatEntitlementService: IChatEntitlementService);
+    private setupEditorTracking;
+    private updateViewContainerRegistration;
+    private registerViewContainer;
+    private deregisterViewContainer;
+}