@theia/ai-ide 1.74.0-next.8 → 1.74.0

package/src/browser/chat-session-list-service.ts

@@ -0,0 +1,261 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ChatService, ChatSession, ChatSessionMetadata, ChatSessionStatus } from '@theia/ai-chat';
+import { PERSISTED_SESSION_LIMIT_PREF, SESSION_STORAGE_PREF } from '@theia/ai-chat/lib/common/ai-chat-preferences';
+import { ChatViewWidget } from '@theia/ai-chat-ui/lib/browser/chat-view-widget';
+import { DisposableCollection, Emitter, Event, PreferenceService } from '@theia/core';
+import { ApplicationShell } from '@theia/core/lib/browser';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { UnreadStateProvider } from './chat-session-item';
+import { SectionedSessions, SessionRow, parentIdOf } from './chat-session-list-components';
+
+@injectable()
+export class ChatSessionListService implements UnreadStateProvider {
+
+    @inject(ChatService)
+    protected readonly chatService: ChatService;
+
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
+    @inject(ApplicationShell)
+    protected readonly shell: ApplicationShell;
+
+    private readonly unreadSessions = new Map<string, {
+        unread: boolean;
+        requiresAction: boolean;
+        seenRequests: number;
+        seenCompleted: number;
+        listener: DisposableCollection;
+    }>();
+    private readonly onUnreadChangedEmitter = new Emitter<string>();
+    readonly onUnreadChanged: Event<string> = this.onUnreadChangedEmitter.event;
+
+    protected _persistedSessions: ChatSessionMetadata[] = [];
+
+    /** Expanded root session IDs (default collapsed). */
+    protected expandedRoots = new Set<string>();
+
+    protected readonly onStateChangedEmitter = new Emitter<void>();
+    readonly onStateChanged: Event<void> = this.onStateChangedEmitter.event;
+
+    @postConstruct()
+    protected init(): void {
+        for (const session of this.chatService.getSessions()) {
+            this.watchSession(session);
+        }
+
+        this.chatService.onSessionEvent(event => {
+            if (event.type === 'created') {
+                const s = this.chatService.getSession(event.sessionId);
+                if (s) {
+                    this.watchSession(s);
+                }
+            } else if (event.type === 'activeChange' && event.sessionId) {
+                this.markSessionRead(event.sessionId);
+            } else if (event.type === 'deleted') {
+                this.unwatchSession(event.sessionId);
+            }
+            this.loadSessions();
+        });
+
+        this.loadSessions();
+        this.preferenceService.onPreferenceChanged(e => {
+            if (e.preferenceName === PERSISTED_SESSION_LIMIT_PREF || e.preferenceName === SESSION_STORAGE_PREF) {
+                this.loadSessions();
+            }
+        });
+    }
+
+    isUnread(sessionId: string): boolean {
+        return this.unreadSessions.get(sessionId)?.unread === true;
+    }
+
+    protected watchSession(session: ChatSession): void {
+        if (this.unreadSessions.has(session.id)) {
+            return;
+        }
+        const reqs = session.model.getRequests();
+        const state = {
+            unread: false,
+            requiresAction: ChatSessionStatus.requiresUserAction(session.model.status),
+            seenRequests: reqs.length,
+            seenCompleted: this.countCompleted(reqs),
+            listener: new DisposableCollection()
+        };
+        this.unreadSessions.set(session.id, state);
+
+        session.model.onDidChange(() => {
+            const requiresAction = ChatSessionStatus.requiresUserAction(session.model.status);
+            if (requiresAction !== state.requiresAction) {
+                state.requiresAction = requiresAction;
+                if (requiresAction) {
+                    this.expandAncestors(session);
+                }
+                this.onStateChangedEmitter.fire();
+            }
+            const current = session.model.getRequests();
+            if (current.length > state.seenRequests || this.countCompleted(current) > state.seenCompleted) {
+                const activeSession = this.chatService.getActiveSession();
+                const chatViewFocused = ChatViewWidget.findActive(this.shell) !== undefined;
+                if (chatViewFocused && activeSession && activeSession.id === session.id) {
+                    state.seenRequests = current.length;
+                    state.seenCompleted = this.countCompleted(current);
+                } else if (!state.unread) {
+                    state.unread = true;
+                    this.onUnreadChangedEmitter.fire(session.id);
+                }
+            }
+        }, undefined, state.listener);
+    }
+
+    protected markSessionRead(sessionId: string): void {
+        const state = this.unreadSessions.get(sessionId);
+        if (!state) {
+            return;
+        }
+        const session = this.chatService.getSession(sessionId);
+        const reqs = session?.model.getRequests() ?? [];
+        state.seenRequests = reqs.length;
+        state.seenCompleted = this.countCompleted(reqs);
+        if (state.unread) {
+            state.unread = false;
+            this.onUnreadChangedEmitter.fire(sessionId);
+        }
+    }
+
+    protected unwatchSession(sessionId: string): void {
+        const state = this.unreadSessions.get(sessionId);
+        if (state) {
+            state.listener.dispose();
+            this.unreadSessions.delete(sessionId);
+        }
+    }
+
+    private countCompleted(reqs: ReturnType<ChatSession['model']['getRequests']>): number {
+        return reqs.filter(r => r.response.isComplete).length;
+    }
+
+    isPersistenceEnabled(): boolean {
+        const limit = this.preferenceService.get<number>(PERSISTED_SESSION_LIMIT_PREF, 25);
+        return limit !== 0;
+    }
+
+    protected async loadSessions(): Promise<void> {
+        if (!this.isPersistenceEnabled()) {
+            this._persistedSessions = [];
+            this.onStateChangedEmitter.fire();
+            return;
+        }
+
+        const hasSessions = await this.chatService.hasPersistedSessions();
+        if (!hasSessions) {
+            this._persistedSessions = [];
+            this.onStateChangedEmitter.fire();
+            return;
+        }
+
+        try {
+            const index = await this.chatService.getPersistedSessions();
+            this._persistedSessions = Object.values(index)
+                .toSorted((a, b) => b.saveDate - a.saveDate);
+        } catch (error) {
+            console.error('Failed to load persisted sessions:', error);
+            this._persistedSessions = [];
+        } finally {
+            this.onStateChangedEmitter.fire();
+        }
+    }
+
+    getSections(): SectionedSessions {
+        const activeRaw = this.chatService.getSessions().filter(s => !!s.title);
+        const activeIds = new Set(activeRaw.map(s => s.id));
+        const active: ChatSessionMetadata[] = activeRaw
+            .toSorted((a, b) => (b.lastInteraction?.getTime() ?? 0) - (a.lastInteraction?.getTime() ?? 0))
+            .map(session => ({
+                sessionId: session.id,
+                title: session.title!,
+                saveDate: session.lastInteraction?.getTime() ?? Date.now(),
+                location: session.model.location,
+                pinnedAgentId: session.pinnedAgent?.id,
+                hasError: session.model.status === 'failed',
+                rootSessionId: session.rootSessionId,
+                parentSessionId: session.parentSessionId
+            }));
+        const restored = this._persistedSessions.filter(metadata => !activeIds.has(metadata.sessionId));
+        return { active, restored };
+    }
+
+    toggleExpand(sessionId: string): void {
+        this.expandedRoots = new Set(this.expandedRoots);
+        if (this.expandedRoots.has(sessionId)) {
+            this.expandedRoots.delete(sessionId);
+        } else {
+            this.expandedRoots.add(sessionId);
+        }
+        this.onStateChangedEmitter.fire();
+    }
+
+    isExpanded(sessionId: string): boolean {
+        return this.expandedRoots.has(sessionId);
+    }
+
+    sessionRequiresAction(sessionId: string): boolean {
+        const session = this.chatService.getSession(sessionId);
+        return session !== undefined && ChatSessionStatus.requiresUserAction(session.model.status);
+    }
+
+    descendantRequiresAction(row: SessionRow): boolean {
+        return row.childSessions.some(child =>
+            this.sessionRequiresAction(child.session.sessionId) || this.descendantRequiresAction(child));
+    }
+
+    protected expandAncestors(session: ChatSession): void {
+        const persistedById = new Map(this._persistedSessions.map(metadata => [metadata.sessionId, metadata]));
+        const parentIdFor = (id: string): string | undefined => {
+            const loaded = this.chatService.getSession(id);
+            if (loaded) {
+                return loaded.parentSessionId ?? loaded.rootSessionId;
+            }
+            const metadata = persistedById.get(id);
+            return metadata && parentIdOf(metadata);
+        };
+        const visited = new Set<string>();
+        let parentId = session.parentSessionId ?? session.rootSessionId;
+        while (parentId && !visited.has(parentId)) {
+            visited.add(parentId);
+            this.expandedRoots.add(parentId);
+            parentId = parentIdFor(parentId);
+        }
+    }
+
+    buildRows(sections: SectionedSessions): SessionRow[] {
+        const allSessions = [...sections.active, ...sections.restored];
+        const activeIds = new Set(sections.active.map(s => s.sessionId));
+        const rowsById = new Map<string, SessionRow>();
+        for (const session of allSessions) {
+            rowsById.set(session.sessionId, { session, isRestored: !activeIds.has(session.sessionId), childSessions: [] });
+        }
+        for (const session of allSessions) {
+            const pid = parentIdOf(session);
+            if (pid) {
+                rowsById.get(pid)?.childSessions.push(rowsById.get(session.sessionId)!);
+            }
+        }
+        return [...rowsById.values()];
+    }
+}

package/src/browser/chat-session-tooltip.ts

@@ -16,7 +16,7 @@
 
 import {
     ChatAgentService, ChatRequestModel, ChatResponseContent, ChatSession, ChatSessionMetadata,
-    ErrorChatResponseContent, FormattedProviderError, formatProviderError, ThinkingChatResponseContent
+    ChatSessionStatus, ErrorChatResponseContent, FormattedProviderError, formatProviderError, ThinkingChatResponseContent
 } from '@theia/ai-chat';
 import { MarkdownRenderer } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
 import { nls } from '@theia/core/lib/common/nls';
@@ -89,27 +89,41 @@ function addDefinitionEntry(definitionList: HTMLDListElement, term: string, deta
 export function buildSessionTooltip(
     session: ChatSession, metadata: ChatSessionMetadata,
     agentService: ChatAgentService, markdownRenderer: MarkdownRenderer,
-    isUnread: boolean, isRunning: boolean, hasError: boolean, isWaitingForInput: boolean
+    isUnread: boolean, descendantNeedsAttention: boolean = false
 ): SessionTooltip {
     const toDispose = new DisposableCollection();
     const requests = session.model.getRequests();
     const lastRequest = requests.at(-1);
+    const status = session.model.status;
 
     const container = document.createElement('div');
     container.className = 'theia-chat-session-tooltip';
 
-    // A session waiting for input is also "running", so check it first to give it precedence.
-    if (isWaitingForInput) {
+    // Waiting on the user takes precedence over the generic running badge: it signals that the
+    // user, not the agent, needs to act.
+    if (status === 'awaitingApproval') {
+        const badge = document.createElement('div');
+        badge.className = 'theia-chat-session-badge-attention-tooltip';
+        badge.textContent = nls.localize('theia/ai/ide/requiresApproval', 'Requires your approval');
+        container.appendChild(badge);
+    } else if (status === 'awaitingInput') {
         const badge = document.createElement('div');
         badge.className = 'theia-chat-session-badge-attention-tooltip';
         badge.textContent = nls.localize('theia/ai/ide/waitingForInput', 'Waiting for your input');
         container.appendChild(badge);
-    } else if (isRunning) {
+    } else if (descendantNeedsAttention) {
+        // The session itself is not awaiting the user, but one of its delegated children is;
+        // surface that instead of the generic running badge so the reason is clear.
+        const badge = document.createElement('div');
+        badge.className = 'theia-chat-session-badge-attention-tooltip';
+        badge.textContent = nls.localize('theia/ai/ide/childInteractionNeeded', 'A delegated session needs your attention');
+        container.appendChild(badge);
+    } else if (ChatSessionStatus.isInProgress(status)) {
         const badge = document.createElement('div');
         badge.className = 'theia-chat-session-badge-running-tooltip';
         badge.textContent = nls.localizeByDefault('Running');
         container.appendChild(badge);
-    } else if (hasError) {
+    } else if (status === 'failed') {
         const badge = document.createElement('div');
         badge.className = 'theia-chat-session-badge-error-tooltip';
         badge.textContent = nls.localizeByDefault('Error');
@@ -123,7 +137,7 @@ export function buildSessionTooltip(
 
     if (lastRequest) {
         const lastResponse = lastRequest.response;
-        const errorText = hasError ? getResponseErrorMessage(lastResponse) : undefined;
+        const errorText = status === 'failed' ? getResponseErrorMessage(lastResponse) : undefined;
 
         if (errorText) {
             const label = document.createElement('div');
@@ -175,7 +189,7 @@ export function buildSessionTooltip(
     const exchangeLabel = count === 1
         ? nls.localize('theia/ai/ide/tooltip/oneExchange', '1 exchange')
         : nls.localize('theia/ai/ide/tooltip/multipleExchanges', '{0} exchanges', count);
-    addDefinitionEntry(definitionList, nls.localize('theia/ai/ide/tooltip/messages', 'Messages'), exchangeLabel);
+    addDefinitionEntry(definitionList, nls.localizeByDefault('Messages'), exchangeLabel);
 
     const date = session.lastInteraction ?? new Date(metadata.saveDate);
     addDefinitionEntry(definitionList, nls.localize('theia/ai/ide/tooltip/lastActivity', 'Last activity'), date.toLocaleString());
@@ -189,14 +203,20 @@ export function buildSessionTooltip(
  * shown on the home view). Avoids any restore I/O so hover does not promote the item to Active.
  */
 export function buildRestoredSessionTooltip(
-    metadata: ChatSessionMetadata, agentService: ChatAgentService
+    metadata: ChatSessionMetadata, agentService: ChatAgentService, descendantNeedsAttention: boolean = false
 ): SessionTooltip {
     const container = document.createElement('div');
     container.className = 'theia-chat-session-tooltip';
 
     const badge = document.createElement('div');
-    badge.className = 'theia-chat-session-badge-restored-tooltip';
-    badge.textContent = nls.localize('theia/ai/ide/restoredSession', 'Restored session');
+    if (descendantNeedsAttention) {
+        // A persisted parent whose delegated child needs the user; show that rather than "Restored".
+        badge.className = 'theia-chat-session-badge-attention-tooltip';
+        badge.textContent = nls.localize('theia/ai/ide/childInteractionNeeded', 'A delegated session needs your attention');
+    } else {
+        badge.className = 'theia-chat-session-badge-restored-tooltip';
+        badge.textContent = nls.localize('theia/ai/ide/restoredSession', 'Restored session');
+    }
     container.appendChild(badge);
 
     const definitionList = document.createElement('dl');