@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

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

@@ -0,0 +1,729 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { ChatOriginKind, SessionStatus, ChatInteractivity } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+class VisibleSession extends Disposable {
+    constructor(_session, initialChat, initialClosedChatUris, initialShownRelatedChatUris) {
+        super();
+        this._session = _session;
+        this._sticky = observableValue("activeSessionSticky", false);
+        this.sticky = this._sticky;
+        this._closedChatOrder = [];
+        this._activeChat = observableValue(`activeChat-${_session.sessionId}`, initialChat);
+        this.activeChat = this._activeChat;
+        this._activeChatModelId = derived(this, reader => this._activeChat.read(reader).modelId.read(reader));
+        this._activeChatMode = derived(this, reader => this._activeChat.read(reader).mode.read(reader));
+        const seed = ( new Set(initialClosedChatUris));
+        seed.delete(( _session.mainChat.get().resource.toString()));
+        const activeUri = initialChat?.resource.toString();
+        if (activeUri) {
+            seed.delete(activeUri);
+        }
+        this._closedChatUris = observableValue("closedChatUris", seed);
+        const shownRelatedChats = ( new Set(initialShownRelatedChatUris));
+        if (initialChat?.origin?.kind === ChatOriginKind.Tool) {
+            shownRelatedChats.add(( initialChat.resource.toString()));
+        }
+        this._shownRelatedChatUris = observableValue("shownRelatedChatUris", shownRelatedChats);
+        this._isCreated = _session.status.map(status => status !== SessionStatus.Untitled);
+        this.isCreated = this._isCreated;
+        this.openChats = derived(this, reader => {
+            const closed = this._closedChatUris.read(reader);
+            const chats = this._session.chats.read(reader);
+            return chats.filter(
+                c => c.interactivity.read(reader) !== ChatInteractivity.Hidden && !( closed.has(( c.resource.toString())))
+            );
+        });
+        this.closedChats = derived(this, reader => {
+            const closed = this._closedChatUris.read(reader);
+            if (closed.size === 0) {
+                return [];
+            }
+            return this._session.chats.read(reader).filter(c => ( closed.has(( c.resource.toString()))));
+        });
+        this.visibleChatTabs = derived(this, reader => {
+            const shownRelatedChats = this._shownRelatedChatUris.read(reader);
+            return this.openChats.read(reader).filter(c => c.origin?.kind !== ChatOriginKind.Tool || ( shownRelatedChats.has(( c.resource.toString()))));
+        });
+        this.shouldShowChatTabs = derived(this, reader => {
+            return this.visibleChatTabs.read(reader).length > 1;
+        });
+    }
+    setActiveChat(chat) {
+        this._activeChat.set(chat, undefined);
+    }
+    closeChat(chat) {
+        const chatUri = ( chat.resource.toString());
+        if (chatUri === ( this._session.mainChat.get().resource.toString())) {
+            return;
+        }
+        if (chat.origin?.kind === ChatOriginKind.Tool) {
+            const shown = this._shownRelatedChatUris.get();
+            if (!( shown.has(chatUri))) {
+                return;
+            }
+            const nextShown = ( new Set(shown));
+            nextShown.delete(chatUri);
+            transaction(tx => {
+                this._shownRelatedChatUris.set(nextShown, tx);
+                if (( this._activeChat.get().resource.toString()) === chatUri) {
+                    this._activeChat.set(this._defaultActiveChat(this._closedChatUris.get(), nextShown), tx);
+                }
+            });
+            return;
+        }
+        const closed = this._closedChatUris.get();
+        if (( closed.has(chatUri))) {
+            return;
+        }
+        const next = ( new Set(closed));
+        next.add(chatUri);
+        this._closedChatOrder.push(chat);
+        transaction(tx => {
+            this._closedChatUris.set(next, tx);
+            if (( this._activeChat.get().resource.toString()) === chatUri) {
+                this._activeChat.set(this._defaultActiveChat(next, this._shownRelatedChatUris.get()), tx);
+            }
+        });
+    }
+    openChat(chat) {
+        if (chat.origin?.kind === ChatOriginKind.Tool) {
+            const shown = this._shownRelatedChatUris.get();
+            if (( shown.has(( chat.resource.toString())))) {
+                return;
+            }
+            const next = ( new Set(shown));
+            next.add(( chat.resource.toString()));
+            this._shownRelatedChatUris.set(next, undefined);
+            return;
+        }
+        const closed = this._closedChatUris.get();
+        if (!( closed.has(( chat.resource.toString())))) {
+            return;
+        }
+        const next = ( new Set(closed));
+        next.delete(( chat.resource.toString()));
+        this._closedChatUris.set(next, undefined);
+        const idx = this._closedChatOrder.findLastIndex(c => ( c.resource.toString()) === ( chat.resource.toString()));
+        if (idx !== -1) {
+            this._closedChatOrder.splice(idx, 1);
+        }
+    }
+    _defaultActiveChat(closed, shownRelatedChats) {
+        const candidates = this._session.chats.get().filter(c => c.interactivity.get() !== ChatInteractivity.Hidden && !( closed.has(( c.resource.toString()))) && (c.origin?.kind !== ChatOriginKind.Tool || ( shownRelatedChats.has(( c.resource.toString())))));
+        return candidates[candidates.length - 1] ?? this._session.mainChat.get();
+    }
+    get lastClosedChat() {
+        const currentChats = this._session.chats.get();
+        const closed = this._closedChatUris.get();
+        for (let i = this._closedChatOrder.length - 1; i >= 0; i--) {
+            const chat = this._closedChatOrder[i];
+            const uri = ( chat.resource.toString());
+            if (( closed.has(uri)) && ( currentChats.some(c => ( c.resource.toString()) === uri))) {
+                return chat;
+            }
+        }
+        return undefined;
+    }
+    setSticky(value) {
+        this._sticky.set(value, undefined);
+    }
+    addDisposable(disposable) {
+        return this._register(disposable);
+    }
+    get sessionId() {
+        return this._session.sessionId;
+    }
+    get resource() {
+        return this._session.resource;
+    }
+    get providerId() {
+        return this._session.providerId;
+    }
+    get sessionType() {
+        return this._session.sessionType;
+    }
+    get icon() {
+        return this._session.icon;
+    }
+    get createdAt() {
+        return this._session.createdAt;
+    }
+    get workspace() {
+        return this._session.workspace;
+    }
+    get hasGitRepository() {
+        return this._session.hasGitRepository;
+    }
+    get worktreePending() {
+        return this._session.worktreePending;
+    }
+    get isQuickChat() {
+        return this._session.isQuickChat;
+    }
+    get isAutomation() {
+        return this._session.isAutomation;
+    }
+    get isExternal() {
+        return this._session.isExternal;
+    }
+    get remoteConnectionStatus() {
+        return this._session.remoteConnectionStatus;
+    }
+    get createdBySession() {
+        return this._session.createdBySession;
+    }
+    get title() {
+        return this._session.title;
+    }
+    get updatedAt() {
+        return this._session.updatedAt;
+    }
+    get status() {
+        return this._session.status;
+    }
+    get completedStateIcon() {
+        return this._session.completedStateIcon;
+    }
+    get changesSummary() {
+        return this._session.changesSummary;
+    }
+    get changesets() {
+        return this._session.changesets;
+    }
+    get changes() {
+        return this._session.changes;
+    }
+    get artifacts() {
+        return this._session.artifacts;
+    }
+    get modelId() {
+        return this._activeChatModelId;
+    }
+    get mode() {
+        return this._activeChatMode;
+    }
+    get loading() {
+        return this._session.loading;
+    }
+    get isNewSessionRequestInProgress() {
+        return this._session.isNewSessionRequestInProgress;
+    }
+    get isArchived() {
+        return this._session.isArchived;
+    }
+    get isRead() {
+        return this._session.isRead;
+    }
+    get description() {
+        return this._session.description;
+    }
+    get lastTurnEnd() {
+        return this._session.lastTurnEnd;
+    }
+    get chats() {
+        return this._session.chats;
+    }
+    get mainChat() {
+        return this._session.mainChat;
+    }
+    get capabilities() {
+        return this._session.capabilities;
+    }
+    get session() {
+        return this._session;
+    }
+}
+class ResourceOverrideSession {
+    constructor(_session, resource) {
+        this._session = _session;
+        this.resource = resource;
+    }
+    get sessionId() {
+        return this._session.sessionId;
+    }
+    get providerId() {
+        return this._session.providerId;
+    }
+    get sessionType() {
+        return this._session.sessionType;
+    }
+    get icon() {
+        return this._session.icon;
+    }
+    get createdAt() {
+        return this._session.createdAt;
+    }
+    get workspace() {
+        return this._session.workspace;
+    }
+    get hasGitRepository() {
+        return this._session.hasGitRepository;
+    }
+    get worktreePending() {
+        return this._session.worktreePending;
+    }
+    get isQuickChat() {
+        return this._session.isQuickChat;
+    }
+    get isAutomation() {
+        return this._session.isAutomation;
+    }
+    get isExternal() {
+        return this._session.isExternal;
+    }
+    get remoteConnectionStatus() {
+        return this._session.remoteConnectionStatus;
+    }
+    get createdBySession() {
+        return this._session.createdBySession;
+    }
+    get title() {
+        return this._session.title;
+    }
+    get updatedAt() {
+        return this._session.updatedAt;
+    }
+    get status() {
+        return this._session.status;
+    }
+    get completedStateIcon() {
+        return this._session.completedStateIcon;
+    }
+    get changesSummary() {
+        return this._session.changesSummary;
+    }
+    get changes() {
+        return this._session.changes;
+    }
+    get changesets() {
+        return this._session.changesets;
+    }
+    get artifacts() {
+        return this._session.artifacts;
+    }
+    get modelId() {
+        return this._session.modelId;
+    }
+    get mode() {
+        return this._session.mode;
+    }
+    get loading() {
+        return this._session.loading;
+    }
+    get isNewSessionRequestInProgress() {
+        return this._session.isNewSessionRequestInProgress;
+    }
+    get isArchived() {
+        return this._session.isArchived;
+    }
+    get isRead() {
+        return this._session.isRead;
+    }
+    get description() {
+        return this._session.description;
+    }
+    get lastTurnEnd() {
+        return this._session.lastTurnEnd;
+    }
+    get chats() {
+        return this._session.chats;
+    }
+    get mainChat() {
+        return this._session.mainChat;
+    }
+    get capabilities() {
+        return this._session.capabilities;
+    }
+}
+const NO_RECENT = Symbol("no-recent");
+let VisibleSessions = class VisibleSessions extends Disposable {
+    constructor(
+        _resolveInitialChat,
+        _resolveInitialClosedChats,
+        _resolveInitialShownRelatedChats,
+        _onSlotReplaced,
+        _uriIdentityService
+    ) {
+        super();
+        this._resolveInitialChat = _resolveInitialChat;
+        this._resolveInitialClosedChats = _resolveInitialClosedChats;
+        this._resolveInitialShownRelatedChats = _resolveInitialShownRelatedChats;
+        this._onSlotReplaced = _onSlotReplaced;
+        this._uriIdentityService = _uriIdentityService;
+        this._activeSession = observableValue(this, undefined);
+        this.activeSession = this._activeSession;
+        this._activePreserveFocus = observableValue(this, false);
+        this.activePreserveFocus = this._activePreserveFocus;
+        this._visibleSessions = observableValue(this, [undefined]);
+        this.visibleSessions = this._visibleSessions;
+        this._wrappers = this._register(( new DisposableMap()));
+        this._visibleList = [];
+        this._stickyIds = ( new Set());
+        this._mostRecentNonStickySlot = NO_RECENT;
+    }
+    _setActiveSession(session, preserveFocus, tsx) {
+        this._activeSession.set(session, tsx);
+        this._activePreserveFocus.set(preserveFocus, tsx);
+    }
+    setActive(session, preserveFocus = false) {
+        const targetId = session?.sessionId;
+        const targetHasVisibleSlot = this._visibleList.includes(targetId);
+        if (!targetHasVisibleSlot) {
+            const activeSlot = this._currentActiveSlot();
+            const activeIsNonSticky = activeSlot !== NO_RECENT && !this._isStickySlot(activeSlot);
+            let replaceSlot;
+            if (activeIsNonSticky) {
+                replaceSlot = activeSlot;
+            } else if (this._mostRecentNonStickySlot !== NO_RECENT && this._visibleList.includes(this._mostRecentNonStickySlot) && !this._isStickySlot(this._mostRecentNonStickySlot)) {
+                replaceSlot = this._mostRecentNonStickySlot;
+            } else {
+                replaceSlot = this._findLastNonSticky();
+            }
+            if (replaceSlot !== NO_RECENT) {
+                const idx = this._visibleList.indexOf(replaceSlot);
+                this._visibleList.splice(idx, 1, targetId);
+                if (replaceSlot !== undefined) {
+                    const replaced = this._wrappers.get(replaceSlot)?.session;
+                    const sticky = ( this._stickyIds.has(replaceSlot));
+                    this._wrappers.deleteAndDispose(replaceSlot);
+                    if (replaced) {
+                        this._onSlotReplaced(replaced, idx, sticky, targetId);
+                    }
+                }
+            } else {
+                this._visibleList.push(targetId);
+            }
+            this._mostRecentNonStickySlot = targetId;
+        }
+        const visibleSession = session ? this._getOrCreateVisibleSession(session) : undefined;
+        transaction(tsx => {
+            this._setActiveSession(visibleSession, preserveFocus, tsx);
+            if (!targetHasVisibleSlot) {
+                this._refresh(tsx);
+            }
+        });
+        return visibleSession;
+    }
+    insertAt(session, targetSessionId, side, activate = true) {
+        const id = session?.sessionId;
+        const targetIdx = this._visibleList.indexOf(targetSessionId);
+        if (targetIdx < 0) {
+            return;
+        }
+        let destIdx = side === "left" ? targetIdx : targetIdx + 1;
+        const currentIdx = this._visibleList.indexOf(id);
+        if (currentIdx >= 0) {
+            if (currentIdx !== destIdx && currentIdx + 1 !== destIdx) {
+                this._visibleList.splice(currentIdx, 1);
+                if (currentIdx < destIdx) {
+                    destIdx--;
+                }
+                this._visibleList.splice(destIdx, 0, id);
+            }
+            if (!this._isStickySlot(id)) {
+                this._mostRecentNonStickySlot = id;
+            }
+        } else {
+            if (session) {
+                this._getOrCreateVisibleSession(session);
+            }
+            this._visibleList.splice(destIdx, 0, id);
+            this._mostRecentNonStickySlot = id;
+        }
+        transaction(tsx => {
+            if (activate) {
+                const wrapper = id !== undefined ? this._wrappers.get(id) : undefined;
+                this._setActiveSession(wrapper, false, tsx);
+            }
+            this._refresh(tsx);
+        });
+    }
+    restoreGrid(slots, activeIndex) {
+        this._visibleList = [];
+        this._stickyIds.clear();
+        let activeWrapper;
+        let lastNonStickySlot = NO_RECENT;
+        for (let i = 0; i < slots.length; i++) {
+            const {
+                session,
+                sticky
+            } = slots[i];
+            const id = session?.sessionId;
+            this._visibleList.push(id);
+            if (session) {
+                const wrapper = this._getOrCreateVisibleSession(session);
+                if (sticky) {
+                    this._stickyIds.add(session.sessionId);
+                }
+                if (i === activeIndex) {
+                    activeWrapper = wrapper;
+                }
+            }
+            if (!this._isStickySlot(id)) {
+                lastNonStickySlot = id;
+            }
+        }
+        for (const existingId of [...( this._wrappers.keys())]) {
+            if (!this._visibleList.includes(existingId)) {
+                this._wrappers.deleteAndDispose(existingId);
+            }
+        }
+        const activeId = activeWrapper?.sessionId;
+        this._mostRecentNonStickySlot = (activeId !== undefined && !this._isStickySlot(activeId)) ? activeId : lastNonStickySlot;
+        transaction(tsx => {
+            this._setActiveSession(activeWrapper, false, tsx);
+            this._refresh(tsx);
+        });
+    }
+    getSlot(sessionId) {
+        const index = this._visibleList.indexOf(sessionId);
+        return index < 0 ? undefined : {
+            index,
+            sticky: this._isStickySlot(sessionId)
+        };
+    }
+    getSession(sessionId) {
+        return sessionId === undefined ? undefined : this._wrappers.get(sessionId)?.session;
+    }
+    insertAtIndex(session, index, sticky) {
+        const id = session.sessionId;
+        if (this._visibleList.includes(id)) {
+            const existing = this._wrappers.get(id);
+            transaction(tsx => this._setActiveSession(existing, false, tsx));
+            return existing;
+        }
+        const destIdx = Math.max(0, Math.min(index, this._visibleList.length));
+        const wrapper = this._getOrCreateVisibleSession(session);
+        this._visibleList.splice(destIdx, 0, id);
+        if (sticky) {
+            this._stickyIds.add(id);
+        } else {
+            this._mostRecentNonStickySlot = id;
+        }
+        transaction(tsx => {
+            this._setActiveSession(wrapper, false, tsx);
+            this._refresh(tsx);
+        });
+        return wrapper;
+    }
+    replaceSlot(slotId, session, sticky) {
+        const id = session.sessionId;
+        const idx = this._visibleList.indexOf(slotId);
+        if (idx < 0 || this._visibleList.includes(id)) {
+            return undefined;
+        }
+        this._visibleList.splice(idx, 1, id);
+        if (slotId !== undefined) {
+            this._stickyIds.delete(slotId);
+            this._wrappers.deleteAndDispose(slotId);
+        }
+        if (sticky) {
+            this._stickyIds.add(id);
+        }
+        if (this._mostRecentNonStickySlot === slotId) {
+            this._mostRecentNonStickySlot = sticky ? this._findLastNonSticky() : id;
+        }
+        const wrapper = this._getOrCreateVisibleSession(session);
+        transaction(tsx => {
+            this._setActiveSession(wrapper, false, tsx);
+            this._refresh(tsx);
+        });
+        return wrapper;
+    }
+    toggleStickiness(session) {
+        const id = session.sessionId;
+        if (!this._visibleList.includes(id)) {
+            this._stickyIds.add(id);
+            this._getOrCreateVisibleSession(session);
+            this._visibleList.push(id);
+        } else if (( this._stickyIds.has(id))) {
+            this._stickyIds.delete(id);
+            this._mostRecentNonStickySlot = id;
+        } else {
+            this._stickyIds.add(id);
+            if (this._mostRecentNonStickySlot === id) {
+                this._mostRecentNonStickySlot = this._findLastNonSticky();
+            }
+        }
+        this._refresh(undefined);
+        return ( this._stickyIds.has(id));
+    }
+    removeMany(sessionIds) {
+        transaction(tsx => {
+            let changed = false;
+            const activeId = this._activeSession.get()?.sessionId;
+            const emptySlotIsActive = activeId === undefined && this._visibleList.includes(undefined);
+            const activeSlotId = emptySlotIsActive ? undefined : activeId;
+            const activeIdx = activeId !== undefined || emptySlotIsActive ? this._visibleList.indexOf(activeSlotId) : -1;
+            let activeRemoved = false;
+            for (const id of sessionIds) {
+                if (this._removeFromModel(id)) {
+                    changed = true;
+                    if (id === undefined ? emptySlotIsActive : id === activeId) {
+                        activeRemoved = true;
+                    }
+                }
+            }
+            if (activeRemoved) {
+                if (this._visibleList.length === 0) {
+                    this._setActiveSession(undefined, false, tsx);
+                } else {
+                    const fallbackIdx = Math.max(0, Math.min(activeIdx - 1, this._visibleList.length - 1));
+                    const fallbackId = this._visibleList[fallbackIdx];
+                    const fallbackWrapper = fallbackId !== undefined ? this._wrappers.get(fallbackId) : undefined;
+                    this._setActiveSession(fallbackWrapper, false, tsx);
+                }
+            }
+            if (changed) {
+                this._refresh(tsx);
+            }
+        });
+    }
+    setActiveChat(session, chat) {
+        this._wrappers.get(session.sessionId)?.setActiveChat(chat);
+    }
+    closeChat(session, chat) {
+        this._wrappers.get(session.sessionId)?.closeChat(chat);
+    }
+    openChat(session, chat) {
+        this._wrappers.get(session.sessionId)?.openChat(chat);
+    }
+    updateSession(session, updatedSession) {
+        const fromId = session.sessionId;
+        if (!this._visibleList.includes(fromId)) {
+            return;
+        }
+        const wasActive = this._activeSession.get()?.sessionId === fromId;
+        this.replaceId(fromId, updatedSession.sessionId);
+        if (fromId === updatedSession.sessionId && ( this._wrappers.has(fromId))) {
+            this._wrappers.deleteAndDispose(fromId);
+        }
+        transaction(tsx => {
+            const visibleSession = this._getOrCreateVisibleSession(updatedSession);
+            if (wasActive) {
+                this._setActiveSession(visibleSession, false, tsx);
+            }
+            this._refresh(tsx);
+        });
+    }
+    updateResourceOfSession(session, resource) {
+        const tmpSession = ( new ResourceOverrideSession(session, resource));
+        this.updateSession(session, tmpSession);
+        return tmpSession;
+    }
+    replaceId(fromId, toId) {
+        if (fromId === toId) {
+            return;
+        }
+        const idx = this._visibleList.indexOf(fromId);
+        if (idx >= 0) {
+            this._visibleList.splice(idx, 1, toId);
+        }
+        if (this._stickyIds.delete(fromId)) {
+            this._stickyIds.add(toId);
+        }
+        if (this._mostRecentNonStickySlot === fromId) {
+            this._mostRecentNonStickySlot = toId;
+        }
+        if (( this._wrappers.has(fromId))) {
+            this._wrappers.deleteAndDispose(fromId);
+        }
+    }
+    refresh() {
+        this._refresh(undefined);
+    }
+    _findLastNonSticky() {
+        for (let i = this._visibleList.length - 1; i >= 0; i--) {
+            const sid = this._visibleList[i];
+            if (!this._isStickySlot(sid)) {
+                return sid;
+            }
+        }
+        return NO_RECENT;
+    }
+    _isStickySlot(id) {
+        return id !== undefined && ( this._stickyIds.has(id));
+    }
+    _currentActiveSlot() {
+        const activeId = this._activeSession.get()?.sessionId;
+        if (activeId !== undefined) {
+            return this._visibleList.includes(activeId) ? activeId : NO_RECENT;
+        }
+        return this._visibleList.includes(undefined) ? undefined : NO_RECENT;
+    }
+    _removeFromModel(sessionId) {
+        let changed = false;
+        const idx = this._visibleList.indexOf(sessionId);
+        if (idx >= 0) {
+            this._visibleList.splice(idx, 1);
+            changed = true;
+        }
+        if (sessionId !== undefined && this._stickyIds.delete(sessionId)) {
+            changed = true;
+        }
+        if (this._mostRecentNonStickySlot === sessionId) {
+            this._mostRecentNonStickySlot = this._findLastNonSticky();
+            changed = true;
+        }
+        if (sessionId !== undefined && ( this._wrappers.has(sessionId))) {
+            this._wrappers.deleteAndDispose(sessionId);
+            changed = true;
+        }
+        return changed;
+    }
+    _refresh(tsx) {
+        const wrappers = [];
+        for (const id of this._visibleList) {
+            if (id === undefined) {
+                wrappers.push(undefined);
+                continue;
+            }
+            const visibleSession = this._wrappers.get(id);
+            if (visibleSession) {
+                visibleSession.setSticky(( this._stickyIds.has(id)));
+                wrappers.push(visibleSession);
+            }
+        }
+        this._visibleSessions.set(wrappers, tsx);
+    }
+    _getOrCreateVisibleSession(session) {
+        let visibleSession = this._wrappers.get(session.sessionId);
+        if (visibleSession) {
+            return visibleSession;
+        }
+        const initialChat = this._resolveInitialChat(session);
+        visibleSession = ( new VisibleSession(
+            session,
+            initialChat,
+            this._resolveInitialClosedChats(session),
+            this._resolveInitialShownRelatedChats(session)
+        ));
+        const visibleSessionRef = visibleSession;
+        visibleSession.addDisposable(autorun(reader => {
+            const chats = session.chats.read(reader);
+            const activeChat = visibleSessionRef.activeChat.read(reader);
+            if (activeChat && !( chats.some(
+                c => this._uriIdentityService.extUri.isEqual(c.resource, activeChat.resource)
+            ))) {
+                const visibleChatTabs = visibleSessionRef.visibleChatTabs.read(reader);
+                const fallback = visibleChatTabs[visibleChatTabs.length - 1] ?? session.mainChat.read(reader);
+                if (fallback) {
+                    visibleSessionRef.setActiveChat(fallback);
+                }
+            }
+        }));
+        this._wrappers.set(session.sessionId, visibleSession);
+        return visibleSession;
+    }
+};
+VisibleSessions = ( __decorate([( __param(4, IUriIdentityService))], VisibleSessions));
+
+export { VisibleSession, VisibleSessions };