@codingame/monaco-vscode-workbench-service-override 37.1.0 → 37.3.0

package/vscode/src/vs/sessions/services/sessions/browser/sessionsService.js

@@ -0,0 +1,1121 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IWorkspaceTrustRequestService, IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SessionStatus, ChatInteractivity, ChatOriginKind } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { inheritableSessionTarget } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ensureSessionWorktreesTrusted } from './worktreeTrust.js';
+import { ClosedItemHistory } from './closedItemHistory.js';
+import { SessionsNavigation } from './sessionNavigation.js';
+import { SessionsRecencyHistory } from './sessionsRecencyHistory.js';
+import { VisibleSessions } from './visibleSessions.js';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ISessionsPartService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service';
+import { ICustomViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/customView/browser/customViewService.service';
+import { IsNewChatSessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { setActiveSessionContextKeys } from '../common/sessionContextKeys.js';
+import { ISessionChangesStatsCache } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionChangesStatsCache.service';
+import { ISessionOpenTelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionOpenTelemetryService.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const ACTIVE_SESSION_STATES_KEY = "agentSessions.activeSessionStates";
+const RESTORE_RESOLVE_BUDGET_MS = 10_000;
+const RESTORE_SESSION_WAIT_TIMEOUT = 30_000;
+const MAX_RECENTLY_OPENED_SESSIONS = 10;
+let SessionsService = class SessionsService extends Disposable {
+    constructor(
+        storageService,
+        logService,
+        uriIdentityService,
+        contextKeyService,
+        sessionsManagementService,
+        sessionsProvidersService,
+        sessionsPartService,
+        customViewService,
+        instantiationService,
+        workspaceTrustRequestService,
+        workspaceTrustManagementService,
+        changesStatsCache,
+        sessionOpenTelemetryService
+    ) {
+        super();
+        this.storageService = storageService;
+        this.logService = logService;
+        this.uriIdentityService = uriIdentityService;
+        this.contextKeyService = contextKeyService;
+        this.sessionsManagementService = sessionsManagementService;
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.sessionsPartService = sessionsPartService;
+        this.customViewService = customViewService;
+        this.instantiationService = instantiationService;
+        this.workspaceTrustRequestService = workspaceTrustRequestService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.changesStatsCache = changesStatsCache;
+        this.sessionOpenTelemetryService = sessionOpenTelemetryService;
+        this._onDidToggleSessionStickiness = this._register(( new Emitter()));
+        this.onDidToggleSessionStickiness = this._onDidToggleSessionStickiness.event;
+        this._initialRestoreComplete = observableValue(this, false);
+        this.initialRestoreComplete = this._initialRestoreComplete;
+        this._navigationRequest = observableValue(this, undefined);
+        this.navigationRequest = this._navigationRequest;
+        this._openSessionCts = this._register(( new MutableDisposable()));
+        this._restoreCts = this._register(( new MutableDisposable()));
+        this._pendingRestoredChatResources = ( new ResourceMap());
+        this._sendFollow = this._register(( new MutableDisposable()));
+        this._sessionStates = this._loadSessionStates();
+        this._visibility = this._register(this.instantiationService.createInstance(
+            VisibleSessions,
+            session => this._restoreInitialChat(session),
+            session => this._restoreClosedChats(session),
+            session => this._restoreShownRelatedChats(session),
+            (replaced, index, sticky, replacedBySessionId) => this._closedItems.recordReplacedSlot(replaced, index, sticky, replacedBySessionId)
+        ));
+        this.visibleSessions = this._visibility.visibleSessions;
+        this.activeSession = this._visibility.activeSession;
+        this._closedItems = this._register(this.instantiationService.createInstance(
+            ClosedItemHistory,
+            this._visibility,
+            (session, chatResource) => this.openChat(session, chatResource)
+        ));
+        this._isNewChatSessionContext = IsNewChatSessionContext.bindTo(this.contextKeyService);
+        this._register(this.storageService.onWillSaveState(() => this._saveSessionStates()));
+        this._recencyHistory = this._register(( new SessionsRecencyHistory(this.storageService, this.logService)));
+        this._navigation = this._register(( new SessionsNavigation(
+            this,
+            this.activeSession,
+            this.sessionsManagementService,
+            this._recencyHistory,
+            this.contextKeyService,
+            this.logService
+        )));
+        this._register(
+            this.sessionsManagementService.onDidChangeSessions(e => this._navigation.onDidRemoveSessions(e))
+        );
+        this._register(
+            this.sessionsManagementService.onDidDeleteSession(session => this._recencyHistory.remove(entry => ( entry.sessionResource.toString()) === ( session.resource.toString())))
+        );
+        this._register(autorun(reader => {
+            const activeSession = this.activeSession.read(reader);
+            const newSession = this.sessionsManagementService.newSession.read(reader);
+            this._isNewChatSessionContext.set(
+                activeSession === undefined || activeSession.sessionId === newSession?.sessionId
+            );
+            setActiveSessionContextKeys(activeSession, this.contextKeyService, reader, this.changesStatsCache);
+        }));
+        this._register(autorun(reader => {
+            const activeSession = this.activeSession.read(reader);
+            if (activeSession) {
+                reader.store.add(this._activeSessionViewListeners(activeSession));
+            }
+        }));
+        this._register(autorun(reader => {
+            const activeSession = this.activeSession.read(reader);
+            if (activeSession && !activeSession.isRead.read(reader)) {
+                this.sessionsManagementService.markRead(activeSession);
+            }
+        }));
+        this._register(
+            this.sessionsManagementService.onDidChangeSessions(e => this._onDidChangeSessions(e))
+        );
+        this._register(this.sessionsManagementService.onDidReplaceSession((
+            {
+                from,
+                to
+            }
+        ) => this._onDidReplaceSession(from, to)));
+        this._register(this.sessionsManagementService.onDidReplaceNewDraftSession((
+            {
+                from,
+                to
+            }
+        ) => this._onDidReplaceSession(from, to)));
+        this._register(
+            this.sessionsManagementService.onWillSendRequest(session => this._startSendFollow(session))
+        );
+        this._register(
+            this.sessionsManagementService.onDidSendRequest(() => this._sendFollow.clear())
+        );
+        this._register(autorun(reader => {
+            const visible = this.visibleSessions.read(reader);
+            const active = this._visibility.activeSession.read(reader);
+            const preserveFocus = this._visibility.activePreserveFocus.read(reader);
+            this.sessionsPartService.updateVisibleSessions(visible, active);
+            const activeId = active?.sessionId;
+            if (activeId !== this._focusedActiveSessionId) {
+                this._focusedActiveSessionId = activeId;
+                if (!preserveFocus) {
+                    this.sessionsPartService.focusSession(active);
+                }
+            }
+        }));
+        this._register(this.sessionsPartService.onDidFocusSession(sessionId => {
+            const session = this.visibleSessions.get().find(s => s?.sessionId === sessionId);
+            if (session) {
+                this.setActive(session);
+            }
+        }));
+    }
+    _onDidReplaceSession(from, to) {
+        this._visibility.updateSession(from, to);
+    }
+    _activeSessionViewListeners(activeSession) {
+        const disposables = ( new DisposableStore());
+        const initialChatResource = activeSession.activeChat.get()?.resource;
+        let pendingRestoredChatResource;
+        this._pendingRestoredChatResources.delete(activeSession.resource);
+        const storedActiveChatResource = this._sessionStates.get(activeSession.resource)?.activeChatResource;
+        if (storedActiveChatResource) {
+            try {
+                const resource = ( URI.parse(storedActiveChatResource));
+                if (!initialChatResource || !this.uriIdentityService.extUri.isEqual(resource, initialChatResource)) {
+                    pendingRestoredChatResource = resource;
+                    this._pendingRestoredChatResources.set(activeSession.resource, resource);
+                }
+            } catch (error) {
+                this.logService.warn(
+                    "[SessionsView] Failed to restore active chat from stored session state",
+                    error
+                );
+            }
+        }
+        let wasArchived = activeSession.isArchived.get();
+        disposables.add(autorun(reader => {
+            const isArchived = activeSession.isArchived.read(reader);
+            if (isArchived && !wasArchived) {
+                if (activeSession.isQuickChat?.read(undefined)) {
+                    this._openQuickChat(undefined, "automatic");
+                } else {
+                    const folderUri = activeSession.workspace.read(undefined)?.folders[0]?.root;
+                    void this._openNewSession(folderUri ? {
+                        folderUri,
+                        ...inheritableSessionTarget(this.sessionsManagementService, activeSession, folderUri)
+                    } : undefined, CancellationToken.None, "automatic").catch(onUnexpectedError);
+                }
+            }
+            wasArchived = isArchived;
+        }));
+        if (activeSession.status.get() !== SessionStatus.Untitled) {
+            disposables.add(autorun(reader => {
+                const chats = activeSession.chats.read(reader);
+                const activeChat = activeSession.activeChat.read(reader);
+                if (activeChat && !( chats.some(
+                    c => this.uriIdentityService.extUri.isEqual(c.resource, activeChat.resource)
+                ))) {
+                    const visible = chats.filter(c => c.interactivity.read(reader) !== ChatInteractivity.Hidden);
+                    const fallback = visible[visible.length - 1] ?? activeSession.mainChat.read(reader);
+                    if (fallback) {
+                        void this._openChatSession(activeSession, fallback.resource, undefined, "automatic").catch(onUnexpectedError);
+                    }
+                }
+            }));
+        }
+        if (pendingRestoredChatResource) {
+            disposables.add(autorun(reader => {
+                const resource = pendingRestoredChatResource;
+                if (!resource) {
+                    return;
+                }
+                const chat = activeSession.chats.read(reader).find(
+                    candidate => this.uriIdentityService.extUri.isEqual(candidate.resource, resource)
+                );
+                if (chat) {
+                    pendingRestoredChatResource = undefined;
+                    this._pendingRestoredChatResources.delete(activeSession.resource);
+                    this._visibility.openChat(activeSession, chat);
+                    this._visibility.setActiveChat(activeSession, chat);
+                }
+            }));
+        }
+        disposables.add(autorun(reader => {
+            const chat = activeSession.activeChat.read(reader);
+            if (chat && chat.status.read(undefined) !== SessionStatus.Untitled) {
+                if (pendingRestoredChatResource && initialChatResource && this.uriIdentityService.extUri.isEqual(chat.resource, initialChatResource)) {
+                    return;
+                }
+                pendingRestoredChatResource = undefined;
+                this._pendingRestoredChatResources.delete(activeSession.resource);
+                const existing = this._sessionStates.get(activeSession.resource);
+                this._sessionStates.set(activeSession.resource, {
+                    ...existing,
+                    sessionResource: ( activeSession.resource.toString()),
+                    activeChatResource: ( chat.resource.toString()),
+                    activeChatOrigin: chat.origin?.kind
+                });
+            }
+        }));
+        return disposables;
+    }
+    _onDidChangeSessions(e) {
+        const currentActive = this._visibility.activeSession.get();
+        if (e.removed.length) {
+            for (const session of e.removed) {
+                this._sessionStates.delete(session.resource);
+            }
+            this._visibility.removeMany(e.removed.map(r => r.sessionId));
+        }
+        if (!currentActive) {
+            return;
+        }
+        if (e.removed.length && ( e.removed.some(r => r.sessionId === currentActive.sessionId))) {
+            const fallback = this._visibility.activeSession.get();
+            if (fallback && this.sessionsManagementService.getSession(fallback.resource)) {
+                void this._openSession(fallback.resource, {
+                    source: "fallback"
+                }, "automatic").catch(onUnexpectedError);
+            } else {
+                void this._openNewSession(undefined, CancellationToken.None, "automatic").catch(onUnexpectedError);
+            }
+        }
+    }
+    _startSendFollow(session) {
+        const store = ( new DisposableStore());
+        let followId = session.sessionId;
+        store.add(this.sessionsManagementService.onDidReplaceSession((
+            {
+                from,
+                to
+            }
+        ) => {
+            if (from.sessionId === followId) {
+                followId = to.sessionId;
+            }
+        }));
+        store.add(autorun(reader => {
+            const active = this._visibility.activeSession.read(reader);
+            if (active && active.sessionId === followId) {
+                const chats = active.visibleChatTabs.read(reader);
+                const lastChat = chats[chats.length - 1];
+                if (lastChat) {
+                    this._visibility.setActiveChat(active, lastChat);
+                }
+            }
+        }));
+        this._sendFollow.value = store;
+    }
+    getRecentlyOpenedSessions() {
+        const seen = ( new Set());
+        const recent = [];
+        for (const entry of this._recencyHistory.entries) {
+            if (recent.length >= MAX_RECENTLY_OPENED_SESSIONS) {
+                break;
+            }
+            const key = ( entry.sessionResource.toString());
+            if (( seen.has(key))) {
+                continue;
+            }
+            seen.add(key);
+            const session = this.sessionsManagementService.getSession(entry.sessionResource);
+            if (session) {
+                recent.push(session);
+            }
+        }
+        const other = this.sessionsManagementService.getSessions().filter(s => !( seen.has(( s.resource.toString())))).sort((a, b) => b.updatedAt.get().getTime() - a.updatedAt.get().getTime());
+        return {
+            recent,
+            other
+        };
+    }
+    _startOpenSession() {
+        this._openSessionCts.value?.cancel();
+        const cts = ( new CancellationTokenSource());
+        this._openSessionCts.value = cts;
+        return cts.token;
+    }
+    _beginNavigation(intent, token = CancellationToken.None, preserveNavigation = false) {
+        if (intent === "explicit") {
+            if (!preserveNavigation) {
+                this._recordNavigation(token);
+            }
+            this.customViewService.hideCustomView();
+        }
+    }
+    _recordNavigation(token = CancellationToken.None) {
+        this._navigationRequest.set({
+            token
+        }, undefined);
+    }
+    _cancelRestore() {
+        this._restoreCts.value?.cancel();
+        this._restoreCts.clear();
+    }
+    _activate(session, preserveFocus) {
+        return this._visibility.setActive(session, preserveFocus);
+    }
+    openChat(session, chatUri, options) {
+        return this._openChatSession(session, chatUri, options, "explicit");
+    }
+    async _openChatSession(session, chatUri, options, intent) {
+        const t0 = Date.now();
+        this._cancelRestore();
+        this._beginNavigation(intent);
+        const token = this._startOpenSession();
+        const resolved = await this._resolveSessionForOpen(session, chatUri);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        session = resolved.session;
+        chatUri = resolved.chatUri ?? chatUri;
+        if (options?.source) {
+            await this.sessionOpenTelemetryService.withOpenRequest(
+                options.source,
+                token,
+                telemetryAttempt => this._openChat(session, chatUri, options.preserveFocus, token, t0, telemetryAttempt)
+            );
+            return;
+        }
+        await this._openChat(session, chatUri, options?.preserveFocus, token, t0);
+    }
+    async _openChat(session, chatUri, preserveFocus, token, startTime, telemetryAttempt) {
+        if (telemetryAttempt) {
+            this.sessionOpenTelemetryService.sessionResolved(
+                telemetryAttempt,
+                session.resource,
+                session.providerId,
+                this.activeSession.get()?.sessionId === session.sessionId,
+                session.loading.get()
+            );
+            this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, chatUri);
+        }
+        this.logService.trace(`[SessionsView] openChat start uri=${( chatUri.toString())} provider=${session.providerId}`);
+        this._activate(session, preserveFocus);
+        if (!(await this._waitForSessionToLoad(session, token))) {
+            this.logService.trace(
+                `[SessionsView] openChat cancelled while waiting for session to load uri=${( chatUri.toString())}`
+            );
+            return;
+        }
+        let chat;
+        const activeSession = this._visibility.activeSession.get();
+        if (activeSession) {
+            chat = activeSession.chats.get().find(c => this.uriIdentityService.extUri.isEqual(c.resource, chatUri));
+            if (chat) {
+                this._visibility.openChat(session, chat);
+                this._visibility.setActiveChat(session, chat);
+                this._setChatVisibilityState(session, chat, true);
+            }
+        }
+        if (telemetryAttempt) {
+            if (chat) {
+                this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, chat.resource);
+            }
+            this.sessionOpenTelemetryService.sessionLoaded(telemetryAttempt);
+        }
+        if (chat && chat.status.get() === SessionStatus.Untitled) {
+            this.logService.trace(
+                `[SessionsView] openChat done total=${Date.now() - startTime}ms uri=${( chatUri.toString())} path=untitled`
+            );
+            return;
+        }
+        this.logService.trace(
+            `[SessionsView] openChat done total=${Date.now() - startTime}ms uri=${( chatUri.toString())}`
+        );
+    }
+    async closeChat(session, chat, options) {
+        this._visibility.closeChat(session, chat);
+        this._setChatVisibilityState(session, chat, false);
+        if (!options?.skipHistory) {
+            this._closedItems.recordClosedChat(session, chat.resource);
+        }
+    }
+    reopenLastClosedItem() {
+        return this._closedItems.reopenLast();
+    }
+    _setChatVisibilityState(session, chat, visible) {
+        if (this.uriIdentityService.extUri.isEqual(chat.resource, session.mainChat.get().resource)) {
+            return;
+        }
+        const existing = this._sessionStates.get(session.resource);
+        const chatResource = ( chat.resource.toString());
+        const closedChatResources = ( new Set(existing?.closedChatResources));
+        const openedChatResources = ( new Set(existing?.openedChatResources));
+        if (visible) {
+            closedChatResources.delete(chatResource);
+            openedChatResources.add(chatResource);
+        } else {
+            closedChatResources.delete(chatResource);
+            openedChatResources.delete(chatResource);
+            if (chat.origin?.kind !== ChatOriginKind.Tool) {
+                closedChatResources.add(chatResource);
+            }
+        }
+        this._sessionStates.set(session.resource, {
+            ...existing,
+            sessionResource: ( session.resource.toString()),
+            closedChatResources: closedChatResources.size ? [...closedChatResources] : undefined,
+            openedChatResources: openedChatResources.size ? [...openedChatResources] : undefined
+        });
+    }
+    _applyActiveChatSelection(session, restoreOnlySideOrToolChat) {
+        if (!restoreOnlySideOrToolChat) {
+            return;
+        }
+        const state = this._sessionStates.get(session.resource);
+        if (state?.activeChatOrigin === ChatOriginKind.SideChat || state?.activeChatOrigin === ChatOriginKind.Tool) {
+            return;
+        }
+        const mainChat = session.mainChat.get();
+        this._visibility.setActiveChat(session, mainChat);
+        this._sessionStates.set(session.resource, {
+            ...state,
+            sessionResource: ( session.resource.toString()),
+            activeChatResource: ( mainChat.resource.toString()),
+            activeChatOrigin: mainChat.origin?.kind
+        });
+    }
+    openSession(sessionResource, options) {
+        return this._openSession(sessionResource, options, "explicit");
+    }
+    async _openSession(sessionResource, options, intent) {
+        this.logService.trace(`[SessionsView] openSession requested uri=${( sessionResource.toString())}`);
+        this._cancelRestore();
+        this._beginNavigation(intent);
+        const token = this._startOpenSession();
+        await this.sessionOpenTelemetryService.withOpenRequest(options?.source ?? "unknown", token, async telemetryAttempt => {
+            const resolved = await this.sessionsManagementService.resolveSessionResource(sessionResource, "open");
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const sessionData = this._getSession(resolved);
+            await this.sessionsProvidersService.getProvider(sessionData.providerId)?.prepareSessionForOpen?.(sessionData, "open");
+            if (token.isCancellationRequested) {
+                return;
+            }
+            this._applyActiveChatSelection(sessionData, options?.restoreOnlySideOrToolChat);
+            this.sessionOpenTelemetryService.sessionResolved(
+                telemetryAttempt,
+                sessionData.resource,
+                sessionData.providerId,
+                this.activeSession.get()?.sessionId === sessionData.sessionId,
+                sessionData.loading.get()
+            );
+            this._showSession(sessionData, options);
+            await this._waitForOpenSessionToLoad(sessionData, token, telemetryAttempt);
+        });
+    }
+    showSession(sessionResource, options) {
+        this._cancelRestore();
+        this._beginNavigation("explicit");
+        this._startOpenSession();
+        this._showSession(this._getSession(sessionResource), options);
+    }
+    async canOpenSession(session) {
+        if (this.activeSession.get()?.sessionId === session.sessionId) {
+            return true;
+        }
+        const workspace = session.workspace.get();
+        if (!workspace?.requiresWorkspaceTrust) {
+            return true;
+        }
+        await ensureSessionWorktreesTrusted(workspace, this.workspaceTrustManagementService);
+        const folders = workspace.folders.map(folder => folder.workingDirectory);
+        const trustInfos = await Promise.all(
+            folders.map(folder => this.workspaceTrustManagementService.getUriTrustInfo(folder))
+        );
+        const untrustedFolders = folders.filter((_, index) => !trustInfos[index].trusted);
+        for (const folder of untrustedFolders) {
+            const trusted = await this.workspaceTrustRequestService.requestResourcesTrust({
+                uri: folder,
+                message: ( localize(
+                    4905,
+                    "An agent session will be able to read files, run commands, and make changes in this folder."
+                ))
+            });
+            if (!trusted) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async openSessionToSide(session, options) {
+        this._beginNavigation("explicit");
+        const token = this._startOpenSession();
+        const resolved = await this._resolveSessionForOpen(session, options?.chatResource);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        session = resolved.session;
+        if (options?.chatResource && resolved.chatUri) {
+            options = {
+                ...options,
+                chatResource: resolved.chatUri
+            };
+        }
+        const visible = this.visibleSessions.get();
+        const lastVisible = visible[visible.length - 1];
+        if (lastVisible && lastVisible.sessionId !== session.sessionId) {
+            this.insertAt(session, lastVisible.sessionId, "right");
+        }
+        if (options?.chatResource) {
+            await this.openChat(session, options.chatResource, {
+                preserveFocus: options.preserveFocus,
+                source: options.source
+            });
+        } else {
+            await this.openSession(session.resource, {
+                preserveFocus: options?.preserveFocus,
+                source: options?.source,
+                restoreOnlySideOrToolChat: options?.restoreOnlySideOrToolChat
+            });
+        }
+    }
+    async openChatToSide(session, chatResource, options) {
+        this._beginNavigation("explicit");
+        const token = this._startOpenSession();
+        const resolved = await this._resolveSessionForOpen(session, chatResource);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        session = resolved.session;
+        chatResource = resolved.chatUri ?? chatResource;
+        this._showSession(this._getSession(session.resource), options);
+        const sessionView = this.sessionsPartService.getSessionView(session.sessionId);
+        if (!sessionView) {
+            throw ( new Error(
+                `Unable to open chat to the side because session view '${session.sessionId}' is not mounted`
+            ));
+        }
+        await sessionView.openChatToSide(chatResource);
+    }
+    async _resolveSessionForOpen(session, chatUri) {
+        const resolved = await this.sessionsManagementService.resolveSessionResource(session.resource, "open");
+        if (this.uriIdentityService.extUri.isEqual(resolved, session.resource)) {
+            return {
+                session,
+                chatUri
+            };
+        }
+        const superseding = this.sessionsManagementService.getSession(resolved);
+        if (!superseding) {
+            return {
+                session,
+                chatUri
+            };
+        }
+        return {
+            session: superseding,
+            chatUri: chatUri ? superseding.mainChat.get().resource : undefined
+        };
+    }
+    _getSession(sessionResource) {
+        const sessionData = this.sessionsManagementService.getSession(sessionResource);
+        if (!sessionData) {
+            this.logService.warn(`[SessionsView] openSession: session not found uri=${( sessionResource.toString())}`);
+            throw ( new Error(`Session with resource ${( sessionResource.toString())} not found`));
+        }
+        return sessionData;
+    }
+    _showSession(sessionData, options) {
+        const t0 = Date.now();
+        this.logService.trace(`[SessionsView] openSession start uri=${( sessionData.resource.toString())} provider=${sessionData.providerId}`);
+        this._activate(sessionData, options?.preserveFocus);
+        this.logService.trace(
+            `[SessionsView] showSession done total=${Date.now() - t0}ms uri=${( sessionData.resource.toString())}`
+        );
+    }
+    async _waitForOpenSessionToLoad(sessionData, token, telemetryAttempt) {
+        const t0 = Date.now();
+        if (!(await this._waitForSessionToLoad(sessionData, token))) {
+            this.logService.trace(
+                `[SessionsView] openSession cancelled while waiting for session to load uri=${( sessionData.resource.toString())}`
+            );
+            return;
+        }
+        const activeSession = this.activeSession.get();
+        const activeChat = activeSession?.sessionId === sessionData.sessionId ? activeSession.activeChat.get() : undefined;
+        if (activeChat) {
+            this.sessionOpenTelemetryService.sessionActivated(telemetryAttempt, activeChat.resource);
+        }
+        this.sessionOpenTelemetryService.sessionLoaded(telemetryAttempt);
+        this.logService.trace(
+            `[SessionsView] openSession loaded total=${Date.now() - t0}ms uri=${( sessionData.resource.toString())}`
+        );
+    }
+    unsetNewSession() {
+        this.sessionsManagementService.discardNewSession();
+        this._activate(undefined);
+    }
+    openNewSession(options, token = CancellationToken.None) {
+        return this._openNewSession(options, token, "explicit");
+    }
+    async _openNewSession(options, token, intent) {
+        if (options?.cancelRestore) {
+            this._cancelRestore();
+        }
+        const folderUri = options?.folderUri;
+        if (folderUri) {
+            const resolved = this.sessionsManagementService.resolveWorkspace(folderUri, options?.providerId);
+            if (resolved?.workspace.requiresWorkspaceTrust) {
+                const trusted = await this.workspaceTrustRequestService.requestResourcesTrust({
+                    uri: folderUri,
+                    message: ( localize(
+                        4905,
+                        "An agent session will be able to read files, run commands, and make changes in this folder."
+                    ))
+                });
+                if (token.isCancellationRequested) {
+                    return {
+                        session: undefined,
+                        trustDeclined: false
+                    };
+                }
+                if (!trusted) {
+                    return {
+                        session: undefined,
+                        trustDeclined: true
+                    };
+                }
+            }
+            if (token.isCancellationRequested) {
+                return {
+                    session: undefined,
+                    trustDeclined: false
+                };
+            }
+            this._beginNavigation(intent, token, options?.preserveNavigation);
+            this._startOpenSession();
+            try {
+                const session = this.sessionsManagementService.createNewSession(folderUri, options);
+                this._activateOrInsert(session, options?.toSide);
+                return {
+                    session,
+                    trustDeclined: false
+                };
+            } catch (e) {
+                this.logService.trace(
+                    `[SessionsView] openNewSession: createNewSession failed for folder ${( folderUri.toString())}, falling back to composer view`
+                );
+            }
+        }
+        if (!folderUri) {
+            this._beginNavigation(intent, token, options?.preserveNavigation);
+        }
+        if (this._visibility.activeSession.get() === undefined && !options?.toSide) {
+            return {
+                session: undefined,
+                trustDeclined: false
+            };
+        }
+        if (!folderUri) {
+            this._startOpenSession();
+        }
+        const newSession = this.sessionsManagementService.newSession.get();
+        const activeSession = this._visibility.activeSession.get();
+        const targetSession = options?.toSide && newSession?.sessionId === activeSession?.sessionId ? undefined : newSession;
+        this._activateOrInsert(targetSession, options?.toSide);
+        return {
+            session: targetSession,
+            trustDeclined: false
+        };
+    }
+    _activateOrInsert(session, toSide) {
+        const activeSessionId = this._visibility.activeSession.get()?.sessionId;
+        const sessionId = session?.sessionId;
+        if (toSide && activeSessionId !== sessionId) {
+            const visible = this.visibleSessions.get();
+            const anchorId = activeSessionId ?? visible[visible.length - 1]?.sessionId;
+            if (anchorId && anchorId !== sessionId) {
+                this.insertAt(session, anchorId, "right", true);
+                return;
+            }
+        }
+        this._activate(session);
+    }
+    openQuickChat(options) {
+        return this._openQuickChat(options, "explicit");
+    }
+    _openQuickChat(options, intent) {
+        this._beginNavigation(intent);
+        this._startOpenSession();
+        try {
+            const session = this.sessionsManagementService.createQuickChat(options);
+            return this._activate(session);
+        } catch (e) {
+            this.logService.trace(`[SessionsView] openQuickChat: createQuickChat failed: ${e}`);
+            return undefined;
+        }
+    }
+    async openNewChatInSession(session, options) {
+        this._cancelRestore();
+        this._beginNavigation("explicit");
+        this._startOpenSession();
+        const chat = await this.sessionsManagementService.createNewChatInSession(session, options);
+        if (!chat) {
+            return;
+        }
+        this._activate(session);
+        this._visibility.setActiveChat(session, chat);
+    }
+    setActive(session) {
+        if (session?.sessionId !== this.activeSession.get()?.sessionId) {
+            this._recordNavigation();
+        }
+        this._activate(session);
+    }
+    async submitNewSessionInput() {
+        let activeSession = this.activeSession.get();
+        if (activeSession?.isCreated.get()) {
+            return false;
+        }
+        if (!this.sessionsPartService.getSessionView(activeSession?.sessionId)) {
+            await this.openNewSession();
+            activeSession = this.activeSession.get();
+            if (activeSession?.isCreated.get()) {
+                return false;
+            }
+        }
+        return this.sessionsPartService.getSessionView(activeSession?.sessionId)?.submitInput() ?? false;
+    }
+    toggleSessionStickiness(session) {
+        const sticky = this._visibility.toggleStickiness(session);
+        this._onDidToggleSessionStickiness.fire({
+            session,
+            sticky
+        });
+    }
+    insertAt(session, targetSessionId, side, activate = true) {
+        this._visibility.insertAt(session, targetSessionId, side, activate);
+    }
+    closeSession(session) {
+        const sessionId = session?.sessionId;
+        const visible = this._visibility.visibleSessions.get();
+        if (!( visible.some(s => s?.sessionId === sessionId))) {
+            return;
+        }
+        const activeSessionId = this._visibility.activeSession.get()?.sessionId;
+        const wasActive = activeSessionId === sessionId;
+        if (session) {
+            this._closedItems.recordClosedSession(session);
+        }
+        this.sessionsManagementService.discardNewSession(session);
+        this._visibility.removeMany([sessionId]);
+        if (!wasActive) {
+            return;
+        }
+        const fallback = this._visibility.activeSession.get();
+        if (fallback === undefined) {
+            this.openNewSession();
+        }
+    }
+    closeAllSessions() {
+        const ids = this._visibility.visibleSessions.get().filter(s => !!s).map(s => s.sessionId);
+        if (ids.length === 0) {
+            return;
+        }
+        this.sessionsManagementService.discardNewSession();
+        this._visibility.removeMany(ids);
+    }
+    _restoreInitialChat(session) {
+        const chats = session.chats.get();
+        let initialChat = chats[0];
+        const sessionState = this._sessionStates.get(session.resource);
+        if (sessionState?.activeChatResource) {
+            try {
+                const lastChatResource = ( URI.parse(sessionState.activeChatResource));
+                const found = chats.find(c => this.uriIdentityService.extUri.isEqual(c.resource, lastChatResource));
+                if (found) {
+                    initialChat = found;
+                }
+            } catch (error) {
+                this.logService.warn(
+                    "[SessionsView] Failed to restore active chat from stored session state",
+                    error
+                );
+            }
+        }
+        return initialChat;
+    }
+    _restoreClosedChats(session) {
+        return this._sessionStates.get(session.resource)?.closedChatResources ?? [];
+    }
+    _restoreShownRelatedChats(session) {
+        return this._sessionStates.get(session.resource)?.openedChatResources ?? [];
+    }
+    async _waitForSessionToLoad(session, token) {
+        if (!session.loading.get()) {
+            return true;
+        }
+        if (token.isCancellationRequested) {
+            return false;
+        }
+        await ( new Promise(resolve => {
+            const disposables = ( new DisposableStore());
+            let resolved = false;
+            const finish = () => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                disposables.dispose();
+                resolve();
+            };
+            disposables.add(token.onCancellationRequested(finish));
+            disposables.add(autorun(reader => {
+                if (!session.loading.read(reader)) {
+                    finish();
+                }
+            }));
+        }));
+        return !token.isCancellationRequested;
+    }
+    _loadSessionStates() {
+        const map = ( new ResourceMap());
+        const raw = this.storageService.get(ACTIVE_SESSION_STATES_KEY, StorageScope.WORKSPACE);
+        if (!raw) {
+            return map;
+        }
+        try {
+            const entries = JSON.parse(raw);
+            for (const entry of entries) {
+                const uri = ( URI.parse(entry.sessionResource));
+                map.set(uri, entry);
+            }
+        } catch {}
+        return map;
+    }
+    _saveSessionStates() {
+        const entries = this._snapshotVisibleSessionStates();
+        const visible = ( new ResourceMap());
+        for (const entry of entries) {
+            visible.set(( URI.parse(entry.sessionResource)), true);
+        }
+        for (const [resource, state] of this._sessionStates) {
+            if (( visible.has(resource))) {
+                continue;
+            }
+            entries.push({
+                sessionResource: state.sessionResource,
+                activeChatResource: state.activeChatResource,
+                activeChatOrigin: state.activeChatOrigin,
+                closedChatResources: state.closedChatResources,
+                openedChatResources: state.openedChatResources
+            });
+        }
+        this.storageService.store(
+            ACTIVE_SESSION_STATES_KEY,
+            JSON.stringify(entries),
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+    }
+    _snapshotVisibleSessionStates() {
+        const activeId = this._visibility.activeSession.get()?.sessionId;
+        const visible = this._visibility.visibleSessions.get();
+        const entries = [];
+        visible.forEach((session, index) => {
+            if (!session) {
+                return;
+            }
+            if (session.status.get() === SessionStatus.Untitled) {
+                this._sessionStates.delete(session.resource);
+                return;
+            }
+            const existing = this._sessionStates.get(session.resource);
+            const state = {
+                sessionResource: ( session.resource.toString()),
+                activeChatResource: this._pendingRestoredChatResources.get(session.resource)?.toString() ?? session.activeChat.get()?.resource.toString() ?? existing?.activeChatResource,
+                activeChatOrigin: session.activeChat.get()?.origin?.kind ?? existing?.activeChatOrigin,
+                closedChatResources: existing?.closedChatResources ?? session.closedChats.get().map(c => ( c.resource.toString())),
+                openedChatResources: existing?.openedChatResources,
+                visibleOrder: index,
+                isSticky: session.sticky.get(),
+                isActive: session.sessionId === activeId
+            };
+            this._sessionStates.set(session.resource, state);
+            entries.push(state);
+        });
+        return entries;
+    }
+    _getVisibleSessionStates() {
+        const states = [];
+        for (const [, state] of this._sessionStates) {
+            if (state.visibleOrder !== undefined) {
+                states.push(state);
+            }
+        }
+        return states.sort((a, b) => (a.visibleOrder - b.visibleOrder));
+    }
+    _waitForSession(sessionResource, token, timeout) {
+        const existing = this.sessionsManagementService.getSession(sessionResource);
+        if (existing) {
+            return Promise.resolve(existing);
+        }
+        return ( new Promise(resolve => {
+            const disposables = ( new DisposableStore());
+            let resolved = false;
+            const finish = session => {
+                if (resolved) {
+                    return;
+                }
+                resolved = true;
+                disposables.dispose();
+                resolve(session);
+            };
+            disposables.add(token.onCancellationRequested(() => finish(undefined)));
+            const tryFind = () => {
+                if (token.isCancellationRequested) {
+                    finish(undefined);
+                    return;
+                }
+                const session = this.sessionsManagementService.getSession(sessionResource);
+                if (session) {
+                    finish(session);
+                }
+            };
+            disposables.add(this.sessionsProvidersService.onDidChangeProviders(() => tryFind()));
+            disposables.add(this.sessionsManagementService.onDidChangeSessions(() => tryFind()));
+            if (timeout !== undefined) {
+                disposables.add(disposableTimeout(() => finish(undefined), timeout));
+            }
+            tryFind();
+        }));
+    }
+    async restoreVisibleSessions() {
+        try {
+            await this._restoreVisibleSessions();
+        } finally {
+            this._initialRestoreComplete.set(true, undefined);
+        }
+    }
+    async _restoreVisibleSessions() {
+        const cts = ( new CancellationTokenSource());
+        this._restoreCts.value = cts;
+        const token = cts.token;
+        const persisted = this._getVisibleSessionStates();
+        const unresolved = persisted.map(state => ({
+            resource: ( URI.parse(state.sessionResource)),
+            isSticky: !!state.isSticky,
+            isActive: !!state.isActive,
+            order: state.visibleOrder
+        }));
+        const targets = (await raceTimeout(Promise.all(persisted.map(async (state, index) => ({
+            resource: await this.sessionsManagementService.resolveSessionResource(( URI.parse(state.sessionResource)), "restore"),
+            isSticky: unresolved[index].isSticky,
+            isActive: unresolved[index].isActive,
+            order: unresolved[index].order
+        }))), RESTORE_RESOLVE_BUDGET_MS)) ?? unresolved;
+        if (token.isCancellationRequested) {
+            return;
+        }
+        if (targets.length === 0) {
+            targets.push({
+                resource: undefined,
+                isSticky: false,
+                isActive: true,
+                order: 1
+            });
+        }
+        targets.sort((a, b) => a.order - b.order);
+        let activeIdx = targets.findIndex(t => t.isActive);
+        if (activeIdx < 0) {
+            activeIdx = 0;
+        }
+        const resolved = ( new Array(targets.length)).fill(undefined);
+        const place = (idx, session) => {
+            let anchor;
+            for (let j = idx - 1; j >= 0 && !anchor; j--) {
+                const neighbour = resolved[j];
+                if (neighbour !== undefined) {
+                    anchor = {
+                        id: neighbour?.sessionId,
+                        side: "right"
+                    };
+                }
+            }
+            for (let j = idx + 1; j < targets.length && !anchor; j++) {
+                const neighbour = resolved[j];
+                if (neighbour !== undefined) {
+                    anchor = {
+                        id: neighbour?.sessionId,
+                        side: "left"
+                    };
+                }
+            }
+            resolved[idx] = session;
+            if (anchor) {
+                this._visibility.insertAt(session, anchor.id, anchor.side, false);
+            } else {
+                this._activate(session);
+            }
+            if (targets[idx].isSticky) {
+                this._visibility.toggleStickiness(session);
+            }
+        };
+        const activeTarget = targets[activeIdx];
+        const activeSessionPromise = activeTarget.resource ? this._waitForSession(activeTarget.resource, token, RESTORE_SESSION_WAIT_TIMEOUT).then(session => session ?? undefined) : Promise.resolve(undefined);
+        const activeSession = await activeSessionPromise;
+        if (token.isCancellationRequested) {
+            return;
+        }
+        if (activeSession) {
+            const provider = this.sessionsProvidersService.getProvider(activeSession.providerId);
+            void provider?.prepareSessionForOpen?.(activeSession, "restore").catch(error => this.logService.warn(
+                `[SessionsView] Failed to prepare restored session for provider '${provider.id}'`,
+                error
+            ));
+        }
+        const slots = [];
+        let activeSlotIndex = -1;
+        for (let idx = 0; idx < targets.length; idx++) {
+            const target = targets[idx];
+            let session;
+            if (!target.resource) {
+                session = null;
+            } else if (idx === activeIdx) {
+                session = activeSession;
+            } else {
+                session = this.sessionsManagementService.getSession(target.resource);
+            }
+            if (session === undefined) {
+                continue;
+            }
+            resolved[idx] = session;
+            if (idx === activeIdx) {
+                activeSlotIndex = slots.length;
+            }
+            slots.push({
+                session: session ?? undefined,
+                sticky: target.isSticky
+            });
+        }
+        this._visibility.restoreGrid(slots, activeSlotIndex);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        await Promise.all(targets.map(async (target, idx) => {
+            if (idx === activeIdx || !target.resource || token.isCancellationRequested || resolved[idx] !== undefined) {
+                return;
+            }
+            const session = await this._waitForSession(target.resource, token, RESTORE_SESSION_WAIT_TIMEOUT);
+            if (!session || token.isCancellationRequested || resolved[idx] !== undefined) {
+                return;
+            }
+            place(idx, session);
+        }));
+    }
+    async openPreviousSession() {
+        await this._navigation.goBack();
+    }
+    async openNextSession() {
+        await this._navigation.goForward();
+    }
+};
+SessionsService = ( __decorate([( __param(0, IStorageService)), ( __param(1, ILogService)), ( __param(2, IUriIdentityService)), ( __param(3, IContextKeyService)), ( __param(4, ISessionsManagementService)), ( __param(5, ISessionsProvidersService)), ( __param(6, ISessionsPartService)), ( __param(7, ICustomViewService)), ( __param(8, IInstantiationService)), ( __param(9, IWorkspaceTrustRequestService)), ( __param(10, IWorkspaceTrustManagementService)), ( __param(11, ISessionChangesStatsCache)), ( __param(12, ISessionOpenTelemetryService))], SessionsService));
+
+export { SessionsService };