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

package/src/common/chat-service.ts

@@ -73,6 +73,8 @@ export interface ChatSession {
     pinnedAgent?: ChatAgent;
     /** ID of the root session in the delegation chain. For delegated sessions, this points to the topmost session where task contexts are stored. */
     rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. Undefined for top-level sessions. */
+    parentSessionId?: string;
 }
 
 export interface ActiveSessionChangedEvent {
@@ -224,6 +226,43 @@ export class ChatServiceImpl implements ChatService {
     }
 
     async deleteSession(sessionId: string): Promise<void> {
+        await this.deleteSessionAndChildren(sessionId, new Set<string>());
+    }
+
+    protected async deleteSessionAndChildren(sessionId: string, visited: Set<string>): Promise<void> {
+        if (visited.has(sessionId)) {
+            return;
+        }
+        visited.add(sessionId);
+
+        // Delete children first. A child is any session whose immediate parent (parentSessionId) or root
+        // (rootSessionId) points to this session. Matching parentSessionId is what lets us cascade through
+        // intermediate levels: deleting B in A -> B -> C reaches C via its parentSessionId even though C's
+        // rootSessionId still points at A. Children may live only in memory, only in persisted storage
+        // (e.g. after a reload, not yet restored), or both, so collect ids from both sources. The visited
+        // set guards against cycles and re-deleting a child reachable from more than one ancestor.
+        const childIds = new Set<string>();
+        for (const s of this._sessions) {
+            if (s.parentSessionId === sessionId || s.rootSessionId === sessionId) {
+                childIds.add(s.id);
+            }
+        }
+        if (this.sessionStore) {
+            try {
+                const index = await this.sessionStore.getSessionIndex();
+                for (const metadata of Object.values(index)) {
+                    if (metadata.parentSessionId === sessionId || metadata.rootSessionId === sessionId) {
+                        childIds.add(metadata.sessionId);
+                    }
+                }
+            } catch (error) {
+                this.logger.error('Failed to read session index for cascade delete', { sessionId, error });
+            }
+        }
+        for (const childId of childIds) {
+            await this.deleteSessionAndChildren(childId, visited);
+        }
+
         const sessionIndex = this._sessions.findIndex(candidate => candidate.id === sessionId);
 
         // If session is in memory, remove it
@@ -351,6 +390,7 @@ export class ChatServiceImpl implements ChatService {
         }
         const requestText = request.request.displayText ?? request.request.text;
         session.title = requestText;
+        this.onSessionEventEmitter.fire({ type: 'renamed', sessionId: session.id });
         if (this.chatSessionNamingService) {
             const otherSessionNames = this._sessions.map(s => s.title).filter((title): title is string => title !== undefined);
             const namingService = this.chatSessionNamingService;
@@ -362,6 +402,7 @@ export class ChatServiceImpl implements ChatService {
                             session.title = name;
                             // Trigger persistence when title changes
                             this.saveSession(session.id);
+                            this.onSessionEventEmitter.fire({ type: 'renamed', sessionId: session.id });
                         }
                         didGenerateName = true;
                     }).catch(error => this.logger.error('Failed to generate chat session name', error));
@@ -411,8 +452,12 @@ export class ChatServiceImpl implements ChatService {
             return mentionedAgent;
         } else if (session.pinnedAgent) {
             // If we have a valid pinned agent, use it (pinned agent may become stale
-            // if it was disabled; so we always need to recheck)
-            const pinnedAgent = this.chatAgentService.getAgent(session.pinnedAgent.id);
+            // if it was disabled; so we always need to recheck). A pin is an explicit choice —
+            // e.g. AgentDelegationTool pins the delegated agent on the session it creates, and
+            // worker agents are often hidden (showInChat: false) — so hidden agents are honored
+            // here, while plain @-mentions above stay hidden-excluding. Without this, a request
+            // in a session pinned to a hidden agent silently falls back to the default agent.
+            const pinnedAgent = this.chatAgentService.getAgent(session.pinnedAgent.id, true);
             if (pinnedAgent) {
                 return pinnedAgent;
             }
@@ -458,9 +503,15 @@ export class ChatServiceImpl implements ChatService {
         // Store session with title, pinned agent info, last interaction timestamp, and error state
         const lastRequest = session.model.getRequests().at(-1);
         const hasError = lastRequest?.response.isComplete === true && lastRequest?.response.isError === true;
-        return this.sessionStore.storeSessions(
-            { model: session.model, title: session.title, pinnedAgentId: session.pinnedAgent?.id, lastInteraction: session.lastInteraction?.getTime(), hasError }
-        ).catch(error => {
+        return this.sessionStore.storeSessions({
+            model: session.model,
+            title: session.title,
+            pinnedAgentId: session.pinnedAgent?.id,
+            lastInteraction: session.lastInteraction?.getTime(),
+            hasError,
+            rootSessionId: session.rootSessionId,
+            parentSessionId: session.parentSessionId
+        }).catch(error => {
             this.logger.error('Failed to store chat sessions', error);
         });
     }
@@ -505,9 +556,10 @@ export class ChatServiceImpl implements ChatService {
         const model = new MutableChatModel(serialized.model);
         await this.restoreSessionData(model, serialized.model);
 
-        // Determine pinned agent
+        // Determine pinned agent (hidden agents included — a restored pin, like a live one,
+        // is an explicit choice; see getPinnedAgent)
         const pinnedAgent = serialized.pinnedAgentId
-            ? this.chatAgentService.getAgent(serialized.pinnedAgentId)
+            ? this.chatAgentService.getAgent(serialized.pinnedAgentId, true)
             : undefined;
 
         // Register as session
@@ -517,8 +569,12 @@ export class ChatServiceImpl implements ChatService {
             lastInteraction: new Date(serialized.saveDate),
             model,
             isActive: false,
-            pinnedAgent
+            pinnedAgent,
+            rootSessionId: serialized.rootSessionId,
+            parentSessionId: serialized.parentSessionId
         };
+        session.model.rootSessionId = serialized.rootSessionId;
+        session.model.parentSessionId = serialized.parentSessionId;
         this._sessions.push(session);
         this.setupAutoSaveForSession(session);
         this.onSessionEventEmitter.fire({ type: 'created', sessionId: session.id });

package/src/common/chat-session-status.spec.ts

@@ -0,0 +1,280 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import {
+    ChatChangeEvent,
+    ChatSessionStatus,
+    MutableChatModel,
+    MutableChatRequestModel,
+    QuestionResponseContentImpl,
+    TextChatResponseContentImpl,
+    ToolCallChatResponseContentImpl
+} from './chat-model';
+import { ParsedChatRequest, ParsedChatRequestTextPart } from './parsed-chat-request';
+
+describe('ChatSessionStatus', () => {
+
+    function parsedRequest(text: string = 'hello'): ParsedChatRequest {
+        return {
+            request: { text },
+            parts: [new ParsedChatRequestTextPart({ start: 0, endExclusive: text.length }, text)],
+            toolRequests: new Map(),
+            variables: []
+        };
+    }
+
+    function trackStatusChanges(model: MutableChatModel): ChatSessionStatus[] {
+        const statuses: ChatSessionStatus[] = [];
+        model.onDidChange(event => {
+            if (ChatChangeEvent.isStatusChangedEvent(event)) {
+                statuses.push(event.status);
+            }
+        });
+        return statuses;
+    }
+
+    /** Simulates the tool request service's confirmation flow up to the point where the user must decide. */
+    function requestConfirmation(request: MutableChatRequestModel, toolCall: ToolCallChatResponseContentImpl): void {
+        toolCall.requestUserConfirmation();
+        request.response.fireInteractionNeeded(toolCall);
+        request.response.waitForInput();
+    }
+
+    describe('fromRequest', () => {
+        it('should be idle without a request', () => {
+            expect(ChatSessionStatus.fromRequest(undefined)).to.equal('idle');
+        });
+    });
+
+    describe('isInProgress', () => {
+        it('should be true for all non-terminal statuses', () => {
+            expect(ChatSessionStatus.isInProgress('running')).to.be.true;
+            expect(ChatSessionStatus.isInProgress('awaitingApproval')).to.be.true;
+            expect(ChatSessionStatus.isInProgress('awaitingToolCall')).to.be.true;
+            expect(ChatSessionStatus.isInProgress('awaitingInput')).to.be.true;
+            expect(ChatSessionStatus.isInProgress('idle')).to.be.false;
+            expect(ChatSessionStatus.isInProgress('failed')).to.be.false;
+        });
+    });
+
+    describe('requiresUserAction', () => {
+        it('should be true only when blocked on the user', () => {
+            expect(ChatSessionStatus.requiresUserAction('awaitingApproval')).to.be.true;
+            expect(ChatSessionStatus.requiresUserAction('awaitingInput')).to.be.true;
+            expect(ChatSessionStatus.requiresUserAction('running')).to.be.false;
+            expect(ChatSessionStatus.requiresUserAction('awaitingToolCall')).to.be.false;
+            expect(ChatSessionStatus.requiresUserAction('idle')).to.be.false;
+            expect(ChatSessionStatus.requiresUserAction('failed')).to.be.false;
+        });
+    });
+
+    describe('MutableChatModel.status', () => {
+        it('should be idle for an empty session', () => {
+            const model = new MutableChatModel();
+            expect(model.status).to.equal('idle');
+        });
+
+        it('should be running while a request is in progress', () => {
+            const model = new MutableChatModel();
+            model.addRequest(parsedRequest());
+            expect(model.status).to.equal('running');
+        });
+
+        it('should fire a statusChanged event with the model already updated', () => {
+            const model = new MutableChatModel();
+            let statusInEvent: ChatSessionStatus | undefined;
+            let statusOnModel: ChatSessionStatus | undefined;
+            model.onDidChange(event => {
+                if (ChatChangeEvent.isStatusChangedEvent(event)) {
+                    statusInEvent = event.status;
+                    statusOnModel = model.status;
+                }
+            });
+
+            model.addRequest(parsedRequest());
+
+            expect(statusInEvent).to.equal('running');
+            expect(statusOnModel).to.equal('running');
+        });
+
+        it('should not fire statusChanged for changes that keep the status', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const statuses = trackStatusChanges(model);
+
+            request.response.response.addContent(new TextChatResponseContentImpl('first'));
+            request.response.response.addContent(new TextChatResponseContentImpl('second'));
+
+            expect(model.status).to.equal('running');
+            expect(statuses).to.deep.equal([]);
+        });
+
+        it('should return to idle when the last request completes', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const statuses = trackStatusChanges(model);
+
+            request.response.complete();
+
+            expect(model.status).to.equal('idle');
+            expect(statuses).to.deep.equal(['idle']);
+        });
+
+        it('should be idle when the last request was canceled', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+
+            request.response.cancel();
+
+            expect(model.status).to.equal('idle');
+        });
+
+        it('should be failed when the last request ended in an error', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+
+            request.response.error(new Error('boom'));
+
+            expect(model.status).to.equal('failed');
+        });
+
+        it('should be running again when a new request is added after a failure', () => {
+            const model = new MutableChatModel();
+            const failed = model.addRequest(parsedRequest());
+            failed.response.error(new Error('boom'));
+
+            model.addRequest(parsedRequest('try again'));
+
+            expect(model.status).to.equal('running');
+        });
+
+        it('should be awaitingToolCall while a tool call is executing', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'myTool', '{}', false);
+
+            request.response.response.addContent(toolCall);
+            expect(model.status).to.equal('awaitingToolCall');
+
+            toolCall.complete('done');
+            expect(model.status).to.equal('running');
+        });
+
+        it('should be awaitingApproval while a tool call waits for user confirmation', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'myTool', '{}', false);
+            request.response.response.addContent(toolCall);
+
+            requestConfirmation(request, toolCall);
+
+            expect(model.status).to.equal('awaitingApproval');
+        });
+
+        it('should move to awaitingToolCall when the user approves the tool call', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'myTool', '{}', false);
+            request.response.response.addContent(toolCall);
+            requestConfirmation(request, toolCall);
+
+            toolCall.confirm();
+            request.response.stopWaitingForInput();
+
+            expect(model.status).to.equal('awaitingToolCall');
+        });
+
+        it('should move back to running when the user denies the tool call', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'myTool', '{}', false);
+            request.response.response.addContent(toolCall);
+            requestConfirmation(request, toolCall);
+
+            toolCall.deny('not allowed');
+            request.response.stopWaitingForInput();
+
+            expect(model.status).to.equal('running');
+        });
+
+        it('should be awaitingInput while a structured question is unanswered', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const question = new QuestionResponseContentImpl(
+                'Proceed?',
+                [{ text: 'Yes' }, { text: 'No' }],
+                request,
+                () => { /* no-op */ }
+            );
+
+            request.response.response.addContent(question);
+            expect(model.status).to.equal('awaitingInput');
+
+            question.selectedOption = { text: 'Yes' };
+            expect(model.status).to.equal('running');
+        });
+
+        it('should be awaitingInput while waiting for input without a question part', () => {
+            // E.g. the user-interaction tool keeps its tool call unfinished while the
+            // user completes a wizard; only the waiting-for-input flag is set.
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'userInteraction', '{}', false);
+            request.response.response.addContent(toolCall);
+
+            request.response.waitForInput();
+            expect(model.status).to.equal('awaitingInput');
+
+            request.response.stopWaitingForInput();
+            expect(model.status).to.equal('awaitingToolCall');
+        });
+
+        it('should prefer awaitingApproval over awaitingInput', () => {
+            const model = new MutableChatModel();
+            const request = model.addRequest(parsedRequest());
+            const question = new QuestionResponseContentImpl(
+                'Proceed?',
+                [{ text: 'Yes' }],
+                request,
+                () => { /* no-op */ }
+            );
+            request.response.response.addContent(question);
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'myTool', '{}', false);
+            request.response.response.addContent(toolCall);
+
+            requestConfirmation(request, toolCall);
+
+            expect(model.status).to.equal('awaitingApproval');
+        });
+
+        it('should record the full transition sequence of a confirmed tool call', () => {
+            const model = new MutableChatModel();
+            const statuses = trackStatusChanges(model);
+            const request = model.addRequest(parsedRequest());
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'myTool', '{}', false);
+
+            request.response.response.addContent(toolCall);
+            requestConfirmation(request, toolCall);
+            toolCall.confirm();
+            request.response.stopWaitingForInput();
+            toolCall.complete('done');
+            request.response.complete();
+
+            expect(statuses).to.deep.equal(['running', 'awaitingToolCall', 'awaitingApproval', 'awaitingToolCall', 'running', 'idle']);
+        });
+    });
+});

package/src/common/chat-session-store.ts

@@ -28,6 +28,10 @@ export interface ChatModelWithMetadata {
     lastInteraction?: number;
     /** Whether the last request ended with an error. */
     hasError?: boolean;
+    /** ID of the root session in the delegation chain. */
+    rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. */
+    parentSessionId?: string;
 }
 
 export interface ChatSessionStore {
@@ -75,4 +79,8 @@ export interface ChatSessionMetadata {
     pinnedAgentId?: string;
     /** Whether the last request ended with an error. */
     hasError?: boolean;
+    /** ID of the root session in the delegation chain. */
+    rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. */
+    parentSessionId?: string;
 }

package/src/common/tool-call-response-content.spec.ts

@@ -290,6 +290,48 @@ describe('ToolCallChatResponseContent - confirmation state transitions', () => {
         expect(result).to.be.false;
         expect(content.result).to.deep.equal({ denied: true, reason: undefined });
     });
+
+    describe('isAwaitingUserConfirmation', () => {
+        it('should be false initially', () => {
+            const content = createToolCallContent();
+            expect(content.isAwaitingUserConfirmation).to.be.false;
+        });
+
+        it('should be true after requestUserConfirmation()', () => {
+            const content = createToolCallContent();
+            content.requestUserConfirmation();
+            expect(content.isAwaitingUserConfirmation).to.be.true;
+        });
+
+        it('should be false after the user confirms', () => {
+            const content = createToolCallContent();
+            content.requestUserConfirmation();
+            content.confirm();
+            expect(content.isAwaitingUserConfirmation).to.be.false;
+        });
+
+        it('should be false after the user denies', () => {
+            const content = createToolCallContent();
+            content.requestUserConfirmation();
+            content.deny('rejected');
+            expect(content.isAwaitingUserConfirmation).to.be.false;
+        });
+
+        it('should be false after the confirmation is canceled', () => {
+            const content = createToolCallContent();
+            content.confirmed.catch(() => undefined);
+            content.requestUserConfirmation();
+            content.cancelConfirmation(new Error('request canceled'));
+            expect(content.isAwaitingUserConfirmation).to.be.false;
+        });
+
+        it('should be false once the tool call is finished', () => {
+            const content = createToolCallContent();
+            content.requestUserConfirmation();
+            content.complete('result');
+            expect(content.isAwaitingUserConfirmation).to.be.false;
+        });
+    });
 });
 
 describe('Tool Confirmation Timeout', () => {