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

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-naming-service.ts

@@ -26,7 +26,7 @@ import {
 } from '@theia/ai-core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { ChatSession } from './chat-service';
-import { generateUuid } from '@theia/core';
+import { generateUuid, nls } from '@theia/core';
 
 import { CHAT_SESSION_NAMING_PROMPT } from './chat-session-naming-prompt-template';
 
@@ -47,7 +47,7 @@ export class ChatSessionNamingAgent implements Agent {
     static ID = 'Chat Session Naming';
     id = ChatSessionNamingAgent.ID;
     name = ChatSessionNamingAgent.ID;
-    description = 'Agent for generating chat session names';
+    description = nls.localize('theia/ai/chat/chatSessionNamingAgent/description', 'Agent for generating chat session names');
     variables = [];
     prompts = [CHAT_SESSION_NAMING_PROMPT];
     languageModelRequirements: LanguageModelRequirement[] = [{
@@ -55,8 +55,16 @@ export class ChatSessionNamingAgent implements Agent {
         identifier: 'default/summarize',
     }];
     agentSpecificVariables = [
-        { name: 'conversation', usedInPrompt: true, description: 'The content of the chat conversation.' },
-        { name: 'listOfSessionNames', usedInPrompt: true, description: 'The list of existing session names.' }
+        {
+            name: 'conversation',
+            usedInPrompt: true,
+            description: nls.localize('theia/ai/chat/chatSessionNamingAgent/vars/conversation/description', 'The content of the chat conversation.')
+        },
+        {
+            name: 'listOfSessionNames',
+            usedInPrompt: true,
+            description: nls.localize('theia/ai/chat/chatSessionNamingAgent/vars/listOfSessionNames/description', 'The list of existing session names.')
+        }
     ];
     functions = [];
 

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/chat-session-summary-agent-prompt.ts

@@ -24,7 +24,7 @@ export const CHAT_SESSION_SUMMARY_PROMPT = {
             'The summary will primarily be used by other AI agents, so tailor your response for use by AI agents. ' +
             'Also consider the system message. ' +
             'Make sure you include all necessary context information and use unique references (such as URIs, file paths, etc.). ' +
-            'If the conversation was about a task, describe the state of the task, i.e.what has been completed and what is open. ' +
+            'If the conversation was about a task, describe the state of the task, i.e. what has been completed and what is open. ' +
             'If a changeset is open in the session, describe the state of the suggested changes. ' +
             `\n\n{{${CHANGE_SET_SUMMARY_VARIABLE_ID}}}`,
     }

package/src/common/chat-session-summary-agent.ts

@@ -21,13 +21,14 @@ import {
 import { injectable } from '@theia/core/shared/inversify';
 import { AbstractStreamParsingChatAgent, ChatAgent } from './chat-agents';
 import { CHAT_SESSION_SUMMARY_PROMPT } from './chat-session-summary-agent-prompt';
+import { nls } from '@theia/core';
 
 @injectable()
 export class ChatSessionSummaryAgent extends AbstractStreamParsingChatAgent implements ChatAgent {
     static ID = 'chat-session-summary-agent';
     id = ChatSessionSummaryAgent.ID;
     name = 'Chat Session Summary';
-    override description = 'Agent for generating chat session summaries.';
+    override description = nls.localize('theia/ai/chat/chatSessionSummaryAgent/description', 'Agent for generating chat session summaries.');
     override prompts: PromptVariantSet[] = [CHAT_SESSION_SUMMARY_PROMPT];
     protected readonly defaultLanguageModelPurpose = 'chat-session-summary';
     languageModelRequirements: LanguageModelRequirement[] = [{

package/src/common/chat-tool-preferences.ts

@@ -70,7 +70,7 @@ export const chatToolPreferences: PreferenceSchema = {
             },
             default: {},
             description: nls.localize('theia/ai/chat/toolConfirmation/description',
-                'Configure confirmation behavior for different tools. Key is the tool ID, value is the confirmation mode.' +
+                'Configure confirmation behavior for different tools. Key is the tool ID, value is the confirmation mode. ' +
                 'Use "*" as the key to set a global default for all tools.'),
             title: AI_CORE_PREFERENCES_TITLE,
         }
@@ -80,4 +80,3 @@ export const chatToolPreferences: PreferenceSchema = {
 export interface ChatToolConfiguration {
     [TOOL_CONFIRMATION_PREFERENCE]: { [toolId: string]: ToolConfirmationMode };
 }
-

package/src/common/image-context-variable.ts

@@ -19,19 +19,34 @@ import {
     AIVariableResolutionRequest,
     ResolvedAIContextVariable
 } from '@theia/ai-core';
+import { nls } from '@theia/core';
 
 export const IMAGE_CONTEXT_VARIABLE: AIVariable = {
     id: 'imageContext',
-    description: 'Provides context information for an image',
+    description: nls.localize('theia/ai/chat/imageContextVariable/description', 'Provides context information for an image'),
     name: 'imageContext',
-    label: 'Image File',
+    label: nls.localize('theia/ai/chat/imageContextVariable/label', 'Image File'),
     iconClasses: ['codicon', 'codicon-file-media'],
     isContextVariable: true,
     args: [
-        { name: 'name', description: 'The name of the image file if available.', isOptional: true },
-        { name: 'wsRelativePath', description: 'The workspace-relative path of the image file if available.', isOptional: true },
-        { name: 'data', description: 'The image data in base64.' },
-        { name: 'mimeType', description: 'The mimetype of the image.' }
+        {
+            name: 'name',
+            description: nls.localize('theia/ai/chat/imageContextVariable/args/name/description', 'The name of the image file if available.'),
+            isOptional: true
+        },
+        {
+            name: 'wsRelativePath',
+            description: nls.localize('theia/ai/chat/imageContextVariable/args/wsRelativePath/description', 'The workspace-relative path of the image file if available.'),
+            isOptional: true
+        },
+        {
+            name: 'data',
+            description: nls.localize('theia/ai/chat/imageContextVariable/args/data/description', 'The image data in base64.')
+        },
+        {
+            name: 'mimeType',
+            description: nls.localize('theia/ai/chat/imageContextVariable/args/mimeType/description', 'The mimetype of the image.')
+        }
     ]
 };
 

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';