@theia/ai-chat 1.66.0-next.67 → 1.66.0-next.73

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

@@ -0,0 +1,269 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { ChatServiceImpl } from './chat-service';
+import { ChatSessionStore, ChatSessionIndex, ChatModelWithMetadata } from './chat-session-store';
+import { ChatAgentService } from './chat-agent-service';
+import { ChatRequestParser } from './chat-request-parser';
+import { AIVariableService } 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 { ChatAgentLocation } from './chat-agents';
+import { ChatModel } from './chat-model';
+import { SerializedChatData } from './chat-model-serialization';
+
+describe('ChatService Session Deletion', () => {
+    let chatService: ChatServiceImpl;
+    let sessionStore: MockChatSessionStore;
+    let container: Container;
+
+    class MockChatSessionStore implements ChatSessionStore {
+        public deletedSessions: string[] = [];
+        public storedSessions: Array<ChatModel | ChatModelWithMetadata> = [];
+
+        async storeSessions(...sessions: Array<ChatModel | ChatModelWithMetadata>): Promise<void> {
+            this.storedSessions = sessions;
+        }
+
+        async readSession(sessionId: string): Promise<SerializedChatData | undefined> {
+            return undefined;
+        }
+
+        async deleteSession(sessionId: string): Promise<void> {
+            this.deletedSessions.push(sessionId);
+        }
+
+        async clearAllSessions(): Promise<void> {
+            this.deletedSessions = [];
+            this.storedSessions = [];
+        }
+
+        async getSessionIndex(): Promise<ChatSessionIndex> {
+            return {};
+        }
+
+        async setSessionTitle(sessionId: string, title: string): Promise<void> {
+        }
+    }
+
+    class MockChatAgentService {
+        getAgent(): undefined {
+            return undefined;
+        }
+        getAgents(): never[] {
+            return [];
+        }
+    }
+
+    class MockChatRequestParser {
+        parseChatRequest(): { parts: never[]; text: string } {
+            return { parts: [], text: '' };
+        }
+    }
+
+    class MockAIVariableService {
+        resolveVariables(): Promise<unknown[]> {
+            return Promise.resolve([]);
+        }
+    }
+
+    class MockLogger {
+        error(): void { }
+        warn(): void { }
+        info(): void { }
+        debug(): void { }
+    }
+
+    beforeEach(() => {
+        container = new Container();
+        sessionStore = new MockChatSessionStore();
+
+        container.bind(ChatSessionStore).toConstantValue(sessionStore);
+        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(ILogger).toConstantValue(new MockLogger() as unknown as ILogger);
+
+        // Bind deserializer registries
+        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);
+    });
+
+    describe('deleteSession', () => {
+        it('should delete session from memory and persistent storage', async () => {
+            // Create a session
+            const session = chatService.createSession(ChatAgentLocation.Panel);
+            expect(chatService.getSessions()).to.have.lengthOf(1);
+
+            // Delete the session (now returns a Promise)
+            await chatService.deleteSession(session.id);
+
+            // Verify it's removed from memory
+            expect(chatService.getSessions()).to.have.lengthOf(0);
+
+            // Verify it's deleted from persistent storage
+            expect(sessionStore.deletedSessions).to.include(session.id);
+        });
+
+        it('should emit SessionDeletedEvent when session is deleted', done => {
+            // Create a session
+            const session = chatService.createSession(ChatAgentLocation.Panel);
+
+            // Listen for deletion event
+            chatService.onSessionEvent(event => {
+                if (event.type === 'deleted') {
+                    expect(event.sessionId).to.equal(session.id);
+                    done();
+                }
+            });
+
+            // Delete the session
+            chatService.deleteSession(session.id);
+        });
+
+        it('should handle deletion when session store is not available', async () => {
+            // Create a new service without session store
+            const containerWithoutStore = new Container();
+            containerWithoutStore.bind(ChatAgentService).toConstantValue(new MockChatAgentService() as unknown as ChatAgentService);
+            containerWithoutStore.bind(ChatRequestParser).toConstantValue(new MockChatRequestParser() as unknown as ChatRequestParser);
+            containerWithoutStore.bind(AIVariableService).toConstantValue(new MockAIVariableService() as unknown as AIVariableService);
+            containerWithoutStore.bind(ILogger).toConstantValue(new MockLogger() as unknown as ILogger);
+
+            // Bind deserializer registries
+            const contentRegistry = new ChatContentDeserializerRegistryImpl();
+            new DefaultChatContentDeserializerContribution().registerDeserializers(contentRegistry);
+            containerWithoutStore.bind(ChatContentDeserializerRegistry).toConstantValue(contentRegistry);
+            containerWithoutStore.bind(ChangeSetElementDeserializerRegistry).toConstantValue(new ChangeSetElementDeserializerRegistryImpl());
+
+            containerWithoutStore.bind(ChatServiceImpl).toSelf().inSingletonScope();
+
+            const serviceWithoutStore = containerWithoutStore.get(ChatServiceImpl);
+
+            // Create and delete a session - should not throw
+            const session = serviceWithoutStore.createSession(ChatAgentLocation.Panel);
+            await serviceWithoutStore.deleteSession(session.id);
+
+            // Verify session is still removed from memory
+            expect(serviceWithoutStore.getSessions()).to.have.lengthOf(0);
+        });
+
+        it('should attempt storage deletion even for non-existent in-memory sessions', async () => {
+            const initialDeletedCount = sessionStore.deletedSessions.length;
+            const nonExistentId = 'non-existent-id';
+
+            // Try to delete non-existent session (could be a persisted-only session)
+            await chatService.deleteSession(nonExistentId);
+
+            // Verify storage deletion was attempted even though session not in memory
+            expect(sessionStore.deletedSessions).to.include(nonExistentId);
+            expect(sessionStore.deletedSessions).to.have.lengthOf(initialDeletedCount + 1);
+        });
+
+        it('should handle deleting active session', () => {
+            // Create two sessions
+            const session1 = chatService.createSession(ChatAgentLocation.Panel);
+            const session2 = chatService.createSession(ChatAgentLocation.Panel);
+
+            // Ensure session2 is active (it should be by default as the latest)
+            expect(chatService.getActiveSession()?.id).to.equal(session2.id);
+
+            // Delete session1 (not active)
+            chatService.deleteSession(session1.id);
+
+            // Verify session2 is still active
+            const activeSession = chatService.getActiveSession();
+            expect(activeSession).to.not.be.undefined;
+            expect(activeSession?.id).to.equal(session2.id);
+        });
+
+        it('should handle storage deletion errors gracefully', async () => {
+            // Create a session store that throws errors
+            const errorStore = new MockChatSessionStore();
+            errorStore.deleteSession = async () => {
+                throw new Error('Storage error');
+            };
+
+            const errorContainer = new Container();
+            errorContainer.bind(ChatSessionStore).toConstantValue(errorStore);
+            errorContainer.bind(ChatAgentService).toConstantValue(new MockChatAgentService() as unknown as ChatAgentService);
+            errorContainer.bind(ChatRequestParser).toConstantValue(new MockChatRequestParser() as unknown as ChatRequestParser);
+            errorContainer.bind(AIVariableService).toConstantValue(new MockAIVariableService() as unknown as AIVariableService);
+            errorContainer.bind(ILogger).toConstantValue(new MockLogger() as unknown as ILogger);
+
+            // Bind deserializer registries
+            const contentRegistry = new ChatContentDeserializerRegistryImpl();
+            new DefaultChatContentDeserializerContribution().registerDeserializers(contentRegistry);
+            errorContainer.bind(ChatContentDeserializerRegistry).toConstantValue(contentRegistry);
+            errorContainer.bind(ChangeSetElementDeserializerRegistry).toConstantValue(new ChangeSetElementDeserializerRegistryImpl());
+
+            errorContainer.bind(ChatServiceImpl).toSelf().inSingletonScope();
+
+            const errorService = errorContainer.get(ChatServiceImpl);
+
+            // Create and delete a session - should not throw even with storage error
+            const session = errorService.createSession(ChatAgentLocation.Panel);
+            await errorService.deleteSession(session.id);
+
+            // Verify session is still removed from memory despite storage error
+            expect(errorService.getSessions()).to.have.lengthOf(0);
+        });
+
+        it('should delete persisted-only sessions (not loaded in memory)', async () => {
+            // This simulates deleting a session from the "Show Chats..." dialog
+            // when the session is persisted but not currently loaded into memory
+            const persistedSessionId = 'persisted-session-123';
+
+            // Verify session is not in memory
+            expect(chatService.getSessions().find(s => s.id === persistedSessionId)).to.be.undefined;
+
+            // Delete the persisted-only session
+            await chatService.deleteSession(persistedSessionId);
+
+            // Verify it was still deleted from storage (even though not in memory)
+            expect(sessionStore.deletedSessions).to.include(persistedSessionId);
+        });
+
+        it('should not fire SessionDeletedEvent for persisted-only sessions', async () => {
+            // When deleting a persisted-only session (not in memory),
+            // we shouldn't fire the event since no in-memory state changed
+            const persistedSessionId = 'persisted-session-456';
+            let eventFired = false;
+
+            // Listen for deletion event
+            chatService.onSessionEvent(event => {
+                if (event.type === 'deleted' && event.sessionId === persistedSessionId) {
+                    eventFired = true;
+                }
+            });
+
+            // Delete the persisted-only session
+            await chatService.deleteSession(persistedSessionId);
+
+            // Event should not have been fired since session wasn't in memory
+            expect(eventFired).to.be.false;
+            // But storage deletion should still have happened
+            expect(sessionStore.deletedSessions).to.include(persistedSessionId);
+        });
+    });
+});

package/src/common/chat-service.ts

@@ -27,6 +27,8 @@ import { Event } from '@theia/core/shared/vscode-languageserver-protocol';
 import { ChatAgentService } from './chat-agent-service';
 import { ChatAgent, ChatAgentLocation, ChatSessionContext } from './chat-agents';
 import {
+    ChangeSetElement,
+    ChangeSetImpl,
     ChatContext,
     ChatModel,
     ChatRequest,
@@ -39,6 +41,11 @@ import {
 import { ChatRequestParser } from './chat-request-parser';
 import { ChatSessionNamingService } from './chat-session-naming-service';
 import { ParsedChatRequest, ParsedChatRequestAgentPart } from './parsed-chat-request';
+import { ChatSessionIndex, ChatSessionStore } from './chat-session-store';
+import { ChatContentDeserializerRegistry } from './chat-content-deserializer';
+import { ChangeSetDeserializationContext, ChangeSetElementDeserializerRegistry } from './change-set-element-deserializer';
+import { SerializableChangeSetElement, SerializedChatModel } from './chat-model-serialization';
+import debounce = require('@theia/core/shared/lodash.debounce');
 
 export interface ChatRequestInvocation {
     /**
@@ -126,7 +133,7 @@ export interface ChatService {
     getSession(id: string): ChatSession | undefined;
     getSessions(): ChatSession[];
     createSession(location?: ChatAgentLocation, options?: SessionOptions, pinnedAgent?: ChatAgent): ChatSession;
-    deleteSession(sessionId: string): void;
+    deleteSession(sessionId: string): Promise<void>;
     getActiveSession(): ChatSession | undefined;
     setActiveSession(sessionId: string, options?: SessionOptions): void;
 
@@ -141,6 +148,15 @@ export interface ChatService {
     cancelRequest(sessionId: string, requestId: string): Promise<void>;
 
     getAgent(parsedRequest: ParsedChatRequest, session: ChatSession): ChatAgent | undefined;
+
+    /**
+     * Get an existing session or restore from storage
+     */
+    getOrRestoreSession(sessionId: string): Promise<ChatSession | undefined>;
+    /**
+     * Get all persisted session metadata
+     */
+    getPersistedSessions(): Promise<ChatSessionIndex>;
 }
 
 interface ChatSessionInternal extends ChatSession {
@@ -176,6 +192,15 @@ export class ChatServiceImpl implements ChatService {
     @inject(ILogger)
     protected logger: ILogger;
 
+    @inject(ChatSessionStore) @optional()
+    protected sessionStore: ChatSessionStore | undefined;
+
+    @inject(ChatContentDeserializerRegistry)
+    protected deserializerRegistry: ChatContentDeserializerRegistry;
+
+    @inject(ChangeSetElementDeserializerRegistry)
+    protected changeSetElementDeserializerRegistry: ChangeSetElementDeserializerRegistry;
+
     protected _sessions: ChatSessionInternal[] = [];
 
     getSessions(): ChatSessionInternal[] {
@@ -190,27 +215,41 @@ export class ChatServiceImpl implements ChatService {
         const model = new MutableChatModel(location);
         const session: ChatSessionInternal = {
             id: model.id,
+            lastInteraction: new Date(),
             model,
             isActive: true,
             pinnedAgent
         };
         this._sessions.push(session);
+        this.setupAutoSaveForSession(session);
         this.setActiveSession(session.id, options);
         this.onSessionEventEmitter.fire({ type: 'created', sessionId: session.id });
         return session;
     }
 
-    deleteSession(sessionId: string): void {
+    async deleteSession(sessionId: string): Promise<void> {
         const sessionIndex = this._sessions.findIndex(candidate => candidate.id === sessionId);
-        if (sessionIndex === -1) { return; }
-        const session = this._sessions[sessionIndex];
-        // If the removed session is the active one, set the newest one as active
-        if (session.isActive) {
-            this.setActiveSession(this._sessions[this._sessions.length - 1]?.id);
+
+        // If session is in memory, remove it
+        if (sessionIndex !== -1) {
+            const session = this._sessions[sessionIndex];
+            // If the removed session is the active one, set the newest one as active
+            if (session.isActive) {
+                this.setActiveSession(this._sessions[this._sessions.length - 1]?.id);
+            }
+            session.model.dispose();
+            this._sessions.splice(sessionIndex, 1);
+            this.onSessionEventEmitter.fire({ type: 'deleted', sessionId: sessionId });
+        }
+
+        // Always delete from persistent storage
+        if (this.sessionStore) {
+            try {
+                await this.sessionStore.deleteSession(sessionId);
+            } catch (error) {
+                this.logger.error('Failed to delete session from storage', { sessionId, error });
+            }
         }
-        session.model.dispose();
-        this._sessions.splice(sessionIndex, 1);
-        this.onSessionEventEmitter.fire({ type: 'deleted', sessionId: sessionId });
     }
 
     getActiveSession(): ChatSession | undefined {
@@ -303,6 +342,8 @@ export class ChatServiceImpl implements ChatService {
                     namingService.generateChatSessionName(session, otherSessionNames).then(name => {
                         if (name && session.title === requestText) {
                             session.title = name;
+                            // Trigger persistence when title changes
+                            this.saveSession(session.id);
                         }
                         didGenerateName = true;
                     }).catch(error => this.logger.error('Failed to generate chat session name', error));
@@ -392,4 +433,180 @@ export class ChatServiceImpl implements ChatService {
     deleteChangeSetElement(sessionId: string, uri: URI): void {
         this.getSession(sessionId)?.model.changeSet.removeElements(uri);
     }
+
+    protected saveSession(sessionId: string): void {
+        if (!this.sessionStore) {
+            this.logger.debug('Session store not available, skipping save');
+            return;
+        }
+
+        const session = this.getSession(sessionId);
+        if (!session) {
+            this.logger.debug('Session not found, skipping save', { sessionId });
+            return;
+        }
+
+        // Don't save empty sessions
+        if (session.model.isEmpty()) {
+            this.logger.debug('Session is empty, skipping save', { sessionId });
+            return;
+        }
+
+        // Store session with title and pinned agent info
+        this.sessionStore.storeSessions(
+            { model: session.model, title: session.title, pinnedAgentId: session.pinnedAgent?.id }
+        ).catch(error => {
+            this.logger.error('Failed to store chat sessions', error);
+        });
+    }
+
+    /**
+     * Set up auto-save for a session by listening to model changes.
+     */
+    protected setupAutoSaveForSession(session: ChatSessionInternal): void {
+        const debouncedSave = debounce(() => this.saveSession(session.id), 500, { maxWait: 5000 });
+        session.model.onDidChange(_event => {
+            debouncedSave();
+        });
+    }
+
+    async getOrRestoreSession(sessionId: string): Promise<ChatSession | undefined> {
+        const existing = this.getSession(sessionId);
+        if (existing) {
+            this.logger.debug('Session already loaded', { sessionId });
+            return existing;
+        }
+
+        if (!this.sessionStore) {
+            this.logger.debug('Session store not available, cannot restore', { sessionId });
+            return undefined;
+        }
+
+        this.logger.debug('Restoring session from storage', { sessionId });
+
+        const serialized = await this.sessionStore.readSession(sessionId);
+        if (!serialized) {
+            this.logger.warn('Session not found in storage', { sessionId });
+            return undefined;
+        }
+
+        this.logger.debug('Session loaded from storage', {
+            sessionId,
+            requestCount: serialized.model.requests.length,
+            responseCount: serialized.model.responses.length,
+            version: serialized.version
+        });
+
+        const model = new MutableChatModel(serialized.model);
+        await this.restoreSessionData(model, serialized.model);
+
+        // Determine pinned agent
+        const pinnedAgent = serialized.pinnedAgentId
+            ? this.chatAgentService.getAgent(serialized.pinnedAgentId)
+            : undefined;
+
+        // Register as session
+        const session: ChatSessionInternal = {
+            id: sessionId,
+            title: serialized.title,
+            lastInteraction: new Date(serialized.saveDate),
+            model,
+            isActive: false,
+            pinnedAgent
+        };
+        this._sessions.push(session);
+        this.setupAutoSaveForSession(session);
+        this.onSessionEventEmitter.fire({ type: 'created', sessionId: session.id });
+
+        this.logger.debug('Session successfully restored and registered', { sessionId, title: session.title });
+
+        return session;
+    }
+
+    async getPersistedSessions(): Promise<ChatSessionIndex> {
+        if (!this.sessionStore) {
+            return {};
+        }
+        return this.sessionStore.getSessionIndex();
+    }
+
+    /**
+     * Deserialize response content and restore changesets.
+     * Called after basic chat model structure was created.
+     */
+    protected async restoreSessionData(model: MutableChatModel, data: SerializedChatModel): Promise<void> {
+        this.logger.debug('Restoring dynamic session data', { sessionId: data.sessionId, requestCount: data.requests.length });
+
+        // Process each request for response content and changeset restoration
+        // IMPORTANT: Use getAllRequests() to include alternatives, not just active requests
+        const requests = model.getAllRequests();
+        for (let i = 0; i < requests.length; i++) {
+            const requestModel = requests[i];
+
+            this.logger.debug('Restore response content', { requestId: requestModel.id, index: i });
+
+            // Restore response content using deserializer registry
+            const respData = data.responses.find(r => r.requestId === requestModel.id);
+            if (respData && respData.content.length > 0) {
+                const restoredContent = await Promise.all(respData.content.map(contentData =>
+                    this.deserializerRegistry.deserialize(contentData)
+                ));
+                restoredContent.forEach(content => requestModel.response.response.addContent(content));
+                this.logger.debug('Restored response content', {
+                    requestId: requestModel.id,
+                    contentCount: restoredContent.length
+                });
+            }
+
+            // Restore changeset elements
+            const serializedChangeSet = data.requests.find(r => r.id === requestModel.id)?.changeSet;
+            if (serializedChangeSet && serializedChangeSet.elements && serializedChangeSet.elements.length > 0) {
+                // Create a changeset if one doesn't exist
+                if (!requestModel.changeSet) {
+                    requestModel.changeSet = new ChangeSetImpl();
+                }
+                await this.restoreChangeSetElements(requestModel, serializedChangeSet.elements, data.sessionId);
+
+                // Restore changeset title
+                if (serializedChangeSet.title) {
+                    requestModel.changeSet.setTitle(serializedChangeSet.title);
+                }
+
+                this.logger.debug('Restored changeset', {
+                    requestId: requestModel.id,
+                    elementCount: serializedChangeSet.elements.length
+                });
+            }
+        }
+
+        this.logger.debug('Restoring dynamic session data complete', { sessionId: data.sessionId });
+    }
+
+    protected async restoreChangeSetElements(
+        requestModel: MutableChatRequestModel,
+        elements: SerializableChangeSetElement[],
+        sessionId: string
+    ): Promise<void> {
+        this.logger.debug('Restoring changeset elements', { requestId: requestModel.id, elementCount: elements.length });
+
+        const context: ChangeSetDeserializationContext = {
+            chatSessionId: sessionId,
+            requestId: requestModel.id
+        };
+
+        const restoredElements: ChangeSetElement[] = [];
+
+        for (const elem of elements) {
+            const restoredElement = await this.changeSetElementDeserializerRegistry.deserialize(elem, context);
+            restoredElements.push(restoredElement);
+        }
+
+        // Add elements to the request's changeset
+        if (requestModel.changeSet) {
+            requestModel.changeSet.addElements(...restoredElements);
+            this.logger.debug('Changeset elements restored', { requestId: requestModel.id, elementCount: restoredElements.length });
+        } else {
+            this.logger.warn('Request has no changeset, cannot restore elements', { requestId: requestModel.id });
+        }
+    }
 }

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

@@ -0,0 +1,63 @@
+// *****************************************************************************
+// Copyright (C) 2025 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 { ChatModel } from './chat-model';
+import { SerializedChatData } from './chat-model-serialization';
+import { ChatAgentLocation } from './chat-agents';
+
+export const ChatSessionStore = Symbol('ChatSessionStore');
+
+export interface ChatModelWithMetadata {
+    model: ChatModel;
+    title?: string;
+    pinnedAgentId?: string;
+}
+
+export interface ChatSessionStore {
+    /**
+     * Stores the handed over sessions.
+     *
+     * Might overwrite existing sessions when maximum storage capacity is exceeded.
+     */
+    storeSessions(...sessions: Array<ChatModel | ChatModelWithMetadata>): Promise<void>;
+    /**
+     * Read specified session
+     */
+    readSession(sessionId: string): Promise<SerializedChatData | undefined>;
+    /**
+     * Delete specified session
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * Deletes all sessions
+     */
+    clearAllSessions(): Promise<void>;
+    /**
+     * Get index of all stored sessions
+     */
+    getSessionIndex(): Promise<ChatSessionIndex>;
+}
+
+export interface ChatSessionIndex {
+    [sessionId: string]: ChatSessionMetadata;
+}
+
+export interface ChatSessionMetadata {
+    sessionId: string;
+    title: string;
+    saveDate: number;
+    location: ChatAgentLocation;
+}

package/src/common/index.ts

@@ -16,9 +16,12 @@
 export * from './chat-agents';
 export * from './chat-agent-service';
 export * from './chat-model';
+export * from './chat-model-serialization';
+export * from './chat-content-deserializer';
 export * from './chat-model-util';
 export * from './chat-request-parser';
 export * from './chat-service';
+export * from './chat-session-store';
 export * from './custom-chat-agent';
 export * from './parsed-chat-request';
 export * from './context-variables';