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

package/src/common/chat-request-parser.ts

@@ -19,7 +19,7 @@
  *--------------------------------------------------------------------------------------------*/
 // Partially copied from https://github.com/microsoft/vscode/blob/a2cab7255c0df424027be05d58e1b7b941f4ea60/src/vs/workbench/contrib/chat/common/chatRequestParser.ts
 
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, optional } from '@theia/core/shared/inversify';
 import { ChatAgentService } from './chat-agent-service';
 import { ChatAgentLocation } from './chat-agents';
 import { ChatContext, ChatRequest } from './chat-model';
@@ -37,7 +37,7 @@ import {
     ParsedChatRequestPart,
 } from './parsed-chat-request';
 import {
-    AIVariable, AIVariableService, createAIResolveVariableCache, getAllResolvedAIVariables, parseFunctionReference, ToolInvocationRegistry, ToolRequest
+    AIVariable, AIVariableService, createAIResolveVariableCache, getAllResolvedAIVariables, parseFunctionReference, PromptService, ToolInvocationRegistry, ToolRequest
 } from '@theia/ai-core';
 import { ILogger } from '@theia/core';
 
@@ -47,7 +47,8 @@ const agentReg = /^@([\w_\-\.]+)(?=(\s|$|\b))/i; // An @-agent
 const functionReg = /^~(\??[\w_\-\.]+)(?=(\s|$|\b))/i;
 const functionPromptFormatReg = /^\~\{\s*(.*?)\s*\}/i;
 const variableReg = /^#([\w_\-]+)(?::([\w_\-_\/\\.:]+))?(?=(\s|$|\b))/i; // A #-variable with an optional : arg (#file:workspace/path/name.ext)
-const commandReg = /^\/([\w_\-]+)(?:\s+(.+?))?(?=\s*$)/; // A /-command with optional arguments (/commandname arg1 arg2)
+const commandReg = /^\/([\w_\-]+)/; // A /-command (/commandname) with optional arguments parsed separately
+const nextCommandReg = /\s+\/([\w_\-]+)(?=\s|$)/g;
 
 export const ChatRequestParser = Symbol('ChatRequestParser');
 export interface ChatRequestParser {
@@ -62,11 +63,15 @@ function offsetRange(start: number, endExclusive: number): OffsetRange {
 }
 @injectable()
 export class ChatRequestParserImpl implements ChatRequestParser {
+
+    @inject(PromptService) @optional()
+    protected readonly promptService?: PromptService;
+
     constructor(
         @inject(ChatAgentService) private readonly agentService: ChatAgentService,
         @inject(AIVariableService) private readonly variableService: AIVariableService,
         @inject(ToolInvocationRegistry) private readonly toolInvocationRegistry: ToolInvocationRegistry,
-        @inject(ILogger) private readonly logger: ILogger
+        @inject(ILogger) private readonly logger: ILogger,
     ) { }
 
     async parseChatRequest(request: ChatRequest, location: ChatAgentLocation, context: ChatContext): Promise<ParsedChatRequest> {
@@ -185,6 +190,7 @@ export class ChatRequestParserImpl implements ChatRequestParser {
                 }
 
                 parts.push(newPart);
+                i = newPart.range.endExclusive - 1;
             }
         }
 
@@ -292,13 +298,52 @@ export class ChatRequestParserImpl implements ChatRequestParser {
             return;
         }
 
-        const [full, commandName, commandArgs] = nextCommandMatch;
-        const commandRange = offsetRange(offset, offset + full.length);
+        const [commandText, commandName] = nextCommandMatch;
+        let commandEnd = commandText.length;
+        let commandArgs: string | undefined;
+
+        const nextCommandOffset = this.findNextCommandOffset(message, commandEnd);
+        const argsEnd = nextCommandOffset ?? message.length;
+        const rawArgs = message.slice(commandEnd, argsEnd);
+        const args = rawArgs.trim();
+        if (args) {
+            commandArgs = args;
+            // Advance the consumed range only up to the end of the trimmed argument, not up to the
+            // next command. This keeps the whitespace between the argument and a following command
+            // out of this part's range, so parseParts emits it as a separator text part. Otherwise
+            // the two resolved prompt fragments would run into each other with no space between them.
+            commandEnd = argsEnd - (rawArgs.length - rawArgs.trimEnd().length);
+        }
+
+        const commandRange = offsetRange(offset, offset + commandEnd);
 
         const variableArg = commandArgs ? `${commandName}|${commandArgs}` : commandName;
         return new ParsedChatRequestVariablePart(commandRange, 'prompt', variableArg);
     }
 
+    private findNextCommandOffset(message: string, startOffset: number): number | undefined {
+        nextCommandReg.lastIndex = startOffset;
+        let match = nextCommandReg.exec(message);
+        while (match) {
+            const commandName = match[1];
+            // Deliberate behavior difference: without a PromptService we cannot tell commands from
+            // path-like arguments, so any `/word` token is treated as a command boundary. With a
+            // PromptService we only break on known command names and keep unknown `/word` tokens
+            // (e.g. `/tmp`, `/path/to/file`) as part of the current command's arguments.
+            if (!this.promptService || this.isKnownCommand(commandName)) {
+                return match.index + match[0].indexOf(chatSubcommandLeader);
+            }
+            match = nextCommandReg.exec(message);
+        }
+        return undefined;
+    }
+
+    private isKnownCommand(commandName: string): boolean {
+        return this.promptService?.getCommands().some(command =>
+            (command.commandName ?? command.id) === commandName
+        ) ?? false;
+    }
+
     private tryToParseFunction(message: string, offset: number): ParsedChatRequestFunctionPart | undefined {
         // Support both the chat and prompt formats for functions
         const nextFunctionMatch = message.match(functionPromptFormatReg) || message.match(functionReg);

package/src/common/chat-service-deletion.spec.ts

@@ -267,6 +267,58 @@ describe('ChatService Session Deletion', () => {
             expect(sessionStore.deletedSessions).to.include(persistedSessionId);
         });
 
+        it('should cascade-delete descendants when deleting an intermediate session (A -> B -> C, in memory)', async () => {
+            // Delegation chain A -> B -> C, all loaded in memory. C's rootSessionId points at A (the
+            // root of the chain), but its immediate parent is B, so deleting B must still remove C.
+            const a = chatService.createSession(ChatAgentLocation.Panel);
+            const b = chatService.createSession(ChatAgentLocation.Panel);
+            const c = chatService.createSession(ChatAgentLocation.Panel);
+            const internal = b as unknown as { rootSessionId?: string; parentSessionId?: string };
+            internal.rootSessionId = a.id;
+            internal.parentSessionId = a.id;
+            const cInternal = c as unknown as { rootSessionId?: string; parentSessionId?: string };
+            cInternal.rootSessionId = a.id;
+            cInternal.parentSessionId = b.id;
+
+            await chatService.deleteSession(b.id);
+
+            const remaining = chatService.getSessions().map(s => s.id);
+            expect(remaining).to.include(a.id);
+            expect(remaining).to.not.include(b.id);
+            expect(remaining).to.not.include(c.id);
+            expect(sessionStore.deletedSessions).to.include(b.id);
+            expect(sessionStore.deletedSessions).to.include(c.id);
+        });
+
+        it('should cascade-delete persisted-only descendants of an intermediate session', async () => {
+            // The whole chain lives only in the persisted index (e.g. after a reload). Deleting the
+            // intermediate B must reach C via its parentSessionId even though C's rootSessionId is A.
+            sessionStore.getSessionIndex = async (): Promise<ChatSessionIndex> => ({
+                A: { sessionId: 'A', title: 'A', saveDate: 0, location: ChatAgentLocation.Panel },
+                B: { sessionId: 'B', title: 'B', saveDate: 0, location: ChatAgentLocation.Panel, rootSessionId: 'A', parentSessionId: 'A' },
+                C: { sessionId: 'C', title: 'C', saveDate: 0, location: ChatAgentLocation.Panel, rootSessionId: 'A', parentSessionId: 'B' }
+            });
+
+            await chatService.deleteSession('B');
+
+            expect(sessionStore.deletedSessions).to.include('B');
+            expect(sessionStore.deletedSessions).to.include('C');
+            expect(sessionStore.deletedSessions).to.not.include('A');
+        });
+
+        it('should not loop forever on a cyclic parent reference', async () => {
+            // Defensive: a corrupted index where two sessions reference each other must still terminate.
+            sessionStore.getSessionIndex = async (): Promise<ChatSessionIndex> => ({
+                X: { sessionId: 'X', title: 'X', saveDate: 0, location: ChatAgentLocation.Panel, parentSessionId: 'Y' },
+                Y: { sessionId: 'Y', title: 'Y', saveDate: 0, location: ChatAgentLocation.Panel, parentSessionId: 'X' }
+            });
+
+            await chatService.deleteSession('X');
+
+            expect(sessionStore.deletedSessions).to.include('X');
+            expect(sessionStore.deletedSessions).to.include('Y');
+        });
+
         it('should fire SessionDeletedEvent for persisted-only sessions', async () => {
             // When deleting a persisted-only session (not in memory),
             // we still fire the event so consumers (e.g. the Welcome view's chat cards)

package/src/common/chat-service-pinned-agent.spec.ts

@@ -74,17 +74,38 @@ describe('ChatService pinned agent behavior', () => {
         prompts: []
     };
 
+    const mockHiddenAgent: ChatAgent = {
+        id: 'hidden-worker',
+        name: 'Hidden Worker',
+        description: 'Test agent that is hidden from chat (showInChat: false)',
+        locations: [ChatAgentLocation.Panel],
+        invoke: async () => { },
+        languageModelRequirements: [],
+        tags: [],
+        variables: [],
+        agentSpecificVariables: [],
+        functions: [],
+        prompts: []
+    };
+
     class MockChatAgentService {
         private agents = new Map<string, ChatAgent>([
             ['pinned-agent', mockPinnedAgent],
             ['mentioned-agent', mockMentionedAgent],
-            ['default-agent', mockDefaultAgent]
+            ['default-agent', mockDefaultAgent],
+            ['hidden-worker', mockHiddenAgent]
         ]);
 
+        /** Mirrors ChatAgentServiceImpl: agents with showInChat === false are only returned with includeHidden. */
+        private hiddenIds = new Set<string>(['hidden-worker']);
+
         readonly onDidChangeAgents = { dispose: () => { } };
         readonly onDefaultAgentChanged = { dispose: () => { } };
 
-        getAgent(id: string): ChatAgent | undefined {
+        getAgent(id: string, includeHidden: boolean = false): ChatAgent | undefined {
+            if (!includeHidden && this.hiddenIds.has(id)) {
+                return undefined;
+            }
             return this.agents.get(id);
         }
 
@@ -222,4 +243,39 @@ describe('ChatService pinned agent behavior', () => {
         // The selected agent (mentioned-agent) becomes the new pinned agent
         expect(session.pinnedAgent).to.equal(mockMentionedAgent);
     });
+
+    it('should resolve a hidden pinned agent instead of falling back to the default agent', () => {
+        // AgentDelegationTool pins the delegated agent on the session it creates; worker agents
+        // are typically hidden (showInChat: false). The pin is an explicit choice, so it must
+        // resolve even for hidden agents — falling back to the default agent would silently run
+        // the wrong agent with the wrong prompt and toolset.
+        const session = createMockSession(mockHiddenAgent);
+        const parsedRequest: ParsedChatRequest = {
+            request: { text: 'test message' },
+            parts: [new ParsedChatRequestTextPart({ start: 0, endExclusive: 'test message'.length }, 'test message')],
+            toolRequests: new Map(),
+            variables: []
+        };
+
+        const agent = chatService.getAgent(parsedRequest, session);
+        expect(agent).to.equal(mockHiddenAgent);
+    });
+
+    it('should resolve a hidden pinned agent when the request mentions that hidden agent', () => {
+        // A delegated request's text is '@<agentId> <prompt>'. The mention of a hidden agent does
+        // not resolve (mentions stay hidden-excluding), but the pin must still catch it.
+        const session = createMockSession(mockHiddenAgent);
+        const parsedRequest: ParsedChatRequest = {
+            request: { text: '@hidden-worker test' },
+            parts: [
+                new ParsedChatRequestAgentPart({ start: 0, endExclusive: '@hidden-worker'.length }, 'hidden-worker', 'hidden-worker'),
+                new ParsedChatRequestTextPart({ start: '@hidden-worker '.length, endExclusive: '@hidden-worker test'.length }, 'test')
+            ],
+            toolRequests: new Map(),
+            variables: []
+        };
+
+        const agent = chatService.getAgent(parsedRequest, session);
+        expect(agent).to.equal(mockHiddenAgent);
+    });
 });

package/src/common/chat-service-session-events.spec.ts

@@ -0,0 +1,161 @@
+// *****************************************************************************
+// 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 { Container } from '@theia/core/shared/inversify';
+import {
+    ActiveSessionChangedEvent,
+    ChatServiceImpl,
+    DefaultChatAgentId,
+    PinChatAgent,
+    SessionCreatedEvent,
+    SessionDeletedEvent,
+    SessionRenamedEvent
+} from './chat-service';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatRequestParser } from './chat-request-parser';
+import { AIVariableService, ToolInvocationRegistry } from '@theia/ai-core';
+import { ILogger } from '@theia/core';
+import { ChatContentDeserializerRegistry, ChatContentDeserializerRegistryImpl, DefaultChatContentDeserializerContribution } from './chat-content-deserializer';
+import { ChangeSetElementDeserializerRegistry, ChangeSetElementDeserializerRegistryImpl } from './change-set-element-deserializer';
+import { ChatAgent, ChatAgentLocation } from './chat-agents';
+import { ChatRequest } from './chat-model';
+import { ParsedChatRequest, ParsedChatRequestTextPart } from './parsed-chat-request';
+
+describe('ChatService session events', () => {
+    let chatService: ChatServiceImpl;
+    let container: Container;
+
+    const mockDefaultAgent: ChatAgent = {
+        id: 'default-agent',
+        name: 'Default Agent',
+        description: 'Test default agent',
+        locations: [ChatAgentLocation.Panel],
+        invoke: async () => { },
+        languageModelRequirements: [],
+        tags: [],
+        variables: [],
+        agentSpecificVariables: [],
+        functions: [],
+        prompts: []
+    };
+
+    class MockChatAgentService {
+        readonly onDidChangeAgents = { dispose: () => { } };
+        readonly onDefaultAgentChanged = { dispose: () => { } };
+
+        getAgent(id: string): ChatAgent | undefined {
+            return id === 'default-agent' ? mockDefaultAgent : undefined;
+        }
+
+        resolveAgent(): ChatAgent | undefined {
+            return mockDefaultAgent;
+        }
+    }
+
+    class MockChatRequestParser {
+        async parseChatRequest(request: ChatRequest): Promise<ParsedChatRequest> {
+            return {
+                request,
+                parts: [new ParsedChatRequestTextPart({ start: 0, endExclusive: request.text.length }, request.text)],
+                toolRequests: new Map(),
+                variables: []
+            };
+        }
+    }
+
+    class MockAIVariableService {
+        async resolveVariable(): Promise<unknown> {
+            return undefined;
+        }
+    }
+
+    class MockLogger {
+        error(): void { }
+        warn(): void { }
+        info(): void { }
+        debug(): void { }
+    }
+
+    beforeEach(() => {
+        container = new Container();
+
+        container.bind(ChatAgentService).toConstantValue(new MockChatAgentService() as unknown as ChatAgentService);
+        container.bind(ChatRequestParser).toConstantValue(new MockChatRequestParser() as unknown as ChatRequestParser);
+        container.bind(AIVariableService).toConstantValue(new MockAIVariableService() as unknown as AIVariableService);
+        container.bind(ToolInvocationRegistry).toConstantValue({});
+        container.bind(ILogger).toConstantValue(new MockLogger() as unknown as ILogger);
+
+        container.bind(DefaultChatAgentId).toConstantValue({ id: 'default-agent' });
+        container.bind(PinChatAgent).toConstantValue(true);
+
+        const contentRegistry = new ChatContentDeserializerRegistryImpl();
+        new DefaultChatContentDeserializerContribution().registerDeserializers(contentRegistry);
+        container.bind(ChatContentDeserializerRegistry).toConstantValue(contentRegistry);
+        container.bind(ChangeSetElementDeserializerRegistry).toConstantValue(new ChangeSetElementDeserializerRegistryImpl());
+        container.bind(ChatServiceImpl).toSelf().inSingletonScope();
+
+        chatService = container.get(ChatServiceImpl);
+    });
+
+    it('should fire a renamed event when sendRequest sets the session title', async () => {
+        const session = chatService.createSession(ChatAgentLocation.Panel);
+        expect(session.title).to.be.undefined;
+
+        const events: (ActiveSessionChangedEvent | SessionCreatedEvent | SessionDeletedEvent | SessionRenamedEvent)[] = [];
+        chatService.onSessionEvent(e => events.push(e));
+
+        await chatService.sendRequest(session.id, { text: 'Hello world' });
+
+        expect(session.title).to.equal('Hello world');
+        const renamedEvents = events.filter(e => e.type === 'renamed');
+        expect(renamedEvents).to.have.length(1);
+        expect((renamedEvents[0] as SessionRenamedEvent).sessionId).to.equal(session.id);
+    });
+
+    it('should not fire a renamed event on subsequent requests when title is already set', async () => {
+        const session = chatService.createSession(ChatAgentLocation.Panel);
+
+        // First request sets the title
+        await chatService.sendRequest(session.id, { text: 'First message' });
+        expect(session.title).to.equal('First message');
+
+        const events: (ActiveSessionChangedEvent | SessionCreatedEvent | SessionDeletedEvent | SessionRenamedEvent)[] = [];
+        chatService.onSessionEvent(e => events.push(e));
+
+        // Second request should not trigger a renamed event
+        await chatService.sendRequest(session.id, { text: 'Second message' });
+
+        const renamedEvents = events.filter(e => e.type === 'renamed');
+        expect(renamedEvents).to.have.length(0);
+        // Title should remain the first message
+        expect(session.title).to.equal('First message');
+    });
+
+    it('should fire a renamed event via renameSession', async () => {
+        const session = chatService.createSession(ChatAgentLocation.Panel);
+
+        const events: (ActiveSessionChangedEvent | SessionCreatedEvent | SessionDeletedEvent | SessionRenamedEvent)[] = [];
+        chatService.onSessionEvent(e => events.push(e));
+
+        await chatService.renameSession(session.id, 'New Title');
+
+        expect(session.title).to.equal('New Title');
+        const renamedEvents = events.filter(e => e.type === 'renamed');
+        expect(renamedEvents).to.have.length(1);
+        expect((renamedEvents[0] as SessionRenamedEvent).sessionId).to.equal(session.id);
+    });
+});

package/src/common/chat-service.spec.ts

@@ -0,0 +1,211 @@
+// *****************************************************************************
+// 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 { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Container } from '@theia/core/shared/inversify';
+import { ChatServiceImpl } from './chat-service';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatSessionStore } from './chat-session-store';
+import { ChatContentDeserializerRegistry } from './chat-content-deserializer';
+import { ChangeSetElementDeserializerRegistry } from './change-set-element-deserializer';
+import { ToolInvocationRegistry, AIVariableService } from '@theia/ai-core';
+import { ILogger } from '@theia/core';
+import { ChatRequestParser } from './chat-request-parser';
+
+disableJSDOM();
+
+describe('ChatServiceImpl', () => {
+    let sandbox: sinon.SinonSandbox;
+    let chatService: ChatServiceImpl;
+    let mockSessionStore: sinon.SinonStubbedInstance<ChatSessionStore>;
+    let mockAgentService: sinon.SinonStubbedInstance<ChatAgentService>;
+    let mockDeserRegistry: sinon.SinonStubbedInstance<ChatContentDeserializerRegistry>;
+    let mockChangeSetDeserRegistry: sinon.SinonStubbedInstance<ChangeSetElementDeserializerRegistry>;
+    let mockToolInvocationRegistry: sinon.SinonStubbedInstance<ToolInvocationRegistry>;
+    let mockVariableService: sinon.SinonStubbedInstance<AIVariableService>;
+    let mockRequestParser: sinon.SinonStubbedInstance<ChatRequestParser>;
+    let mockLogger: sinon.SinonStubbedInstance<ILogger>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        mockSessionStore = {
+            storeSessions: sandbox.stub().resolves(),
+            readSession: sandbox.stub().resolves(undefined) as never,
+            deleteSession: sandbox.stub().resolves() as never,
+            clearAllSessions: sandbox.stub().resolves() as never,
+            getSessionIndex: sandbox.stub().resolves({}) as never,
+            hasPersistedSessions: sandbox.stub().resolves(false) as never
+        };
+
+        mockAgentService = {
+            getAgent: sandbox.stub().returns(undefined),
+            getAgents: sandbox.stub().returns([]),
+            resolveAgent: sandbox.stub().returns(undefined)
+        } as sinon.SinonStubbedInstance<ChatAgentService>;
+
+        mockDeserRegistry = {
+            deserialize: sandbox.stub().resolves([])
+        } as sinon.SinonStubbedInstance<ChatContentDeserializerRegistry>;
+
+        mockChangeSetDeserRegistry = {
+            deserialize: sandbox.stub().resolves([])
+        } as sinon.SinonStubbedInstance<ChangeSetElementDeserializerRegistry>;
+
+        mockToolInvocationRegistry = {
+            getFunction: sandbox.stub().returns(undefined)
+        } as sinon.SinonStubbedInstance<ToolInvocationRegistry>;
+
+        mockVariableService = {
+            resolveVariable: sandbox.stub().resolves(undefined)
+        } as sinon.SinonStubbedInstance<AIVariableService>;
+
+        mockRequestParser = {
+            parseChatRequest: sandbox.stub().resolves({ parts: [], toolRequests: [], variables: [] })
+        } as sinon.SinonStubbedInstance<ChatRequestParser>;
+
+        mockLogger = {
+            debug: sandbox.stub(),
+            info: sandbox.stub(),
+            warn: sandbox.stub(),
+            error: sandbox.stub()
+        } as sinon.SinonStubbedInstance<ILogger>;
+
+        const container = new Container();
+        container.bind(ChatServiceImpl).toSelf().inSingletonScope();
+        container.bind(ChatAgentService).toConstantValue(mockAgentService);
+        container.bind(ChatSessionStore).toConstantValue(mockSessionStore);
+        container.bind(ChatContentDeserializerRegistry).toConstantValue(mockDeserRegistry);
+        container.bind(ChangeSetElementDeserializerRegistry).toConstantValue(mockChangeSetDeserRegistry);
+        container.bind(ToolInvocationRegistry).toConstantValue(mockToolInvocationRegistry);
+        container.bind(ChatRequestParser).toConstantValue(mockRequestParser);
+        container.bind(AIVariableService).toConstantValue(mockVariableService);
+        container.bind(ILogger).toConstantValue(mockLogger);
+
+        chatService = container.get(ChatServiceImpl);
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe('deleteSession', () => {
+        it('should delete child sessions when deleting a parent session', async () => {
+            // Create a parent session
+            const parentSession = chatService.createSession();
+
+            // Create a child session by directly setting rootSessionId
+            const childSession = chatService.createSession();
+            childSession.rootSessionId = parentSession.id;
+
+            // Delete the parent session
+            await chatService.deleteSession(parentSession.id);
+
+            // Verify parent session was deleted
+            expect(chatService.getSession(parentSession.id)).to.be.undefined;
+
+            // Verify child session was also deleted (cascade delete)
+            expect(chatService.getSession(childSession.id)).to.be.undefined;
+
+            // Verify deleteSession was called for both sessions
+            expect(mockSessionStore.deleteSession.callCount).to.equal(2);
+            expect(mockSessionStore.deleteSession.calledWith(parentSession.id)).to.be.true;
+            expect(mockSessionStore.deleteSession.calledWith(childSession.id)).to.be.true;
+        });
+
+        it('should handle multiple child sessions', async () => {
+            // Create a parent session
+            const parentSession = chatService.createSession();
+
+            // Create multiple child sessions
+            const child1 = chatService.createSession();
+            child1.rootSessionId = parentSession.id;
+            const child2 = chatService.createSession();
+            child2.rootSessionId = parentSession.id;
+            const child3 = chatService.createSession();
+            child3.rootSessionId = parentSession.id;
+
+            // Delete the parent session
+            await chatService.deleteSession(parentSession.id);
+
+            // Verify all sessions were deleted
+            expect(chatService.getSession(parentSession.id)).to.be.undefined;
+            expect(chatService.getSession(child1.id)).to.be.undefined;
+            expect(chatService.getSession(child2.id)).to.be.undefined;
+            expect(chatService.getSession(child3.id)).to.be.undefined;
+
+            // Verify deleteSession was called for all sessions
+            expect(mockSessionStore.deleteSession.callCount).to.equal(4);
+        });
+
+        it('should not delete sessions without rootSessionId', async () => {
+            // Create a standalone session
+            const standaloneSession = chatService.createSession();
+
+            // Delete it
+            await chatService.deleteSession(standaloneSession.id);
+
+            // Verify only that session was deleted
+            expect(chatService.getSession(standaloneSession.id)).to.be.undefined;
+            expect(mockSessionStore.deleteSession.callCount).to.equal(1);
+        });
+
+        it('should delete persisted-only child sessions that are not loaded in memory', async () => {
+            // Parent is in memory; the child exists only in the persisted index (e.g. after a reload).
+            const parentSession = chatService.createSession();
+            const persistedChildId = 'persisted-child-id';
+            mockSessionStore.getSessionIndex.resolves({
+                [persistedChildId]: {
+                    sessionId: persistedChildId,
+                    title: 'Persisted child',
+                    saveDate: 0,
+                    location: parentSession.model.location,
+                    rootSessionId: parentSession.id
+                }
+            });
+
+            await chatService.deleteSession(parentSession.id);
+
+            // Both the in-memory parent and the persisted-only child are removed from storage.
+            expect(mockSessionStore.deleteSession.calledWith(parentSession.id)).to.be.true;
+            expect(mockSessionStore.deleteSession.calledWith(persistedChildId)).to.be.true;
+        });
+
+        it('should not delete sessions with different rootSessionId', async () => {
+            // Create two independent sessions
+            const session1 = chatService.createSession();
+            const session2 = chatService.createSession();
+
+            // Set session2 as a child of a non-existent session
+            session2.rootSessionId = 'non-existent-session-id';
+
+            // Delete session1
+            await chatService.deleteSession(session1.id);
+
+            // Verify only session1 was deleted
+            expect(chatService.getSession(session1.id)).to.be.undefined;
+            expect(chatService.getSession(session2.id)).to.not.be.undefined;
+            expect(mockSessionStore.deleteSession.callCount).to.equal(1);
+            expect(mockSessionStore.deleteSession.calledWith(session1.id)).to.be.true;
+        });
+    });
+});